/** * Get a free connection * * @return * @throws IllegalStateException - Thrown if a connection cannot be created. * @since 1.0.0 */ public IREMConnection getFreeConnection() throws IllegalStateException { Thread thread = Thread.currentThread(); if (thread instanceof REMCallbackThread) { // The current thread is a call back thread, so just reuse the connection. // But this thread could actually be trying to access another registry. // So if this thread is for this registry, use it, if not for this registry, create a new // connection. // But if for this registry AND is already in a transaction, we need a fresh connection. REMCallbackThread callbackThread = (REMCallbackThread) thread; if (callbackThread.registry == this && !callbackThread.inTransaction()) { // This way any calls out to the remote vm will be on same thread as callback caller // on remote vm because that thread is waiting on this connection for commands. IREMConnection c = (callbackThread).getConnection(); if (c.isConnected()) return c; else throw new IllegalStateException( ProxyRemoteMessages.REMProxyFactoryRegistry_CallbackConnectionNotWorking_EXC_); } } synchronized (fConnectionPool) { if (!fConnectionPool.isEmpty()) return (IREMConnection) fConnectionPool.pop(); // else we need to allocate one. return createConnection(); } }
/** Free the connection */ public void returnConnection(IREMConnection connection) { if (connection.isConnected()) { Thread thread = Thread.currentThread(); if (!(thread instanceof REMCallbackThread) || ((REMCallbackThread) thread).getConnection() != connection) { // We are not a callback thread, or we are but the connection is not for the thread, then // the connection // can be returned. synchronized (fConnectionPool) { if (fConnectionPool.size() < NUMBER_FREE_CONNECTIONS) fConnectionPool.push(connection); else connection.close(); // We don't need to maintain more than five free connections. } } } }
/** Release this connection. This means close it out. */ public void closeConnection(IREMConnection connection) { connection.close(); }
protected void registryTerminated(boolean wait) { if (processListener != null) { // Remove listener cause we are now going to terminate process and don't want premature // terminate notice. // Sometimes in shutdown we are called and the debug plugin may of already been shutdown. In // that case the db // will be null and there is nothing remove listener from. DebugPlugin db = DebugPlugin.getDefault(); if (db != null) db.removeDebugEventListener(processListener); processListener = null; } Job tjob = null; if (waitRegistrationThread != null) { synchronized (waitRegistrationThread) { // Still waiting. close it out. WaitForRegistrationThread wThread = waitRegistrationThread; waitRegistrationThread = null; wThread.notifyAll(); } } if (fServerPort != 0) { IREMConnection closeCon = null; // The connection we will use to close the remote vm. synchronized (fConnectionPool) { // Now we walk through all of the free connections and close them properly. Iterator itr = fConnectionPool.iterator(); if (itr.hasNext()) closeCon = (IREMConnection) itr.next(); while (itr.hasNext()) { IREMConnection con = (IREMConnection) itr.next(); con.close(); } } // Now we terminate the server. if (closeCon == null) try { closeCon = getFreeConnection(); // There weren't any free connections, so get a new one so that // we can close it. } catch (IllegalStateException e) { // Do nothing, don't want to stop termination just because we can't get a connection. } if (closeCon != null) { closeCon .terminateServer(); // We got a connection to terminate (process may of terminated // early, so we would not have a conn then). } fConnectionPool.clear(); fServerPort = 0; if (fProcess != null && !fRegistryController.inShutDown()) { tjob = new TerminateProcess(fProcess); tjob.setSystem(true); tjob.schedule(); fProcess = null; } } if (fCallbackServer != null) { fCallbackServer.requestShutdown(); fCallbackServer = null; } fConnectionPool.clear(); fRegistryController.deregisterRegistry(fRegistryKey); // De-register this registry. if (wait && tjob != null) { try { tjob.join(); } catch (InterruptedException e) { // It timed out, so we'll just go on. } } }