/** 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 } }
@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(); } */ } } } }
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 } }
@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); }
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; }
@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(); }
@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; }
/** * 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; }
@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); }
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); } }
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); }
/** * 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); }
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; } }); }
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; }
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); } }
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; }
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); } }
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()); }