예제 #1
0
  @Test
  public void testHalfCloseClientServer() throws Exception {
    ServerSocketChannel connector = ServerSocketChannel.open();
    connector.socket().bind(null);

    Socket client = SocketChannel.open(connector.socket().getLocalSocketAddress()).socket();
    client.setSoTimeout(1000);
    client.setSoLinger(false, -1);
    Socket server = connector.accept().socket();
    server.setSoTimeout(1000);
    server.setSoLinger(false, -1);

    // Write from client to server
    client.getOutputStream().write(1);

    // Server reads
    assertEquals(1, server.getInputStream().read());

    // Write from server to client with oshut
    server.getOutputStream().write(1);
    // System.err.println("OSHUT "+server);
    server.shutdownOutput();

    // Client reads response
    assertEquals(1, client.getInputStream().read());

    try {
      // Client reads -1 and does ishut
      assertEquals(-1, client.getInputStream().read());
      assertFalse(client.isInputShutdown());
      // System.err.println("ISHUT "+client);
      client.shutdownInput();

      // Client ???
      // System.err.println("OSHUT "+client);
      client.shutdownOutput();
      // System.err.println("CLOSE "+client);
      client.close();

      // Server reads -1, does ishut and then close
      assertEquals(-1, server.getInputStream().read());
      assertFalse(server.isInputShutdown());
      // System.err.println("ISHUT "+server);

      try {
        server.shutdownInput();
      } catch (SocketException e) {
        // System.err.println(e);
      }
      // System.err.println("CLOSE "+server);
      server.close();

    } catch (Exception e) {
      System.err.println(e);
      assertTrue(OS.IS_OSX);
    }
  }
예제 #2
0
 public void receive() throws IOException, InterruptedException {
   Socket socket = null;
   socket = serverSocket.accept();
   BufferedReader br = getReader(socket);
   for (int i = 0; i < 20; i++) {
     String msg = br.readLine();
     System.out.println("receive:" + msg);
     TimeUnit.MILLISECONDS.sleep(1000);
     if (i == 2) {
       if (stopWay == SUDDEN_STOP) {
         System.out.println("突然终止程序");
         System.exit(0);
       }
       if (stopWay == SOCKET_STOP) {
         System.out.println("关闭Socket并终止程序");
         socket.close();
         break;
       }
       if (stopWay == INPUT_STOP) {
         System.out.println("关闭输入流并终止程序");
         socket.shutdownInput();
         break;
       }
       if (stopWay == SERVERSOCKET_STOP) {
         System.out.println("关闭ServerSocket并终止程序");
         serverSocket.close();
         break;
       }
     }
   }
   if (stopWay == NATURAL_STOP) {
     socket.close();
     serverSocket.close();
   }
 }
예제 #3
0
 protected void shutdownIO(final boolean read) {
   if (!isConnected()) {
     throw new NotYetConnectedException();
   }
   final SocketChannel channel = (SocketChannel) key.channel();
   try {
     final Method method =
         channel.getClass().getDeclaredMethod(read ? "shutdownInput" : "shutdownOutput");
     method.setAccessible(true);
     method.invoke(channel);
     return;
   } catch (NoSuchMethodException e) {
     logger.warn("{}", this, e);
   } catch (IllegalAccessException e) {
     logger.warn("{}", this, e);
   } catch (InvocationTargetException e) {
     logger.warn("{}", this, e);
   }
   final Socket socket = channel.socket();
   try {
     if (read) {
       socket.shutdownInput();
     } else {
       socket.shutdownOutput();
     }
   } catch (IOException e) {
     logger.warn("{}", this, e);
   }
 }
예제 #4
0
 private Socket getSocket(InetAddress addr, int portNo) {
   Socket socket = null;
   if (sockets.containsKey(addr) == true) {
     socket = sockets.get(addr);
     // check the status of the socket
     if (socket.isConnected() == false
         || socket.isInputShutdown() == true
         || socket.isOutputShutdown() == true
         || socket.getPort() != portNo) {
       // if socket is not suitable, then create a new socket
       sockets.remove(addr);
       try {
         socket.shutdownInput();
         socket.shutdownOutput();
         socket.close();
         socket = new Socket(addr, portNo);
         sockets.put(addr, socket);
       } catch (IOException e) {
         Log.e("getSocket: when closing and removing", "");
       }
     }
   } else {
     try {
       socket = new Socket(addr, portNo);
       sockets.put(addr, socket);
     } catch (IOException e) {
       Log.e("getSocket: when creating", "");
     }
   }
   return socket;
 }
예제 #5
0
 private void _closeSocket() {
   synchronized (sendLock) {
     long interval = System.currentTimeMillis() - lastConnectTime;
     if (interval < connectWaitTime * 1000) {
       trace.trace("can not close socket within " + connectWaitTime + " sec");
       return;
     }
     try {
       try {
         socket.shutdownInput();
         socket.shutdownOutput();
       } catch (Exception e) {
       }
       socket.close();
     } catch (Exception e) {
     } finally {
       lastConnectTime = System.currentTimeMillis();
       connectWaitTime = 1;
       socket = null;
       listener.onClose(this);
       readBuffer.clear();
       sendBuffer.clear();
       if (State.STOPPING == _state || State.STOPPED == _state) {
         reader = null;
         return;
       }
       _state = State.STARTING;
     }
   }
 }
 /** {@inheritDoc} */
 @Override
 public AsyncSocketChannelImpl shutdown(ShutdownType how) throws IOException {
   final Socket socket = channel.socket();
   try {
     if (how == ShutdownType.READ || how == ShutdownType.BOTH) {
       if (!socket.isInputShutdown()) {
         socket.shutdownInput();
         key.selected(OP_READ);
       }
     }
     if (how == ShutdownType.WRITE || how == ShutdownType.BOTH) {
       if (!socket.isOutputShutdown()) {
         socket.shutdownOutput();
         key.selected(OP_WRITE);
       }
     }
   } catch (SocketException e) {
     if (!socket.isConnected()) {
       throw Util.initCause(new NotYetConnectedException(), e);
     }
     if (socket.isClosed()) {
       throw Util.initCause(new ClosedChannelException(), e);
     }
     throw e;
   }
   return this;
 }
  /** Destroys the server stored list. */
  @Override
  public void destroy() {
    stopped = true;

    try {
      if (connection != null) {
        connection.shutdownInput();
        connection.close();
        connection = null;
      }
    } catch (IOException e) {
    }

    try {
      if (connectionReader != null) {
        connectionReader.close();
        connectionReader = null;
      }
    } catch (IOException ex) {
    }

    if (connectionWriter != null) {
      connectionWriter.close();
      connectionWriter = null;
    }
  }
예제 #8
0
 public static void closeSocket(final Socket socket) {
   if (!socket.isClosed()) {
     try {
       if (!socket.isOutputShutdown()) {
         socket.shutdownInput();
       }
       if (!socket.isInputShutdown()) {
         socket.shutdownInput();
       }
       socket.close();
     } catch (IOException e) {
       e.printStackTrace();
       logger.severe(e.getMessage());
     }
   }
 }
예제 #9
0
 public void close() {
   try {
     sock.shutdownInput();
     sock.shutdownOutput();
     sock.close();
   } catch (Exception ign) {
   }
 }
예제 #10
0
 public void close() {
   _closed.set(true);
   try {
     _socket.shutdownInput();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
 private void closeInputStream() {
   if (in != null) {
     try {
       client.shutdownInput();
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
  private void shutdownInput(Socket socket) {
    if (socket == null) return;

    try {
      socket.shutdownInput();
    } catch (IOException ignore) {
      debug(ignore);
    }
  }
 @Override
 protected void onStop() {
   super.onStop();
   try {
     socket.shutdownInput();
     socket.close();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
 public void cancel() {
   try {
     mSocket.shutdownInput();
     mSocket.shutdownOutput();
     mmInStream.close();
     mmOutStream.close();
     mSocket.close();
     mSocket = null;
   } catch (Exception e) {
     Log.e(TAG, "close() of connect socket failed", e);
   }
 }
예제 #15
0
  @Test
  public void testReset() throws Exception {
    ServerSocket connector;
    Socket client;
    Socket server;

    connector = new ServerSocket(9123);
    client = new Socket("127.0.0.1", connector.getLocalPort());
    server = connector.accept();
    client.setTcpNoDelay(true);
    client.setSoLinger(true, 0);
    server.setTcpNoDelay(true);
    server.setSoLinger(true, 0);

    client.getOutputStream().write(1);
    assertEquals(1, server.getInputStream().read());
    server.getOutputStream().write(1);
    assertEquals(1, client.getInputStream().read());

    // Server generator shutdowns output after non persistent sending response.
    server.shutdownOutput();

    // client endpoint reads EOF and shutdown input as result
    assertEquals(-1, client.getInputStream().read());
    client.shutdownInput();

    // client connection see's EOF and shutsdown output as no more requests to be sent.
    client.shutdownOutput();

    // Since input already shutdown, client also closes socket.
    client.close();

    // Server reads the EOF from client oshut and shut's down it's input
    assertEquals(-1, server.getInputStream().read());
    server.shutdownInput();

    // Since output was already shutdown, server closes
    server.close();
  }
예제 #16
0
 public void closedInput() {
   try {
     sock.shutdownInput();
   } catch (IOException e) {
     // Ignore
   }
   synchronized (this) {
     inputClosed = true;
     if (!outputClosed) return;
   }
   try {
     sock.close();
   } catch (IOException e) {
     // Ignore
   }
 }
 @Override
 protected void finalize() throws Throwable {
   try {
     if (clientSocket != null) {
       clientSocket.shutdownInput();
       clientSocket.shutdownOutput();
       clientSocket.close();
     }
     if (serverSocket != null) {
       serverSocket.close();
     }
   } catch (java.io.IOException e) {
   } finally {
     super.finalize();
   }
 }
예제 #18
0
 public void disconnect() {
   if (m_connConfigd) {
     if (connected) {
       try {
         if (!socket.isInputShutdown()) socket.shutdownInput();
         if (!socket.isOutputShutdown()) socket.shutdownOutput();
         socket.close();
       } catch (IOException eClose) {
         s_logger.error("Error closing TCP: " + eClose);
       }
       inputStream = null;
       outputStream = null;
       connected = false;
       socket = null;
     }
   }
 }
예제 #19
0
  @Override
  public void exit() {
    for (Iterator<Socket> iterator = sockets.values().iterator(); iterator.hasNext(); ) {
      Socket socket = iterator.next();
      try {
        socket.shutdownInput();
        socket.shutdownOutput();
        socket.close();
      } catch (IOException e) {
      }
    }

    sockets.clear();
    this.stopListening();
    appManager = null;
    // timer.cancel();
  }
예제 #20
0
  void close() {
    try {
      mSocket.shutdownInput();
      mSocket.shutdownOutput();

      mInstream.close();
      mInstream = null;

      mOutstream.close();
      mOutstream = null;

      mSocket.close();
      mSocket = null;
    } catch (SocketException e) {
      // the socket was reset by the client - ignore
    } catch (IOException e) {
      // ignore
    }
  }
  /** Close left-over sockets, streams and so on. */
  public void cleanup() {
    if (socket != null && socket.isConnected() && !socket.isClosed()) {
      try {
        if (socket != null && !socket.isOutputShutdown()) {
          socket.shutdownOutput();
        }
        if (socket != null && !socket.isInputShutdown()) {
          socket.shutdownInput();
        }
        if (socket != null && !socket.isClosed()) {
          socket.close();
        }

        if (bufferedInputStream != null) {
          bufferedInputStream.close();
          bufferedInputStream = null;
        }
        if (gzipInputStream != null) {
          gzipInputStream.close();
          gzipInputStream = null;
        }
        if (inputStream != null) {
          inputStream.close();
          inputStream = null;
        }
        if (gzipOutputStream != null) {
          gzipOutputStream.close();
          gzipOutputStream = null;
        }
        if (bufferedOutputStream != null) {
          bufferedOutputStream.close();
          bufferedOutputStream = null;
        }
        if (outputStream != null) {
          outputStream.close();
          outputStream = null;
        }
      } catch (Exception e) {
        baseStep.logError("Error closing socket", e);
      }
    }
  }
예제 #22
0
  /** {@inheritDoc} */
  public void closeChannel(SelectableChannel channel) {
    // channel could be either SocketChannel or ServerSocketChannel
    if (channel instanceof SocketChannel) {
      Socket socket = ((SocketChannel) channel).socket();

      try {
        if (!socket.isInputShutdown()) socket.shutdownInput();
      } catch (IOException e) {
        logger.log(Level.FINEST, "Unexpected exception during channel inputShutdown", e);
      }

      try {
        if (!socket.isOutputShutdown()) socket.shutdownOutput();
      } catch (IOException e) {
        logger.log(Level.FINEST, "Unexpected exception during channel outputShutdown", e);
      }

      try {
        socket.close();
      } catch (IOException e) {
        logger.log(Level.FINEST, "Unexpected exception during socket close", e);
      }
    }

    try {
      channel.close();
    } catch (IOException e) {
      logger.log(Level.FINEST, "Unexpected exception during channel close", e);
    }

    if (asyncQueueReader != null) {
      asyncQueueReader.onClose(channel);
    }

    if (asyncQueueWriter != null) {
      asyncQueueWriter.onClose(channel);
    }
  }
 /** @see com.thinkparity.network.NetworkConnection#disconnect() */
 @Override
 public void disconnect() {
   logger.logTraceId();
   logger.logInfo("{0} - Disconnect", getId());
   if (isConnected()) {
     try {
       if (Boolean.FALSE == protocol.isSecure()) {
         socket.shutdownInput();
       }
     } catch (final IOException iox) {
       logger.logWarning(iox, "{0} - Error disconnecting.", getId());
     } finally {
       try {
         if (Boolean.FALSE == protocol.isSecure()) {
           socket.shutdownOutput();
         }
       } catch (final IOException iox) {
         logger.logWarning(iox, "{0} - Error disconnecting.", getId());
       } finally {
         try {
           socket.close();
         } catch (final IOException iox) {
           logger.logWarning(iox, "{0} - Error disconnecting.", getId());
         } finally {
           socket = null;
           input = null;
           output = null;
           logger.logInfo("{0} - Disconnected", getId());
           connected = false;
         }
       }
     }
   } else {
     logger.logWarning("{0} - Is not connected.", getId());
   }
 }
예제 #24
0
    @Override
    public void run() {
      try {
        // PrintWriter out = new
        // PrintWriter(clientSocket.getOutputStream(), true);
        BufferedReader in =
            new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        String inputLine;

        while ((inputLine = in.readLine()) != null) {
          if (inputLine.equals("exit") == false) {
            // appManager.messageReceived(inputLine);
          } else {
            clientSocket.shutdownInput();
            clientSocket.shutdownOutput();
            clientSocket.close();
            SocketOperator.this.sockets.remove(clientSocket.getInetAddress());
          }
        }

      } catch (IOException e) {
        Log.e("ReceiveConnection.run: when receiving connection ", "");
      }
    }
  public synchronized BlockingRowSet openReaderSocket(final BaseStep baseStep)
      throws IOException, KettleException {
    this.baseStep = baseStep;

    final BlockingRowSet rowSet = new BlockingRowSet(baseStep.getTransMeta().getSizeRowset());

    // Make sure we handle the case with multiple step copies running on a
    // slave...
    //
    rowSet.setThreadNameFromToCopy(sourceStep, sourceStepCopyNr, targetStep, targetStepCopyNr);
    rowSet.setRemoteSlaveServerName(targetSlaveServerName);

    final int portNumber = Integer.parseInt(baseStep.environmentSubstitute(port));
    final String realHostname = baseStep.environmentSubstitute(hostname);

    // Connect to the server socket (started during BaseStep.init())
    // Because the accept() call on the server socket can be called after we
    // reached this code
    // it is best to build in a retry loop with a time-out here.
    //
    long startTime = System.currentTimeMillis();
    boolean connected = false;
    KettleException lastException = null;

    // // timeout with retry until connected
    while (!connected
        && (TIMEOUT_IN_SECONDS > (System.currentTimeMillis() - startTime) / 1000)
        && !baseStep.isStopped()) {
      try {
        socket = new Socket();
        socket.setReuseAddress(true);

        baseStep.logDetailed(
            "Step variable MASTER_HOST : [" + baseStep.getVariable("MASTER_HOST") + "]");
        baseStep.logDetailed(
            "Opening client (reader) socket to server ["
                + Const.NVL(realHostname, "")
                + ":"
                + port
                + "]");
        socket.connect(new InetSocketAddress(realHostname, portNumber), 5000);

        connected = true;

        if (compressingStreams) {
          gzipInputStream = new GZIPInputStream(socket.getInputStream());
          bufferedInputStream = new BufferedInputStream(gzipInputStream, bufferSize);
        } else {
          bufferedInputStream = new BufferedInputStream(socket.getInputStream(), bufferSize);
        }
        inputStream = new DataInputStream(bufferedInputStream);

        lastException = null;
      } catch (Exception e) {
        lastException =
            new KettleException(
                "Unable to open socket to server " + realHostname + " port " + portNumber, e);
      }
      if (lastException != null) {
        // Sleep for a while
        try {
          Thread.sleep(250);
        } catch (InterruptedException e) {
          if (socket != null) {
            socket.shutdownInput();
            socket.shutdownOutput();
            socket.close();
            baseStep.logDetailed(
                "Closed connection to server socket to read rows from remote step on server "
                    + realHostname
                    + " port "
                    + portNumber
                    + " - Local port="
                    + socket.getLocalPort());
          }

          throw new KettleException(
              "Interrupted while trying to connect to server socket: " + e.toString());
        }
      }
    }

    // See if all was OK...
    if (lastException != null) {

      baseStep.logError("Error initialising step: " + lastException.toString());
      if (socket != null) {
        socket.shutdownInput();
        socket.shutdownOutput();
        socket.close();
        baseStep.logDetailed(
            "Closed connection to server socket to read rows from remote step on server "
                + realHostname
                + " port "
                + portNumber
                + " - Local port="
                + socket.getLocalPort());
      }
      throw lastException;
    } else {
      if (inputStream == null)
        throw new KettleException(
            "Unable to connect to the SocketWriter in the "
                + TIMEOUT_IN_SECONDS
                + "s timeout period.");
    }

    baseStep.logDetailed(
        "Opened connection to server socket to read rows from remote step on server "
            + realHostname
            + " port "
            + portNumber
            + " - Local port="
            + socket.getLocalPort());

    // Create a thread to take care of the reading from the client socket.
    // The rows read will be put in a RowSet buffer.
    // That buffer will hand over the rows to the step that has this RemoteStep
    // object defined
    // as a remote input step.
    //
    Runnable runnable =
        new Runnable() {
          public void run() {
            try {

              // First read the row meta data from the socket...
              //
              RowMetaInterface rowMeta = null;
              while (!baseStep.isStopped() && rowMeta == null) {
                try {
                  rowMeta = new RowMeta(inputStream);
                } catch (SocketTimeoutException e) {
                  rowMeta = null;
                }
              }

              if (rowMeta == null) {
                throw new KettleEOFException(); // leave now.
              }

              // And a first row of data...
              //
              Object[] rowData = getRowOfData(rowMeta);

              // Now get the data itself, row by row...
              //
              while (rowData != null && !baseStep.isStopped()) {
                baseStep.incrementLinesInput();
                baseStep.decrementLinesRead();

                if (baseStep.log.isDebug())
                  baseStep.logDebug("Received row from remote step: " + rowMeta.getString(rowData));

                baseStep.putRowTo(rowMeta, rowData, rowSet);
                baseStep.decrementLinesWritten();
                rowData = getRowOfData(rowMeta);
              }
            } catch (KettleEOFException e) {
              // Nothing, we're simply done reading...
              //
              if (baseStep.log.isDebug())
                baseStep.logDebug(
                    "Finished reading from remote step on server "
                        + hostname
                        + " port "
                        + portNumber);

            } catch (Exception e) {
              baseStep.logError("Error reading from client socket to remote step", e);
              baseStep.setErrors(1);
              baseStep.stopAll();
            } finally {
              // Close the input socket
              if (socket != null && !socket.isClosed() && !socket.isInputShutdown()) {
                try {
                  socket.shutdownInput();
                } catch (Exception e) {
                  baseStep.logError(
                      "Error shutting down input channel on client socket connection to remote step",
                      e);
                }
              }
              if (socket != null && !socket.isClosed() && !socket.isOutputShutdown()) {
                try {
                  socket.shutdownOutput();
                } catch (Exception e) {
                  baseStep.logError(
                      "Error shutting down output channel on client socket connection to remote step",
                      e);
                }
              }
              if (socket != null && !socket.isClosed()) {
                try {
                  socket.close();
                } catch (Exception e) {
                  baseStep.logError(
                      "Error shutting down client socket connection to remote step", e);
                }
              }
              if (inputStream != null) {
                try {
                  inputStream.close();
                } catch (Exception e) {
                  baseStep.logError(
                      "Error closing input stream on socket connection to remote step", e);
                }
                inputStream = null;
              }
              if (bufferedInputStream != null) {
                try {
                  bufferedInputStream.close();
                } catch (Exception e) {
                  baseStep.logError(
                      "Error closing input stream on socket connection to remote step", e);
                }
              }
              bufferedInputStream = null;
              if (gzipInputStream != null) {
                try {
                  gzipInputStream.close();
                } catch (Exception e) {
                  baseStep.logError(
                      "Error closing input stream on socket connection to remote step", e);
                }
              }
              gzipInputStream = null;
              baseStep.logDetailed(
                  "Closed connection to server socket to read rows from remote step on server "
                      + realHostname
                      + " port "
                      + portNumber
                      + " - Local port="
                      + socket.getLocalPort());
            }

            // signal baseStep that nothing else comes from this step.
            //
            rowSet.setDone();
          }
        };
    new Thread(runnable).start();

    return rowSet;
  }
 @Override
 public void shutdownInput() throws IOException {
   sock.shutdownInput();
 }
  @Test
  public void testReturnSocket() throws Exception {

    // Force close, successfully

    ServerSocketChannel serverSocketChannel =
        SocketUtil.createServerSocketChannel(
            InetAddressUtil.getLoopbackInetAddress(), _spiConfiguration.getConnectorPort(), null);

    serverSocketChannel.configureBlocking(true);

    ServerSocket serverSocket = serverSocketChannel.socket();

    HttpClientSPIAgent httpClientSPIAgent =
        new HttpClientSPIAgent(
            new SPIConfiguration(
                null,
                null,
                serverSocket.getLocalPort(),
                _spiConfiguration.getBaseDir(),
                null,
                null,
                null),
            new MockRegistrationReference(new MockIntraband()));

    SocketChannel socketChannel = SocketChannel.open(httpClientSPIAgent.socketAddress);

    Socket socket = socketChannel.socket();

    httpClientSPIAgent.returnSocket(socket, true);

    Queue<Socket> socketBlockingQueue = httpClientSPIAgent.socketBlockingQueue;

    Assert.assertTrue(socketBlockingQueue.isEmpty());

    closePeers(socket, serverSocket);

    // Force close, failed without log

    List<LogRecord> logRecords =
        JDKLoggerTestUtil.configureJDKLogger(HttpClientSPIAgent.class.getName(), Level.OFF);

    socket =
        new Socket(InetAddressUtil.getLoopbackInetAddress(), _spiConfiguration.getConnectorPort());

    SocketImpl socketImpl = swapSocketImpl(socket, null);

    httpClientSPIAgent.returnSocket(socket, true);

    Assert.assertTrue(socketBlockingQueue.isEmpty());

    swapSocketImpl(socket, socketImpl);

    closePeers(socket, serverSocket);

    Assert.assertTrue(logRecords.isEmpty());

    // Force close, failed with log

    logRecords =
        JDKLoggerTestUtil.configureJDKLogger(HttpClientSPIAgent.class.getName(), Level.WARNING);

    socket =
        new Socket(InetAddressUtil.getLoopbackInetAddress(), _spiConfiguration.getConnectorPort());

    socketImpl = swapSocketImpl(socket, null);

    httpClientSPIAgent.returnSocket(socket, true);

    Assert.assertTrue(socketBlockingQueue.isEmpty());

    swapSocketImpl(socket, socketImpl);

    closePeers(socket, serverSocket);

    Assert.assertEquals(1, logRecords.size());

    LogRecord logRecord = logRecords.get(0);

    Throwable throwable = logRecord.getThrown();

    Assert.assertSame(IOException.class, throwable.getClass());

    // socket.isConnected()

    httpClientSPIAgent.returnSocket(new Socket(), false);

    Assert.assertTrue(socketBlockingQueue.isEmpty());

    // socket.isInputShutdown()

    socketChannel = SocketChannel.open(httpClientSPIAgent.socketAddress);

    socket = socketChannel.socket();

    socket.shutdownInput();

    httpClientSPIAgent.returnSocket(socket, false);

    Assert.assertTrue(socketBlockingQueue.isEmpty());

    closePeers(socket, serverSocket);

    // socket.isOutputShutdown()

    socketChannel = SocketChannel.open(httpClientSPIAgent.socketAddress);

    socket = socketChannel.socket();

    socket.shutdownOutput();

    httpClientSPIAgent.returnSocket(socket, false);

    Assert.assertTrue(socketBlockingQueue.isEmpty());

    closePeers(socket, serverSocket);

    // Successfully return

    socketChannel = SocketChannel.open(httpClientSPIAgent.socketAddress);

    socket = socketChannel.socket();

    httpClientSPIAgent.returnSocket(socket, false);

    Assert.assertEquals(1, socketBlockingQueue.size());
    Assert.assertSame(socket, socketBlockingQueue.poll());

    closePeers(socket, serverSocket);

    serverSocket.close();
  }
  @Test
  public void testBorrowSocket() throws Exception {

    // Create on empty

    ServerSocketChannel serverSocketChannel =
        SocketUtil.createServerSocketChannel(
            InetAddressUtil.getLoopbackInetAddress(), _spiConfiguration.getConnectorPort(), null);

    serverSocketChannel.configureBlocking(true);

    ServerSocket serverSocket = serverSocketChannel.socket();

    SPIConfiguration spiConfiguration =
        new SPIConfiguration(
            null,
            null,
            serverSocket.getLocalPort(),
            _spiConfiguration.getBaseDir(),
            null,
            null,
            null);

    HttpClientSPIAgent httpClientSPIAgent =
        new HttpClientSPIAgent(
            spiConfiguration, new MockRegistrationReference(new MockIntraband()));

    Socket socket = httpClientSPIAgent.borrowSocket();

    closePeers(socket, serverSocket);

    // Clean up when closed

    Queue<Socket> socketBlockingQueue = httpClientSPIAgent.socketBlockingQueue;

    socketBlockingQueue.add(socket);

    socket = httpClientSPIAgent.borrowSocket();

    closePeers(socket, serverSocket);

    // Clean up not connected

    socketBlockingQueue.add(new Socket());

    socket = httpClientSPIAgent.borrowSocket();

    closePeers(socket, serverSocket);

    // Clean up when input is shutdown

    socket = httpClientSPIAgent.borrowSocket();

    socket.shutdownInput();

    socketBlockingQueue.add(socket);

    socket = httpClientSPIAgent.borrowSocket();

    closePeers(socket, serverSocket);

    socket = serverSocket.accept();

    socket.close();

    // Clean up when input is shutdown, failed without log

    List<LogRecord> logRecords =
        JDKLoggerTestUtil.configureJDKLogger(HttpClientSPIAgent.class.getName(), Level.OFF);

    socket =
        new Socket(InetAddressUtil.getLoopbackInetAddress(), _spiConfiguration.getConnectorPort());

    socket.shutdownInput();

    SocketImpl socketImpl = swapSocketImpl(socket, null);

    socketBlockingQueue.add(socket);

    socket = httpClientSPIAgent.borrowSocket();

    swapSocketImpl(socket, socketImpl);

    closePeers(socket, serverSocket);

    socket = serverSocket.accept();

    socket.close();

    Assert.assertTrue(logRecords.isEmpty());

    // Clean up when input is shutdown, failed with log

    logRecords =
        JDKLoggerTestUtil.configureJDKLogger(HttpClientSPIAgent.class.getName(), Level.WARNING);

    socket =
        new Socket(InetAddressUtil.getLoopbackInetAddress(), _spiConfiguration.getConnectorPort());

    socket.shutdownInput();

    socketImpl = swapSocketImpl(socket, null);

    socketBlockingQueue.add(socket);

    socket = httpClientSPIAgent.borrowSocket();

    swapSocketImpl(socket, socketImpl);

    closePeers(socket, serverSocket);

    socket = serverSocket.accept();

    socket.close();

    Assert.assertEquals(1, logRecords.size());

    LogRecord logRecord = logRecords.get(0);

    Throwable throwable = logRecord.getThrown();

    Assert.assertSame(IOException.class, throwable.getClass());

    // Clean up when output is shutdown()

    socket = httpClientSPIAgent.borrowSocket();

    socket.shutdownOutput();

    socketBlockingQueue.add(socket);

    socket = httpClientSPIAgent.borrowSocket();

    closePeers(socket, serverSocket);

    socket = serverSocket.accept();

    socket.close();

    // Reuse socket

    socket = httpClientSPIAgent.borrowSocket();

    socketBlockingQueue.add(socket);

    Assert.assertSame(socket, httpClientSPIAgent.borrowSocket());

    closePeers(socket, serverSocket);

    serverSocket.close();
  }
예제 #29
0
  @Test
  public void testHalfClose() throws Exception {
    ServerSocket connector = new ServerSocket(0);

    Socket client = new Socket("localhost", connector.getLocalPort());
    Socket server = connector.accept();

    // we can write both ways
    client.getOutputStream().write(1);
    assertEquals(1, server.getInputStream().read());
    server.getOutputStream().write(1);
    assertEquals(1, client.getInputStream().read());

    // shutdown output results in read -1
    client.shutdownOutput();
    assertEquals(-1, server.getInputStream().read());

    // Even though EOF has been read, the server input is not seen as shutdown
    assertFalse(server.isInputShutdown());

    // and we can read -1 again
    assertEquals(-1, server.getInputStream().read());

    // but cannot write
    try {
      client.getOutputStream().write(1);
      fail("exception expected");
    } catch (SocketException e) {
    }

    // but can still write in opposite direction.
    server.getOutputStream().write(1);
    assertEquals(1, client.getInputStream().read());

    // server can shutdown input to match the shutdown out of client
    server.shutdownInput();

    // now we EOF instead of reading -1
    try {
      server.getInputStream().read();
      fail("exception expected");
    } catch (SocketException e) {
    }

    // but can still write in opposite direction.
    server.getOutputStream().write(1);
    assertEquals(1, client.getInputStream().read());

    // client can shutdown input
    client.shutdownInput();

    // now we EOF instead of reading -1
    try {
      client.getInputStream().read();
      fail("exception expected");
    } catch (SocketException e) {
    }

    // But we can still write at the server (data which will never be read)
    server.getOutputStream().write(1);

    // and the server output is not shutdown
    assertFalse(server.isOutputShutdown());

    // until we explictly shut it down
    server.shutdownOutput();

    // and now we can't write
    try {
      server.getOutputStream().write(1);
      fail("exception expected");
    } catch (SocketException e) {
    }

    // but the sockets are still open
    assertFalse(client.isClosed());
    assertFalse(server.isClosed());

    // but if we close one end
    client.close();

    // it is seen as closed.
    assertTrue(client.isClosed());

    // but not the other end
    assertFalse(server.isClosed());

    // which has to be closed explictly
    server.close();
    assertTrue(server.isClosed());
  }
예제 #30
0
 public void shutdownInput() throws IOException {
   mSocket.shutdownInput();
 }