예제 #1
0
 /**
  * Asynchronous exception handling.
  *
  * @param block <code>true</code> => block until an exception is available, <code>false</code =>
  *     return <code>null</code> if no exception is available.
  * @return The exception, or <code>null</code> if no exception is available or this Acceptor has
  *     been shut down.
  */
 public Exception getPendingException(boolean block) {
   try {
     return (Exception) m_exceptionQueue.dequeue(block);
   } catch (ThreadSafeQueue.ShutdownException e) {
     return null;
   }
 }
예제 #2
0
  /**
   * Shut down this acceptor.
   *
   * @throws CommunicationException If an IO exception occurs.
   */
  public void shutdown() throws CommunicationException {

    synchronized (m_socketSets) {
      // Prevent recursion and creation of new ResourcePools.

      if (m_isShutdown) {
        return;
      }

      m_isShutdown = true;
    }

    try {
      m_serverSocket.close();
    } catch (IOException e) {
      UncheckedInterruptedException.ioException(e);
      throw new CommunicationException("Error closing socket", e);
    } finally {
      // Interrupt the acceptor thread group.
      m_threadPool.stop();

      // We clone contents of m_socketSets and don't hold m_socketSets whilst
      // closing the ResourcePools to remove opportunity for dead lock with
      // events triggered by closing resources.
      final ResourcePool[] socketSets = cloneListOfSocketSets();

      for (int i = 0; i < socketSets.length; ++i) {
        socketSets[i].closeCurrentResources();
      }

      m_exceptionQueue.shutdown();
    }
  }
예제 #3
0
  private void discriminateConnection(Socket localSocket) throws IOException, ShutdownException {

    boolean closeSocket = true;

    try {
      final Connector.ConnectDetails connectDetails = Connector.read(localSocket.getInputStream());

      final SocketWrapper socketWrapper = new SocketWrapper(localSocket);
      socketWrapper.setAddress(connectDetails.getAddress());

      // Possible minor race if the socket is closed between here...
      final ResourcePool.Closeable closeable =
          getSocketSet(connectDetails.getConnectionType()).add(socketWrapper);

      // .. and the time a listener is registered. Will pick up such a zombie
      // the next time we try to use the resource.
      socketWrapper.addClosedListener(
          new SocketWrapper.ClosedListener() {
            public void socketClosed() {
              closeable.close();
            }
          });

      // We did good.
      closeSocket = false;
    } catch (CommunicationException e) {
      try {
        m_exceptionQueue.queue(e);
      } catch (ThreadSafeQueue.ShutdownException shutdownException) {
        // Can happen due to race condition with shutdown, ignore.
      }
    } finally {
      if (closeSocket) {
        try {
          localSocket.close();
        } catch (IOException ioException) {
          UncheckedInterruptedException.ioException(ioException);
          // Ignore.
        }
      }
    }
  }