@Override public boolean hasCompleted( final Runner runner, final Project project, final int runNumber, final Class<?> testClass ) { // get run status information WebResource resource = Client.create().resource( coordinatorFig.getEndpoint() ); resource = addQueryParameters( resource, project, runner ); ClientResponse result = resource.path( coordinatorFig.getRunCompletedPath() ) .queryParam( RUNNER_HOSTNAME, runner.getHostname() ) .queryParam( COMMIT_ID, project.getVcsVersion() ) .queryParam( RUN_NUMBER, String.valueOf( runNumber ) ) .queryParam( TEST_CLASS, testClass.getName() ) .type( MediaType.APPLICATION_JSON ) .get( ClientResponse.class ); if( result.getStatus() != Response.Status.CREATED.getStatusCode() ) { LOG.error( "Could not get if run has completed status from coordinator, HTTP status: {}", result.getStatus() ); return false; } return result.getEntity( Boolean.class ); }
private static void decompressResponse(ClientResponse response) { InputStream entityInputStream = response.getEntityInputStream(); GZIPInputStream uncompressedIS; try { uncompressedIS = new GZIPInputStream(entityInputStream); } catch (IOException ex) { try { entityInputStream.close(); } catch (IOException ignored) { } throw new ClientHandlerException(ex); } response.setEntityInputStream(uncompressedIS); }
@Override public ClientResponse handle(ClientRequest request) { // If 'Accept-Encoding' is not set, assume gzip as a default if (!request.getHeaders().containsKey(HttpHeaders.ACCEPT_ENCODING)) { request.getHeaders().add(HttpHeaders.ACCEPT_ENCODING, GZIP_ENCODING); } if (request.getEntity() != null) { Object requestEncoding = request.getHeaders().getFirst(HttpHeaders.CONTENT_ENCODING); if (GZIP_ENCODING.equals(requestEncoding)) { request.setAdapter(new GzipAdapter(request.getAdapter())); } else if (isCompressionEnabled()) { request.getHeaders().add(HttpHeaders.CONTENT_ENCODING, GZIP_ENCODING); request.setAdapter(new GzipAdapter(request.getAdapter())); } } ClientResponse response = getNext().handle(request); String responseEncoding = response.getHeaders().getFirst(HttpHeaders.CONTENT_ENCODING); if (response.hasEntity() && GZIP_ENCODING.equals(responseEncoding)) { response.getHeaders().remove(HttpHeaders.CONTENT_ENCODING); decompressResponse(response); } return response; }
private EurekaHttpResponse<InstanceInfo> getInstanceInternal(String urlPath) { ClientResponse response = null; try { Builder requestBuilder = jerseyClient.resource(serviceUrl).path(urlPath).getRequestBuilder(); addExtraHeaders(requestBuilder); response = requestBuilder.accept(MediaType.APPLICATION_JSON_TYPE).get(ClientResponse.class); InstanceInfo infoFromPeer = null; if (response.getStatus() == Status.OK.getStatusCode() && response.hasEntity()) { infoFromPeer = response.getEntity(InstanceInfo.class); } return anEurekaHttpResponse(response.getStatus(), InstanceInfo.class) .headers(headersOf(response)) .entity(infoFromPeer) .build(); } finally { if (logger.isDebugEnabled()) { logger.debug("Jersey HTTP GET {}/{}; statusCode={}", serviceUrl, urlPath, response == null ? "N/A" : response.getStatus()); } if (response != null) { response.close(); } } }
private static String extractContent( ClientResponse response ) { if ( response.getStatus() == Status.NO_CONTENT.getStatusCode() ) { return null; } return response.getEntity( String.class ); }
public <T> T getAsJson( com.sun.jersey.api.client.GenericType<T> returnType ) { UriBuilder localUriBuilder = _uriBuilder.clone(); com.sun.jersey.api.client.WebResource resource = _client.resource( localUriBuilder.buildFromMap( _templateAndMatrixParameterValues ) ); com.sun.jersey.api.client.WebResource.Builder resourceBuilder = resource.getRequestBuilder(); resourceBuilder = resourceBuilder.accept( "application/json" ); com.sun.jersey.api.client.ClientResponse response; response = resourceBuilder.method( "GET", com.sun.jersey.api.client.ClientResponse.class ); if ( response.getStatus() >= 400 ) { throw new PentahoDiPlugin.WebApplicationExceptionMessage( Response .status( response.getClientResponseStatus() ).build() ); } return response.getEntity( returnType ); }
ClientConfig config = new DefaultClientConfig(); Client client = Client.create(config); WebResource webResource = client.resource(UriBuilder.fromUri(restprotocol + elastiCenterAddress + restpath).build()); queryParams.add(queryparamapikey, apiKey); queryParams.add(queryparamresponse, responseType); queryParams.add(queryparamcommand, command); System.out.println("Command Sent " + command + " : " + queryParams); ClientResponse response = webResource.queryParams(queryParams).accept(MediaType.APPLICATION_JSON).get(ClientResponse.class); if (response.getStatus() >= 300) { if (debug) System.out.println("ElastiCenter returned error code : " + response.getStatus()); if (401 == response.getStatus()) { throw new InvalidCredentialsException("Please specify a valid API Key."); } else if (431 == response.getStatus()) { throw new InvalidParameterException(response.getHeaders().getFirst("X-Description")); } else if (432 == response.getStatus()) { throw new InvalidParameterException(command + " does not exist on the ElastiCenter server. Please specify a valid command or contact your ElastiCenter Administrator."); } else { String jsonResponse = response.getEntity(String.class); if (debug) { System.out.println("Command Response : " + jsonResponse);
@Test public void shouldPickFirstXForwardedHostHeaderValueFromCommaOrCommaAndSpaceSeparatedList() { // when ClientResponse response = client.resource( getManageUri() ) .accept( APPLICATION_JSON ) .header( X_FORWARDED_HOST, "jimwebber.org, kathwebber.com,neo4j.org" ) .get( ClientResponse.class ); // then String entity = response.getEntity( String.class ); assertTrue( entity.contains( "http://jimwebber.org" ) ); assertFalse( entity.contains( "http://localhost" ) ); }
static void testRunCompleted( TestParams testParams ) { ClientResponse response = testParams.addQueryParameters( QUERY_PARAMS ) .setEndpoint( RunManagerResource.ENDPOINT ) .newWebResource() .queryParam( RestParams.RUNNER_HOSTNAME, "localhost" ) .queryParam( RestParams.RUN_NUMBER, "1" ) .queryParam( RestParams.TEST_CLASS, "org.apache.usergrid.chop.example.MechanicalWatchTest" ) .path( "/completed" ) .type( MediaType.APPLICATION_JSON ) .accept( MediaType.APPLICATION_JSON ) .get( ClientResponse.class ); assertEquals( Response.Status.CREATED.getStatusCode(), response.getStatus() ); assertEquals( Boolean.TRUE, response.getEntity( Boolean.class ) ); }
public ImageInspectResponse inspectImage(String imageId) throws DockerException, NotFoundException { WebResource webResource = client.resource(restEndpointUrl + String.format("/images/%s/json", imageId)); try { LOGGER.trace("GET: {}", webResource); return webResource.accept(MediaType.APPLICATION_JSON).get(ImageInspectResponse.class); } catch (UniformInterfaceException exception) { if (exception.getResponse().getStatus() == 404) { throw new NotFoundException(String.format("No such image %s", imageId)); } else if (exception.getResponse().getStatus() == 500) { throw new DockerException("Server error", exception); } else { throw new DockerException(exception); } } }
@Override public EurekaHttpResponse<Void> cancel(String appName, String id) { String urlPath = "apps/" + appName + '/' + id; ClientResponse response = null; try { Builder resourceBuilder = jerseyClient.resource(serviceUrl).path(urlPath).getRequestBuilder(); addExtraHeaders(resourceBuilder); response = resourceBuilder.delete(ClientResponse.class); return anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build(); } finally { if (logger.isDebugEnabled()) { logger.debug("Jersey HTTP DELETE {}/{}; statusCode={}", serviceUrl, urlPath, response == null ? "N/A" : response.getStatus()); } if (response != null) { response.close(); } } }
client.addFilter( data.basicAuthentication ); webResource = client.resource( data.realUrl ); UriBuilder builder = webResource.getUriBuilder(); for ( int i = 0; i < data.nrMatrixParams; i++ ) { String value = data.inputRowMeta.getString( rowData, data.indexOfMatrixParamFields[i] ); webResource = client.resource( builder.build() ); logDebug( BaseMessages.getString( PKG, "Rest.Log.queryParameterValue", data.paramNames[i], value ) ); webResource = webResource.queryParams( createMultivalueMap( data.paramNames[i], value ) ); logDebug( BaseMessages.getString( PKG, "Rest.Log.ConnectingToURL", webResource.getURI() ) ); WebResource.Builder builder = webResource.getRequestBuilder(); response = u.getResponse(); int status = response.getStatus(); String headerString = null; try { body = response.getEntity( String.class ); } catch ( UniformInterfaceException ex ) { body = "";
private String getIp(String host, String token) throws ParseException { ClientConfig config = new DefaultClientConfig(); Client client = Client.create(config); String baseURI = getBaseURI(host); WebResource service = client.resource(baseURI); service.path("Priam/REST/v1/cassadmin/gossipinfo") .accept(MediaType.APPLICATION_JSON) .get(ClientResponse.class); if (clientResp.getStatus() != 200) return null; textEntity = clientResp.getEntity(String.class);
Builder builder = client.resource(input.uri).type(input.contentType); builder.entity(input.body); ClientResponse cr = builder.accept(input.accept).method(input.method, ClientResponse.class); if (cr.getStatus() != 204 && cr.hasEntity()) { response.body = extractBody(cr); response.statusCode = cr.getStatus(); response.reasonPhrase = cr.getStatusInfo().getReasonPhrase(); response.headers = cr.getHeaders(); return response; ClientResponse cr = ex.getResponse(); logger.error(String.format("Got unexpected http response - uri: %s, vipAddress: %s, status code: %s", input.getUri(), input.getVipAddress(), cr.getStatus()), ex); if(cr.getStatus() > 199 && cr.getStatus() < 300) { if(cr.getStatus() != 204 && cr.hasEntity()) { response.body = extractBody(cr); response.headers = cr.getHeaders(); response.statusCode = cr.getStatus(); response.reasonPhrase = cr.getStatusInfo().getReasonPhrase(); return response; }else { String reason = cr.getEntity(String.class); logger.error(reason, ex); throw new Exception(reason);
@Test public void testDefaultBehavior() throws Exception { createInjector(); WebResource r = resource(); ClientResponse response = r.path("ws").path("v1").path("cluster") .path("info").accept("application/xml") .get(ClientResponse.class); assertEquals("Should have received DENY x-frame options header", "DENY", response.getHeaders().get(XFrameOptionsFilter.X_FRAME_OPTIONS).get(0)); }
Client client = new Client(); ClientResponse response = client.handle( request ); if ( response.hasEntity() && response.getStatus() != 204 ) data.setEntity( response.getEntity( String.class ) ); if ( response.getType() != null ) assertTrue( "wrong response type: " + data.entity, response.getType().isCompatible( type ) ); assertTrue( "wrong headers: " + response.getHeaders(), headerField.other().test( response.getHeaders() .getFirst( headerField.first() ) ) ); assertEquals( "Wrong response status. response: " + data.entity, responseCode, response.getStatus() ); getResponseHeaders( data, response.getHeaders(), headerNames(headerFields) ); return new ResponseEntity( response, data.entity );
@Test public void testCallEndpointWithDeleteVerb() throws KettleException { MultivaluedMap<String, String> headers = new MultivaluedMapImpl(); headers.add( "Content-Type", "application/json" ); doReturn( 200 ).when( response ).getStatus(); doReturn( headers ).when( response ).getHeaders(); doReturn( "true" ).when( response ).getEntity( String.class ); doReturn( response ).when( builder ).delete( ClientResponse.class ); doReturn( builder ).when( resource ).getRequestBuilder(); verify( builder, times( 1 ) ).delete( ClientResponse.class ); assertEquals( "true", output[1] ); assertEquals( 200L, output[2] );
public class Test { public static void main(String[] args) { ClientConfig config = new DefaultClientConfig(); Client client = Client.create(config); WebResource service = client.resource(getBaseURI()); // Now do the MAP stuff MyHashMapObject<String, String> map = new MyHashMapObject<String, String>(); map.getMapProperty().put("a", "1"); map.getMapProperty().put("b", "2"); ClientResponse response = service.path("rest").path("hello2") .type(MediaType.APPLICATION_XML) .accept(MediaType.APPLICATION_XML) .post(ClientResponse.class, map); Map<String, String> myMap = response.getEntity(MyHashMapObject.class).getMapProperty(); for(Map.Entry<String, String> entry : myMap.entrySet()) System.out.format("Key: %s, Value: %s\n", entry.getKey(), entry.getValue()); } private static URI getBaseURI() { return UriBuilder.fromUri( "http://localhost:8080/org.nowaq.jersey.first").build(); } }
@Override public AndroidKeyResponse unlockKey(WebResource resource, ResourcePath<Key> keyResourcePath, AndroidKeyUnlockRequest androidKeyUnlockRequest) { try { FormDataMultiPart multiPart = new FormDataMultiPart(); multiPart.bodyPart(new FormDataBodyPart("data", androidKeyUnlockRequest, MediaType.APPLICATION_JSON_TYPE)); return resource.path(keyResourcePath.getPath()).type(MediaType.MULTIPART_FORM_DATA_TYPE).put( AndroidKeyResponse.class, multiPart); } catch (UniformInterfaceException e) { throw new ApiException(e.getResponse().getEntity(ErrorResponse.class), e); } }
private MultivaluedMap<String,Object> extractMetaData( ClientResponse jettyResponse ) { MultivaluedMap<String,Object> metadata = new StringKeyObjectValueIgnoreCaseMultivaluedMap(); for ( Map.Entry<String,List<String>> header : jettyResponse.getHeaders().entrySet() ) { for ( Object value : header.getValue() ) { metadata.putSingle( header.getKey(), value ); } } return metadata; }