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);
@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 ); }
/** * Use REST API to authenticate provided credentials * * @throws Exception */ @VisibleForTesting void authenticateLoginCredentials() throws Exception { KettleClientEnvironment.init(); if ( client == null ) { ClientConfig clientConfig = new DefaultClientConfig(); clientConfig.getFeatures().put( JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE ); client = Client.create( clientConfig ); client.addFilter( new HTTPBasicAuthFilter( username, Encr.decryptPasswordOptionallyEncrypted( password ) ) ); } WebResource resource = client.resource( url + AUTHENTICATION + AdministerSecurityAction.NAME ); String response = resource.get( String.class ); if ( !response.equals( "true" ) ) { throw new Exception( Messages.getInstance().getString( "REPOSITORY_CLEANUP_UTIL.ERROR_0012.ACCESS_DENIED" ) ); } }
@Override public EurekaHttpResponse<Void> statusUpdate(String asgName, ASGStatus newStatus) { ClientResponse response = null; try { String urlPath = "asg/" + asgName + "/status"; response = jerseyApacheClient.resource(serviceUrl) .path(urlPath) .queryParam("value", newStatus.name()) .header(PeerEurekaNode.HEADER_REPLICATION, "true") .put(ClientResponse.class); return EurekaHttpResponse.status(response.getStatus()); } finally { if (response != null) { response.close(); } } }
@Override public EurekaHttpResponse<Void> statusUpdate(String appName, String id, InstanceStatus newStatus, InstanceInfo info) { String urlPath = "apps/" + appName + '/' + id + "/status"; ClientResponse response = null; try { Builder requestBuilder = jerseyClient.resource(serviceUrl) .path(urlPath) .queryParam("value", newStatus.name()) .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp().toString()) .getRequestBuilder(); addExtraHeaders(requestBuilder); response = requestBuilder.put(ClientResponse.class); return anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build(); } finally { if (logger.isDebugEnabled()) { logger.debug("Jersey HTTP PUT {}/{}; statusCode={}", serviceUrl, urlPath, response == null ? "N/A" : response.getStatus()); } if (response != null) { response.close(); } } }
public static boolean sendMessage(String email, String subject, String text) { if (email.isEmpty()) { logger.info("Email is not sent because the address is empty"); return false; } Client client = Client.create(); client.addFilter(new HTTPBasicAuthFilter("api", ConfigSettings.instance.getMailgunApiKey())); String domain = ConfigSettings.instance.getMailgunDomain(); WebResource webResource = client.resource("https://api.mailgun.net/v3/" + domain + "/messages"); MultivaluedMapImpl formData = new MultivaluedMapImpl(); formData.add("from", "XMage <postmaster@" + domain + '>'); formData.add("to", email); formData.add("subject", subject); formData.add("text", text); ClientResponse response = webResource.type(MediaType.APPLICATION_FORM_URLENCODED).post(ClientResponse.class, formData); boolean succeeded = response.getStatus() == 200; if (!succeeded) { logger.error("Error sending message to " + email + ". Status code: " + response.getStatus()); } return succeeded; } }
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(); } } }
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 ); }
@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 ) ); }
@Override public void register( final Runner runner ) { WebResource resource = Client.create().resource( coordinatorFig.getEndpoint() ); resource = addQueryParameters( resource, project, runner ); Boolean result = resource.path( coordinatorFig.getRunnersRegisterPath() ) .type( MediaType.APPLICATION_JSON ).post( Boolean.class, runner ); LOG.debug( "Got back results from register post = {}", result ); }
OAuthParameters params = new OAuthParameters().consumerKey(input.oauthConsumerKey).signatureMethod("HMAC-SHA1").version("1.0"); OAuthSecrets secrets = new OAuthSecrets().consumerSecret(input.oauthConsumerSecret); client.addFilter(new OAuthClientFilter(client.getProviders(), params, secrets)); Builder builder = client.resource(input.uri).type(input.contentType); builder.entity(input.body); try { 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(); 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) {
public List<SearchItem> search(String search) throws DockerException { WebResource webResource = client.resource(restEndpointUrl + "/images/search").queryParam("term", search); try { return webResource.accept(MediaType.APPLICATION_JSON).get(new GenericType<List<SearchItem>>() { }); } catch (UniformInterfaceException exception) { if (exception.getResponse().getStatus() == 500) { throw new DockerException("Server error.", exception); } else { throw new DockerException(exception); } } }
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(); builder = builder.header( data.headerNames[i], value ); if ( "Content-Type".equals( data.headerNames[i] ) ) { contentType = value; response = u.getResponse(); int status = response.getStatus();
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); } }
/** {@inheritDoc} */ @Override public Feature read(String uid) { if (uid == null || uid.isEmpty()) { throw new IllegalArgumentException(FEATURE_IDENTIFIER_CANNOT_BE_NULL_NOR_EMPTY); } ClientResponse cRes = getStore().path(uid).get(ClientResponse.class); if (Status.NOT_FOUND.getStatusCode() == cRes.getStatus()) { throw new FeatureNotFoundException(uid); } return parseFeature(cRes.getEntity(String.class)); }
@Override public EurekaHttpResponse<ReplicationListResponse> submitBatchUpdates(ReplicationList replicationList) { ClientResponse response = null; try { response = jerseyApacheClient.resource(serviceUrl) .path(PeerEurekaNode.BATCH_URL_PATH) .accept(MediaType.APPLICATION_JSON_TYPE) .type(MediaType.APPLICATION_JSON_TYPE) .post(ClientResponse.class, replicationList); if (!isSuccess(response.getStatus())) { return anEurekaHttpResponse(response.getStatus(), ReplicationListResponse.class).build(); } ReplicationListResponse batchResponse = response.getEntity(ReplicationListResponse.class); return anEurekaHttpResponse(response.getStatus(), batchResponse).type(MediaType.APPLICATION_JSON_TYPE).build(); } finally { if (response != null) { response.close(); } } }
public static void main(String[] args) { if (args.length != 2) { System.out.println("RemoveCAS corpusAddress casId"); System.exit(-1); } Client c = Client.create(); WebResource r = c.resource(args[0]); ClientResponse response = r .path(args[1]) .delete(ClientResponse.class); System.out.println("Result: " + response.getStatus()); }
private <T> T getForEntity(String url, Object[] queryParams, Function<ClientResponse, T> entityProvider, Object... uriVariables) { URI uri = null; ClientResponse clientResponse; try { uri = getURIBuilder(root + url, queryParams).build(uriVariables); clientResponse = client.resource(uri) .accept(MediaType.APPLICATION_JSON, MediaType.TEXT_PLAIN) .get(ClientResponse.class); if (clientResponse.getStatus() < 300) { return entityProvider.apply(clientResponse); } else { throw new UniformInterfaceException(clientResponse); } } catch (UniformInterfaceException e) { handleUniformInterfaceException(e, uri); } catch (RuntimeException e) { handleRuntimeException(e, uri); } return null; }