Java Examples for com.ning.http.client.AsyncHttpClient

public static void main(final String[] args) throws Exception {
    final AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    asyncHttpClient.prepareGet("https://www.google.co.nz/").execute(new AsyncCompletionHandler<Response>() {

        @Override
        public Response onCompleted(final Response response) throws Exception {
            // System.out.println(response.getResponseBody());
            return response;
        }
    });
}

public static String asyncHttpGet(String url) {
    String body = "";
    try {
        AsyncHttpClientConfig cf = new AsyncHttpClientConfig.Builder().setFollowRedirects(true).setAllowPoolingConnection(true).setUserAgent(userAgent).build();
        AsyncHttpClient asyncHttpClient = new AsyncHttpClient(cf);
        Future<Response> f = asyncHttpClient.prepareGet(url).execute();
        Response r = f.get();
        body = (r.getResponseBody());
        asyncHttpClient.close();
    } catch (Exception e) {
    }
    return body;
}

@Test
public void canServePushedFiles() throws IOException, ExecutionException, InterruptedException {
    //
    // I don't think we can test this completely without some changes to the mock server, because we have no way
    // of pausing the test while the push is in progress. Once the push is over, the file isn't actually there for
    // us to fetch any more. We can however test the access and error conditions, which comprise most of the logic.
    //
    int gitBridgePort = 33873;
    int mockServerPort = 3873;
    MockSnapshotServer server = new MockSnapshotServer(mockServerPort, getResource("/canServePushedFiles").toFile());
    server.start();
    server.setState(states.get("canServePushedFiles").get("state"));
    GitBridgeApp wlgb = new GitBridgeApp(new String[] { makeConfigFile(gitBridgePort, mockServerPort) });
    wlgb.run();
    File dir = folder.newFolder();
    File testprojDir = cloneRepository("testproj", gitBridgePort, dir);
    assertTrue(FileUtil.gitDirectoriesAreEqual(getResource("/canServePushedFiles/state/testproj"), testprojDir.toPath()));
    runtime.exec("touch push.tex", null, testprojDir).waitFor();
    runtime.exec("git add -A", null, testprojDir).waitFor();
    runtime.exec("git commit -m \"push\"", null, testprojDir).waitFor();
    Process gitPush = runtime.exec("git push", null, testprojDir);
    int pushExitCode = gitPush.waitFor();
    assertEquals(0, pushExitCode);
    // With no key, we should get a 404.
    String url = "http://127.0.0.1:" + gitBridgePort + "/api/testproj/push.tex";
    Response response = new AsyncHttpClient().prepareGet(url).execute().get();
    assertEquals(404, response.getStatusCode());
    // With an invalid project and no key, we should get a 404.
    url = "http://127.0.0.1:" + gitBridgePort + "/api/notavalidproject/push.tex";
    response = new AsyncHttpClient().prepareGet(url).execute().get();
    assertEquals(404, response.getStatusCode());
    // With a bad key for a valid project, we should get a 404.
    url = "http://127.0.0.1:" + gitBridgePort + "/api/testproj/push.tex?key=notavalidkey";
    response = new AsyncHttpClient().prepareGet(url).execute().get();
    assertEquals(404, response.getStatusCode());
    // With a bad key for an invalid project, we should get a 404.
    url = "http://127.0.0.1:" + gitBridgePort + "/api/notavalidproject/push.tex?key=notavalidkey";
    response = new AsyncHttpClient().prepareGet(url).execute().get();
    assertEquals(404, response.getStatusCode());
    wlgb.stop();
}

@Test(groups = "standalone")
public void testCertAuth() throws Exception {
    AsyncHttpClientConfig cfg = super.builder().setSSLContext(CertUtil.sslContext(keystorePath, keystorePass, alias)).build();
    client = new AsyncHttpClient(cfg);
    Response response = execute(client.prepareGet(url("content", "test")));
    assertEquals(200, response.getStatusCode());
    assertEquals("test", response.getResponseBody());
}

@BeforeClass
public static void setUp() throws Exception {
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    Request request = asyncHttpClient.prepareGet("http://localhost:" + getUiPort() + "/backend/config/transaction?agent-id=" + agentId).build();
    Response response = asyncHttpClient.executeRequest(request).get();
    JsonNode responseNode = new ObjectMapper().readTree(response.getResponseBody());
    String version = responseNode.get("version").asText();
    request = asyncHttpClient.preparePost("http://localhost:" + getUiPort() + "/backend/config/transaction?agent-id=" + agentId).setBody("{\"slowThresholdMillis\":0,\"profilingIntervalMillis\":10," + "\"captureThreadStats\":false,\"version\":\"" + version + "\"}").build();
    int statusCode = asyncHttpClient.executeRequest(request).get().getStatusCode();
    if (statusCode != 200) {
        asyncHttpClient.close();
        throw new AssertionError("Unexpected status code: " + statusCode);
    }
    for (int i = 0; i < 3; i++) {
        container.executeNoExpectedTrace(JdbcServlet.class);
        container.executeNoExpectedTrace(ErrorServlet.class);
    }
    // wait until above transactions are reported in UI
    Stopwatch stopwatch = Stopwatch.createStarted();
    Set<String> transactionNames = Sets.newHashSet();
    while (stopwatch.elapsed(SECONDS) < 30) {
        long from = System.currentTimeMillis() - HOURS.toMillis(2);
        long to = from + HOURS.toMillis(4);
        request = asyncHttpClient.prepareGet("http://localhost:" + getUiPort() + "/backend/transaction/summaries?agent-rollup-id=" + agentId + "&transaction-type=Web&from=" + from + "&to=" + to + "&sort-order=total-time&limit=10").build();
        response = asyncHttpClient.executeRequest(request).get();
        responseNode = new ObjectMapper().readTree(response.getResponseBody());
        for (JsonNode transactionNode : responseNode.get("transactions")) {
            transactionNames.add(transactionNode.get("transactionName").asText());
        }
        if (transactionNames.contains("/jdbcservlet") && transactionNames.contains("/errorservlet")) {
            break;
        }
        Thread.sleep(10);
    }
    asyncHttpClient.close();
    if (!transactionNames.contains("/jdbcservlet") || !transactionNames.contains("/errorservlet")) {
        throw new AssertionError("Timed out waiting for /jdbcservlet and /errorservlet to both" + " show up in sidebar");
    }
    Executors.newSingleThreadExecutor().submit(new Callable<Void>() {

        @Override
        public Void call() throws Exception {
            container.executeNoExpectedTrace(SleepServlet.class);
            return null;
        }
    });
}

@Before
public void setUp() throws Exception {
    final Constructor<AsyncLobClient> ctor = AsyncLobClient.class.getDeclaredConstructor(AsyncHttpClient.class, String.class);
    ctor.setAccessible(true);
    this.lobClient = ctor.newInstance(httpClient, baseUrl);
    when(httpClient.prepareGet(anyString())).thenReturn(builder);
    when(builder.setQueryParams(any(FluentStringsMap.class))).thenReturn(builder);
    Lob.setApiVersion("lol");
    AsyncLobClient.create("lol", new AsyncHttpClientConfig.Builder().build());
}

@Override
public void setup(ProfilerPluginSetupContext context) {
    transformTemplate.transform("com.ning.http.client.AsyncHttpClient", new TransformCallback() {

        @Override
        public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
            InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer);
            target.addInterceptor("com.navercorp.pinpoint.plugin.ning.asynchttpclient.interceptor.ExecuteRequestInterceptor");
            return target.toBytecode();
        }
    });
}

@Before
public void setUp() throws Exception {
    final AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    reader = new MavenRepositoryReader(asyncHttpClient);
    // Create a Jetty server with a handler that returns the content of the
    // given target (i.e. an emulated html, S3Repo, etc, file from the test
    // resources)
    Handler handler = new AbstractHandler() {

        public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException {
            String path = target;
            if (path.endsWith("/") && StringUtils.isNotEmpty(request.getParameter("prefix"))) {
                String prefix = request.getParameter("prefix");
                path = path + prefix.replaceAll("/", "-");
            } else if (target.endsWith("/")) {
                // might need welcome pages later.
                path += "root";
            }
            response.setStatus(HttpServletResponse.SC_OK);
            InputStream stream = this.getClass().getResourceAsStream(path);
            // we need to fall back to the file name that matches
            if (stream == null && path.endsWith("root")) {
                path = target;
                stream = this.getClass().getResourceAsStream(path);
            }
            if (stream == null) {
                System.out.println("Error handling: " + path);
            }
            StringBuilder result = new StringBuilder();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line = null;
            while ((line = reader.readLine()) != null) {
                result.append(line).append(System.getProperty("line.separator"));
            }
            response.getWriter().println(result.toString());
            ((Request) request).setHandled(true);
        }
    };
    // We choose an arbitrary server port
    server = new Server(0);
    // Assign the handler of incoming requests
    server.setHandler(handler);
    server.start();
    // connect to the server in the tests
    for (Connector connector : server.getConnectors()) {
        nameOfConnector = connector.getName();
        // We only need one connector name (and there should only be
        break;
    // one...)
    }
}

@Override
public void setup(ProfilerPluginSetupContext context) {
    transformTemplate.transform("com.ning.http.client.AsyncHttpClient", new TransformCallback() {

        @Override
        public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
            InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer);
            target.addInterceptor("com.navercorp.pinpoint.plugin.ning.asynchttpclient.interceptor.ExecuteRequestInterceptor");
            return target.toBytecode();
        }
    });
}

public static final AsyncHttpClient createDefaultAsyncHttpClient(int requestTimeout) {
    NettyAsyncHttpProviderConfig nettyConfig = new NettyAsyncHttpProviderConfig();
    nettyConfig.addProperty("child.tcpNoDelay", "true");
    nettyConfig.addProperty("child.keepAlive", "true");
    AsyncHttpClientConfig.Builder b = new AsyncHttpClientConfig.Builder();
    b.setFollowRedirect(true).setMaxRequestRetry(-1).setConnectTimeout(-1).setReadTimeout(requestTimeout);
    AsyncHttpClientConfig config = b.setAsyncHttpClientProviderConfig(nettyConfig).build();
    return new AsyncHttpClient(config);
}

/**
     * Retrieve the OAuth2.0 access token from the remote token endpoint
     * using pre-configured clientId/clientSecret.
     */
private OAuth2Token retrieveAccessToken(String username, String password) {
    AsyncHttpClient client = new AsyncHttpClient();
    BoundRequestBuilder request = client.preparePost(this.accessTokenEndPoint);
    request.setHeader(Http.CONTENT_TYPE, Http.FORM);
    request.setHeader(Http.ACCEPT, Http.JSON);
    request.addParameter(GRANT_TYPE_PARAMETER_NAME, PASSWORD_PARAMETER_VALUE);
    request.addParameter(CLIENT_ID_PARAMETER_NAME, clientId);
    request.addParameter(CLIENT_SECRET_PARAMETER_NAME, clientSecret);
    request.addParameter(USERNAME_PARAMETER_NAME, username);
    request.addParameter(PASSWORD_PARAMETER_NAME, password);
    Response response;
    OAuth2Token token;
    try {
        response = request.execute().get();
        token = JsonHelper.deserialize(response.getResponseBody("UTF-8"), OAuth2Token.class);
        acquireTime = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());
    } catch (InterruptedException e) {
        throw new SerializationException(e);
    } catch (ExecutionException e) {
        throw new SerializationException(e);
    } catch (IOException e) {
        throw new SerializationException(e);
    }
    return token;
}

@Provides
@Singleton
@Named(BARAGON_SERVICE_HTTP_CLIENT)
public AsyncHttpClient providesHttpClient(HttpClientConfiguration config) {
    AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder();
    builder.setMaxRequestRetry(config.getMaxRequestRetry());
    builder.setRequestTimeoutInMs(config.getRequestTimeoutInMs());
    builder.setFollowRedirects(true);
    builder.setConnectionTimeoutInMs(config.getConnectionTimeoutInMs());
    builder.setUserAgent(config.getUserAgent());
    return new AsyncHttpClient(builder.build());
}

private void executeRequest(AsyncHttpClient.BoundRequestBuilder requestBuilder, final TransportResponseHandler handler) throws IOException {
    try {
        conLock.acquire();
        requestBuilder.execute(new AsyncCompletionHandler<Void>() {

            @Override
            public void onThrowable(Throwable t) {
                conLock.release();
                handler.onThrowable(t);
            }

            @Override
            public Void onCompleted(Response response) throws Exception {
                conLock.release();
                handler.onResponse(response.getStatusCode(), response.getStatusText(), response.getResponseBodyAsStream());
                return null;
            }
        });
    } catch (InterruptedException e) {
        handler.onThrowable(new RuntimeException("Interrupted acquiring connection lock"));
    }
}

@Test
public void shouldDoNothingIfNotEnabled() throws Exception {
    // given
    addEnvironment(context, "edison.serviceregistry.enabled=false");
    context.register(AsyncHttpClient.class);
    context.register(ApplicationInfoConfiguration.class);
    context.register(AsyncHttpRegistryClient.class);
    context.refresh();
    // when
    RegistryClient bean = context.getBean(RegistryClient.class);
    assertThat(bean.isRunning(), is(false));
}

/**
    *
    * @param request
    * @throws InterruptedException
    * @throws ExecutionException
    * @throws TimeoutException
    * @throws IOException
    */
protected void executeRequest(AsyncHttpClient client, Request request) throws InterruptedException, ExecutionException, TimeoutException, IOException {
    final CountDownLatch l = new CountDownLatch(1);
    client.executeRequest(request, new AsyncCompletionHandlerBase() {

        @Override
        public Response onCompleted(Response response) throws Exception {
            Assert.assertEquals(200, response.getStatusCode());
            //System.out.println(response.getResponseBody());
            l.countDown();
            return super.onCompleted(response);
        }
    }).get(3, TimeUnit.SECONDS);
    if (!l.await(1000, TimeUnit.SECONDS)) {
        Assert.fail("Timeout out");
    }
    client.close();
}

@Override
public RestClientResponse doPost(String url, KanbaneryResource resource) {
    AsyncHttpClient.BoundRequestBuilder requestBuilder = asyncHttpClient.preparePost(url);
    authorize(requestBuilder);
    String requestBody = encodedBodyGenerator.asString(resource);
    log.info("Generated request body is: '{}'", requestBody);
    setFormUrlEncodedBody(requestBuilder, requestBody);
    RestClientResponse response = execute(requestBuilder);
    verifyResponseCode(response);
    if (log.isDebugEnabled()) {
        log.debug("Got response for creating resource: {}", response.getResponseBody());
    }
    return response;
}

public static void push(String ip, String port, final ContainerRoot model) throws IOException, ExecutionException, InterruptedException {
    AsyncHttpClientConfig cf = new AsyncHttpClientConfig.Builder().build();
    final AsyncHttpClient c = new AsyncHttpClient(cf);
    WebSocket websocket = c.prepareGet("ws://" + ip + ":" + port).execute(new WebSocketUpgradeHandler.Builder().addWebSocketListener(new WebSocketTextListener() {

        @Override
        public void onMessage(String message) {
        }

        @Override
        public void onFragment(String s, boolean b) {
        }

        @Override
        public void onOpen(WebSocket websocket) {
            Protocol.PushMessage pushMessage = new Protocol.PushMessage(saver.serialize(model));
            websocket.sendTextMessage(pushMessage.toRaw());
        //websocket.sendTextMessage(saver.serialize(model));
        }

        @Override
        public void onClose(WebSocket websocket) {
        }

        @Override
        public void onError(Throwable t) {
        }
    }).build()).get();
}

@Test(timeOut = 20000)
public void testPut() throws Throwable {
    logger.info("running test: testPut");
    AsyncHttpClient c = new AsyncHttpClient();
    Response r = c.preparePut(targetUrl + "/createAddressBook/myBook").addHeader("Accept", acceptHeader).setBody("{\"entries\":\"foo - bar - \"}").execute().get();
    assertNotNull(r);
    assertEquals(r.getStatusCode(), 201);
    c.close();
}

@Test
public void basicHTML() throws Exception {
    String url = AsyncEmbeddedJsonStatusBlockCrawler.getUrl(1121915133L, "jkrums");
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    AsyncHttpClient.BoundRequestBuilder request = asyncHttpClient.prepareGet(url);
    Future<Response> f = request.execute();
    Response response = f.get();
    // Make sure status is OK.
    String html = response.getResponseBody("UTF-8");
    assertTrue(html != null);
}

@PostConstruct
public void initAHC() throws MalformedURLException {
    AsyncHttpClientConfig.Builder b = new AsyncHttpClientConfig.Builder();
    b.setFollowRedirects(true).setIdleConnectionTimeoutInMs(-1).setRequestTimeoutInMs(-1).setUserAgent("Zodiark/1.1");
    NettyAsyncHttpProviderConfig nettyConfig = new NettyAsyncHttpProviderConfig();
    nettyConfig.addProperty("child.tcpNoDelay", "true");
    nettyConfig.addProperty("child.keepAlive", "true");
    dbLocation = dbTarget.toURL().toString();
    if (dbLocation.endsWith("/")) {
        dbLocation.substring(0, dbLocation.length() - 1);
    }
    client = new AsyncHttpClient(b.setAsyncHttpClientProviderConfig(nettyConfig).build());
    logger.debug("AHC Client ready", client);
}

Request createPostRequest(final File file) {
    AsyncHttpClient.BoundRequestBuilder requestBuilder = client.preparePost(collectorURI).setBody(file).setHeader("Content-Type", // zero-bytes-copy
    headers.get(eventType));
    /*
         * Need to ensure we won't be using a single connection indefinitely,
         * to ensure load balancing works.
         */
    if (httpConnectionExpiration.isExpired()) {
        requestBuilder = requestBuilder.setHeader("Connection", "close");
    }
    return requestBuilder.build();
}

@Test
public void testSimpleGet() throws Exception {
    server.handle(Method.GET, "/").with(200, "text/plain", "Hello");
    /* 
         * we're using the ning.com AsyncHttpClient, check it out: 
         * https://github.com/AsyncHttpClient/async-http-client 
         */
    Response resp = new AsyncHttpClient().prepareGet("http://localhost:8080/").execute().get();
    assertEquals("Hello", resp.getResponseBody().trim());
}

@Override
public void init(final ServletConfig config) throws ServletException {
    this.config = config;
    // Don't limit the number of connections per host
    // See https://github.com/ning/async-http-client/issues/issue/28
    final AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder();
    builder.setMaximumConnectionsPerHost(-1);
    builder.setAllowPoolingConnection(true);
    builder.setExecutorService(Executors.newCachedThreadPool("HttpProxyServlet-AsyncHttpClient"));
    builder.setUserAgent("ning-service/1.0");
    client = new AsyncHttpClient(builder.build());
    config.getServletContext().log("Created new HttpProxyServlet");
}

private <T> Future<T> doExecuteAsync(String userAgent, Map<String, String> headers, Verb httpVerb, String completeUrl, BodySetter bodySetter, Object bodyContents, OAuthAsyncRequestCallback<T> callback, OAuthRequest.ResponseConverter<T> converter) {
    AsyncHttpClient.BoundRequestBuilder boundRequestBuilder;
    switch(httpVerb) {
        case GET:
            boundRequestBuilder = client.prepareGet(completeUrl);
            break;
        case POST:
            boundRequestBuilder = client.preparePost(completeUrl);
            break;
        case PUT:
            boundRequestBuilder = client.preparePut(completeUrl);
            break;
        case DELETE:
            boundRequestBuilder = client.prepareDelete(completeUrl);
            break;
        default:
            throw new IllegalArgumentException("message build error: unknown verb type");
    }
    if (httpVerb.isPermitBody()) {
        if (!headers.containsKey(CONTENT_TYPE)) {
            boundRequestBuilder = boundRequestBuilder.addHeader(CONTENT_TYPE, DEFAULT_CONTENT_TYPE);
        }
        boundRequestBuilder = bodySetter.setBody(boundRequestBuilder, bodyContents);
    }
    for (Map.Entry<String, String> header : headers.entrySet()) {
        boundRequestBuilder.addHeader(header.getKey(), header.getValue());
    }
    if (userAgent != null) {
        boundRequestBuilder.setHeader(OAuthConstants.USER_AGENT_HEADER_NAME, userAgent);
    }
    return boundRequestBuilder.execute(new OAuthAsyncCompletionHandler<>(callback, converter));
}

private <T> Future<T> doExecuteAsync(String userAgent, Map<String, String> headers, Verb httpVerb, String completeUrl, BodySetter bodySetter, Object bodyContents, OAuthAsyncRequestCallback<T> callback, OAuthRequest.ResponseConverter<T> converter) {
    AsyncHttpClient.BoundRequestBuilder boundRequestBuilder;
    switch(httpVerb) {
        case GET:
            boundRequestBuilder = client.prepareGet(completeUrl);
            break;
        case POST:
            boundRequestBuilder = client.preparePost(completeUrl);
            break;
        case PUT:
            boundRequestBuilder = client.preparePut(completeUrl);
            break;
        case DELETE:
            boundRequestBuilder = client.prepareDelete(completeUrl);
            break;
        default:
            throw new IllegalArgumentException("message build error: unknown verb type");
    }
    if (httpVerb.isPermitBody()) {
        if (!headers.containsKey(CONTENT_TYPE)) {
            boundRequestBuilder = boundRequestBuilder.addHeader(CONTENT_TYPE, DEFAULT_CONTENT_TYPE);
        }
        boundRequestBuilder = bodySetter.setBody(boundRequestBuilder, bodyContents);
    }
    for (Map.Entry<String, String> header : headers.entrySet()) {
        boundRequestBuilder.addHeader(header.getKey(), header.getValue());
    }
    if (userAgent != null) {
        boundRequestBuilder.setHeader(OAuthConstants.USER_AGENT_HEADER_NAME, userAgent);
    }
    return boundRequestBuilder.execute(new OAuthAsyncCompletionHandler<>(callback, converter));
}

private <T> Future<T> doExecuteAsync(String userAgent, Map<String, String> headers, Verb httpVerb, String completeUrl, BodySetter bodySetter, Object bodyContents, OAuthAsyncRequestCallback<T> callback, OAuthRequest.ResponseConverter<T> converter) {
    AsyncHttpClient.BoundRequestBuilder boundRequestBuilder;
    switch(httpVerb) {
        case GET:
            boundRequestBuilder = client.prepareGet(completeUrl);
            break;
        case POST:
            boundRequestBuilder = client.preparePost(completeUrl);
            break;
        case PUT:
            boundRequestBuilder = client.preparePut(completeUrl);
            break;
        case DELETE:
            boundRequestBuilder = client.prepareDelete(completeUrl);
            break;
        default:
            throw new IllegalArgumentException("message build error: unknown verb type");
    }
    if (httpVerb.isPermitBody()) {
        if (!headers.containsKey(CONTENT_TYPE)) {
            boundRequestBuilder = boundRequestBuilder.addHeader(CONTENT_TYPE, DEFAULT_CONTENT_TYPE);
        }
        boundRequestBuilder = bodySetter.setBody(boundRequestBuilder, bodyContents);
    }
    for (Map.Entry<String, String> header : headers.entrySet()) {
        boundRequestBuilder.addHeader(header.getKey(), header.getValue());
    }
    if (userAgent != null) {
        boundRequestBuilder.setHeader(OAuthConstants.USER_AGENT_HEADER_NAME, userAgent);
    }
    return boundRequestBuilder.execute(new OAuthAsyncCompletionHandler<>(callback, converter));
}

@Override
public void configure(Binder binder) {
    binder.bind(HostAndPort.class).annotatedWith(named(HTTP_HOST_AND_PORT)).toProvider(SingularityHostAndPortProvider.class).in(Scopes.SINGLETON);
    binder.bind(LeaderLatch.class).to(SingularityLeaderLatch.class).in(Scopes.SINGLETON);
    binder.bind(CuratorFramework.class).toProvider(SingularityCuratorProvider.class).in(Scopes.SINGLETON);
    Multibinder<ConnectionStateListener> connectionStateListeners = Multibinder.newSetBinder(binder, ConnectionStateListener.class);
    connectionStateListeners.addBinding().to(SingularityAbort.class).in(Scopes.SINGLETON);
    Multibinder<LeaderLatchListener> leaderLatchListeners = Multibinder.newSetBinder(binder, LeaderLatchListener.class);
    leaderLatchListeners.addBinding().to(SingularityLeaderController.class).in(Scopes.SINGLETON);
    binder.bind(SingularityDriverManager.class).in(Scopes.SINGLETON);
    binder.bind(SingularityLeaderController.class).in(Scopes.SINGLETON);
    if (configuration.getSmtpConfigurationOptional().isPresent()) {
        binder.bind(SingularityMailer.class).to(SmtpMailer.class).in(Scopes.SINGLETON);
    } else {
        binder.bind(SingularityMailer.class).toInstance(NoopMailer.getInstance());
    }
    binder.bind(SingularitySmtpSender.class).in(Scopes.SINGLETON);
    binder.bind(MailTemplateHelpers.class).in(Scopes.SINGLETON);
    binder.bind(SingularityExceptionNotifier.class).in(Scopes.SINGLETON);
    binder.bind(LoadBalancerClient.class).to(LoadBalancerClientImpl.class).in(Scopes.SINGLETON);
    binder.bind(SingularityMailRecordCleaner.class).in(Scopes.SINGLETON);
    binder.bind(SingularityWebhookPoller.class).in(Scopes.SINGLETON);
    binder.bind(SingularityAbort.class).in(Scopes.SINGLETON);
    binder.bind(SingularityExceptionNotifierManaged.class).in(Scopes.SINGLETON);
    binder.bind(SingularityWebhookSender.class).in(Scopes.SINGLETON);
    binder.bind(SingularityUsageHelper.class).in(Scopes.SINGLETON);
    binder.bind(NotifyingExceptionMapper.class).in(Scopes.SINGLETON);
    binder.bind(ObjectMapper.class).toProvider(DropwizardObjectMapperProvider.class).in(Scopes.SINGLETON);
    binder.bind(MetricRegistry.class).toProvider(DropwizardMetricRegistryProvider.class).in(Scopes.SINGLETON);
    binder.bind(AsyncHttpClient.class).to(SingularityAsyncHttpClient.class).in(Scopes.SINGLETON);
    binder.bind(ServerProvider.class).in(Scopes.SINGLETON);
    binder.bind(SingularityDropwizardHealthcheck.class).in(Scopes.SINGLETON);
    binder.bindConstant().annotatedWith(Names.named(SERVER_ID_PROPERTY)).to(UUID.randomUUID().toString());
    binder.bind(SingularityManagedScheduledExecutorServiceFactory.class).in(Scopes.SINGLETON);
    binder.bind(ScheduledExecutorService.class).annotatedWith(HEALTHCHECK_THREADPOOL_NAMED).toProvider(new SingularityManagedScheduledExecutorServiceProvider(configuration.getHealthcheckStartThreads(), configuration.getThreadpoolShutdownDelayInSeconds(), "healthcheck")).in(Scopes.SINGLETON);
    binder.bind(ScheduledExecutorService.class).annotatedWith(NEW_TASK_THREADPOOL_NAMED).toProvider(new SingularityManagedScheduledExecutorServiceProvider(configuration.getCheckNewTasksScheduledThreads(), configuration.getThreadpoolShutdownDelayInSeconds(), "check-new-task")).in(Scopes.SINGLETON);
    binder.bind(SingularityGraphiteReporterManaged.class).in(Scopes.SINGLETON);
    binder.bind(SingularityMesosStatusUpdateHandler.class).in(Scopes.SINGLETON);
    if (configuration.isCacheOffers()) {
        binder.bind(OfferCache.class).to(SingularityOfferCache.class).in(Scopes.SINGLETON);
    } else {
        binder.bind(OfferCache.class).to(SingularityNoOfferCache.class).in(Scopes.SINGLETON);
    }
}

public void connect() {
    try {
        if (c != null && !c.isClosed()) {
            log.debug("Already connected, so diconnecting first.");
            disconnect();
        }
        c = new AsyncHttpClient();
        c.prepareGet("ws://localhost:8080/vlove/s/agent").execute(new WebSocketUpgradeHandler.Builder().addWebSocketListener(new AgentWebSocketListener(this, reader)).build()).get();
        log.debug("Agent connected to server.");
    } catch (Exception ex) {
        try {
            reader.println("Could not establish WebSocketConnection.  " + ex.getMessage());
            reader.flush();
        } catch (IOException e) {
        }
    }
}

private void uploadOVFPackageInstance(final String idEnterprise, final TemplateDto diskInfo, final File diskFile, final boolean blocking) throws IOException, InterruptedException, ExecutionException {
    final String ovfsposturl = String.format("%s/erepos/%s/templates", TestServerListener.BASE_URI, idEnterprise);
    AsyncHttpClient httpClient = uploadClient();
    ListenableFuture<com.ning.http.client.Response> resFuture = httpClient.executeRequest(uploadParts(ovfsposturl, diskInfo, diskFile));
    if (blocking) {
        com.ning.http.client.Response res = resFuture.get();
        if (res.getStatusCode() / 200 != 1) {
            throw new RuntimeException("Can't upload " + res.getStatusText());
        }
        httpClient.close();
    }
// TODO add callbacks
}

@Test(expected = SunCertPathBuilderException.class)
public void failsOnSelfSignedCertificate() throws Throwable {
    try {
        ProxyConfiguration proxy = Jenkins.getInstance().proxy;
        URL url = new URL("https://letsencrypt.org");
        HttpURLConnection connection = (HttpURLConnection) (proxy == null ? url.openConnection() : url.openConnection(proxy.createProxy("self-signed.badssl.com")));
        connection.setRequestMethod("HEAD");
        connection.setConnectTimeout(30000);
        connection.connect();
        throw new AssumptionViolatedException("The certificate for self-signed.badssl.com is not trusted");
    } catch (SSLHandshakeException e) {
    } catch (SocketTimeoutException e) {
        throw new AssumptionViolatedException("We can connect to self-signed.badssl.com", e);
    }
    AsyncHttpClient ahc = AHC.instance();
    ListenableFuture<Response> response = ahc.prepareGet("https://self-signed.badssl.com/").execute();
    try {
        response.get();
    } catch (ExecutionException e) {
        throw e.getCause().getCause().getCause().getCause().getCause();
    }
    fail("Self Signed certificate accepted");
}

@Test(timeOut = 20000)
public void testSuspendTimeout() {
    logger.info("running test: testSuspendTimeout");
    AsyncHttpClient c = new AsyncHttpClient();
    try {
        long t1 = System.currentTimeMillis();
        Response r = c.prepareGet(urlTarget).execute().get(10, TimeUnit.SECONDS);
        assertNotNull(r);
        assertEquals(r.getStatusCode(), 200);
        String resume = r.getResponseBody();
        assertEquals(resume, "resume");
        long current = System.currentTimeMillis() - t1;
        assertTrue(current > 5000 && current < 10000);
    } catch (Exception e) {
        logger.error("test failed", e);
        fail(e.getMessage());
    }
    c.close();
}

@Test
public void basicRestPercolationTest() throws ExecutionException, InterruptedException, IOException {
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    final String docId = "docId";
    logger.info("--> Add dummy doc");
    client.admin().indices().prepareDelete("_all").execute().actionGet();
    client.prepareIndex("test", "type", "1").setSource("field1", "value", "field2", "value").execute().actionGet();
    logger.info("--> register query1 with highlights");
    client.prepareIndex("test", BatchPercolatorService.TYPE_NAME, "1").setSource(getSource(termQuery("field1", "fox"), new HighlightBuilder().field("field1").preTags("<b>").postTags("</b>"))).execute().actionGet();
    logger.info("--> register query2 with highlights");
    client.prepareIndex("test", BatchPercolatorService.TYPE_NAME, "2").setSource(getSource(termQuery("field2", "meltwater"), new HighlightBuilder().requireFieldMatch(true).order("score").highlightQuery(termQuery("field2", "meltwater")).field("field2").preTags("<b>").postTags("</b>"))).execute().actionGet();
    logger.info("--> Doing percolation with Rest API");
    BytesReference source = new BatchPercolateSourceBuilder().addDoc(docBuilder().setDoc(jsonBuilder().startObject().field("_id", docId).field("field1", "the fox is here").field("field2", "meltwater percolator").endObject())).toXContent(JsonXContent.contentBuilder(), EMPTY_PARAMS).bytes();
    Response restResponse = asyncHttpClient.preparePost("http://localhost:9200/test/type/_batchpercolate").setHeader("Content-type", "application/json").setBody(source.toUtf8()).execute().get();
    assertThat(restResponse.getStatusCode(), equalTo(200));
    String responseBody = restResponse.getResponseBody();
    List<String> results = JsonPath.read(responseBody, "$.results");
    assertThat(results.size(), is(1));
    String matchedDoc = JsonPath.read(responseBody, "$.results[0].doc");
    assertThat(matchedDoc, is(docId));
    List<String> matches = JsonPath.read(responseBody, "$.results[0].matches");
    assertThat(matches.size(), is(2));
    assertThat(JsonPath.<List<String>>read(responseBody, "$.results[0].matches[?(@.query_id==1)].query_id").get(0), is("1"));
    assertThat(JsonPath.<List<String>>read(responseBody, "$.results[0].matches[?(@.query_id==1)].highlights.field1[0]").get(0), is("the <b>fox</b> is here"));
    assertThat(JsonPath.<List<String>>read(responseBody, "$.results[0].matches[?(@.query_id==2)].query_id").get(0), is("2"));
    assertThat(JsonPath.<List<String>>read(responseBody, "$.results[0].matches[?(@.query_id==2)].highlights.field2[0]").get(0), is("<b>meltwater</b> percolator"));
}

// note: if called from base-class constructor, couldn't sub-class; hence just make static
private static AsyncHttpClient createHttpClient() {
    // Don't limit the number of connections per host
    // See https://github.com/ning/async-http-client/issues/issue/28
    final AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder();
    builder.setMaximumConnectionsPerHost(-1);
    return new AsyncHttpClient(builder.build());
}

/**
     * Create a default AsyncHttpClient client handler.
     *
     * @return a default AsyncHttpClient client handler.
     */
private static AhcClientHandler createDefaultClientHander(final ClientConfig cc) {
    if (AhcConfig.class.isAssignableFrom(cc.getClass()) || DefaultAhcConfig.class.isAssignableFrom(cc.getClass())) {
        final AhcConfig c = AhcConfig.class.cast(cc);
        return new AhcClientHandler(new AsyncHttpClient(c.getAsyncHttpClientConfigBuilder().build()), c);
    } else {
        throw new IllegalStateException("Client Config Type not supported");
    }
}

/**
     * Retrieve the underlying Grizzly {@link AsyncHttpClient} instance from
     * {@link org.glassfish.jersey.client.JerseyClient} or {@link org.glassfish.jersey.client.JerseyWebTarget}
     * configured to use {@code GrizzlyConnectorProvider}.
     *
     * @param component {@code JerseyClient} or {@code JerseyWebTarget} instance that is configured to use
     *                  {@code GrizzlyConnectorProvider}.
     * @return underlying Grizzly {@code AsyncHttpClient} instance.
     *
     * @throws java.lang.IllegalArgumentException in case the {@code component} is neither {@code JerseyClient}
     *                                            nor {@code JerseyWebTarget} instance or in case the component
     *                                            is not configured to use a {@code GrizzlyConnectorProvider}.
     * @since 2.8
     */
public static AsyncHttpClient getHttpClient(Configurable<?> component) {
    if (!(component instanceof Initializable)) {
        throw new IllegalArgumentException(LocalizationMessages.INVALID_CONFIGURABLE_COMPONENT_TYPE(component.getClass().getName()));
    }
    final Initializable<?> initializable = (Initializable<?>) component;
    Connector connector = initializable.getConfiguration().getConnector();
    if (connector == null) {
        initializable.preInitialize();
        connector = initializable.getConfiguration().getConnector();
    }
    if (connector instanceof GrizzlyConnector) {
        return ((GrizzlyConnector) connector).getGrizzlyClient();
    }
    throw new IllegalArgumentException(LocalizationMessages.EXPECTED_CONNECTOR_PROVIDER_NOT_USED());
}

@Before
public void setUp() throws Exception {
    LogManager.getLogManager().reset();
    SLF4JBridgeHandler.install();
    final MetricRegistry registry = new MetricRegistry();
    metricRegistry = registry;
    final Map<String, String> initParams = new HashMap<>();
    initParams.put(ResourceConfig.PROPERTY_RESOURCE_FILTER_FACTORIES, HttpStatusCodeCounterResourceFilterFactory.class.getCanonicalName());
    initParams.put(ResourceConfig.FEATURE_DISABLE_WADL, "true");
    Injector injector = Guice.createInjector(new AbstractModule() {

        @Override
        protected void configure() {
            binder().requireExplicitBindings();
            install(new ResourceMethodWrappedDispatchModule());
            install(new ServletModule() {

                @Override
                protected void configureServlets() {
                    serve("/*").with(GuiceContainer.class, initParams);
                }
            });
            install(new JerseyServletModule());
            bind(GuiceFilter.class);
            bind(GuiceContainer.class);
            bind(EnabledOnClass.class);
            bind(DisabledOnClass.class);
            bind(EnabledOnClassDisabledOnMethod.class);
            install(new ConfigModuleBuilder().build());
            install(new ResourceMethodMetricsModule());
            bind(MetricRegistry.class).annotatedWith(JerseyResourceMetrics.class).toInstance(registry);
        }
    });
    httpClient = new AsyncHttpClient();
    server = getServer(injector.getInstance(GuiceFilter.class));
    server.start();
    consoleReporter = ConsoleReporter.forRegistry(registry).build();
}

@Test(groups = "slow")
public void testJerseyIntegration() throws Exception {
    final BaseServerModuleBuilder builder = new BaseServerModuleBuilder();
    builder.addJaxrsResource("org.killbill.commons.skeleton.modules");
    final Server server = startServer(builder.build(), new HelloModule());
    final AsyncHttpClient client = new AsyncHttpClient();
    final Future<Response> responseFuture = client.prepareGet("http://127.0.0.1:" + ((NetworkConnector) server.getConnectors()[0]).getPort() + "/hello/alhuile/").execute();
    final String body = responseFuture.get().getResponseBody();
    Assert.assertEquals(body, "Hello alhuile");
    server.stop();
}

@Override
public void prepare() {
    Builder builder = new AsyncHttpClientConfig.Builder();
    AsyncHttpClientConfig asyncConfig = builder.setAllowPoolingConnection(true).setConnectionTimeoutInMs(HTTP_TIMEOUT).setRequestTimeoutInMs(HTTP_TIMEOUT).setFollowRedirects(false).build();
    _asyncHttpClient = new AsyncHttpClient(asyncConfig);
}

@Test
public void shouldGetWsUrl() throws Exception {
    final AsyncHttpClient c = new AsyncHttpClient();
    //get a sessionid
    Response r1 = c.prepareGet("http://localhost:" + restPort + SIGNALK_AUTH + "/demo/pass").execute().get();
    assertEquals(200, r1.getStatusCode());
    Response r2 = c.prepareGet("http://localhost:" + restPort + SIGNALK_DISCOVERY).setCookies(r1.getCookies()).execute().get();
    Json json = Json.read(r2.getResponseBody());
    assertEquals("ws://localhost:" + wsPort + SIGNALK_WS, json.at("endpoints").at("v1").at(websocketUrl).asString());
    c.close();
}

private void upload(String baseUrl, File zipFile, String slootContentJson) throws IllegalArgumentException, IOException, CoreException {
    final AsyncHttpClient client = new AsyncHttpClient();
    /* Send the Sloot Content */
    AsyncCompletionHandler<String> handler = new AsyncCompletionHandler<String>() {

        @Override
        public String onCompleted(Response resp) throws Exception {
            System.err.println("Response: " + resp.getResponseBody());
            return null;
        }
    };
    String url = String.format("http://%s/api/slootContent", baseUrl);
    client.preparePost(url).addHeader("Content-Type", "application/json").setBody(slootContentJson).execute(handler);
    /* Send all the generated files */
    IPath genPath = toExport.getFullPath().append("tmp").append(slootProjectProvider.collectionTitle);
    IFolder tmpFolder = ResourcesPlugin.getWorkspace().getRoot().getFolder(genPath);
    final String putUrl = url + "/" + slootProjectProvider.collectionTitle;
    if (!tmpFolder.exists()) {
        return;
    }
    FilePart zipFilePart = new FilePart(zipFile.getName(), zipFile);
    client.preparePut(putUrl).addHeader("Content-Type", "multipart/form-data").addBodyPart(zipFilePart).execute();
}

@Override
protected void openConnectionInternal() throws ConnectionException, AuthenticationException {
    String protocol = UrlUtils.getProtocol(getRepository().getUrl());
    protocol = UrlUtils.normalizeProtocol(protocol);
    AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder();
    RealmBuilder realmBuilder = null;
    if (authenticationInfo != null) {
        String username = authenticationInfo.getUserName();
        String password = authenticationInfo.getPassword();
        realmBuilder = (new Realm.RealmBuilder()).setPrincipal(username).setPassword(password).setUsePreemptiveAuth(false).setEnconding(credentialEncoding);
        builder.setRealm(realmBuilder.build());
    }
    ProxyInfo proxyInfo = getProxyInfo(protocol, getRepository().getHost());
    if (proxyInfo == null && "https".equalsIgnoreCase(protocol)) {
        proxyInfo = getProxyInfo("http", getRepository().getHost());
    }
    if (proxyInfo != null) {
        String proxyUsername = proxyInfo.getUserName();
        String proxyPassword = proxyInfo.getPassword();
        String proxyHost = proxyInfo.getHost();
        int proxyPort = proxyInfo.getPort();
        String proxyNtlmHost = proxyInfo.getNtlmHost();
        String proxyNtlmDomain = proxyInfo.getNtlmDomain();
        if (StringUtils.isNotEmpty(proxyNtlmHost)) {
            proxyHost = proxyNtlmDomain;
        }
        if (proxyHost != null) {
            ProxyServer proxyServer = new ProxyServer(proxyHost, proxyPort);
            if (proxyUsername != null && proxyPassword != null) {
                proxyServer = new ProxyServer(proxyHost, proxyPort, proxyUsername, proxyPassword);
                proxyServer.setEncoding(credentialEncoding);
            } else {
                proxyServer = new ProxyServer(proxyHost, proxyPort);
            }
            if (StringUtils.isNotEmpty(proxyNtlmDomain)) {
                proxyServer.setNtlmDomain(proxyNtlmDomain);
            }
            builder.setProxyServer(proxyServer);
        }
    }
    builder.setConnectionTimeoutInMs(getTimeout());
    builder.setRequestTimeoutInMs(getTimeout());
    builder.setFollowRedirects(maxRedirections > 0);
    builder.setMaximumNumberOfRedirects(maxRedirections);
    builder.setUserAgent("Apache-Maven");
    builder.setCompressionEnabled(true);
    if (httpHeaders != null && httpHeaders.getProperty("User-Agent") != null) {
        builder.setUserAgent(httpHeaders.getProperty("User-Agent"));
    }
    AsyncHttpClientConfig config = builder.build();
    // NOTE: Explicitly specify provider to workaround class loading bug in ahc:1.4.0
    httpClient = new AsyncHttpClient(new NettyAsyncHttpProvider(config), config);
}

public void connect() throws IOException {
    checkState(socket == null, "the client is already listening to events");
    checkState(asyncClient == null, "the client is already listening to events");
    LOG.fine("Connecting to " + endpoint + "...");
    AtmosphereClient client = ClientFactory.getDefault().newClient(AtmosphereClient.class);
    AtmosphereRequest request = //
    client.newRequestBuilder().method(//
    METHOD.GET).uri(//
    endpoint + "?Content-Type=application/json").transport(//
    TRANSPORT.SSE).transport(TRANSPORT.LONG_POLLING).build();
    AsyncHttpClientConfig.Builder config = new AsyncHttpClientConfig.Builder();
    config.setRequestTimeoutInMs(-1);
    config.setIdleConnectionTimeoutInMs(-1);
    if (sslConfiguration != null) {
        config.setHostnameVerifier(sslConfiguration.hostnameVerifier());
        config.setSSLContext(sslConfiguration.sslContext());
    }
    config.setRealm(//
    new Realm.RealmBuilder().setPrincipal(//
    username).setPassword(//
    password).setUsePreemptiveAuth(//
    true).setScheme(//
    Realm.AuthScheme.BASIC).build());
    asyncClient = new AsyncHttpClient(config.build());
    socket = client.create(client.newOptionsBuilder().runtime(asyncClient).build());
    socket.open(request);
    configure();
    LOG.fine("Connected!");
}

@Test
public void testRouterAsync() throws Exception {
    int numElements = 123;
    AsyncHttpClientConfig.Builder configBuilder = new AsyncHttpClientConfig.Builder();
    final AsyncHttpClient asyncHttpClient = new AsyncHttpClient(new NettyAsyncHttpProvider(configBuilder.build()), configBuilder.build());
    final CountDownLatch latch = new CountDownLatch(numElements);
    final AtomicInteger numSuccessfulRequests = new AtomicInteger(0);
    for (int i = 0; i < numElements; ++i) {
        final int elem = i;
        final Request request = new RequestBuilder("GET").setUrl(resolveURI(DEFAULT_SERVICE, String.format("%s/%s-%d", "/v1/ping", "async", i))).build();
        asyncHttpClient.executeRequest(request, new AsyncCompletionHandler<Void>() {

            @Override
            public Void onCompleted(Response response) throws Exception {
                latch.countDown();
                Assert.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatusCode());
                numSuccessfulRequests.incrementAndGet();
                return null;
            }

            @Override
            public void onThrowable(Throwable t) {
                LOG.error("Got exception while posting {}", elem, t);
                latch.countDown();
            }
        });
        // Sleep so as not to overrun the server.
        TimeUnit.MILLISECONDS.sleep(1);
    }
    latch.await();
    asyncHttpClient.close();
    Assert.assertEquals(numElements, numSuccessfulRequests.get());
    // we use sticky endpoint strategy so the sum of requests from the two gateways should be NUM_ELEMENTS
    Assert.assertTrue(numElements == (defaultServer1.getNumRequests() + defaultServer2.getNumRequests()));
}

public void setup() {
    config.setRequestTimeout(this.getCfg().requestTimeout()).setConnectTimeout(this.getCfg().connectionTimeout()).setReadTimeout(this.getCfg().readTimeout());
    asyncHttpClient = new AsyncHttpClient(config.build());
    get("/" + this.getCfg().routeName(), ( req,  res) -> {
        log().log(Level.INFO, req.body());
        String file = req.queryParams("file");
        if (file == null || file == "") {
            file = this.getCfg().fileToPost();
        }
        Path toPost = Paths.get(file);
        if (!Files.exists(toPost)) {
            log().warning("no content to be processed; check if the file: " + this.getCfg().fileToPost() + " exists and is readable.");
            res.status(HttpServletResponse.SC_NO_CONTENT);
        } else {
            String url = req.queryParams("post_url");
            if (url == null || url == "") {
                url = this.getCfg().remoteUrl();
            }
            String authHeaderName = this.getAuthHeaderName();
            ListenableFuture<Response> future = null;
            if (req.params().containsKey(authHeaderName)) {
                String authHeaderValue = req.queryParams(authHeaderName);
                if (!StringUtils.isEmpty(this.getAuthHeaderRename())) {
                    authHeaderName = this.getAuthHeaderRename();
                }
                future = postIt(toPost, url, authHeaderName, authHeaderValue);
            } else {
                future = postIt(toPost, url);
            }
            if (future != null) {
                Response r = future.get();
                r.getCookies().stream().map( cookie -> {
                    res.cookie(cookie.getName(), cookie.getValue());
                    return res;
                });
                r.getHeaders().keySet().stream().map( h -> {
                    String v = r.getHeaders(h).stream().map( hv -> hv).collect(Collectors.joining("; "));
                    res.header(h, v);
                    return res;
                });
                res.status(200);
                res.body(r.getResponseBody());
                res.type(r.getContentType());
                if (r.getStatusCode() == this.getCfg().remoteStatusExpected()) {
                    log().info(r.getResponseBody());
                    res.status(200);
                } else {
                    log().warning(r.getResponseBody());
                    res.status(r.getStatusCode());
                }
                return res.body();
            }
        }
        return "";
    });
}

@Override
public void run() throws InterruptedException {
    while (true) {
        AsyncHttpClient client = new AsyncHttpClient();
        WebSocketListener listener = new Listener();
        WebSocketUpgradeHandler handler = new WebSocketUpgradeHandler.Builder().addWebSocketListener(listener).build();
        WebSocket socket = null;
        boolean connectionSuccessful = true;
        // Try to create a websocket connection
        try {
            socket = client.prepareGet(url).execute(handler).get();
            LOG.info("Successfully connected to {}.", url);
        } catch (ExecutionException e) {
            LOG.error("Could not connect to {}: {}", url, e.getCause().getMessage());
            connectionSuccessful = false;
        } catch (Exception e) {
            LOG.error("Unknown exception when trying to connect to {}:", url, e);
            connectionSuccessful = false;
        }
        // If connection was unsuccessful, wait some time before trying again
        if (!connectionSuccessful) {
            Thread.sleep(reconnectPeriodSec * 1000);
        }
        // Keep checking whether connection is still open
        while (true) {
            if (socket == null || !socket.isOpen()) {
                // The connection is closed somehow, try to reconnect
                if (connectionSuccessful) {
                    LOG.warn("Connection to {} was lost. Trying to reconnect...", url);
                }
                break;
            }
            Thread.sleep(CHECK_CONNECTION_PERIOD_SEC * 1000);
        }
        client.close();
    }
}

@Override
public void run() throws InterruptedException {
    while (true) {
        AsyncHttpClient client = new AsyncHttpClient();
        WebSocketListener listener = new Listener();
        WebSocketUpgradeHandler handler = new WebSocketUpgradeHandler.Builder().addWebSocketListener(listener).build();
        WebSocket socket = null;
        boolean connectionSuccessful = true;
        // Try to create a websocket connection
        try {
            socket = client.prepareGet(url).execute(handler).get();
            LOG.info("Successfully connected to {}.", url);
        } catch (ExecutionException e) {
            LOG.error("Could not connect to {}: {}", url, e.getCause().getMessage());
            connectionSuccessful = false;
        } catch (Exception e) {
            LOG.error("Unknown exception when trying to connect to {}:", url, e);
            connectionSuccessful = false;
        }
        // If connection was unsuccessful, wait some time before trying again
        if (!connectionSuccessful) {
            Thread.sleep(reconnectPeriodSec * 1000);
        }
        // Keep checking whether connection is still open
        while (true) {
            if (socket == null || !socket.isOpen()) {
                // The connection is closed somehow, try to reconnect
                if (connectionSuccessful) {
                    LOG.warn("Connection to {} was lost. Trying to reconnect...", url);
                }
                break;
            }
            Thread.sleep(CHECK_CONNECTION_PERIOD_SEC * 1000);
        }
        client.close();
    }
}

@Test(timeout = 120000)
public void test_http_transport() throws Exception {
    InputStream is = getClass().getResourceAsStream("transport.types.manifest");
    Serializer serializer = Serializer.create(new DefaultProtocol(is, Collections.emptyList()));
    Packet packet = new Packet("login");
    packet.setValue("username", "Stan");
    Message message = Message.create(packet);
    CompletableFuture<Object> future = new CompletableFuture<>();
    Object result = practice(() -> {
        AsyncHttpClient client = newHttpClient();
        Response response = handshake(client, serializer, httpAddress()).get();
        Identifier connectionId = null;
        try (AutoClosableDecoder decoder = decodeResponse(serializer, response)) {
            if (decoder.readBoolean()) {
                connectionId = decoder.readObject();
            }
            if (!(decoder.readObject() instanceof Handshake)) {
                fail("No HandshakeResponse received");
            }
        }
        AtomicBoolean stop = new AtomicBoolean(false);
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(2);
        startLongPolling(client, serializer, connectionId, ses, stop, ( m) -> {
            stop.set(true);
            System.out.println(m);
            future.complete(m);
        }, httpAddress());
        writeRequest(client, serializer, connectionId, message, null, httpAddress());
        return future.get(120, TimeUnit.SECONDS);
    }, ssl(), ServerTransports.HTTP_TRANSPORT);
    assertEquals(message, result);
}

private void initClient(HttpConnectionParams httpConnParams) throws IOException {
    if (httpAsyncClient != null) {
        return;
    }
    if (httpAsyncClient == null) {
        synchronized (AsyncHttpConnection.class) {
            if (httpAsyncClient == null) {
                LOG.info("Initializing AsyncClient (TezBodyDeferringAsyncHandler)");
                AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder();
                if (httpConnParams.isSslShuffle()) {
                    //Configure SSL
                    SSLFactory sslFactory = httpConnParams.getSslFactory();
                    Preconditions.checkArgument(sslFactory != null, "SSLFactory can not be null");
                    sslFactory.configure(builder);
                }
                /**
           * TODO : following settings need fine tuning.
           * Change following config to accept common thread pool later.
           * Change max connections based on the total inputs (ordered & unordered). Need to tune
           * setMaxConnections & addRequestFilter.
           */
                builder.setAllowPoolingConnection(httpConnParams.isKeepAlive()).setAllowSslConnectionPool(httpConnParams.isKeepAlive()).setCompressionEnabled(false).setMaximumConnectionsPerHost(//.addRequestFilter(new ThrottleRequestFilter())
                1).setConnectionTimeoutInMs(httpConnParams.getConnectionTimeout()).setRequestTimeoutInMs(httpConnParams.getReadTimeout()).setUseRawUrl(true).build();
                httpAsyncClient = new AsyncHttpClient(builder.build());
            }
        }
    }
}

@Test
public void testGetAll() throws InterruptedException, ExecutionException, IOException {
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    Future<Response> f = asyncHttpClient.prepareGet("http://localhost:8080/employeesmanager/employees").execute();
    Response r = f.get();
    String responseString = r.getResponseBody();
    asyncHttpClient.close();
    List<Employee> actual = JsonTransformer.toObjectList(responseString, Employee.class);
    for (Employee employee : actual) {
        assertTrue(employees.contains(employee));
    }
}

private Response processRequest(final ClientRequest cr, final HandlerContext context) throws IOException {
    AsyncHttpClient asyncHttpClient = openConnection(cr);
    NonCloseableOutputStream ncos = new NonCloseableOutputStream();
    OutputStream os = adaptOutputStream(ncos, cr, context.getOutputStreamAdapters());
    Request request = setupHttpRequest(cr, ncos, os);
    Response response;
    final AtomicReference<Throwable> failureHolder = new AtomicReference<Throwable>();
    try {
        response = asyncHttpClient.executeRequest(request, new AsyncCompletionHandlerBase() {

            @Override
            public Response onCompleted(final Response response) throws Exception {
                logger.trace("Response received: {}", response);
                return super.onCompleted(response);
            }

            public void onThrowable(Throwable t) {
                logger.trace("Request failed", t);
                failureHolder.set(t);
            }
        }).get();
    } catch (InterruptedException e) {
        throw (IOException) new IOException().initCause(e);
    } catch (ExecutionException e) {
        throw (IOException) new IOException().initCause(e);
    }
    // If a failure occurred, then decode and re-throw
    Throwable failure = failureHolder.get();
    if (failure != null) {
        if (failure instanceof RuntimeException) {
            throw (RuntimeException) failure;
        }
        if (failure instanceof IOException) {
            throw (IOException) failure;
        }
        throw (IOException) new IOException().initCause(failure);
    }
    return response;
}

/**
     * Command for executing Urban Airship requests asynchronously with a ResponseCallback.
     *
     * @param request An Urban Airship request object.
     * @param callback A ResponseCallback instance.
     * @return A client response future.
     */
public <T> Future<Response> executeAsync(final Request<T> request, final ResponseCallback callback) throws IOException {
    AsyncHttpClient.BoundRequestBuilder requestBuilder;
    String uri;
    try {
        uri = request.getUri(baseUri).toString();
    } catch (URISyntaxException e) {
        log.error("Failed to generate a request URI from base URI " + baseUri.toString(), e);
        throw new RuntimeException(e);
    }
    switch(request.getHttpMethod()) {
        case GET:
            requestBuilder = client.prepareGet(uri);
            break;
        case PUT:
            requestBuilder = client.preparePut(uri);
            break;
        case POST:
            requestBuilder = client.preparePost(uri);
            break;
        case DELETE:
            requestBuilder = client.prepareDelete(uri);
            break;
        default:
            requestBuilder = client.prepareGet(uri);
            break;
    }
    // Headers
    Map<String, String> requestHeaders = request.getRequestHeaders();
    if (requestHeaders != null) {
        for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
            requestBuilder.addHeader(entry.getKey(), entry.getValue());
        }
    }
    // Auth
    requestBuilder.setHeader("Authorization", "Basic " + BaseEncoding.base64().encode((appKey + ":" + appSecret).getBytes()));
    // Body
    String body = request.getRequestBody();
    ContentType contentType = request.getContentType();
    if (body != null && contentType != null) {
        requestBuilder.setBody(body.getBytes(contentType.getCharset()));
    }
    log.debug(String.format("Executing Urban Airship request to %s with body %s.", uri, request.getRequestBody()));
    ResponseAsyncHandler<T> handler = new ResponseAsyncHandler<>(Optional.fromNullable(callback), request.getResponseParser());
    return requestBuilder.execute(handler);
}

private AsyncHttpClient.BoundRequestBuilder prepareRequest(final String method, final ProtoHttpContent payload) throws IOException {
    final AsyncHttpClient.BoundRequestBuilder builder = client.preparePost(prefixUri + method);
    builder.addHeader("Authorization", "Bearer " + accessToken);
    builder.addHeader("Content-Type", "application/x-protobuf");
    builder.addHeader("User-Agent", USER_AGENT);
    builder.addHeader("Accept-Encoding", "gzip");
    builder.setContentLength((int) payload.getLength());
    builder.setBody(payload.getMessage().toByteArray());
    return builder;
}

@Test
public void initParamTest() throws Exception {
    final CountDownLatch l = new CountDownLatch(1);
    final AtomicBoolean b = new AtomicBoolean(false);
    Config config = new Config.Builder().port(port).host("127.0.0.1").initParam("foo", "bar").resource("/suspend", new AtmosphereHandler() {

        @Override
        public void onRequest(AtmosphereResource r) throws IOException {
            if (r.getAtmosphereConfig().getInitParameter("foo") != null) {
                b.set(true);
            }
            l.countDown();
        }

        @Override
        public void onStateChange(AtmosphereResourceEvent r) throws IOException {
        }

        @Override
        public void destroy() {
        }
    }).build();
    server = new Nettosphere.Builder().config(config).build();
    assertNotNull(server);
    server.start();
    AsyncHttpClient c = new AsyncHttpClient();
    try {
        Response r = c.prepareGet(targetUrl + "/suspend").execute().get();
        assertEquals(r.getStatusCode(), 200);
        assertEquals(b.get(), true);
    } finally {
        c.close();
    }
}

/*
     * (non-Javadoc)
     * 
     * @see akka.actor.UntypedActor#onReceive(java.lang.Object)
     */
@Override
public void onReceive(Object message) {
    try {
        // Start all workers
        if (message instanceof InitialRequestToManager) {
            director = getSender();
            logger.info("parallec task state : " + ParallelTaskState.IN_PROGRESS.toString());
            task.setState(ParallelTaskState.IN_PROGRESS);
            task.setExecuteStartTime(startTime);
            taskId = task.getTaskId();
            // assumption: at least REDUCE_LEN
            taskIdTrim = taskId.length() <= REDUCE_LEN ? taskId : taskId.substring(taskId.length() - REDUCE_LEN, taskId.length());
            httpMeta = task.getHttpMeta();
            targetHostMeta = task.getTargetHostMeta();
            final RequestProtocol requestProtocol = task.getRequestProtocol();
            // Get request parameters to construct a REST CALL
            final String requestUrlPrefixOrig = httpMeta.getRequestUrlPostfix();
            final HttpMethod httpMethod = httpMeta.getHttpMethod();
            String requestPortStrOrig = httpMeta.getRequestPort();
            final boolean pollable = httpMeta.isPollable();
            final int maxConcurrency = task.getConcurrency();
            Map<String, NodeReqResponse> nodeDataMapValid = task.getParallelTaskResult();
            logger.info("Before Safety Check: total entry count: " + nodeDataMapValid.size());
            Map<String, NodeReqResponse> nodeDataMapValidSafe = new HashMap<String, NodeReqResponse>();
            InternalDataProvider.getInstance().filterUnsafeOrUnnecessaryRequest(nodeDataMapValid, nodeDataMapValidSafe);
            logger.info("After Safety Check: total entry count in nodeDataMapValidSafe: {}", nodeDataMapValidSafe.size());
            logger.debug("maxConcurrency : {}", maxConcurrency);
            // after filter, no duplicated target hosts for this count.
            requestCount = nodeDataMapValidSafe.size();
            task.setRequestNumActual(requestCount);
            logger.info("!Obtain command request for target host meta id " + targetHostMeta.getTargetHostId() + "  with count: " + requestCount);
            // message back
            if (requestCount <= 0) {
                getSender().tell(new ResponseFromManager(requestCount), getSelf());
                logger.info("req count <=0. return");
                // not really error. just no task to run
                reply(ParallelTaskState.COMPLETED_WITHOUT_ERROR, new RuntimeException("ReqCount after trim is 0. Return."));
                return;
            }
            int sentRequestCounter = 0;
            asyncHttpClientGlobal = task.getAsyncHttpClient();
            final AsyncHttpClient asyncHttpClient = asyncHttpClientGlobal;
            // always send with valid safe data.
            for (Entry<String, NodeReqResponse> entry : nodeDataMapValidSafe.entrySet()) {
                final String targetHost = entry.getKey();
                NodeReqResponse nodeReqResponse = entry.getValue();
                final String requestContentOrig = nodeReqResponse.getRequestParameters().get(PcConstants.REQUEST_BODY_PLACE_HOLDER);
                final String requestContent = NodeReqResponse.replaceStrByMap(nodeReqResponse.getRequestParameters(), requestContentOrig);
                final String resourcePath = NodeReqResponse.replaceStrByMap(nodeReqResponse.getRequestParameters(), requestUrlPrefixOrig);
                // add support for port replacement
                final String requestPortStr = NodeReqResponse.replaceStrByMap(nodeReqResponse.getRequestParameters(), requestPortStrOrig);
                int requestPort = 80;
                try {
                    requestPort = Integer.parseInt(requestPortStr);
                } catch (NumberFormatException nfe) {
                    logger.error("Error parsing replacable port with NumberFormatException. " + "No valid port for host {}. Now use default port 80", targetHost);
                }
                // only pass when it is not in manager
                final ParallecResponseHandler handler = task.getConfig().getHandlerExecutionLocation() == HandlerExecutionLocation.MANAGER ? null : task.getHandler();
                final Map<String, Object> responseContext = task.getConfig().getHandlerExecutionLocation() == HandlerExecutionLocation.MANAGER ? null : task.getResponseContext();
                Map<String, String> httpHeaderMapLocal = new HashMap<String, String>();
                httpHeaderMapLocal.putAll(httpMeta.getHeaderMetadata().getHeaderMap());
                // 3rd, add the dynamic part ; generic var based
                // replacement.
                PcHttpUtils.replaceHttpHeaderMapNodeSpecific(httpHeaderMapLocal, nodeReqResponse.getRequestParameters());
                /**
                     * If want to print to check
                     */
                if (task.getConfig().isPrintHttpTrueHeaderMap()) {
                    for (Entry<String, String> headerEntry : httpHeaderMapLocal.entrySet()) {
                        String headerKey = headerEntry.getKey();
                        String headerValue = headerEntry.getValue();
                        nodeReqResponse.getRequestParameters().put(PcConstants.REQUEST_PARAMETER_HTTP_HEADER_PREFIX + headerKey, headerValue);
                    }
                }
                if (task.getConfig().isPrintPoller()) {
                    // put the one before encoding
                    nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_NEED_POLLER, Boolean.toString(pollable));
                }
                /**
                     * 20140310: END add pass HTTP header into Operation worker
                     * as part of the
                     */
                String targetHostNew = nodeReqResponse.getRequestParameters().get(PcConstants.UNIFORM_TARGET_HOST_VAR_WHEN_CHECK);
                if (targetHostNew != null) {
                    nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_TRUE_TARGET_NODE, targetHostNew);
                }
                final String hostUniform = (targetHostNew == null) ? null : targetHostNew;
                nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_STATUS, SingleTargetTaskStatus.IN_PROGRESS.toString());
                nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_TRUE_CONTENT, requestContent);
                // put the one before encoding
                nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_TRUE_URL, resourcePath);
                nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_TRUE_PORT, Integer.toString(requestPort));
                nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_HTTP_HEADER_META, httpMeta.getHeaderMetadata().getHeaderStr());
                long prepareRequestTime = System.currentTimeMillis();
                String prepareRequestTimeStr = PcDateUtils.getDateTimeStrStandard(new Date(prepareRequestTime));
                nodeReqResponse.getRequestParameters().put(PcConstants.NODE_REQUEST_PREPARE_TIME, prepareRequestTimeStr);
                final SshMeta sshMeta = task.getSshMeta();
                final TcpMeta tcpMeta = task.getTcpMeta();
                final UdpMeta udpMeta = task.getUdpMeta();
                final PingMeta pingMeta = task.getPingMeta();
                final ResponseHeaderMeta responseHeaderMeta = task.getHttpMeta().getResponseHeaderMeta();
                logger.debug("REQUEST GENERATED: " + (sentRequestCounter + 1) + " / " + requestCount + " after " + Double.toString((prepareRequestTime - startTime) / 1000.0) + " secs" + ":  (NOT SEND YET) " + targetHost + " at " + prepareRequestTimeStr);
                ActorRef worker = getContext().system().actorOf(Props.create(OperationWorker.class, new TaskRequest(task.getConfig().getActorMaxOperationTimeoutSec(), requestProtocol, targetHost, hostUniform, requestPort, resourcePath, requestContent, httpMethod, pollable, httpHeaderMapLocal, handler, responseContext, sshMeta, tcpMeta, udpMeta, pingMeta, responseHeaderMeta), asyncHttpClient, task.getHttpMeta().getHttpPollerProcessor()));
                workers.put(targetHost, worker);
                ++sentRequestCounter;
            }
            // end for loop
            final RequestToBatchSenderAsstManager requestToBatchSenderAsstManager = new RequestToBatchSenderAsstManager(taskId, task.getConfig().getAsstManagerRetryIntervalMillis(), new ArrayList<ActorRef>(workers.values()), getSelf(), maxConcurrency);
            batchSenderAsstManager = getContext().system().actorOf(Props.create(AssistantExecutionManager.class), "RequestToBatchSenderAsstManager-" + UUID.randomUUID().toString());
            batchSenderAsstManager.tell(requestToBatchSenderAsstManager, getSelf());
            final FiniteDuration timeOutDuration = Duration.create(task.getConfig().getTimeoutInManagerSec(), TimeUnit.SECONDS);
            timeoutMessageCancellable = getContext().system().scheduler().scheduleOnce(timeOutDuration, getSelf(), ExecutionManagerMsgType.OPERATION_TIMEOUT, getContext().system().dispatcher(), getSelf());
            logger.debug("Scheduled TIMEOUT_IN_MANAGER_SCONDS OPERATION_TIMEOUT after SEC {} ", task.getConfig().getTimeoutInManagerSec());
        } else if (message instanceof ResponseOnSingleTask) {
            ResponseOnSingleTask taskResponse = (ResponseOnSingleTask) message;
            this.responseCount += 1;
            task.setResponsedNum(responseCount);
            /**
                 * add feedback of current responseCount to asst manager
                 * ResponseCountToBatchSenderAsstManager
                 */
            final ResponseCountToBatchSenderAsstManager responseCountToBatchSenderAsstManager = new ResponseCountToBatchSenderAsstManager(this.responseCount);
            batchSenderAsstManager.tell(responseCountToBatchSenderAsstManager, getSelf());
            logger.debug("Send batchSenderAsstManager to responseCountToBatchSenderAsstManager: " + this.responseCount);
            String hostName = taskResponse.getRequest().getHost();
            if (responseMap.containsKey(hostName)) {
                logger.error("ERROR: duplicate response received {}", hostName);
            }
            responseMap.put(hostName, taskResponse);
            String responseSummary = taskResponse.isError() ? "FAIL_GET_RESPONSE: " + taskResponse.getErrorMessage() : taskResponse.getStatusCode();
            Map<String, LinkedHashSet<String>> resultMap = task.getAggregateResultMap();
            if (resultMap.containsKey(responseSummary)) {
                resultMap.get(responseSummary).add(hostName);
            } else {
                LinkedHashSet<String> set = new LinkedHashSet<String>();
                set.add(hostName);
                resultMap.put(responseSummary, set);
            }
            // save response to result map
            NodeReqResponse nrr = task.getParallelTaskResult().get(hostName);
            nrr.setSingleTaskResponse(taskResponse);
            String responseTrim = taskResponse.getResponseContent() == null ? null : taskResponse.getResponseContent().trim();
            String displayResponse = (Strings.isNullOrEmpty(responseTrim)) ? "EMPTY" : responseTrim.substring(0, Math.min(PcConstants.AGNET_RESPONSE_MAX_RESPONSE_DISPLAY_BYTE, responseTrim.length()));
            long responseReceiveTime = System.currentTimeMillis();
            // %.5g%n
            double progressPercent = (double) (responseCount) / (double) (requestCount) * 100.0;
            String responseReceiveTimeStr = PcDateUtils.getDateTimeStrStandard(new Date(responseReceiveTime));
            String secondElapsedStr = Double.toString((responseReceiveTime - startTime) / 1000.0);
            // log the first/ last 5 percent; then sample the middle
            if (requestCount < ParallecGlobalConfig.logAllResponseIfTotalLessThan || responseCount <= ParallecGlobalConfig.logAllResponseBeforeInitCount || progressPercent < ParallecGlobalConfig.logAllResponseBeforePercent || progressPercent > ParallecGlobalConfig.logAllResponseAfterPercent || responseCount % ParallecGlobalConfig.logResponseInterval == 0) {
                // percent is escaped using percent sign; hostName
                logger.info(String.format("\n[%d]__RESP_RECV_IN_MGR %d (+%d) / %d (%.5g%%)  " + "AFT %s S @ %s @ %s , TaskID : %s , CODE: %s, RESP_BRIEF: %s %s", responseCount, responseCount, requestCount - responseCount, requestCount, progressPercent, secondElapsedStr, hostName, responseReceiveTimeStr, taskIdTrim, taskResponse.getStatusCode(), displayResponse, taskResponse.getErrorMessage() == null ? "" : ", ERR: " + taskResponse.getErrorMessage()));
            }
            nrr.getRequestParameters().put(PcConstants.NODE_REQUEST_STATUS, SingleTargetTaskStatus.COMPLETED.toString());
            if (task.getConfig().getHandlerExecutionLocation() == HandlerExecutionLocation.MANAGER && task != null && task.getHandler() != null) {
                try {
                    // logger.debug("HANDLE In manager: " +
                    // taskResponse.getHost());
                    task.getHandler().onCompleted(taskResponse, task.getResponseContext());
                } catch (Exception t) {
                    logger.error("Error handling onCompleted in manager for response: {} Error {}", taskResponse.toString(), t.getLocalizedMessage());
                }
            }
            if (!task.getConfig().isSaveResponseToTask()) {
                taskResponse.setResponseContent(PcConstants.NOT_SAVED);
                taskResponse.setResponseHeaders(null);
                logger.debug("Erased single task response content and response headers to save space.");
            }
            if (this.responseCount == this.requestCount) {
                if (wasIssuedCancel) {
                    ExecutionManagerExecutionException exCanceled = new ExecutionManagerExecutionException("ExecutionManager: task was canceled by user", ManagerExceptionType.CANCEL);
                    reply(ParallelTaskState.COMPLETED_WITH_ERROR, exCanceled);
                } else {
                    reply(ParallelTaskState.COMPLETED_WITHOUT_ERROR, null);
                }
            }
        // end when all requests have resonponse
        } else if (message instanceof CancelTaskOnHostRequest) {
            CancelTaskOnHostRequest msg = (CancelTaskOnHostRequest) message;
            cancelRequestAndWorkerOnHost(msg.getTargetHosts());
        } else if (message instanceof ExecutionManagerMsgType) {
            switch((ExecutionManagerMsgType) message) {
                // reply
                case OPERATION_TIMEOUT:
                    cancelRequestAndWorkers();
                    String msg = "Execution manager timeout on whole Parallel Task.";
                    ExecutionManagerExecutionException ex = new ExecutionManagerExecutionException(msg, ManagerExceptionType.TIMEOUT);
                    logger.error(msg);
                    reply(ParallelTaskState.COMPLETED_WITH_ERROR, ex);
                    break;
                // this will wait for the works to reply.
                case CANCEL:
                    cancelRequestAndWorkers();
                    wasIssuedCancel = true;
                    break;
                default:
                    break;
            }
        } else {
            logger.error("Unhandled: " + message);
            unhandled(message);
        }
    } catch (Exception t) {
        logger.error("Command Manager error: " + t + " trace: ", t);
        task.getTaskErrorMetas().add(new TaskErrorMeta(TaskErrorType.COMMAND_MANAGER_ERROR, t == null ? "NA" : t.getLocalizedMessage()));
        reply(ParallelTaskState.COMPLETED_WITH_ERROR, t);
    }
}

/**
         * Adds the queryString-part of the url to the BoundRequestBuilder
         */
protected void addQueryString(BoundRequestBuilder requestBuilder) {
    // AsyncHttpClient is by default encoding everything in utf-8 so for us to be able to use
    // different encoding we have configured AHC to use raw urls. When using raw urls,
    // AHC does not encode url and QueryParam with utf-8 - but there is another problem:
    // If we send raw (none-encoded) url (with queryString) to AHC, it does not url-encode it,
    // but transform all illegal chars to '?'.
    // If we pre-encoded the url with QueryString before sending it to AHC, ahc will decode it, and then
    // later break it with '?'.
    // This method basically does the same as RequestBuilderBase.buildUrl() except from destroying the
    // pre-encoding
    // does url contain query_string?
    int i = url.indexOf('?');
    if (i > 0) {
        try {
            // extract query-string-part
            String queryPart = url.substring(i + 1);
            // parse queryPart - and decode it... (it is going to be re-encoded later)
            for (String param : queryPart.split("&")) {
                i = param.indexOf('=');
                String name;
                String value = null;
                if (i <= 0) {
                    // only a flag
                    name = URLDecoder.decode(param, encoding);
                } else {
                    name = URLDecoder.decode(param.substring(0, i), encoding);
                    value = URLDecoder.decode(param.substring(i + 1), encoding);
                }
                if (value == null) {
                    requestBuilder.addQueryParameter(URLEncoder.encode(name, encoding), null);
                } else {
                    requestBuilder.addQueryParameter(URLEncoder.encode(name, encoding), URLEncoder.encode(value, encoding));
                }
            }
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Error parsing query-part of url", e);
        }
    }
}

/**
         * Adds the queryString-part of the url to the BoundRequestBuilder
         */
protected void addQueryString(BoundRequestBuilder requestBuilder) {
    // AsyncHttpClient is by default encoding everything in utf-8 so for us to be able to use
    // different encoding we have configured AHC to use raw urls. When using raw urls,
    // AHC does not encode url and QueryParam with utf-8 - but there is another problem:
    // If we send raw (none-encoded) url (with queryString) to AHC, it does not url-encode it,
    // but transform all illegal chars to '?'.
    // If we pre-encoded the url with QueryString before sending it to AHC, ahc will decode it, and then
    // later break it with '?'.
    // This method basically does the same as RequestBuilderBase.buildUrl() except from destroying the
    // pre-encoding
    // does url contain query_string?
    int i = url.indexOf('?');
    if (i > 0) {
        try {
            // extract query-string-part
            String queryPart = url.substring(i + 1);
            // parse queryPart - and decode it... (it is going to be re-encoded later)
            for (String param : queryPart.split("&")) {
                i = param.indexOf('=');
                String name;
                String value = null;
                if (i <= 0) {
                    // only a flag
                    name = URLDecoder.decode(param, encoding);
                } else {
                    name = URLDecoder.decode(param.substring(0, i), encoding);
                    value = URLDecoder.decode(param.substring(i + 1), encoding);
                }
                if (value == null) {
                    requestBuilder.addQueryParameter(URLEncoder.encode(name, encoding), null);
                } else {
                    requestBuilder.addQueryParameter(URLEncoder.encode(name, encoding), URLEncoder.encode(value, encoding));
                }
            }
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Error parsing query-part of url", e);
        }
    }
}

@Override
public ListenableFuture<Orders> getOrders(long timestamp, Order.Side side, Iterable<Order.Status> status, Iterable<Order.OrderType> orderTypes, int page, int pageSize) {
    AsyncHttpClient.BoundRequestBuilder builder = httpClient.prepareGet(baseUrl + "/v1/orders").addHeader("X-Buttercoin-Date", "" + timestamp);
    if (side != null)
        builder.addQueryParam("side", side.getName());
    if (status != null && status.iterator().hasNext())
        builder.addQueryParam("status", mkString(status, ","));
    if (orderTypes != null && orderTypes.iterator().hasNext())
        builder.addQueryParam("orderType", mkString(orderTypes, ","));
    if (page > 0)
        builder.addQueryParam("page", "" + page);
    if (pageSize > 0)
        builder.addQueryParam("pageSize", "" + pageSize);
    return transform(new ListenableFutureAdapter<>(builder.setSignatureCalculator(signatureCalculator()).execute(new ThrowOnHttpFailure())), new MapResponseJson<>(objectMapper.reader(Orders.class)));
}

public void run() {
    download.setState(Transfer.State.ACTIVE);
    final String uri = validateUri(path);
    final DefaultTransferResource transferResource = new DefaultTransferResource(repository.getUrl(), path, file, download.getTrace());
    final boolean ignoreChecksum = RepositoryPolicy.CHECKSUM_POLICY_IGNORE.equals(checksumPolicy);
    CompletionHandler completionHandler = null;
    final FileLockCompanion fileLockCompanion = (file != null) ? createOrGetTmpFile(file.getPath(), allowResumable) : new FileLockCompanion(null, null);
    try {
        long length = 0;
        if (fileLockCompanion.getFile() != null) {
            fileProcessor.mkdirs(fileLockCompanion.getFile().getParentFile());
        }
        // Position the file to the end in case we are resuming an aborded download.
        final RandomAccessFile resumableFile = fileLockCompanion.getFile() == null ? null : new RandomAccessFile(fileLockCompanion.getFile(), "rw");
        if (resumableFile != null) {
            length = resumableFile.length();
        }
        FluentCaseInsensitiveStringsMap headers = new FluentCaseInsensitiveStringsMap();
        if (!useCache) {
            headers.add("Pragma", "no-cache");
        }
        headers.add("Accept", "text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2");
        headers.replaceAll(AsyncRepositoryConnector.this.headers);
        Request request = null;
        final AtomicInteger maxRequestTry = new AtomicInteger();
        AsyncHttpClient client = httpClient;
        final AtomicBoolean closeOnComplete = new AtomicBoolean(false);
        /**
                 * If length > 0, it means we are resuming a interrupted download. If that's the case,
                 * we can't re-use the current httpClient because compression is enabled, and supporting
                 * compression per request is not supported in ahc and may never has it could have
                 * a performance impact.
                 */
        if (length > 0) {
            AsyncHttpClientConfig config = createConfig(session, repository, false);
            client = new AsyncHttpClient(new NettyAsyncHttpProvider(config));
            request = client.prepareGet(uri).setRangeOffset(length).setHeaders(headers).build();
            closeOnComplete.set(true);
        } else {
            request = httpClient.prepareGet(uri).setHeaders(headers).build();
        }
        final Request activeRequest = request;
        final AsyncHttpClient activeHttpClient = client;
        completionHandler = new CompletionHandler(transferResource, httpClient, logger, RequestType.GET) {

            private final AtomicBoolean handleTmpFile = new AtomicBoolean(true);

            private final AtomicBoolean localException = new AtomicBoolean(false);

            /**
                     * {@inheritDoc}
                     */
            @Override
            public STATE onHeadersReceived(final HttpResponseHeaders headers) throws Exception {
                FluentCaseInsensitiveStringsMap h = headers.getHeaders();
                String rangeByteValue = h.getFirstValue("Content-Range");
                // Make sure the server acceptance of the range requests headers
                if (rangeByteValue != null && rangeByteValue.compareToIgnoreCase("none") != 0) {
                    resumableFile.seek(resumableFile.length());
                } else {
                    resumableFile.seek(0);
                }
                return super.onHeadersReceived(headers);
            }

            @Override
            public void onThrowable(Throwable t) {
                boolean resume = false;
                try {
                    logger.debug("onThrowable", t);
                    /**
                             * If an IOException occurs, let's try to resume the request based on how much bytes has
                             * been so far downloaded. Fail after IOException.
                             */
                    try {
                        if (!disableResumeSupport && !localException.get() && maxRequestTry.get() < maxIOExceptionRetry && isResumeWorthy(t)) {
                            logger.debug("Trying to recover from an IOException " + activeRequest);
                            maxRequestTry.incrementAndGet();
                            Request newRequest = new RequestBuilder(activeRequest).setRangeOffset(resumableFile.length()).build();
                            activeHttpClient.executeRequest(newRequest, this);
                            resume = true;
                            return;
                        }
                    } catch (Throwable rt) {
                        logger.warn("Could not resume download", rt);
                    }
                    localException.set(false);
                    if (Exception.class.isAssignableFrom(t.getClass())) {
                        exception = Exception.class.cast(t);
                    } else {
                        exception = new Exception(t);
                    }
                    if (closeOnComplete.get()) {
                        activeHttpClient.close();
                    }
                    super.onThrowable(t);
                    fireTransferFailed();
                } catch (Throwable ex) {
                    logger.warn("Unexpected exception", ex);
                } finally {
                    if (resume) {
                        return;
                    }
                    if (resumableFile != null) {
                        try {
                            resumableFile.close();
                        } catch (IOException ex) {
                        }
                    }
                    deleteFile(fileLockCompanion);
                    latch.countDown();
                    removeListeners();
                }
            }

            private void removeListeners() {
                removeTransferListener(listener);
            }

            public STATE onBodyPartReceived(final HttpResponseBodyPart content) throws Exception {
                if (status() != null && (status().getStatusCode() == 200 || status().getStatusCode() == 206)) {
                    byte[] bytes = content.getBodyPartBytes();
                    try {
                        resumableFile.write(bytes);
                    } catch (IOException ex) {
                        logger.debug("onBodyPartReceived", ex);
                        exception = ex;
                        localException.set(true);
                        throw ex;
                    }
                }
                return super.onBodyPartReceived(content);
            }

            @Override
            public Response onCompleted(Response r) throws Exception {
                try {
                    deleteFile.set(true);
                    try {
                        resumableFile.close();
                    } catch (IOException ex) {
                    }
                    final Response response = super.onCompleted(r);
                    handleResponseCode(uri, response.getStatusCode(), response.getStatusText());
                    if (!ignoreChecksum) {
                        activeHttpClient.getConfig().executorService().execute(new Runnable() {

                            public void run() {
                                try {
                                    try {
                                        Map<String, Object> checksums = ChecksumUtils.calc(fileLockCompanion.getFile(), checksumAlgos.keySet());
                                        if (!verifyChecksum(file, uri, (String) checksums.get("SHA-1"), ".sha1") && !verifyChecksum(file, uri, (String) checksums.get("MD5"), ".md5")) {
                                            throw new ChecksumFailureException("Checksum validation failed" + ", no checksums available from the repository");
                                        }
                                    } catch (ChecksumFailureException e) {
                                        if (RepositoryPolicy.CHECKSUM_POLICY_FAIL.equals(checksumPolicy)) {
                                            throw e;
                                        }
                                        if (listener != null) {
                                            listener.transferCorrupted(newEvent(transferResource, e, RequestType.GET, EventType.CORRUPTED));
                                        }
                                    }
                                } catch (Exception ex) {
                                    exception = ex;
                                } finally {
                                    if (exception == null) {
                                        try {
                                            rename(fileLockCompanion.getFile(), file);
                                            releaseLock(fileLockCompanion);
                                        } catch (IOException e) {
                                            exception = e;
                                        }
                                    } else {
                                        deleteFile(fileLockCompanion);
                                    }
                                    latch.countDown();
                                    if (closeOnComplete.get()) {
                                        activeHttpClient.close();
                                    }
                                }
                            }
                        });
                    } else {
                        rename(fileLockCompanion.getFile(), file);
                        releaseLock(fileLockCompanion);
                        handleTmpFile.set(false);
                        // asyncHttpClient.close may takes time before all connections get closed.
                        // We unlatch first.
                        latch.countDown();
                        if (closeOnComplete.get()) {
                            activeHttpClient.close();
                        }
                    }
                    removeListeners();
                    return response;
                } catch (Exception ex) {
                    exception = ex;
                    localException.set(true);
                    throw ex;
                } finally {
                    try {
                        if (handleTmpFile.get() && fileLockCompanion.getFile() != null) {
                            if (exception != null) {
                                deleteFile(fileLockCompanion);
                            } else if (ignoreChecksum) {
                                rename(fileLockCompanion.getFile(), file);
                                releaseLock(fileLockCompanion);
                            }
                        }
                    } catch (IOException ex) {
                        exception = ex;
                    }
                }
            }
        };
        try {
            if (file == null) {
                if (!resourceExist(uri)) {
                    throw new ResourceDoesNotExistException("Could not find " + uri + " in " + repository.getUrl());
                }
                latch.countDown();
            } else {
                if (listener != null) {
                    completionHandler.addTransferListener(listener);
                    listener.transferInitiated(newEvent(transferResource, null, RequestType.GET, EventType.INITIATED));
                }
                activeHttpClient.executeRequest(request, completionHandler);
            }
        } catch (Exception ex) {
            try {
                if (resumableFile != null) {
                    resumableFile.close();
                }
            } catch (IOException ex2) {
            }
            deleteFile(fileLockCompanion);
            exception = ex;
            latch.countDown();
        }
    } catch (Throwable t) {
        deleteFile(fileLockCompanion);
        try {
            if (Exception.class.isAssignableFrom(t.getClass())) {
                exception = Exception.class.cast(t);
            } else {
                exception = new Exception(t);
            }
            if (listener != null) {
                listener.transferFailed(newEvent(transferResource, exception, RequestType.GET, EventType.FAILED));
            }
        } finally {
            latch.countDown();
        }
    }
}

//ning === http://github.com/ning/async-http-client
@Test
public void doSimpleAsyncRequestTestWithNing() throws IOException, InterruptedException {
    int iterations = 100;
    final CountDownLatch latch = new CountDownLatch(iterations);
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    for (int i = 1; i <= iterations; i++) {
        asyncHttpClient.prepareGet("http://localhost:" + PORT + "/").execute(new AsyncCompletionHandler<com.ning.http.client.Response>() {

            @Override
            public com.ning.http.client.Response onCompleted(com.ning.http.client.Response response) throws Exception {
                String body = response.getResponseBody();
                assertEquals(expectedPayload, body);
                {
                    List<String> expectedHeaders = Arrays.asList(new String[] { "Server", "Date", "Content-Length", "Etag", "Connection" });
                    assertEquals(200, response.getStatusCode());
                    assertEquals(expectedHeaders.size(), response.getHeaders().size());
                    for (String header : expectedHeaders) {
                        assertTrue(response.getHeader(header) != null);
                    }
                    assertEquals(expectedPayload.length() + "", response.getHeader("Content-Length"));
                }
                latch.countDown();
                return response;
            }

            @Override
            public void onThrowable(Throwable t) {
                assertTrue(false);
            }
        });
    }
    latch.await(15 * 1000, TimeUnit.MILLISECONDS);
    assertEquals(0, latch.getCount());
}

@Override
protected HttpAsyncEngine createHttpAsyncEngine() {
    AsyncHttpClient client = new AsyncHttpClient();
    return new NingHttpAsyncEngine(client);
}

private BoundRequestBuilder clientPreparePost(String url) {
    if (this.client.isClosed()) {
        Builder builder = new AsyncHttpClientConfig.Builder();
        this.client = new AsyncHttpClient(builder.build());
    }
    return this.client.preparePost(url);
}

@Before
public void before() {
    client = new AsyncHttpClient(new AsyncHttpClientConfig.Builder().build());
}

@Override
public AsyncHttpClient getUnderlying() {
    return asyncHttpClient;
}

@Singleton
@Provides
AsyncHttpClient provideNingClient() {
    AsyncHttpClientConfig config = new AsyncHttpClientConfig.Builder().setFollowRedirects(true).build();
    return new AsyncHttpClient(config);
}

/**
   * Returns raw http client. If client has not been initialized yet
   * then new client is created with default configuration.
   * @return raw http client
   */
public static synchronized AsyncHttpClient getNingClient() {
    if (_client.get() == null) {
        initialize(new AsyncHttpClientConfig.Builder().build());
    }
    return _client.get();
}

public static int post(@Nonnull final String url, @Nonnull final JSONObject data) throws IOException, ExecutionException, InterruptedException {
    AsyncHttpClient httpClient = AHC.instance();
    ListenableFuture<Response> execute = httpClient.preparePost(url).setBodyEncoding("UTF-8").setHeader("Content-Type", "application/json; charset=UTF-8").setBody(data.toString()).execute();
    return execute.get().getStatusCode();
}

private static AsyncHttpClient newAsyncHttpClient() {
    //        return new AsyncHttpClient(new GrizzlyAsyncHttpProvider(asyncHttpClientConfig), asyncHttpClientConfig);
    return new AsyncHttpClient(new SimpleAsyncHttpProvider(asyncHttpClientConfig), asyncHttpClientConfig);
}

AsyncHttpClient createHttpClient() {
    return new AsyncHttpClient(config);
}

@Before
public void setUp() throws Exception {
    LogManager.getLogManager().reset();
    SLF4JBridgeHandler.install();
    wrapper = new StubNewRelicWrapper();
    httpClient = new AsyncHttpClient();
}

private void forwardToCluster(Request request, Response response) {
//		AsyncHttpClient c = new AsyncHttpClient();
//		c.prepareGet(null)
}

private void forwardToCluster(Request request, Response response) {
//		AsyncHttpClient c = new AsyncHttpClient();
//		c.prepareGet(null)
}

public static AsyncHttpClient getAsyncHttpClient() {
    return ASYNC_HTTP_CLIENT;
}

public AsyncHttpClient getHttpClient() {
    return client;
}

/**
	 * Get asynchronous http client
	 */
private AsyncHttpClient getAsyncHttpClient() {
    if (asyncHttpClient == null) {
        asyncHttpClient = new AsyncHttpClient();
    }
    return asyncHttpClient;
}

private AsyncHttpClient getAsyncHttpClient() {
    return client;
}

public Builder setClient(AsyncHttpClient client) {
    this.client = client;
    return this;
}