Java ConnectTimeoutException类代码示例

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private void assertRetriesOnSocketTimeouts(Configuration conf,
    int maxTimeoutRetries) throws IOException {
  SocketFactory mockFactory = Mockito.mock(SocketFactory.class);
  doThrow(new ConnectTimeoutException("fake")).when(mockFactory).createSocket();
  Client client = new Client(IntWritable.class, conf, mockFactory);
  InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9090);
  try {
    client.call(new IntWritable(RANDOM.nextInt()), address, null, null, 0,
        conf);
    fail("Not throwing the SocketTimeoutException");
  } catch (SocketTimeoutException e) {
    Mockito.verify(mockFactory, Mockito.times(maxTimeoutRetries))
        .createSocket();
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private void assertRetriesOnSocketTimeouts(Configuration conf,
    int maxTimeoutRetries) throws IOException {
  SocketFactory mockFactory = Mockito.mock(SocketFactory.class);
  doThrow(new ConnectTimeoutException("fake")).when(mockFactory).createSocket();
  Client client = new Client(IntWritable.class, conf, mockFactory);
  InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9090);
  try {
    client.call(new IntWritable(RANDOM.nextInt()), address, null, null, 0,
        conf);
    fail("Not throwing the SocketTimeoutException");
  } catch (SocketTimeoutException e) {
    Mockito.verify(mockFactory, Mockito.times(maxTimeoutRetries))
        .createSocket();
  }
  client.stop();
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
@Override
public boolean canInfinitelyRetry(Throwable t){
    t=Throwables.getRootCause(t);
    t=processPipelineException(t);
    if(t instanceof NotServingPartitionException
            || t instanceof WrongPartitionException
            || t instanceof PipelineTooBusy
            || t instanceof RegionBusyException
            || t instanceof NoRouteToHostException
            || t instanceof org.apache.hadoop.hbase.ipc.FailedServerException
            || t instanceof FailedServerException
            || t instanceof ServerNotRunningYetException
            || t instanceof ConnectTimeoutException
            || t instanceof IndexNotSetUpException) return true;
    return false;
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private void assertRetriesOnSocketTimeouts(Configuration conf,
    int maxTimeoutRetries) throws IOException {
  SocketFactory mockFactory = Mockito.mock(SocketFactory.class);
  doThrow(new ConnectTimeoutException("fake")).when(mockFactory).createSocket();
  Client client = new Client(LongWritable.class, conf, mockFactory);
  InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9090);
  try {
    call(client, RANDOM.nextLong(), address, conf);
    fail("Not throwing the SocketTimeoutException");
  } catch (SocketTimeoutException e) {
    Mockito.verify(mockFactory, Mockito.times(maxTimeoutRetries))
        .createSocket();
  }
  client.stop();
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
@Override
public Socket createSocket() throws IOException {
  Socket spy = Mockito.spy(defaultFactory.createSocket());
  // Simplify our spying job by not having to also spy on the channel
  Mockito.doReturn(null).when(spy).getChannel();
  // Throw a ConnectTimeoutException when connecting to our target "bad"
  // host.
  Mockito.doThrow(new ConnectTimeoutException("injected"))
    .when(spy).connect(
        Mockito.argThat(new MatchesPort()),
        Mockito.anyInt());
  return spy;
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
@Override
public RetryAction shouldRetry(Exception e, int retries,
    int failovers, boolean isIdempotentOrAtMostOnce) throws Exception {
  if (failovers >= maxFailovers) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
        "failovers (" + failovers + ") exceeded maximum allowed ("
        + maxFailovers + ")");
  }
  if (retries - failovers > maxRetries) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0, "retries ("
        + retries + ") exceeded maximum allowed (" + maxRetries + ")");
  }
  
  if (e instanceof ConnectException ||
      e instanceof NoRouteToHostException ||
      e instanceof UnknownHostException ||
      e instanceof StandbyException ||
      e instanceof ConnectTimeoutException ||
      isWrappedStandbyException(e)) {
    return new RetryAction(RetryAction.RetryDecision.FAILOVER_AND_RETRY,
        getFailoverOrRetrySleepTime(failovers));
  } else if (e instanceof RetriableException
      || getWrappedRetriableException(e) != null) {
    // RetriableException or RetriableException wrapped 
    return new RetryAction(RetryAction.RetryDecision.RETRY,
          getFailoverOrRetrySleepTime(retries));
  } else if (e instanceof SocketException
      || (e instanceof IOException && !(e instanceof RemoteException))) {
    if (isIdempotentOrAtMostOnce) {
      return RetryAction.FAILOVER_AND_RETRY;
    } else {
      return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
          "the invoked method is not idempotent, and unable to determine "
              + "whether it was invoked");
    }
  } else {
      return fallbackPolicy.shouldRetry(e, retries, failovers,
          isIdempotentOrAtMostOnce);
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
@Override
public RetryAction shouldRetry(Exception e, int retries,
    int failovers, boolean isIdempotentOrAtMostOnce) throws Exception {
  if (failovers >= maxFailovers) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
        "failovers (" + failovers + ") exceeded maximum allowed ("
        + maxFailovers + ")");
  }
  
  if (e instanceof ConnectException ||
      e instanceof NoRouteToHostException ||
      e instanceof UnknownHostException ||
      e instanceof StandbyException ||
      e instanceof ConnectTimeoutException ||
      isWrappedStandbyException(e)) {
    return new RetryAction(
        RetryAction.RetryDecision.FAILOVER_AND_RETRY,
        // retry immediately if this is our first failover, sleep otherwise
        failovers == 0 ? 0 :
            calculateExponentialTime(delayMillis, failovers, maxDelayBase));
  } else if (e instanceof SocketException ||
             (e instanceof IOException && !(e instanceof RemoteException))) {
    if (isIdempotentOrAtMostOnce) {
      return RetryAction.FAILOVER_AND_RETRY;
    } else {
      return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
          "the invoked method is not idempotent, and unable to determine " +
          "whether it was invoked");
    }
  } else {
    return fallbackPolicy.shouldRetry(e, retries, failovers,
        isIdempotentOrAtMostOnce);
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
protected static RetryPolicy createRetryPolicy(Configuration conf,
    String maxWaitTimeStr, long defMaxWaitTime,
    String connectRetryIntervalStr, long defRetryInterval) {
  long maxWaitTime = conf.getLong(maxWaitTimeStr, defMaxWaitTime);
  long retryIntervalMS =
      conf.getLong(connectRetryIntervalStr, defRetryInterval);

  Preconditions.checkArgument((maxWaitTime == -1 || maxWaitTime > 0),
      "Invalid Configuration. " + maxWaitTimeStr + " should be either"
          + " positive value or -1.");
  Preconditions.checkArgument(retryIntervalMS > 0, "Invalid Configuration. "
      + connectRetryIntervalStr + "should be a positive value.");

  RetryPolicy retryPolicy = null;
  if (maxWaitTime == -1) {
    // wait forever.
    retryPolicy = RetryPolicies.retryForeverWithFixedSleep(retryIntervalMS,
        TimeUnit.MILLISECONDS);
  } else {
    retryPolicy =
        RetryPolicies.retryUpToMaximumTimeWithFixedSleep(maxWaitTime,
            retryIntervalMS, TimeUnit.MILLISECONDS);
  }

  Map<Class<? extends Exception>, RetryPolicy> exceptionToPolicyMap =
      new HashMap<Class<? extends Exception>, RetryPolicy>();
  exceptionToPolicyMap.put(EOFException.class, retryPolicy);
  exceptionToPolicyMap.put(ConnectException.class, retryPolicy);
  exceptionToPolicyMap.put(NoRouteToHostException.class, retryPolicy);
  exceptionToPolicyMap.put(UnknownHostException.class, retryPolicy);
  exceptionToPolicyMap.put(ConnectTimeoutException.class, retryPolicy);
  exceptionToPolicyMap.put(RetriableException.class, retryPolicy);
  exceptionToPolicyMap.put(SocketException.class, retryPolicy);
  // When client got an SSLException should not retry to connect
  exceptionToPolicyMap.put(SSLException.class, RetryPolicies.TRY_ONCE_THEN_FAIL);
  exceptionToPolicyMap.put(NMNotYetReadyException.class, retryPolicy);

  return RetryPolicies.retryByException(RetryPolicies.TRY_ONCE_THEN_FAIL,
    exceptionToPolicyMap);
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private 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(true);
      
      if (tcpLowLatency) {
        /*
         * This allows intermediate switches to shape IPC traffic
         * differently from Shuffle/HDFS DataStreamer traffic.
         *
         * IPTOS_RELIABILITY (0x04) | IPTOS_LOWDELAY (0x10)
         *
         * Prefer to optimize connect() speed & response latency over net
         * throughput.
         */
        this.socket.setTrafficClass(0x04 | 0x10);
        this.socket.setPerformancePreferences(1, 2, 0);
      }

      /*
       * Bind the socket to the host specified in the principal name of the
       * client, to ensure Server matching address of the client connection
       * to host name in principal passed.
       */
      UserGroupInformation ticket = remoteId.getTicket();
      if (ticket != null && ticket.hasKerberosCredentials()) {
        KerberosInfo krbInfo = 
          remoteId.getProtocol().getAnnotation(KerberosInfo.class);
        if (krbInfo != null && krbInfo.clientPrincipal() != null) {
          String host = 
            SecurityUtil.getHostFromPrincipal(remoteId.getTicket().getUserName());
          
          // If host name is a valid local address then bind socket to it
          InetAddress localAddr = NetUtils.getLocalInetAddress(host);
          if (localAddr != null) {
            this.socket.setReuseAddress(true);
            this.socket.bind(new InetSocketAddress(localAddr, 0));
          }
        }
      }
      
      NetUtils.connect(this.socket, server, connectionTimeout);
      if (rpcTimeout > 0) {
        pingInterval = rpcTimeout;  // rpcTimeout overwrites pingInterval
      }
      this.socket.setSoTimeout(pingInterval);
      return;
    } catch (ConnectTimeoutException toe) {
      /* Check for an address change and update the local reference.
       * Reset the failure counter if the address was changed
       */
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionTimeout(timeoutFailures++,
          maxRetriesOnSocketTimeouts, toe);
    } catch (IOException ie) {
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionFailure(ioFailures++, ie);
    }
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
@Override
public RetryAction shouldRetry(Exception e, int retries,
    int failovers, boolean isIdempotentOrAtMostOnce) throws Exception {
  if (failovers >= maxFailovers) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
        "failovers (" + failovers + ") exceeded maximum allowed ("
        + maxFailovers + ")");
  }
  if (retries - failovers > maxRetries) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0, "retries ("
        + retries + ") exceeded maximum allowed (" + maxRetries + ")");
  }
  
  if (e instanceof ConnectException ||
      e instanceof NoRouteToHostException ||
      e instanceof UnknownHostException ||
      e instanceof StandbyException ||
      e instanceof ConnectTimeoutException ||
      isWrappedStandbyException(e)) {
    return new RetryAction(RetryAction.RetryDecision.FAILOVER_AND_RETRY,
        getFailoverOrRetrySleepTime(failovers));
  } else if (e instanceof RetriableException
      || getWrappedRetriableException(e) != null) {
    // RetriableException or RetriableException wrapped 
    return new RetryAction(RetryAction.RetryDecision.RETRY,
          getFailoverOrRetrySleepTime(retries));
  } else if (e instanceof InvalidToken) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
        "Invalid or Cancelled Token");
  } else if (e instanceof SocketException
      || (e instanceof IOException && !(e instanceof RemoteException))) {
    if (isIdempotentOrAtMostOnce) {
      return RetryAction.FAILOVER_AND_RETRY;
    } else {
      return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
          "the invoked method is not idempotent, and unable to determine "
              + "whether it was invoked");
    }
  } else {
      return fallbackPolicy.shouldRetry(e, retries, failovers,
          isIdempotentOrAtMostOnce);
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private 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(true);
      
      /*
       * Bind the socket to the host specified in the principal name of the
       * client, to ensure Server matching address of the client connection
       * to host name in principal passed.
       */
      UserGroupInformation ticket = remoteId.getTicket();
      if (ticket != null && ticket.hasKerberosCredentials()) {
        KerberosInfo krbInfo = 
          remoteId.getProtocol().getAnnotation(KerberosInfo.class);
        if (krbInfo != null && krbInfo.clientPrincipal() != null) {
          String host = 
            SecurityUtil.getHostFromPrincipal(remoteId.getTicket().getUserName());
          
          // If host name is a valid local address then bind socket to it
          InetAddress localAddr = NetUtils.getLocalInetAddress(host);
          if (localAddr != null) {
            this.socket.bind(new InetSocketAddress(localAddr, 0));
          }
        }
      }
      
      NetUtils.connect(this.socket, server, connectionTimeout);
      if (rpcTimeout > 0) {
        pingInterval = rpcTimeout;  // rpcTimeout overwrites pingInterval
      }
      this.socket.setSoTimeout(pingInterval);
      return;
    } catch (ConnectTimeoutException toe) {
      /* Check for an address change and update the local reference.
       * Reset the failure counter if the address was changed
       */
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionTimeout(timeoutFailures++,
          maxRetriesOnSocketTimeouts, toe);
    } catch (IOException ie) {
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionFailure(ioFailures++, ie);
    }
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private 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(true);
      
      if (tcpLowLatency) {
        /*
         * This allows intermediate switches to shape IPC traffic
         * differently from Shuffle/HDFS DataStreamer traffic.
         *
         * IPTOS_RELIABILITY (0x04) | IPTOS_LOWDELAY (0x10)
         *
         * Prefer to optimize connect() speed & response latency over net
         * throughput.
         */
        this.socket.setTrafficClass(0x04 | 0x10);
        this.socket.setPerformancePreferences(1, 2, 0);
      }

      /*
       * Bind the socket to the host specified in the principal name of the
       * client, to ensure Server matching address of the client connection
       * to host name in principal passed.
       */
      UserGroupInformation ticket = remoteId.getTicket();
      if (ticket != null && ticket.hasKerberosCredentials()) {
        KerberosInfo krbInfo = 
          remoteId.getProtocol().getAnnotation(KerberosInfo.class);
        if (krbInfo != null && krbInfo.clientPrincipal() != null) {
          String host = 
            SecurityUtil.getHostFromPrincipal(remoteId.getTicket().getUserName());
          
          // If host name is a valid local address then bind socket to it
          InetAddress localAddr = NetUtils.getLocalInetAddress(host);
          if (localAddr != null) {
            this.socket.bind(new InetSocketAddress(localAddr, 0));
          }
        }
      }
      
      NetUtils.connect(this.socket, server, connectionTimeout);
      if (rpcTimeout > 0) {
        pingInterval = rpcTimeout;  // rpcTimeout overwrites pingInterval
      }
      this.socket.setSoTimeout(pingInterval);
      return;
    } catch (ConnectTimeoutException toe) {
      /* Check for an address change and update the local reference.
       * Reset the failure counter if the address was changed
       */
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionTimeout(timeoutFailures++,
          maxRetriesOnSocketTimeouts, toe);
    } catch (IOException ie) {
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionFailure(ioFailures++, ie);
    }
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private synchronized void setupConnection() throws IOException {
  short ioFailures = 0;
  short timeoutFailures = 0;
  while (true) {
    try {
      this.socket = socketFactory.createSocket();
      this.socket.setTcpNoDelay(tcpNoDelay);
      
      /*
       * Bind the socket to the host specified in the principal name of the
       * client, to ensure Server matching address of the client connection
       * to host name in principal passed.
       */
      UserGroupInformation ticket = remoteId.getTicket();
      if (ticket != null && ticket.hasKerberosCredentials()) {
        KerberosInfo krbInfo = 
          remoteId.getProtocol().getAnnotation(KerberosInfo.class);
        if (krbInfo != null && krbInfo.clientPrincipal() != null) {
          String host = 
            SecurityUtil.getHostFromPrincipal(remoteId.getTicket().getUserName());
          
          // If host name is a valid local address then bind socket to it
          InetAddress localAddr = NetUtils.getLocalInetAddress(host);
          if (localAddr != null) {
            this.socket.bind(new InetSocketAddress(localAddr, 0));
          }
        }
      }
      
      NetUtils.connect(this.socket, server, connectionTimeout);
      if (rpcTimeout > 0) {
        pingInterval = rpcTimeout;  // rpcTimeout overwrites pingInterval
      }
      this.socket.setSoTimeout(pingInterval);
      return;
    } catch (ConnectTimeoutException toe) {
      /* Check for an address change and update the local reference.
       * Reset the failure counter if the address was changed
       */
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionTimeout(timeoutFailures++,
          maxRetriesOnSocketTimeouts, toe);
    } catch (IOException ie) {
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionFailure(ioFailures++, ie);
    }
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
private 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(true);
      
      if (tcpLowLatency) {
        /*
         * This allows intermediate switches to shape IPC traffic
         * differently from Shuffle/HDFS DataStreamer traffic.
         *
         * IPTOS_RELIABILITY (0x04) | IPTOS_LOWDELAY (0x10)
         *
         * Prefer to optimize connect() speed & response latency over net
         * throughput.
         */
        this.socket.setTrafficClass(0x04 | 0x10);
        this.socket.setPerformancePreferences(1, 2, 0);
      }

      /*
       * Bind the socket to the host specified in the principal name of the
       * client, to ensure Server matching address of the client connection
       * to host name in principal passed.
       */
      UserGroupInformation ticket = remoteId.getTicket();
      if (ticket != null && ticket.hasKerberosCredentials()) {
        KerberosInfo krbInfo =
                remoteId.getProtocol().getAnnotation(KerberosInfo.class);
        if (krbInfo != null && krbInfo.clientPrincipal() != null) {
          String host =
                  SecurityUtil.getHostFromPrincipal(remoteId.getTicket().getUserName());

          // If host name is a valid local address then bind socket to it
          InetAddress localAddr = NetUtils.getLocalInetAddress(host);
          if (localAddr != null) {
            this.socket.bind(new InetSocketAddress(localAddr, 0));
          }
        }
      }

      NetUtils.connect(this.socket, server, connectionTimeout);
      this.socket.setSoTimeout(soTimeout);
      return;
    } catch (ConnectTimeoutException toe) {
      /* Check for an address change and update the local reference.
       * Reset the failure counter if the address was changed
       */
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionTimeout(timeoutFailures++,
          maxRetriesOnSocketTimeouts, toe);
    } catch (IOException ie) {
      if (updateAddress()) {
        timeoutFailures = ioFailures = 0;
      }
      handleConnectionFailure(ioFailures++, ie);
    }
  }
}
 

import org.apache.hadoop.net.ConnectTimeoutException; //导入依赖的package包/类
@Override
public RetryAction shouldRetry(Exception e, int retries,
    int failovers, boolean isIdempotentOrAtMostOnce) throws Exception {
  if (failovers >= maxFailovers) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
        "failovers (" + failovers + ") exceeded maximum allowed ("
        + maxFailovers + ")");
  }
  if (retries - failovers > maxRetries) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0, "retries ("
        + retries + ") exceeded maximum allowed (" + maxRetries + ")");
  }

  if (e instanceof ConnectException ||
      e instanceof EOFException ||
      e instanceof NoRouteToHostException ||
      e instanceof UnknownHostException ||
      e instanceof StandbyException ||
      e instanceof ConnectTimeoutException ||
      isWrappedStandbyException(e)) {
    return new RetryAction(RetryAction.RetryDecision.FAILOVER_AND_RETRY,
        getFailoverOrRetrySleepTime(failovers));
  } else if (e instanceof RetriableException
      || getWrappedRetriableException(e) != null) {
    // RetriableException or RetriableException wrapped 
    return new RetryAction(RetryAction.RetryDecision.RETRY,
          getFailoverOrRetrySleepTime(retries));
  } else if (e instanceof InvalidToken) {
    return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
        "Invalid or Cancelled Token");
  } else if (e instanceof SocketException
      || (e instanceof IOException && !(e instanceof RemoteException))) {
    if (isIdempotentOrAtMostOnce) {
      return RetryAction.FAILOVER_AND_RETRY;
    } else {
      return new RetryAction(RetryAction.RetryDecision.FAIL, 0,
          "the invoked method is not idempotent, and unable to determine "
              + "whether it was invoked");
    }
  } else {
      return fallbackPolicy.shouldRetry(e, retries, failovers,
          isIdempotentOrAtMostOnce);
  }
}