private static boolean isIPv6Address(String input) { return isIPv6StdAddress(input) || isIPv6HexCompressedAddress(input); }
@Override public void onThrowable(Throwable t) { IOException e = t instanceof IOException ? (IOException) t : new IOException(t); if (retryHandler.shouldRetry(request, e)) { retryHandler.retry(); } else { future.setException(e); } } }
@Override public HttpResponse onCompleted(Response ningResponse) throws Exception { AbstractHttpResponse response = new NingHttpResponse(request, ningResponse, mapper); if ("snappy".equals(ningResponse.getHeader(HttpHeaders.CONTENT_ENCODING))) { response = new SnappyHttpResponseWrapper(response); } if (retryHandler.shouldRetry(request, response)) { retryHandler.retry(); } else { future.setNonnull(response); } return response; }
private ListenableFuture<HttpResponse> internalExecute(HttpRequest request, Options options, Callback callback) { Preconditions.checkNotNull(request); Preconditions.checkNotNull(options); Preconditions.checkNotNull(callback); NingRetryHandler retryHandler = new NingRetryHandler(defaultOptions.mergeFrom(options)); NingFuture future = new NingFuture(callback); final NingCompletionHandler completionHandler = new NingCompletionHandler(request, future, retryHandler, mapper); final Request ningRequest = requestConverter.convert(request); Runnable runnable = new Runnable() { @Override public void run() { try { ningClient.executeRequest(ningRequest, completionHandler); } catch (RuntimeException e) { completionHandler.onThrowable(e); } } }; retryHandler.setRetryRunnable(runnable); runnable.run(); return future; }
private void verify(String host, X509Certificate cert) throws SSLException { List<String> cns = getCNs(cert); List<String> subjectAlts = getSubjectAlts(cert, host); boolean doWildcard = parts.length >= 3 && parts[0].endsWith("*") && acceptableCountryWildcard(cn) && !isIPAddress(host);
public NingAsyncHttpClient(HttpConfig config) { Preconditions.checkNotNull(config); NettyAsyncHttpProviderConfig nettyConfig = new NettyAsyncHttpProviderConfig(); int workerThreads = Math.min(Runtime.getRuntime().availableProcessors(), 4); this.workerExecutorService = newWorkerThreadPool(workerThreads); this.channelFactory = newSocketChannelFactory(this.workerExecutorService, workerThreads); nettyConfig.setSocketChannelFactory(this.channelFactory); nettyConfig.setNettyTimer(TIMER); AsyncHttpClientConfig ningConfig = new AsyncHttpClientConfig.Builder() .addRequestFilter(new ThrottleRequestFilter(config.getMaxConnections())) .addRequestFilter(new AcceptEncodingRequestFilter()) .setMaxConnectionsPerHost(config.getMaxConnectionsPerHost()) .setConnectTimeout(config.getConnectTimeoutMillis()) .setRequestTimeout(config.getRequestTimeoutMillis()) .setReadTimeout(config.getRequestTimeoutMillis()) .setMaxRedirects(config.getMaxRedirects()) .setFollowRedirect(config.isFollowRedirects()) .setHostnameVerifier(new NingHostnameVerifier(config.getSSLConfig())) .setSSLContext(NingSSLContext.forConfig(config.getSSLConfig())) .setAsyncHttpClientProviderConfig(nettyConfig) .setUserAgent(config.getUserAgent()) .setIOThreadMultiplier(1) .build(); this.ningClient = new com.ning.http.client.AsyncHttpClient(ningConfig); this.requestConverter = new NingHttpRequestConverter(config.getObjectMapper()); this.defaultOptions = config.getOptions(); this.mapper = config.getObjectMapper(); }
private static boolean isIPAddress(@Nullable String hostname) { return hostname != null && (isIPv4Address(hostname) || isIPv6Address(hostname)); }
public void retry() { RETRY_EXECUTOR.schedule(retryRunnable(), computeBackoff(currentRetries.incrementAndGet()), TimeUnit.MILLISECONDS); }
@Override public boolean shouldRetry(HttpRequest request, IOException exception) { return retriesRemaining() && options.getRetryStrategy().shouldRetry(request, exception); }
public NingFuture(Callback callback) { this.callback = new CallbackWrapper(Preconditions.checkNotNull(callback)); }
@Override public boolean verify(String host, SSLSession session) { if (acceptAllSSL) { return true; } else { try { Certificate[] certs = session.getPeerCertificates(); X509Certificate x509 = (X509Certificate) certs[0]; verify(host, x509); return true; } catch(SSLException e) { return false; } } }
@Override public void run() { try { ningClient.executeRequest(ningRequest, completionHandler); } catch (RuntimeException e) { completionHandler.onThrowable(e); } } };
private static SSLContext acceptAllSSLContext() { try { SSLContext sslcontext = SSLContext.getInstance("SSL"); sslcontext.init(null, new TrustManager[]{ new AcceptAllTrustManager() }, new SecureRandom()); return sslcontext; } catch (GeneralSecurityException e) { throw new RuntimeException(e); } }
public boolean setNonnull(HttpResponse response) { Preconditions.checkNotNull(response); if (set(response)) { callback.completed(response); return true; } else { return false; } }
private static List<String> getSubjectAlts(X509Certificate cert, @Nullable String hostname) { int subjectType; if (isIPAddress(hostname)) { subjectType = 7; } else { subjectType = 2; } LinkedList<String> subjectAltList = new LinkedList<String>(); try { for (List<?> aC : cert.getSubjectAlternativeNames()) { int type = ((Integer) aC.get(0)); if (type == subjectType) { String s = (String) aC.get(1); if (s != null) { subjectAltList.add(s); } } } } catch(CertificateParsingException cpe) { // ignored } return subjectAltList; }
public NingHttpResponse(HttpRequest request, Response ningResponse, ObjectMapper mapper) throws IOException { this.request = request; this.statusCode = ningResponse.getStatusCode(); this.headers = convertHeaders(ningResponse.getHeaders()); this.responseStream = ningResponse.getResponseBodyAsStream(); this.mapper = mapper; }
public static SSLContext forConfig(SSLConfig config) { if (config.isAcceptAllSSL()) { return acceptAllSSLContext(); } else { try { SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(config.getKeyManagers(), config.getTrustManagers(), null); return sslContext; } catch (GeneralSecurityException e) { throw new RuntimeException(e); } } }
@Override public boolean shouldRetry(HttpRequest request, HttpResponse response) { return retriesRemaining() && options.getRetryStrategy().shouldRetry(request, response); }