Example #1
0
 /** create request builder with url */
 private RequestBuilder newBuilder(String url) throws RequestException {
   RequestBuilder builder = new RequestBuilder().session(this).url(url);
   if (pooledClient != null) {
     builder.executedBy(pooledClient);
   }
   return builder;
 }
  public static void retrieveAncestors(final Event event, final PathHandler handler) {
    String url = "/ReactomeRESTfulAPI/RESTfulWS/queryEventAncestors/" + event.getDbId();
    RequestBuilder requestBuilder = new RequestBuilder(RequestBuilder.GET, url);
    requestBuilder.setHeader("Accept", "application/json");
    try {
      requestBuilder.sendRequest(
          null,
          new RequestCallback() {
            @Override
            public void onResponseReceived(Request request, Response response) {
              try {
                JSONArray list = JSONParser.parseStrict(response.getText()).isArray();
                Ancestors ancestors = new Ancestors(list);
                List<Path> paths =
                    getPathsWithoutOrphanPathways(ancestors.getPathsContaining(event));
                handler.onPathsRetrieved(paths);
              } catch (Exception ex) {
                // ToDo: Look into new Error Handling
              }
            }

            @Override
            public void onError(Request request, Throwable exception) {
              // ToDo: Look into new Error Handling
            }
          });
    } catch (RequestException ex) {
      // ToDo: Look into new Error Handling
    }
  }
Example #3
0
 @Override
 public void run() {
   while (true) {
     for (SocketProcessor socket : queue) {
       if (socket.isRequestTextLoader) {
         socket.isRequestTextLoader = false;
         // TODO
         Handler handler = new FileHandler(new ErrorHandler());
         // @SuppressWarnings("unused")
         RequestBuilder rb = new RequestBuilder(socket.requestText);
         Request request = rb.getRequest();
         Response response = handler.handle(request);
         socket.sendResponse(response);
         queue.remove(socket);
         socket.close();
         // socket.sendTestResponse(socket.requestText);
         /*
          * try { socket.sendResponse( "<html><body><h1>Hello
          * World!!!</h1></body></html>");
          * socket.bufferWritter.flush(); System.out.print("Response
          * sent!"); } catch (IOException e) { // TODO Auto-generated
          * catch block e.printStackTrace(); }
          */
       }
     }
   }
 }
Example #4
0
  public void getMessages() {

    RequestBuilder builder = new RequestBuilder(RequestBuilder.GET, URL.encode(URLGET));

    try {
      Request request =
          builder.sendRequest(
              null,
              new RequestCallback() {
                public void onError(Request request, Throwable exception) {}

                public void onResponseReceived(Request request, Response response) {
                  if (200 == response.getStatusCode()) {
                    IResponse serverResponse = decodeJSON(response.getText());
                    processResponse(serverResponse);

                  } else {

                    Window.alert("Messages couldn't  been recieved");
                  }
                }
              });
    } catch (RequestException e) {
      // Couldn't connect to server
    }
  }
Example #5
0
 @SuppressWarnings("unchecked")
 public static Result route(Application app, RequestBuilder requestBuilder, long timeout) {
   final scala.Option<scala.concurrent.Future<play.api.mvc.Result>> opt =
       play.api.test.Helpers.jRoute(
           app.getWrappedApplication(),
           requestBuilder.build()._underlyingRequest(),
           requestBuilder.body());
   return wrapScalaResult(Scala.orNull(opt), timeout);
 }
Example #6
0
 private RequestBuilder postRequestBuilder() {
   // lazy init, because endpointConfig.getUrl() is not initialized at construction time
   if (prb == null) {
     prb = new RequestBuilder(RequestBuilder.POST, endpointConfig.getUrl());
     prb.setHeader(HEADER_ACCEPT, DMR_ENCODED);
     prb.setHeader(HEADER_CONTENT_TYPE, DMR_ENCODED);
     prb.setIncludeCredentials(true);
   }
   return prb;
 }
Example #7
0
  @Test
  public void testFormat() {
    A10ClientImpl c = Mockito.mock(A10ClientImpl.class);

    RequestBuilder b = new RequestBuilder(c, "test");

    Assertions.assertThat(b.getParams()).doesNotContainKey("format");

    assertThat(b.withXmlRequest().getParams()).containsEntry("format", "xml");
    assertThat(b.withJsonRequest().getParams()).containsEntry("format", "json");
  }
 @Test
 public void defaultValuesIgnored() {
   RequestBuilder b = new RequestBuilder();
   b.scale(1);
   assertThat(b.options).isNull();
   b.scale(1, 1);
   assertThat(b.options).isNull();
   b.rotate(0);
   assertThat(b.options).isNull();
   b.rotate(0, 40, 10);
   assertThat(b.options).isNull();
 }
Example #9
0
  @Test
  public void testImmuableParams() {
    A10ClientImpl c = Mockito.mock(A10ClientImpl.class);

    RequestBuilder b = new RequestBuilder(c, "test");

    try {
      b.getParams().put("foo", "bar");
      Assert.fail();
    } catch (UnsupportedOperationException e) {

    }
  }
 @Test
 public void chainableParamBuilder() {
   String queryString =
       instance.order("followers").highlightsCountFrom(50).getRequest().queryString();
   assertThat(queryString, containsString("order=followers"));
   assertThat(queryString, containsString("highlights_count%5Bfrom%5D=50"));
 }
  /**
   * Smoke test for webserice.
   *
   * @return current date of server string representation.
   */
  public String smokeTest() {
    RequestBuilder rb = new RequestBuilder();
    rb.withURI(getUrl().toString() + "/test");
    rb.withMethod("GET");
    rb.withContentType("text/plain");
    Request r = rb.build();

    Object execute;
    try {
      execute = execute(r);
    } catch (Exception e) {
      throw new OnlineWebException(e);
    }

    return (String) execute;
  }
Example #12
0
 /**
  * Perform initialization and simulates a call to WroFilter with given requestUri.
  *
  * @param requestUri
  */
 private void requestGroupByUri(
     final String requestUri, final RequestBuilder requestBuilder, final FilterChain chain)
     throws Exception {
   final HttpServletRequest request = requestBuilder.newRequest();
   final ServletOutputStream sos = mock(ServletOutputStream.class);
   when(mockResponse.getOutputStream()).thenReturn(sos);
   victim.init(mockFilterConfig);
   victim.doFilter(request, mockResponse, chain);
 }
  /**
   * Call webservice to obtain all JDBC strings.
   *
   * @return all JDBC strings or null if error
   */
  public JdbcsXml doGetJdbcs() {
    JdbcsXml xml;
    RequestBuilder rb = new RequestBuilder();
    rb.withURI(getUrl().toString());
    rb.withMethod("GET");
    rb.withContentType("application/xml");
    Request r = rb.build();

    Object execute;
    try {
      execute = execute(r, JdbcsXml.class);
    } catch (Exception e) {
      throw new DbLocatorException(e);
    }
    xml = (JdbcsXml) execute;

    return xml;
  }
Example #14
0
  @Test
  public void testIt() {
    A10ClientImpl c = Mockito.mock(A10ClientImpl.class);

    RequestBuilder b = new RequestBuilder(c, "test");

    Assertions.assertThat(b.getParams()).containsEntry("method", "test").hasSize(1);

    Assertions.assertThat(b.method("foo").getParams()).containsEntry("method", "foo").hasSize(1);

    Assertions.assertThat(b.param("a", "1").getParams())
        .containsEntry("method", "foo")
        .containsEntry("a", "1")
        .hasSize(2);
    Assertions.assertThat(b.param("a", "2").getParams())
        .containsEntry("method", "foo")
        .containsEntry("a", "2")
        .hasSize(2);
  }
Example #15
0
  private void updateFeatureLocation(final AnnotationInfo originalInfo) {
    String url = Annotator.getRootUrl() + "annotator/updateFeatureLocation";
    RequestBuilder builder = new RequestBuilder(RequestBuilder.POST, URL.encode(url));
    builder.setHeader("Content-type", "application/x-www-form-urlencoded");
    StringBuilder sb = new StringBuilder();
    sb.append(
        "data="
            + AnnotationInfoConverter.convertAnnotationInfoToJSONObject(this.internalAnnotationInfo)
                .toString());
    final AnnotationInfo updatedInfo = this.internalAnnotationInfo;
    builder.setRequestData(sb.toString());
    enableFields(false);
    RequestCallback requestCallback =
        new RequestCallback() {
          @Override
          public void onResponseReceived(Request request, Response response) {
            JSONValue returnValue = JSONParser.parseStrict(response.getText());
            GWT.log("return value: " + returnValue.toString());
            enableFields(true);
            Annotator.eventBus.fireEvent(
                new AnnotationInfoChangeEvent(
                    updatedInfo, AnnotationInfoChangeEvent.Action.UPDATE));
            updateDetailData(updatedInfo);
            redrawExonTable();
          }

          @Override
          public void onError(Request request, Throwable exception) {
            // todo: handling different types of errors
            Bootbox.alert("Error updating exon: " + exception.toString());
            coordinatesToPrime(originalInfo.getMin(), originalInfo.getMax());
            enableFields(true);
          }
        };
    try {
      builder.setCallback(requestCallback);
      builder.send();
    } catch (RequestException e) {
      Bootbox.alert(e.getMessage());
      enableFields(true);
    }
  }
Example #16
0
  private <B, R> R executeRequest(
      RequestSpec requestSpec,
      PathParams pathParams,
      B requestBody,
      Class<R> responseType,
      int expectedStatus) {
    String url =
        String.format(
            ADMIN_URL_PREFIX + requestSpec.path(pathParams), scheme, host, port, urlPathPrefix);
    RequestBuilder requestBuilder =
        RequestBuilder.create(requestSpec.method().getName()).setUri(url);

    if (requestBody != null) {
      requestBuilder.setEntity(jsonStringEntity(Json.write(requestBody)));
    }

    String responseBodyString = safelyExecuteRequest(url, expectedStatus, requestBuilder.build());

    return responseType == Void.class ? null : Json.read(responseBodyString, responseType);
  }
Example #17
0
 /**
  * Perform initialization and simulates a call to WroFilter with given requestUri.
  *
  * @param requestUri
  */
 private void requestGroupByUri(
     final String requestUri, final RequestBuilder requestBuilder, final FilterChain chain)
     throws IOException, ServletException {
   initFilterWithValidConfig();
   final HttpServletRequest request = requestBuilder.newRequest();
   final HttpServletResponse response = Mockito.mock(HttpServletResponse.class);
   final ServletOutputStream sos = Mockito.mock(ServletOutputStream.class);
   Mockito.when(response.getOutputStream()).thenReturn(sos);
   filter.init(config);
   filter.doFilter(request, response, chain);
 }
Example #18
0
  public static void fbLogin(String profileId) throws RequestException {
    RequestBuilder builder =
        new RequestBuilder(
            RequestBuilder.POST, "http://localhost:8080/j_spring_service_security_check");
    builder.setHeader("Content-type", "application/x-www-form-urlencoded");
    builder.sendRequest(
        "profile_id=" + profileId + "&service_name=facebook",
        new RequestCallback() {
          @Override
          public void onResponseReceived(Request request, Response response) {
            if (response.getStatusCode() < 400) {
              History.newItem("photo");
            }
          }

          @Override
          public void onError(Request request, Throwable exception) {
            return;
          }
        });
  }
Example #19
0
  private void getAllTreeLessons() {
    RequestBuilder builder = new RequestBuilder(RequestBuilder.GET, URLConstants.JSON_LESSONS);
    try {
      builder.sendRequest(
          null,
          new RequestCallback() {
            public void onError(Request request, Throwable exception) {
              displayError("Couldn't retrieve JSON : " + exception.getMessage());
            }

            public void onResponseReceived(Request request, Response response) {
              if (Response.SC_OK == response.getStatusCode()) {
                buildLessonTree(response);
              } else {
                displayError("Couldn't retrieve JSON (" + response.getStatusText() + ")");
              }
            }
          });
    } catch (RequestException e) {
      displayError("Couldn't retrieve JSON : " + e.getMessage());
    }
  }
  public void deliver() {
    String url = Configuration.getEndpointUrl();
    RequestBuilder builder = new RequestBuilder(RequestBuilder.POST, url);

    List<PerformanceTiming> timings = deliveryQueue.popTimings();
    List<IncidentReport> incidents = deliveryQueue.popIncidents();

    ResultInjector injector = new RequestBodyInjector();
    HeaderInjector.Result result = injector.inject(builder, timings, incidents);

    if (result.shouldSend()) {
      MeasurementRequestCallback callback = new MeasurementRequestCallback(timings, incidents);
      builder.setCallback(callback);
      try {
        builder.send();
      } catch (RequestException e) {
        deliveryQueue.pushTiming(timings);
        deliveryQueue.pushIncident(incidents);
        // TODO Consider lost piggybacked timings as well
      }
    }
  }
  public RequestBuilder resource(String resourceUrl) {
    RequestBuilder request = createRequestBuilder(resourceUrl);

    if (isEnabled(Feature.VERBOSE)) {
      request.setVerbose(true);
    }

    Token token = null;
    if (access != null) {
      token = access.getToken();
    }

    String authTokenId = null;
    if (token != null) {
      authTokenId = token.getId();
    }

    if (authTokenId != null && !authTokenId.isEmpty()) {
      request.putHeader("X-Auth-Token", authTokenId);
    }

    return request;
  }
Example #22
0
 public static Result routeAndCall(Router router, RequestBuilder requestBuilder, long timeout) {
   try {
     Request request = requestBuilder.build();
     if (router.routes().isDefinedAt(request._underlyingRequest())) {
       return invokeHandler(router.routes().apply(request._underlyingRequest()), request, timeout);
     } else {
       return null;
     }
   } catch (RuntimeException e) {
     throw e;
   } catch (Throwable t) {
     throw new RuntimeException(t);
   }
 }
Example #23
0
 public static ResponseParser performHttpRequest(
     String hostname, int hostPort, RequestBuilder builder) throws IOException {
   Socket socket = new Socket(hostname, hostPort);
   OutputStream socketOut = socket.getOutputStream();
   InputStream socketIn = socket.getInputStream();
   builder.send(socketOut);
   socketOut.flush();
   try {
     return new ResponseParser(socketIn);
   } finally {
     socketOut.close();
     socket.close();
   }
 }
  /**
   * users/1/apps/1/countries/1/params/locale
   *
   * @return parameter filled with values from ws call
   */
  @SuppressWarnings("UnusedDeclaration")
  public Parameter resolveParam(Builder c) {
    Parameter xml;
    RequestBuilder rb = new RequestBuilder();
    final Context ctx = c.build();
    StringBuilder sb = new StringBuilder("users/" + ctx.getUserId());
    sb.append("/apps/").append(ctx.getApplication());
    sb.append("/countries/").append(ctx.getCountry());
    sb.append("/params/").append(ctx.getParam());
    rb.withURI(getUrl().toString() + sb.toString());
    rb.withMethod("GET");
    rb.withContentType("application/xml");
    Request r = rb.build();

    Object execute;
    try {
      execute = execute(r, Parameter.class);
    } catch (Exception e) {
      throw new OnlineWebException(e);
    }
    xml = (Parameter) execute;

    return xml;
  }
  @Test(groups = "online")
  public void evilCoookieTest() throws Exception {
    try (AsyncHttpClient c = asyncHttpClient()) {
      RequestBuilder builder =
          get("http://localhost") //
              .setFollowRedirect(true) //
              .setUrl("http://www.google.com/") //
              .addHeader("Content-Type", "text/plain") //
              .addCookie(
                  new Cookie(
                      "evilcookie",
                      "test",
                      false,
                      ".google.com",
                      "/",
                      Long.MIN_VALUE,
                      false,
                      false));

      Response response = c.executeRequest(builder.build()).get();
      assertNotNull(response);
      assertEquals(response.getStatusCode(), 200);
    }
  }
  /**
   * Call webservice to obtain specific JDBC string for country.
   *
   * @param c country
   * @return JDBC connection string or null if error
   */
  public JdbcXml doGetJdbc(Country c) {
    JdbcXml execute;
    RequestBuilder rb = new RequestBuilder();
    rb.withURI(getUrl().toString());
    rb.withMethod("GET");
    rb.withContentType("application/xml");
    rb.withEntity(c.getCountry());
    Request r = rb.build();

    try {
      execute = (JdbcXml) execute(r, JdbcXml.class);
    } catch (Exception e) {
      throw new DbLocatorException(e);
    }
    return execute;
  }
Example #27
0
 public static Result routeAndCall(
     Class<? extends Router> router, RequestBuilder requestBuilder, long timeout) {
   try {
     Request request = requestBuilder.build();
     Router routes =
         (Router)
             router
                 .getClassLoader()
                 .loadClass(router.getName() + "$")
                 .getDeclaredField("MODULE$")
                 .get(null);
     if (routes.routes().isDefinedAt(request._underlyingRequest())) {
       return invokeHandler(routes.routes().apply(request._underlyingRequest()), request, timeout);
     } else {
       return null;
     }
   } catch (RuntimeException e) {
     throw e;
   } catch (Throwable t) {
     throw new RuntimeException(t);
   }
 }
Example #28
0
 private RequestBuilder chooseRequestBuilder(final ModelNode operation) {
   RequestBuilder requestBuilder;
   final String op = operation.get(OP).asString();
   if (READ_RESOURCE_DESCRIPTION_OPERATION.equals(op)) {
     String endpoint = endpointConfig.getUrl();
     if (endpoint.endsWith("/")) {
       endpoint = endpoint.substring(0, endpoint.length() - 1);
     }
     String descriptionUrl = endpoint + descriptionOperationToUrl(operation);
     requestBuilder =
         new RequestBuilder(
             RequestBuilder.GET, com.google.gwt.http.client.URL.encode(descriptionUrl));
     requestBuilder.setHeader(HEADER_ACCEPT, DMR_ENCODED);
     requestBuilder.setHeader(HEADER_CONTENT_TYPE, DMR_ENCODED);
     requestBuilder.setIncludeCredentials(true);
     requestBuilder.setRequestData(null);
   } else {
     requestBuilder = postRequestBuilder();
     requestBuilder.setRequestData(operation.toBase64String());
   }
   return requestBuilder;
 }
  Request buildRequest() {
    RequestBuilder builder = new RequestBuilder(method);

    builder.setUrl(url);
    builder.setQueryParams(new FluentStringsMap(queryParameters));
    builder.setHeaders(headers);

    if (body == null) {
      // do nothing
    } else if (body instanceof String) {
      String stringBody = ((String) body);
      FluentCaseInsensitiveStringsMap headers = new FluentCaseInsensitiveStringsMap(this.headers);

      // Detect and maybe add charset
      String contentType = headers.getFirstValue(HttpHeaders.Names.CONTENT_TYPE);
      if (contentType == null) {
        contentType = "text/plain";
      }
      Charset charset = HttpUtils.parseCharset(contentType);
      if (charset == null) {
        charset = StandardCharsets.UTF_8;
        List<String> contentTypeList = new ArrayList<String>();
        contentTypeList.add(contentType + "; charset=utf-8");
        headers.replace(HttpHeaders.Names.CONTENT_TYPE, contentTypeList);
      }

      byte[] bodyBytes;
      bodyBytes = stringBody.getBytes(charset);

      // If using a POST with OAuth signing, the builder looks at
      // getFormParams() rather than getBody() and constructs the signature
      // based on the form params.
      if (contentType.equals(HttpHeaders.Values.APPLICATION_X_WWW_FORM_URLENCODED)) {
        Map<String, List<String>> stringListMap =
            FormUrlEncodedParser.parseAsJava(stringBody, "utf-8");
        for (String key : stringListMap.keySet()) {
          List<String> values = stringListMap.get(key);
          for (String value : values) {
            builder.addFormParam(key, value);
          }
        }
      } else {
        builder.setBody(stringBody);
      }

      builder.setHeaders(headers);
      builder.setBodyCharset(charset);
    } else if (body instanceof JsonNode) {
      JsonNode jsonBody = (JsonNode) body;
      FluentCaseInsensitiveStringsMap headers = new FluentCaseInsensitiveStringsMap(this.headers);
      List<String> contentType = new ArrayList<String>();
      contentType.add("application/json; charset=utf-8");
      headers.replace(HttpHeaders.Names.CONTENT_TYPE, contentType);
      String bodyStr = Json.stringify(jsonBody);
      byte[] bodyBytes;
      try {
        bodyBytes = bodyStr.getBytes("utf-8");
      } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
      }

      builder.setBody(bodyStr);
      builder.setHeaders(headers);
      builder.setBodyCharset(StandardCharsets.UTF_8);
    } else if (body instanceof File) {
      File fileBody = (File) body;
      FileBodyGenerator bodyGenerator = new FileBodyGenerator(fileBody);
      builder.setBody(bodyGenerator);
    } else if (body instanceof InputStream) {
      InputStream inputStreamBody = (InputStream) body;
      InputStreamBodyGenerator bodyGenerator = new InputStreamBodyGenerator(inputStreamBody);
      builder.setBody(bodyGenerator);
    } else if (body instanceof Source) {
      Source<ByteString, ?> sourceBody = (Source<ByteString, ?>) body;
      Publisher<ByteBuffer> publisher =
          sourceBody.map(ByteString::toByteBuffer).runWith(Sink.asPublisher(false), materializer);
      builder.setBody(publisher);
    } else {
      throw new IllegalStateException("Impossible body: " + body);
    }

    if (this.timeout == -1 || this.timeout > 0) {
      builder.setRequestTimeout(this.timeout);
    }

    if (this.followRedirects != null) {
      builder.setFollowRedirect(this.followRedirects);
    }
    if (this.virtualHost != null) {
      builder.setVirtualHost(this.virtualHost);
    }

    if (this.username != null && this.password != null && this.scheme != null) {
      builder.setRealm(auth(this.username, this.password, this.scheme));
    }

    if (this.calculator != null) {
      if (this.calculator instanceof OAuth.OAuthCalculator) {
        OAuthSignatureCalculator calc = ((OAuth.OAuthCalculator) this.calculator).getCalculator();
        builder.setSignatureCalculator(calc);
      } else {
        throw new IllegalStateException("Use OAuth.OAuthCalculator");
      }
    }

    return builder.build();
  }
 public Response handle(RequestBuilder request) throws Exception {
   return build().handle(request.build());
 }