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) {
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; }
@Override public String getApplicationToken(String persistenceUnit, String externalProperties) { String applicationToken; try { log.debug("\n\nGetting Application Token..."); WebResource.Builder atBuilder = webResource.path(Constants.KUNDERA_API_PATH + "/application/" + persistenceUnit).accept(mediaType) .type(mediaType); StringBuffer sb = new StringBuffer().append(externalProperties); ClientResponse insertResponse = (ClientResponse) atBuilder.post(ClientResponse.class, sb.toString()); InputStream is = insertResponse.getEntityInputStream(); applicationToken = StreamUtils.toString(is); log.debug("Application Token:" + applicationToken); } catch (UniformInterfaceException e) { log.error("Error during getApplicationToken, Caused by:" + e.getMessage() + ", returning null"); return null; } catch (ClientHandlerException e) { log.error("Error during getApplicationToken, Caused by:" + e.getMessage() + ", returning null"); return null; } return applicationToken; }
public void kill(String containerId) throws DockerException { WebResource webResource = client.resource(restEndpointUrl + String.format("/containers/%s/kill", containerId)); try { LOGGER.trace("POST: {}", webResource); webResource.accept(MediaType.APPLICATION_JSON).type(MediaType.APPLICATION_JSON).post(); } catch (UniformInterfaceException exception) { if (exception.getResponse().getStatus() == 404) { LOGGER.warn("No such container {}", containerId); } else if (exception.getResponse().getStatus() == 204) { //no error LOGGER.trace("Successfully killed container {}", containerId); } else if (exception.getResponse().getStatus() == 500) { throw new DockerException("Server error", exception); } else { throw new DockerException(exception); } } }
@Test public void testInvalidUri() throws JSONException, Exception { WebResource r = resource(); String responseStr = ""; try { responseStr = r.path("ws").path("v1").path("applicationhistory").path("bogus") .queryParam("user.name", USERS[round]) .accept(MediaType.APPLICATION_JSON).get(String.class); fail("should have thrown exception on invalid uri"); } catch (UniformInterfaceException ue) { ClientResponse response = ue.getResponse(); assertResponseStatusCode(Status.NOT_FOUND, response.getStatusInfo()); WebServicesTestUtils.checkStringMatch( "error string exists and shouldn't", "", responseStr); } }
@Override public AppResponse updateAppDetails(final WebResource resource, final ResourcePath<App> keyResourcePath, final AppDetailsRequest appDetailsRequest) { try { final FormDataMultiPart multiPart = new FormDataMultiPart(); multiPart.bodyPart(new FormDataBodyPart("data", appDetailsRequest, MediaType.APPLICATION_JSON_TYPE)); return resource.path(keyResourcePath.getPath()).type(MediaType.MULTIPART_FORM_DATA_TYPE).put( AppResponse.class, multiPart); } catch (UniformInterfaceException e) { throw new ApiException(e.getResponse().getEntity(ErrorResponse.class), e); } }
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();
protected T get(ClientResponse response) { if (c == ClientResponse.class) return c.cast(response); if (response.getStatus() < 300) return response.getEntity(c); throw new UniformInterfaceException(response, request.getPropertyAsFeature(ClientConfig.PROPERTY_BUFFER_RESPONSE_ENTITY_ON_EXCEPTION, true)); } };
private RuntimeException convertException(UniformInterfaceException e) { ClientResponse response = e.getResponse(); String exceptionType = response.getHeaders().getFirst("X-BV-Exception"); if (response.getStatus() == Response.Status.BAD_REQUEST.getStatusCode() && IllegalArgumentException.class.getName().equals(exceptionType)) { return new IllegalArgumentException(response.getEntity(String.class), e); } return e; } }
private <T> T handle(Class<T> c, ClientRequest ro) throws UniformInterfaceException, ClientHandlerException { setProperties(ro); ClientResponse r = getHeadHandler().handle(ro); if (c == ClientResponse.class) return c.cast(r); if (r.getStatus() < 300) return r.getEntity(c); throw new UniformInterfaceException(r, ro.getPropertyAsFeature(ClientConfig.PROPERTY_BUFFER_RESPONSE_ENTITY_ON_EXCEPTION, true)); }
@Override public <T> OpenStackResponse request(OpenStackRequest<T> request) { WebResource target = client.resource(request.endpoint()).path(request.path()); for(Map.Entry<String, List<Object> > entry : request.queryParams().entrySet()) { for (Object o : entry.getValue()) { target = target.queryParam(entry.getKey(), String.valueOf(o)); target.addFilter(new LoggingFilter()); MultivaluedMap<String, Object> headers = new OutBoundHeaders(); for(Map.Entry<String, List<Object>> h : request.headers().entrySet()) { throw new OpenStackResponseException(e.getResponse().getClientResponseStatus().getReasonPhrase(), e.getResponse().getStatus());
LOG.error("REST Server error. Message: {}", e.getMessage()); } catch (ClientHandlerException e) { if (e.getCause() instanceof ConnectException) { if (clientRemoteResponse.getStatus() != HTTP_OK) { throw new UniformInterfaceException(HTTP_ERROR_MSG + clientRemoteResponse.getStatus(), clientRemoteResponse); case POST: try { clientRemoteResponse = wrb.post(ClientResponse.class, json); } catch (UniformInterfaceException e) { LOG.error("REST Server error. Message: {}", e.getMessage()); } catch (ClientHandlerException e) { if (e.getCause() instanceof ConnectException) { throw new UniformInterfaceException(HTTP_ERROR_MSG + clientRemoteResponse.getStatus(), clientRemoteResponse); case DELETE: try { clientRemoteResponse = wrb.delete(ClientResponse.class); } catch (UniformInterfaceException e) { LOG.error("REST Server error. Message: {}", e.getMessage()); } catch (ClientHandlerException e) { if (e.getCause() instanceof ConnectException) { throw new UniformInterfaceException(HTTP_ERROR_MSG + clientRemoteResponse.getStatus(), clientRemoteResponse);
public OrderDto getOrder(Long orderId) throws OrderNotFoundException, IOException { try { String path = resource.path(orderId.toString()).getURI().getPath(); CacheEntry entry = CacheManager.get(path); Builder wr = resource.path(orderId.toString()).accept(MediaType.APPLICATION_XML); wr.header("If-None-Match", entry.getEtag().getValue()); ClientResponse response = wr.get(ClientResponse.class); if (response.getResponseStatus().equals(Status.NOT_MODIFIED)) { LOG.debug("Order has not been modified..returning Cached Order..."); return (OrderDto) entry.getObject(); else if (response.getResponseStatus().equals(Status.OK)) { LOG.debug("Obtained full Order from Service...Caching it.."); OrderDto dto = response.getEntity(OrderDto.class); CacheManager.cache(path, new CacheEntry(dto, response.getEntityTag(), null)); LOG.debug("Order not found on server...removing from cache"); CacheManager.remove(path); throw new UniformInterfaceException(response); if (e.getResponse().getStatus() == Status.NOT_FOUND.getStatusCode()) { throw new OrderNotFoundException(e.getResponse().getEntity(String.class));
/** * Sends the optionally provided request entity using the provided method. The response entity is then * deserialized to the provided type. */ private <T> T send(String method, Class<T> responseType, @Nullable Object entity) { // Narrow the response type if (responseType == EmoResponse.class) { // noinspection unchecked return (T) toEmoResponse(entity == null ? builder().method(method, ClientResponse.class) : builder().method(method, ClientResponse.class, entity)); } try { ClientResponse response = entity == null ? builder().method(method, ClientResponse.class) : builder().method(method, ClientResponse.class, entity); // This is as per Jersey's WebResource builder() code. if (response.getStatus() >= 300) { throw new UniformInterfaceException(response); } if (!response.getType().equals(MediaType.APPLICATION_JSON_TYPE)) { return response.getEntity(responseType); } return EntityHelper.getEntity(response.getEntity(InputStream.class), responseType); } catch (UniformInterfaceException e) { throw asEmoClientException(e); } }
private void handleUniformInterfaceException(UniformInterfaceException exception, URI uri) { ClientResponse clientResponse = exception.getResponse(); if (clientResponse == null) { throw new ConductorClientException(String.format("Unable to invoke Conductor API with uri: %s", uri)); } try { if (clientResponse.getStatus() < 300) { return; } String errorMessage = clientResponse.getEntity(String.class); logger.error("Unable to invoke Conductor API with uri: {}, unexpected response from server: {}", uri, clientResponseToString(exception.getResponse()), exception); ErrorResponse errorResponse; try { errorResponse = objectMapper.readValue(errorMessage, ErrorResponse.class); } catch (IOException e) { throw new ConductorClientException(clientResponse.getStatus(), errorMessage); } throw new ConductorClientException(clientResponse.getStatus(), errorResponse); } catch (ConductorClientException e) { throw e; } catch (ClientHandlerException e) { handleClientHandlerException(e, uri); } catch (RuntimeException e) { handleRuntimeException(e, uri); } finally { clientResponse.close(); } }
private String getLocationOfMetadata(final String url, final MetadataType metadataType) { final ClientResponse clientResponse = getNexusClient().getClient() .resource(url + "repodata/repomd.xml") .get(ClientResponse.class); try { if (clientResponse.getStatus() < 300) { final RepoMD repomd = new RepoMD(clientResponse.getEntityInputStream()); return repomd.getLocation(metadataType.getType()); } throw getNexusClient().convert(new UniformInterfaceException(clientResponse)); } finally { clientResponse.close(); } }
@Override public final void processTrial(Trial trial) { if (uploadUri.isPresent()) { WebResource resource = client.resource(uploadUri.get()); if (apiKey.isPresent()) { resource = resource.queryParam("key", apiKey.get().toString()); } boolean threw = true; try { // TODO(gak): make the json part happen automagically resource.type(APPLICATION_JSON_TYPE).post(gson.toJson(ImmutableList.of(trial))); // only set the run id if a result has been successfully uploaded runId = Optional.of(trial.run().id()); threw = false; } catch (ClientHandlerException e) { logUploadFailure(trial, e); } catch (UniformInterfaceException e) { logUploadFailure(trial, e); logger.fine("Failed upload response: " + e.getResponse().getStatus()); } finally { failure |= threw; } } }
/** * Remove an image, deleting any tags it might have. */ public void removeImage(String imageId) throws DockerException { Preconditions.checkState(!StringUtils.isEmpty(imageId), "Image ID can't be empty"); try { WebResource webResource = client.resource(restEndpointUrl + "/images/" + imageId) .queryParam("force", "true"); LOGGER.trace("DELETE: {}", webResource); webResource.delete(); } catch (UniformInterfaceException exception) { if (exception.getResponse().getStatus() == 204) { //no error LOGGER.trace("Successfully removed image " + imageId); } else if (exception.getResponse().getStatus() == 404) { LOGGER.warn("{} no such image", imageId); } else if (exception.getResponse().getStatus() == 409) { throw new DockerException("Conflict"); } else if (exception.getResponse().getStatus() == 500) { throw new DockerException("Server error.", exception); } else { throw new DockerException(exception); } } }
WebResource webResource = client.resource(restEndpointUrl + "/build").queryParams(params); .type("application/tar") .accept(MediaType.TEXT_PLAIN) .post(ClientResponse.class, FileUtils.openInputStream(dockerFolderTar)); } catch (UniformInterfaceException exception) { if (exception.getResponse().getStatus() == 500) { throw new DockerException("Server error", exception); } else {
@Override public SuccessResponse deleteApp(WebResource resource, ResourcePath<App> appResourcePath) { try { return resource.path(appResourcePath.getPath()).delete(SuccessResponse.class); } catch (UniformInterfaceException e) { throw new ApiException(e.getResponse().getEntity(ErrorResponse.class), e); } }