/** * Tries to add a reuseable connection to the connection pool. Replace any not in use connections * to the same host and port. Will not add to the same host and port in use. Will replace oldest * not in use element (if any) if the pool is full. * * @param p_protocol The protocol for the connection * @param p_host The Hostname for the connection * @param p_port The port number for the connection * @param sc The base stream connection * @param dos The data output stream from the base connection * @param dis The data input stream from the base connection * @return true if the connection was added, otherwise false */ synchronized boolean add( String p_protocol, String p_host, int p_port, StreamConnection sc, DataOutputStream dos, DataInputStream dis) { StreamConnectionElement oldestNotInUse = null; // find the last unused element Enumeration cons = m_connections.elements(); while (cons.hasMoreElements()) { StreamConnectionElement sce = (StreamConnectionElement) cons.nextElement(); if (sce.m_in_use) { if (p_host.equals(sce.m_host) && p_port == sce.m_port) { return false; } continue; } // if the connection is a duplicate, delete it if (p_host.equals(sce.m_host) && p_port == sce.m_port) { // no protocol duplicates on host and port sce.close(); m_connections.removeElement(sce); break; } else { if (oldestNotInUse == null || sce.m_time < oldestNotInUse.m_time) { // save the oldest not in use, it may be removed later oldestNotInUse = sce; } } } /* * first check and see if the maximum number of connections * has been reached - if so delete the first one in the list (FIFO) * or * if this port and host are already in the pool. */ if (m_connections.size() >= m_max_connections) { if (oldestNotInUse == null) { return false; } oldestNotInUse.close(); m_connections.removeElement(oldestNotInUse); } m_connections.addElement(new StreamConnectionElement(p_protocol, p_host, p_port, sc, dos, dis)); return true; }
/** * Return an instance of the stream connection element to the connection pool so it can be reused. * It is done in the method so it can be synchronized with the get method. * * @param returned The stream connection element to return */ synchronized void returnForReuse(StreamConnectionElement returned) { returned.m_in_use = false; if (returned.m_removed) { // the connection was out too long returned.close(); return; } returned.m_time = System.currentTimeMillis(); }
/** * get an available connection and set the boolean flag to true (unavailable) in the connection * pool. Also removes any stale connections, since this method gets called more than add or * remove. * * @param callerSecurityToken The security token of the caller * @param p_protocol The protocol for the connection * @param p_host The Hostname for the connection * @param p_port The port number for the connection * @return A stream connection element or null if not found */ public synchronized StreamConnectionElement get( SecurityToken callerSecurityToken, String p_protocol, String p_host, int p_port) { StreamConnectionElement result = null; long c_time = System.currentTimeMillis(); Enumeration cons = m_connections.elements(); callerSecurityToken.checkIfPermissionAllowed(Permissions.MIDP); while (cons.hasMoreElements()) { StreamConnectionElement sce = (StreamConnectionElement) cons.nextElement(); if ((c_time - sce.m_time) > m_connectionLingerTime) { if (!sce.m_in_use) { sce.close(); } else { // signal returnToUse() to close sce.m_removed = true; } m_connections.removeElement(sce); continue; } if (p_host.equals(sce.m_host) && p_port == sce.m_port && p_protocol.equals(sce.m_protocol) && !sce.m_in_use) { result = sce; // do not break out so old connections can be removed continue; } } if (result != null) { result.m_in_use = true; } return result; }
/** * Close connection and remove an instance of the stream connection element from the connection * pool. * * @param sce The stream connection element to remove */ synchronized void remove(StreamConnectionElement sce) { sce.close(); m_connections.removeElement(sce); }