Esempio n. 1
0
    /**
     * Handle connection failures
     *
     * <p>If the current number of retries is equal to the max number of retries, stop retrying and
     * throw the exception; Otherwise backoff N seconds and try connecting again.
     *
     * <p>This Method is only called from inside setupIOstreams(), which is synchronized. Hence the
     * sleep is synchronized; the locks will be retained.
     *
     * @param curRetries current number of retries
     * @param maxRetries max number of retries allowed
     * @param ioe failure reason
     * @throws IOException if max number of retries is reached
     */
    private void handleConnectionFailure(int curRetries, int maxRetries, IOException ioe)
        throws IOException {

      closeConnection();

      // throw the exception if the maximum number of retries is reached
      if (curRetries >= maxRetries) {
        throw ioe;
      }

      // otherwise back off and retry
      try {
        Thread.sleep(failureSleep);
      } catch (InterruptedException ignored) {
      }

      LOG.info(
          "Retrying connect to server: "
              + remoteId.getAddress()
              + " after sleeping "
              + failureSleep
              + "ms. Already tried "
              + curRetries
              + " time(s).");
    }
Esempio n. 2
0
 protected synchronized void setupConnection() throws IOException {
   short ioFailures = 0;
   short timeoutFailures = 0;
   while (true) {
     try {
       this.socket = socketFactory.createSocket();
       this.socket.setTcpNoDelay(tcpNoDelay);
       this.socket.setKeepAlive(tcpKeepAlive);
       // connection time out is 20s
       NetUtils.connect(this.socket, remoteId.getAddress(), getSocketTimeout(conf));
       if (remoteId.rpcTimeout > 0) {
         pingInterval = remoteId.rpcTimeout; // overwrite pingInterval
       }
       this.socket.setSoTimeout(pingInterval);
       return;
     } catch (SocketTimeoutException toe) {
       /* The max number of retries is 45,
        * which amounts to 20s*45 = 15 minutes retries.
        */
       handleConnectionFailure(timeoutFailures++, maxRetries, toe);
     } catch (IOException ie) {
       handleConnectionFailure(ioFailures++, maxRetries, ie);
     }
   }
 }
Esempio n. 3
0
    /**
     * Connect to the server and set up the I/O streams. It then sends a header to the server and
     * starts the connection thread that waits for responses.
     *
     * @throws java.io.IOException e
     */
    protected synchronized void setupIOstreams() throws IOException, InterruptedException {

      if (socket != null || shouldCloseConnection.get()) {
        return;
      }

      if (failedServers.isFailedServer(remoteId.getAddress())) {
        if (LOG.isDebugEnabled()) {
          LOG.debug(
              "Not trying to connect to "
                  + remoteId.getAddress()
                  + " this server is in the failed servers list");
        }
        IOException e =
            new FailedServerException(
                "This server is in the failed servers list: " + remoteId.getAddress());
        markClosed(e);
        close();
        throw e;
      }

      try {
        if (LOG.isDebugEnabled()) {
          LOG.debug("Connecting to " + remoteId);
        }
        setupConnection();
        this.in =
            new DataInputStream(
                new BufferedInputStream(new PingInputStream(NetUtils.getInputStream(socket))));
        this.out = new DataOutputStream(new BufferedOutputStream(NetUtils.getOutputStream(socket)));
        writeHeader();

        // update last activity time
        touch();

        // start the receiver thread after the socket connection has been set up
        start();
      } catch (IOException e) {
        failedServers.addToFailedServers(remoteId.address);
        markClosed(e);
        close();

        throw e;
      }
    }
Esempio n. 4
0
    Connection(ConnectionId remoteId) throws IOException {
      if (remoteId.getAddress().isUnresolved()) {
        throw new UnknownHostException("unknown host: " + remoteId.getAddress().getHostName());
      }
      this.remoteId = remoteId;
      User ticket = remoteId.getTicket();
      Class<? extends VersionedProtocol> protocol = remoteId.getProtocol();

      header = new ConnectionHeader(protocol == null ? null : protocol.getName(), ticket);

      this.setName(
          "IPC Client ("
              + socketFactory.hashCode()
              + ") connection to "
              + remoteId.getAddress().toString()
              + ((ticket == null) ? " from an unknown user" : (" from " + ticket.getName())));
      this.setDaemon(true);
    }
Esempio n. 5
0
 public InetSocketAddress getRemoteAddress() {
   return remoteId.getAddress();
 }