Ejemplo n.º 1
0
 public void init() throws Exception {
   client = new HttpClient();
   client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
   client.setThreadPool(new ExecutorThreadPool(4, 256, timeout, TimeUnit.SECONDS));
   client.setTimeout(timeout);
   client.start();
 }
Ejemplo n.º 2
0
  @Test
  public void testResponseHeadersAreNotRemoved() throws Exception {
    prepareProxy();
    proxyContext.stop();
    final String headerName = "X-Test";
    final String headerValue = "test-value";
    proxyContext.addFilter(
        new FilterHolder(
            new Filter() {
              @Override
              public void init(FilterConfig filterConfig) throws ServletException {}

              @Override
              public void doFilter(
                  ServletRequest request, ServletResponse response, FilterChain chain)
                  throws IOException, ServletException {
                ((HttpServletResponse) response).addHeader(headerName, headerValue);
                chain.doFilter(request, response);
              }

              @Override
              public void destroy() {}
            }),
        "/*",
        EnumSet.of(DispatcherType.REQUEST));
    proxyContext.start();
    prepareServer(new EmptyHttpServlet());

    HttpClient client = prepareClient();
    ContentResponse response =
        client.newRequest("localhost", serverConnector.getLocalPort()).send();

    Assert.assertEquals(200, response.getStatus());
    Assert.assertEquals(headerValue, response.getHeaders().get(headerName));
  }
Ejemplo n.º 3
0
  /**
   * Create a http client
   *
   * @return
   * @throws Exception
   */
  private static BayeuxClient makeClient() throws Exception {
    HttpClient httpClient = new HttpClient();
    httpClient.setConnectTimeout(connectionTimeout);
    httpClient.setTimeout(readTimeout); // TODO optional parameters
    httpClient.start();

    SoapLoginUtil.login(httpClient, userName, password);
    final String sessionId = SoapLoginUtil.getSessionId();
    String endpoint = SoapLoginUtil.getEndpoint();
    System.out.println("Login successful!\nEndpoint: " + endpoint + "\nSessionid=" + sessionId);

    Map<String, Object> options = new HashMap<String, Object>();
    options.put(ClientTransport.TIMEOUT_OPTION, readTimeout);
    LongPollingTransport transport =
        new LongPollingTransport(options, httpClient) {

          @Override
          protected void customize(ContentExchange exchange) {
            super.customize(exchange);
            exchange.addRequestHeader("Authorization", "OAuth " + sessionId);
          }
        };

    BayeuxClient client = new BayeuxClient(salesforceStreamingEndpoint(endpoint), transport);
    if (useCookies) establishCookies(client, userName, sessionId);
    return client;
  }
Ejemplo n.º 4
0
  @Test
  public void testClientExcludedHosts() throws Exception {
    prepareProxy();
    prepareServer(
        new HttpServlet() {
          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse resp)
              throws ServletException, IOException {
            if (req.getHeader("Via") != null) resp.addHeader(PROXIED_HEADER, "true");
          }
        });
    int port = serverConnector.getLocalPort();
    client
        .getProxyConfiguration()
        .getProxies()
        .get(0)
        .getExcludedAddresses()
        .add("127.0.0.1:" + port);

    // Try with a proxied host
    ContentResponse response =
        client.newRequest("localhost", port).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(response.getHeaders().containsKey(PROXIED_HEADER));

    // Try again with an excluded host
    response = client.newRequest("127.0.0.1", port).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(200, response.getStatus());
    Assert.assertFalse(response.getHeaders().containsKey(PROXIED_HEADER));
  }
Ejemplo n.º 5
0
 /** Initialize the client object */
 public StockManagerHTTPProxy(String serverAddress) throws Exception {
   setServerAddress(serverAddress);
   client = new HttpClient();
   client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
   client.setMaxConnectionsPerAddress(
       BookStoreClientConstants.CLIENT_MAX_CONNECTION_ADDRESS); // max
   // concurrent
   // connections
   // to
   // every
   // address
   client.setThreadPool(
       new QueuedThreadPool(BookStoreClientConstants.CLIENT_MAX_THREADSPOOL_THREADS)); // max
   // threads
   client.setTimeout(BookStoreClientConstants.CLIENT_MAX_TIMEOUT_MILLISECS); // seconds
   // timeout;
   // if
   // no
   // server
   // reply,
   // the
   // request
   // expires
   client.start();
 }
  @Test
  public void testSessionMigration() throws Exception {
    String contextPath = "";
    String servletMapping = "/server";
    AbstractTestServer server1 = createServer(0);
    server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);

    try {
      server1.start();
      int port1 = server1.getPort();

      AbstractTestServer server2 = createServer(0);
      server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);

      try {
        server2.start();
        int port2 = server2.getPort();

        HttpClient client = new HttpClient();
        client.start();
        try {
          // Perform one request to server1 to create a session
          int value = 1;
          Request request1 =
              client.POST(
                  "http://localhost:"
                      + port1
                      + contextPath
                      + servletMapping
                      + "?action=set&value="
                      + value);
          ContentResponse response1 = request1.send();
          assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
          String sessionCookie = response1.getHeaders().get("Set-Cookie");
          assertTrue(sessionCookie != null);
          // Mangle the cookie, replacing Path with $Path, etc.
          sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");

          // Perform a request to server2 using the session cookie from the previous request
          // This should migrate the session from server1 to server2.
          Request request2 =
              client.newRequest(
                  "http://localhost:" + port2 + contextPath + servletMapping + "?action=get");
          request2.header("Cookie", sessionCookie);
          ContentResponse response2 = request2.send();
          assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
          String response = response2.getContentAsString();
          assertEquals(response.trim(), String.valueOf(value));
        } finally {
          client.stop();
        }
      } finally {
        server2.stop();
      }
    } finally {
      server1.stop();
    }
  }
  @Test
  public void testAttributeNamesWithDots() throws Exception {
    String contextPath = "";
    String servletMapping = "/server";
    int maxInactivePeriod = 10000;
    int scavengePeriod = 20000;
    AbstractTestServer server1 = createServer(0, maxInactivePeriod, scavengePeriod);
    server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
    server1.start();
    int port1 = server1.getPort();

    AbstractTestServer server2 = createServer(0, maxInactivePeriod, scavengePeriod);
    server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
    server2.start();
    int port2 = server2.getPort();

    try {

      HttpClient client = new HttpClient();
      client.start();
      try {

        // Perform one request to server1 to create a session with attribute with dotted name
        ContentResponse response =
            client.GET("http://localhost:" + port1 + contextPath + servletMapping + "?action=init");

        assertEquals(HttpServletResponse.SC_OK, response.getStatus());

        String resp = response.getContentAsString();

        String[] sessionTestResponse = resp.split("/");
        assertEquals("a.b.c", sessionTestResponse[0]);

        String sessionCookie = response.getHeaders().get(HttpHeader.SET_COOKIE);

        assertTrue(sessionCookie != null);
        // Mangle the cookie, replacing Path with $Path, etc.
        sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");

        // Make a request to the 2nd server which will do a refresh, use TestServlet to ensure that
        // the
        // session attribute with dotted name is not removed
        Request request2 =
            client.newRequest(
                "http://localhost:" + port2 + contextPath + servletMapping + "?action=get");
        request2.header("Cookie", sessionCookie);
        ContentResponse response2 = request2.send();
        assertEquals(HttpServletResponse.SC_OK, response2.getStatus());

      } finally {
        client.stop();
      }
    } finally {
      server1.stop();
      server2.stop();
    }
  }
Ejemplo n.º 8
0
 private HttpClient prepareClient() throws Exception {
   HttpClient result = new HttpClient();
   result
       .getProxyConfiguration()
       .getProxies()
       .add(new HttpProxy("localhost", proxyConnector.getLocalPort()));
   result.start();
   return result;
 }
Ejemplo n.º 9
0
  private static HttpClient httpClient() throws Exception {
    if (_httpClient == null) {
      _httpClient = new HttpClient();
      _httpClient.setConnectorType(CONNECTOR_SELECT_CHANNEL);
      _httpClient.setConnectTimeout(TIMEOUT_CONNECT);
      _httpClient.start();
    }

    return _httpClient;
  }
  // TODO: client.start() could potentially have some side effects.
  // Need to understand more of what's going on under the hood.
  @Provides
  HttpClient provideHttpClient() {
    LOGGER.info("Providing http client for connection name " + connectionName);

    HttpClient client = new HttpClient();
    client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
    client.setConnectTimeout(timeoutOption);
    client.setTimeout(timeoutOption);

    return client;
  }
 @Override
 protected void sendContent(HttpExchange exchange, HttpContent content, Callback callback) {
   try {
     HttpClient client = getHttpChannel().getHttpDestination().getHttpClient();
     ByteBufferPool bufferPool = client.getByteBufferPool();
     ByteBuffer chunk = null;
     while (true) {
       ByteBuffer contentBuffer = content.getByteBuffer();
       boolean lastContent = content.isLast();
       HttpGenerator.Result result =
           generator.generateRequest(null, null, chunk, contentBuffer, lastContent);
       switch (result) {
         case NEED_CHUNK:
           {
             chunk = bufferPool.acquire(HttpGenerator.CHUNK_SIZE, false);
             break;
           }
         case FLUSH:
           {
             EndPoint endPoint = getHttpChannel().getHttpConnection().getEndPoint();
             if (chunk != null)
               endPoint.write(
                   new ByteBufferRecyclerCallback(callback, bufferPool, chunk),
                   chunk,
                   contentBuffer);
             else endPoint.write(callback, contentBuffer);
             return;
           }
         case SHUTDOWN_OUT:
           {
             shutdownOutput();
             break;
           }
         case CONTINUE:
           {
             break;
           }
         case DONE:
           {
             assert generator.isEnd();
             callback.succeeded();
             return;
           }
         default:
           {
             throw new IllegalStateException();
           }
       }
     }
   } catch (Exception x) {
     LOG.debug(x);
     callback.failed(x);
   }
 }
Ejemplo n.º 12
0
  /**
   * If nodeA creates a session, and just afterwards crashes, it is the only node that knows about
   * the session. We want to test that the session data is gone after scavenging.
   */
  @Test
  public void testOrphanedSession() throws Exception {
    // Disable scavenging for the first server, so that we simulate its "crash".
    String contextPath = "";
    String servletMapping = "/server";
    int inactivePeriod = 5;
    AbstractTestServer server1 = createServer(0, inactivePeriod, -1);
    server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
    try {
      server1.start();
      int port1 = server1.getPort();
      int scavengePeriod = 2;
      AbstractTestServer server2 = createServer(0, inactivePeriod, scavengePeriod);
      server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
      try {
        server2.start();
        int port2 = server2.getPort();
        HttpClient client = new HttpClient();
        client.start();
        try {
          // Connect to server1 to create a session and get its session cookie
          ContentResponse response1 =
              client.GET(
                  "http://localhost:" + port1 + contextPath + servletMapping + "?action=init");
          assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
          String sessionCookie = response1.getHeaders().getStringField("Set-Cookie");
          assertTrue(sessionCookie != null);
          // Mangle the cookie, replacing Path with $Path, etc.
          sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");

          // Wait for the session to expire.
          // The first node does not do any scavenging, but the session
          // must be removed by scavenging done in the other node.
          Thread.sleep(TimeUnit.SECONDS.toMillis(inactivePeriod + 2L * scavengePeriod));

          // Perform one request to server2 to be sure that the session has been expired
          Request request =
              client.newRequest(
                  "http://localhost:" + port2 + contextPath + servletMapping + "?action=check");
          request.header("Cookie", sessionCookie);
          ContentResponse response2 = request.send();
          assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
        } finally {
          client.stop();
        }
      } finally {
        server2.stop();
      }
    } finally {
      server1.stop();
    }
  }
  /** @throws Exception */
  public void testSessionRenewal() throws Exception {
    String contextPath = "";
    String servletMapping = "/server";
    int maxInactive = 1;
    int scavengePeriod = 3;
    _server = createServer(0, maxInactive, scavengePeriod, SessionCache.NEVER_EVICT);
    WebAppContext context = _server.addWebAppContext(".", contextPath);
    context.setParentLoaderPriority(true);
    context.addServlet(TestServlet.class, servletMapping);
    TestHttpSessionIdListener testListener = new TestHttpSessionIdListener();
    context.addEventListener(testListener);

    HttpClient client = new HttpClient();
    try {
      _server.start();
      int port = _server.getPort();

      client.start();

      // make a request to create a session
      ContentResponse response =
          client.GET("http://localhost:" + port + contextPath + servletMapping + "?action=create");
      assertEquals(HttpServletResponse.SC_OK, response.getStatus());

      String sessionCookie = response.getHeaders().get("Set-Cookie");
      assertTrue(sessionCookie != null);
      assertFalse(testListener.isCalled());

      // make a request to change the sessionid
      Request request =
          client.newRequest(
              "http://localhost:" + port + contextPath + servletMapping + "?action=renew");
      request.header("Cookie", sessionCookie);
      ContentResponse renewResponse = request.send();

      assertEquals(HttpServletResponse.SC_OK, renewResponse.getStatus());
      String renewSessionCookie = renewResponse.getHeaders().get("Set-Cookie");
      assertNotNull(renewSessionCookie);
      assertNotSame(sessionCookie, renewSessionCookie);
      assertTrue(testListener.isCalled());

      assertTrue(
          verifyChange(
              context,
              AbstractTestServer.extractSessionId(sessionCookie),
              AbstractTestServer.extractSessionId(renewSessionCookie)));
    } finally {
      client.stop();
      _server.stop();
    }
  }
Ejemplo n.º 14
0
  @Test
  public void testProxyWithRequestContentAndResponseContent() throws Exception {
    prepareProxy();
    prepareServer(
        new HttpServlet() {
          @Override
          protected void doPost(HttpServletRequest req, HttpServletResponse resp)
              throws ServletException, IOException {
            if (req.getHeader("Via") != null) resp.addHeader(PROXIED_HEADER, "true");
            IO.copy(req.getInputStream(), resp.getOutputStream());
          }
        });

    byte[] content = new byte[1024];
    new Random().nextBytes(content);
    ContentResponse response =
        client
            .newRequest("localhost", serverConnector.getLocalPort())
            .method(HttpMethod.POST)
            .content(new BytesContentProvider(content))
            .timeout(5, TimeUnit.SECONDS)
            .send();

    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(response.getHeaders().containsKey(PROXIED_HEADER));
    Assert.assertArrayEquals(content, response.getContent());
  }
  @BeforeClass
  public static void startServer() throws Exception {
    server = new Server();

    ServerConnector connector = new ServerConnector(server);
    connector.setIdleTimeout(30000);
    server.addConnector(connector);

    ServletContextHandler context = new ServletContextHandler(server, "/");

    // CometD servlet
    ServletHolder cometdServletHolder = new ServletHolder(CometDServlet.class);
    cometdServletHolder.setInitParameter("timeout", "10000");
    cometdServletHolder.setInitParameter("multiSessionInterval", "2000");
    cometdServletHolder.setInitOrder(1);

    String cometdServletPath = "/cometd";
    context.addServlet(cometdServletHolder, cometdServletPath + "/*");

    server.start();
    int port = connector.getLocalPort();
    cometdURL = "http://localhost:" + port + cometdServletPath;

    httpClient = new HttpClient();
    httpClient.start();
  }
Ejemplo n.º 16
0
  @Test
  public void testProxyWithBigRequestContentConsumed() throws Exception {
    final byte[] content = new byte[128 * 1024];
    new Random().nextBytes(content);

    prepareProxy();
    prepareServer(
        new HttpServlet() {
          @Override
          protected void doPost(HttpServletRequest req, HttpServletResponse resp)
              throws ServletException, IOException {
            if (req.getHeader("Via") != null) resp.addHeader(PROXIED_HEADER, "true");
            InputStream input = req.getInputStream();
            int index = 0;
            while (true) {
              int value = input.read();
              if (value < 0) break;
              Assert.assertEquals(
                  "Content mismatch at index=" + index, content[index] & 0xFF, value);
              ++index;
            }
          }
        });

    ContentResponse response =
        client
            .newRequest("localhost", serverConnector.getLocalPort())
            .method(HttpMethod.POST)
            .content(new BytesContentProvider(content))
            .timeout(5, TimeUnit.SECONDS)
            .send();

    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(response.getHeaders().containsKey(PROXIED_HEADER));
  }
 @After
 public void dispose() throws Exception {
   server1.stop();
   server2.stop();
   balancer.stop();
   client.stop();
 }
Ejemplo n.º 18
0
  @Test
  public void testProxyBlackList() throws Exception {
    prepareProxy();
    prepareServer(new EmptyHttpServlet());
    int port = serverConnector.getLocalPort();
    proxyServlet.getBlackListHosts().add("localhost:" + port);

    // Try with the wrong host
    ContentResponse response =
        client.newRequest("localhost", port).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(403, response.getStatus());

    // Try again with the right host
    response = client.newRequest("127.0.0.1", port).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(200, response.getStatus());
  }
Ejemplo n.º 19
0
  @Test
  public void testTransparentProxyWithoutPrefix() throws Exception {
    final String target = "/test";
    prepareServer(
        new HttpServlet() {
          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse resp)
              throws ServletException, IOException {
            if (req.getHeader("Via") != null) resp.addHeader(PROXIED_HEADER, "true");
            resp.setStatus(target.equals(req.getRequestURI()) ? 200 : 404);
          }
        });

    final String proxyTo = "http://localhost:" + serverConnector.getLocalPort();
    proxyServlet = new ProxyServlet.Transparent();
    Map<String, String> initParams = new HashMap<>();
    initParams.put("proxyTo", proxyTo);
    prepareProxy(initParams);

    // Make the request to the proxy, it should transparently forward to the server
    ContentResponse response =
        client
            .newRequest("localhost", proxyConnector.getLocalPort())
            .path(target)
            .timeout(5, TimeUnit.SECONDS)
            .send();
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(response.getHeaders().containsKey(PROXIED_HEADER));
  }
Ejemplo n.º 20
0
  @Test
  public void testGZIPContentIsProxied() throws Exception {
    final byte[] content = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    prepareProxy();
    prepareServer(
        new HttpServlet() {
          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse resp)
              throws ServletException, IOException {
            if (req.getHeader("Via") != null) resp.addHeader(PROXIED_HEADER, "true");

            resp.addHeader("Content-Encoding", "gzip");
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(resp.getOutputStream());
            gzipOutputStream.write(content);
            gzipOutputStream.close();
          }
        });

    ContentResponse response =
        client
            .newRequest("localhost", serverConnector.getLocalPort())
            .timeout(5, TimeUnit.SECONDS)
            .send();
    Assert.assertEquals(200, response.getStatus());
    Assert.assertTrue(response.getHeaders().containsKey(PROXIED_HEADER));
    Assert.assertArrayEquals(content, response.getContent());
  }
Ejemplo n.º 21
0
  public void requestControl(
      final Player player,
      Figure.Type type,
      int x,
      int y,
      final Joystick joystick,
      List<Plot> plots)
      throws IOException {
    ContentExchange exchange = new MyContentExchange(joystick, player);

    exchange.setMethod("GET");
    String callbackUrl =
        player.getCallbackUrl().endsWith("/")
            ? player.getCallbackUrl()
            : player.getCallbackUrl() + "/";
    StringBuilder sb = exportGlassState(plots);

    String url =
        callbackUrl
            + "?figure="
            + type
            + "&x="
            + x
            + "&y="
            + y
            + "&glass="
            + URLEncoder.encode(sb.toString(), "UTF-8");
    exchange.setURL(url);
    client.send(exchange);
  }
  @AfterClass
  public static void stopServer() throws Exception {
    httpClient.stop();

    server.stop();
    server.join();
  }
Ejemplo n.º 23
0
 protected void startClient() throws Exception {
   if (httpClient != null) {
     stopClient();
   }
   httpClient = new HttpClient();
   httpClient.start();
 }
  @Override
  public void tearDown() throws Exception {

    // if (log.isInfoEnabled())
    log.warn("tearing down test: " + getName());

    if (m_fixture != null) {

      m_fixture.stop();

      m_fixture = null;
    }

    if (m_indexManager != null && namespace != null) {

      dropTripleStore(m_indexManager, namespace);

      m_indexManager = null;
    }

    namespace = null;

    m_rootURL = null;
    m_serviceURL = null;

    m_repo.close();

    m_client.stop();

    log.info("tear down done");

    super.tearDown();
  }
  @Test
  public void createsMetricsForTheHandler() throws Exception {
    final ContentResponse response =
        client.GET("http://localhost:" + connector.getLocalPort() + "/hello");

    assertThat(response.getStatus()).isEqualTo(404);

    assertThat(registry.getNames())
        .containsOnly(
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.1xx-responses",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.2xx-responses",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.3xx-responses",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.4xx-responses",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.5xx-responses",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.active-suspended",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.async-dispatches",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.async-timeouts",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.get-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.put-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.active-dispatches",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.trace-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.other-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.connect-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.dispatches",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.head-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.post-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.options-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.active-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.delete-requests",
            "org.eclipse.jetty.server.handler.DefaultHandler.handler.move-requests");
  }
  protected void performTest(MonitorAction action, long count, long interval) throws Exception {
    _monitor.addActions(action);

    for (long cnt = 0; cnt < count; cnt++) {
      try {
        ContentExchange getExchange = new ContentExchange();
        getExchange.setURL(_requestUrl);
        getExchange.setMethod(HttpMethods.GET);

        _client.send(getExchange);
        int state = getExchange.waitForDone();

        String content = "";
        int responseStatus = getExchange.getResponseStatus();
        if (responseStatus == HttpStatus.OK_200) {
          content = getExchange.getResponseContent();
        }

        assertEquals(HttpStatus.OK_200, responseStatus);
        Thread.sleep(interval);
      } catch (InterruptedException ex) {
        break;
      }
    }

    Thread.sleep(interval);

    _monitor.removeActions(action);
  }
Ejemplo n.º 27
0
 @Override
 public void close() {
   try {
     client.stop();
   } catch (final Exception e) {
     throw new ProcessingException("Failed to stop the client.", e);
   }
 }
Ejemplo n.º 28
0
 public void stop() {
   try {
     client.stop();
   } catch (Exception e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
 protected byte[] sendRequestToBalancer(String path) throws Exception {
   ContentResponse response =
       client
           .newRequest("localhost", getServerPort(balancer))
           .path(CONTEXT_PATH + SERVLET_PATH + path)
           .send()
           .get(5, TimeUnit.SECONDS);
   return response.getContent();
 }
 @Before
 public void setUp() throws Exception {
   handler.setName("handler");
   handler.setHandler(new DefaultHandler());
   server.addConnector(connector);
   server.setHandler(handler);
   server.start();
   client.start();
 }