protected HttpResponse getHttpResponse(final HttpUriRequest httpRequest, final String url) throws DSSException { final HttpClient client = getHttpClient(url); final String host = httpRequest.getURI().getHost(); final int port = httpRequest.getURI().getPort(); final String scheme = httpRequest.getURI().getScheme(); final HttpHost targetHost = new HttpHost(host, port, scheme); // Create AuthCache instance AuthCache authCache = new BasicAuthCache(); // Generate BASIC scheme object and add it to the local // auth cache BasicScheme basicAuth = new BasicScheme(); authCache.put(targetHost, basicAuth); // Add AuthCache to the execution context HttpClientContext localContext = HttpClientContext.create(); localContext.setAuthCache(authCache); try { final HttpResponse response = client.execute(targetHost, httpRequest, localContext); return response; } catch (IOException e) { throw new DSSException(e); } }
String createCanonicalRequest(HttpUriRequest request) { StringBuilder result = new StringBuilder(); result.append(request.getMethod()).append('\n'); String path = request.getURI().getPath(); if (path.isEmpty()) { path = "/"; } result.append(path).append('\n'); String queryString = request.getURI().getQuery(); queryString = queryString != null ? queryString : ""; addCanonicalQueryString(queryString, result).append('\n'); addCanonicalHeaders(request, result).append('\n'); HttpEntity entity = null; try { if (request instanceof HttpEntityEnclosingRequestBase) { entity = ((HttpEntityEnclosingRequestBase) request).getEntity(); } else { entity = new StringEntity(""); } InputStream content = entity.getContent(); addHashedPayload(content, result); } catch (IOException e) { throw new RuntimeException("Could not create hash for entity " + entity, e); } return result.toString(); }
private void runLoop() throws InterruptedException { while (!stop) { CrawlerTask task = crawlerResponseQueue.take(); if (task.isExitTask()) { crawlerRequestQueue.add(CrawlerTask.createExitTask()); crawlerResponseQueue.add(task); return; } HttpUriRequest req = task.getRequest(); activeRequest = req; try { if (task.getResponse() != null) { task.getResponseProcessor() .processResponse(crawler, req, task.getResponse(), task.getArgument()); } } catch (Exception e) { logger.log( Level.WARNING, "Unexpected exception processing crawler request: " + req.getURI(), e); } finally { synchronized (requestLock) { activeRequest = null; } final HttpEntity entity = (task.getResponse() == null) ? (null) : task.getResponse().getRawResponse().getEntity(); if (entity != null) try { EntityUtils.consume(entity); } catch (IOException e) { logger.log( Level.WARNING, "I/O exception consuming request entity content for " + req.getURI() + " : " + e.getMessage()); } } synchronized (counter) { counter.addCompletedTask(); crawler.updateProgress(); } if (task.causedException()) { crawler.notifyException(req, task.getException()); } if (outstandingTasks.decrementAndGet() <= 0) { crawlerRequestQueue.add(CrawlerTask.createExitTask()); crawlerResponseQueue.add(CrawlerTask.createExitTask()); return; } } }
private static String getUrlAfterRedirects(HttpContext context) { String lastRedirectUrl = (String) context.getAttribute(LAST_REDIRECT_URL); if (lastRedirectUrl != null) return lastRedirectUrl; else { HttpUriRequest currentReq = (HttpUriRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); HttpHost currentHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); String currentUrl = (currentReq.getURI().isAbsolute()) ? currentReq.getURI().toString() : (currentHost.toURI() + currentReq.getURI()); return currentUrl; } }
@Override public Cursor query( Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { try { HttpUriRequest request = queryRequest(uri, projection, selection, selectionArgs, sortOrder); if (DEBUG) Log.i(TAG, "will query: " + request.getURI()); Cursor cursor = getQueryHandler(uri).handleResponse(httpClient.execute(request)); // httpClient.getConnectionManager().shutdown(); return cursor; } catch (ConnectException e) { Log.w(TAG, "an error occured in query", e); return ErrorCursor.getCursor(0, e.getMessage()); } catch (ClientProtocolException e) { Log.w(TAG, "an error occured in query", e); return ErrorCursor.getCursor(0, e.getMessage()); } catch (IOException e) { Log.w(TAG, "an error occured in query", e); return ErrorCursor.getCursor(0, e.getMessage()); } catch (IllegalArgumentException e) { Log.w(TAG, "an error occured in query", e); return ErrorCursor.getCursor( 0, "Unknown URI (not in cache or not answerable by the implementator): " + uri.toString()); } }
/** * Send an HTTP message to a worker and get the result * * <p>Note: expects the worker to respond with OK (200) status code. * * @param uriRequest The request to make * @return An InputStream of the response content */ private InputStream askWorker(HttpUriRequest uriRequest) { try { HttpResponse response = httpClient.execute(uriRequest); if (response.getStatusLine().getStatusCode() != Response.Status.OK.getStatusCode()) { StatusLine statusLine = response.getStatusLine(); EntityUtils.consume(response.getEntity()); logger.warn( "Problem asking worker <" + metadata.getWorkerId() + "> " + "(" + uriRequest.getURI() + "), " + "reason [" + statusLine.getStatusCode() + ": " + statusLine.getReasonPhrase() + "]"); } return response.getEntity().getContent(); } catch (IOException e) { logger.warn("Unable to communicated with worker " + metadata.toString()); throw Throwables.propagate(e); } }
/** * Send an HTTP message to a worker, producing helpful logging if there was a problem * * @param uriRequest The request to make * @param expectedStatus The expected return status * @return true if the method was successfully delivered & the worker gave the expected response */ private boolean tellWorker(HttpUriRequest uriRequest, Response.Status expectedStatus) { try { HttpResponse response = httpClient.execute(uriRequest); if (response.getStatusLine().getStatusCode() != expectedStatus.getStatusCode()) { StatusLine statusLine = response.getStatusLine(); EntityUtils.consume(response.getEntity()); logger.warn( "Problem telling worker <" + metadata.getWorkerId() + "> " + "(" + uriRequest.getURI() + "), " + "reason [" + statusLine.getStatusCode() + ": " + statusLine.getReasonPhrase() + "]"); return false; } return true; } catch (IOException e) { logger.warn("Unable to communicated with worker " + metadata.toString()); return false; } }
@Mock public void $init( CloudProvider provider, HttpClientBuilder clientBuilder, HttpUriRequest request, ResponseHandler handler) { String requestUri = request.getURI().toString(); if (request.getMethod().equals("GET") && requestUri.equals( String.format(VM_RESOURCES, ENDPOINT, ACCOUNT_NO, DATACENTER_ID, VM_1_ID))) { requestResourceType = 11; } else if (request.getMethod().equals("PUT") && requestUri.equals( String.format(VM_RESOURCES, ENDPOINT, ACCOUNT_NO, DATACENTER_ID, VM_1_ID))) { requestResourceType = 12; WAPVirtualMachineModel wapVirtualMachineModel = createWAPVirtualMachineModel(); wapVirtualMachineModel.setOperation(operation); assertPut( request, String.format(VM_RESOURCES, ENDPOINT, ACCOUNT_NO, DATACENTER_ID, VM_1_ID), new Header[0], wapVirtualMachineModel); } else { super.$init(provider, clientBuilder, request, handler); } }
@Mock public void $init( CloudProvider provider, HttpClientBuilder clientBuilder, HttpUriRequest request, ResponseHandler handler) { String requestUri = request.getURI().toString(); if (request.getMethod().equals("GET") && requestUri.equals( String.format(VM_RESOURCES, ENDPOINT, ACCOUNT_NO, DATACENTER_ID, VM_1_ID))) { requestResourceType = 1; } if (request.getMethod().equals("GET") && requestUri.equals( String.format(VM_NETWORK_ADAPTERS, ENDPOINT, ACCOUNT_NO, DATACENTER_ID, VM_1_ID))) { requestResourceType = 2; } if (request.getMethod().equals("GET") && requestUri.equals(String.format(HARDWARE_PROFILES, ENDPOINT, ACCOUNT_NO))) { requestResourceType = 3; } if (request.getMethod().equals("GET") && requestUri.equals(String.format(LIST_VM_RESOURCES, ENDPOINT, ACCOUNT_NO))) { requestResourceType = 4; } responseHandler = handler; }
@Test public void GetRequest() throws URISyntaxException, ClientProtocolException, IOException, ParserConfigurationException, UnsupportedOperationException, SAXException { HttpUriRequest request = new HttpGet(url); URIBuilder uri = new URIBuilder(request.getURI()).addParameter("CountryName", country); ((HttpRequestBase) request).setURI(uri.build()); // Testing headers HttpResponse response = client.execute(request); Header[] headers = response.getAllHeaders(); for (Header head : headers) { System.out.println(head.getName() + "---" + head.getValue()); } System.out.println("================================================"); // Testing response // parsing xml DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); Document doc = dBuilder.parse(response.getEntity().getContent()); // Printing root doc.getDocumentElement().normalize(); NodeList nList = doc.getElementsByTagName("string"); Node aNode = nList.item(0); Element element = (Element) aNode; System.out.println(element.getFirstChild()); }
@Test public void shouldHandleMultipleInvocationsOfExecute() throws Exception { Robolectric.addPendingHttpResponse(200, "a happy response body"); Robolectric.addPendingHttpResponse(201, "another happy response body"); requestDirector.execute(null, new HttpGet("http://example.com"), null); requestDirector.execute(null, new HttpGet("www.example.com"), null); HttpUriRequest request1 = (HttpUriRequest) Robolectric.getSentHttpRequest(0); assertThat(request1.getMethod(), equalTo(HttpGet.METHOD_NAME)); assertThat(request1.getURI(), equalTo(URI.create("http://example.com"))); HttpUriRequest request2 = (HttpUriRequest) Robolectric.getSentHttpRequest(1); assertThat(request2.getMethod(), equalTo(HttpGet.METHOD_NAME)); assertThat(request2.getURI(), equalTo(URI.create("www.example.com"))); }
public PingInfo ping(String host, int restPort, boolean noProxy) throws Exception { PingInfo myPingInfo = pingInfoProvider.createPingInfo(); RequestConfig.Builder requestConfigBuilder = httpClientProvider.createRequestConfigBuilder(host, noProxy); String url = String.format(URL_PATTERN, host, restPort) + PingHandler.URL; HttpUriRequest request = RequestBuilder.post(url) .setConfig(requestConfigBuilder.build()) .addParameter(PingHandler.PING_INFO_INPUT_NAME, gson.toJson(myPingInfo)) .build(); CloseableHttpResponse response = httpClientProvider.executeRequest(request); try { StatusLine statusLine = response.getStatusLine(); if (statusLine.getStatusCode() != HttpStatus.SC_OK) { EntityUtils.consumeQuietly(response.getEntity()); throw new Exception(statusLine.getStatusCode() + " " + statusLine.getReasonPhrase()); } HttpEntity entity = response.getEntity(); String content = EntityUtils.toString(entity); EntityUtils.consumeQuietly(entity); PingInfo receivedPingInfo = gson.fromJson(content, PingInfo.class); receivedPingInfo.getAgentId().setHost(request.getURI().getHost()); return receivedPingInfo; } finally { response.close(); } }
private HttpStatus commit(HttpUriRequest method) throws IOException { HttpStatus status; HttpClient httpclient = createHttpClient(); // reduce the TIME_WAIT // method.addHeader("Connection", "close"); if (method.getFirstHeader("Referer") == null) { URI uri = method.getURI(); method.setHeader("Referer", uri.getScheme() + "://" + uri.getHost() + ":" + uri.getPort()); } ; try { HttpResponse resp = execute(method, httpclient); status = new HttpStatus(resp.getStatusLine()); if (resp.getEntity() != null) { status.setMessage(EntityUtils.toString(resp.getEntity(), "UTF-8")); } } catch (IOException e) { // cancel the connection when the error happen method.abort(); throw e; } finally { HttpClientUtils.abortConnection(method, httpclient); } return status; }
public HttpResponse execute(HttpUriRequest request, HttpContext context) throws IOException { // Rewrite the supplied URL... URI uri = request.getURI(); String original = uri.toString(); UrlRules rules = UrlRules.getRules(mResolver); UrlRules.Rule rule = rules.matchRule(original); String rewritten = rule.apply(original); if (rewritten == null) { Log.w(TAG, "Blocked by " + rule.mName + ": " + original); throw new BlockedRequestException(rule); } else if (rewritten == original) { return executeWithoutRewriting(request, context); // Pass through } try { uri = new URI(rewritten); } catch (URISyntaxException e) { throw new RuntimeException("Bad URL from rule: " + rule.mName, e); } // Wrap request so we can replace the URI. RequestWrapper wrapper = wrapRequest(request); wrapper.setURI(uri); request = wrapper; if (Config.LOGV) { Log.v(TAG, "Rule " + rule.mName + ": " + original + " -> " + rewritten); } return executeWithoutRewriting(request, context); }
private HttpResponse executeRequest(HttpClient client, HttpUriRequest request) throws ClientProtocolException, IOException { if (logger != null && logger.isDebugEnabled()) { StringBuilder builder = new StringBuilder(); Header[] allHeaders = request.getAllHeaders(); for (Header header : allHeaders) { builder.append(header.getName()); builder.append(":"); builder.append(header.getValue()); builder.append("\n"); } logger.debug( "Executing request \nurl:[" + request.getURI().toString() + "] \nheaders:\n" + builder.toString() + ""); } return client.execute(request); }
@Override public Result loadInBackground() { final Fetch fetch = mFetch; final HttpConnectionHelper helper = mHelper; List<NameValuePair> parameters = mParameterExtractor.extract(fetch); HttpUriRequest request = helper.obtainHttpRequest(fetch.getFetchMethod(), fetch.getUrl(), parameters); Utils.debug(request.getURI().toString()); if (fetch.onPreFetch(request, Collections.unmodifiableList(parameters))) { return mResult; } HttpResponse response = helper.execute(request); fetch.onPostFetch(request); if (null == response) { return null; } try { Result result = mResult = mParser.parse(fetch, new InputStreamReader(response.getEntity().getContent())); Utils.debug(result); return result; } catch (IllegalStateException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return null; }
/** * Executes the HTTP request. * * <p>In case of any exception thrown by HttpClient, it will release the connection. In other * cases it is the duty of caller to do it, or process the input stream. * * @param repository to execute the HTTP method for * @param request resource store request that triggered the HTTP request * @param httpRequest HTTP request to be executed * @param baseUrl The BaseURL used to construct final httpRequest * @return response of making the request * @throws RemoteStorageException If an error occurred during execution of HTTP request */ @VisibleForTesting HttpResponse executeRequest( final ProxyRepository repository, final ResourceStoreRequest request, final HttpUriRequest httpRequest, final String baseUrl, final boolean contentRequest) throws RemoteStorageException { final Timer timer = timer(repository, httpRequest, baseUrl); final TimerContext timerContext = timer.time(); Stopwatch stopwatch = null; if (outboundRequestLog.isDebugEnabled()) { stopwatch = new Stopwatch().start(); } try { return doExecuteRequest(repository, request, httpRequest, contentRequest); } finally { timerContext.stop(); if (stopwatch != null) { outboundRequestLog.debug( "[{}] {} {} - {}", repository.getId(), httpRequest.getMethod(), httpRequest.getURI(), stopwatch); } } }
private void attachSignature( final HttpUriRequest request, final List<NameValuePair> params, final byte[] content) { final RequestDigestBuffer digest = RequestDigestBuffer.newBuilder(config) .withMethod(request.getMethod()) .withPath(request.getURI().getPath()) .withQueryParams(params) .withTimestamp(Instant.now(Clock.systemUTC()).toEpochMilli()) .build(); final byte[] signature = digest.doFinal(content); for (final Header h : digest.requestHeaders(signature)) { request.addHeader(h); } }
@Override public CloseableHttpResponse execute(final HttpUriRequest request, final HttpContext context) throws IOException, ClientProtocolException { return HttpClientTracing.execute( request.getURI().toString(), traceHeaderName, request, new HttpClientTracing.Executor<CloseableHttpResponse>() { @Override public CloseableHttpResponse execute() throws IOException { return client.execute(request, context); } }); }
private static void printDebugInfo(HttpUriRequest request, HttpResponse response) { String br = System.getProperty("line.separator"); StringBuffer builder = new StringBuffer(); builder.append("URL: "); builder.append(request.getURI().toString()); builder.append(br); builder.append("Request Headers: "); builder.append(headersToString(request.getAllHeaders())); builder.append(br); builder.append("Request Body: "); if (request instanceof HttpPost) { HttpPost post = (HttpPost) request; String body = "This body can't be outputted."; try { body = ResponseUtil.fromHttpEntityToString(post.getEntity(), "UTF-8"); } catch (ResponseBodyParseException e) { Log.d(TAG, "Parsing request is failed.", e); } builder.append(body); } else { builder.append("No body by Get request."); } builder.append(br); builder.append("HTTP Status Code: "); builder.append(response.getStatusLine().getStatusCode()); builder.append(br); builder.append("Response Headers: "); builder.append(headersToString(response.getAllHeaders())); builder.append(br); Header contentType = response.getFirstHeader("Content-Type"); if (contentType != null && "application/json".equals(contentType.getValue())) { builder.append("Response Body: "); String body = "This body can't be outputted."; try { body = ResponseUtil.fromHttpEntityToString(response.getEntity(), "UTF-8"); response.setEntity(new StringEntity(body, "UTF-8")); } catch (ResponseBodyParseException e) { Log.d(TAG, "Parsing response is failed.", e); } catch (UnsupportedEncodingException e) { Log.e(TAG, e.getMessage()); } builder.append(body); builder.append(br); } else { builder.append("Response Body is binary data."); builder.append(br); } Log.d(TAG, builder.toString()); }
private ManticoreHttpResponse httpExecute(HttpUriRequest request) { int statusCode = 200; String ret = ""; try { Logger.verbose( LOG_TAG, String.format("Executing %s %s", request.getMethod(), request.getURI().toString())); ret = _http.execute(request, _handler, _context); } catch (HttpResponseException httpEx) { // Bad status code statusCode = httpEx.getStatusCode(); ret = httpEx.getLocalizedMessage(); Logger.warn( LOG_TAG, String.format("Error executing %s %s", request.getMethod(), request.getURI().toString()), httpEx); } catch (IOException ioEx) { Logger.error(LOG_TAG, "Error loading page " + request.getURI().toString(), ioEx); return null; } return new ManticoreHttpResponse(statusCode, ret, _handler.getHeaders()); }
StringBuilder addCanonicalHeaders(HttpUriRequest request, StringBuilder builder) { SortedMap<String, String> sortedHeaders = sortedFormattedHeaders(request.getAllHeaders()); if (!sortedHeaders.containsKey(DATE_HEADER_NAME)) { String timestamp = timestamp(); sortedHeaders.put(DATE_HEADER_NAME, timestamp); request.addHeader(DATE_HEADER_NAME, timestamp); } if (!sortedHeaders.containsKey(HOST_HEADER_NAME)) { sortedHeaders.put(HOST_HEADER_NAME, request.getURI().getHost()); request.addHeader(HOST_HEADER_NAME, request.getURI().getHost()); } addCanonicalHeaders(sortedHeaders, builder).append('\n'); return addSignedHeaders(sortedHeaders, builder); }
@Override public <T> T execute( final HttpUriRequest request, final ResponseHandler<? extends T> responseHandler) throws IOException, ClientProtocolException { return HttpClientTracing.execute( request.getURI().toString(), traceHeaderName, request, new HttpClientTracing.Executor<T>() { @Override public T execute() throws IOException { return client.execute(request, responseHandler); } }); }
private <T> T executeRequest(final HttpUriRequest request, final ResponseHandler<T> handler) throws IOException { final CloseableHttpClient client = createClientInstance(); try { final CloseableHttpResponse response = client.execute(request); // Wrap the response in a buffer to facilitate error handlers re-playing the content if the // response // size is smaller than the max allowable buffer if (response.getEntity().getContentLength() >= 0 && response.getEntity().getContentLength() < config.getMaxBufferSize()) { EntityUtils.updateEntity(response, new BufferedHttpEntity(response.getEntity())); } // Explicit check for the authorization status of the API key if (response.getStatusLine().getStatusCode() == HttpStatus.SC_UNAUTHORIZED) { throw new HyppoAuthException(config); } try { log.debug( "{} - {} : {}", request.getMethod(), request.getURI().getPath(), response.getStatusLine().getStatusCode()); return handler.handleResponse(response); } finally { IOUtils.closeQuietly(response); } } catch (Exception e) { log.error( "{} - {} : FAILED - {}", request.getMethod(), request.getURI().getPath(), e.toString()); throw e; } finally { IOUtils.closeQuietly(client); } }
@Mock public void $init( CloudProvider provider, HttpClientBuilder clientBuilder, HttpUriRequest request, ResponseHandler handler) { String requestUri = request.getURI().toString(); if (request.getMethod().equals("GET") && requestUri.equals(String.format(VMTEMPLATES_RESOURCES, ENDPOINT, ACCOUNT_NO))) { requestResourceType = 1; } if (request.getMethod().equals("GET") && requestUri.equals(String.format(HARDWARE_PROFILES, ENDPOINT, ACCOUNT_NO))) { requestResourceType = 2; } }
private void assertBuild(final Charset charset) throws Exception { final RequestBuilder requestBuilder = RequestBuilder.create("GET").setCharset(charset); requestBuilder.setUri("https://somehost.com/stuff"); requestBuilder.addParameters(createParameters()); final String encodedData1 = URLEncoder.encode("\"1\u00aa position\"", charset.displayName()); final String encodedData2 = URLEncoder.encode("Jos\u00e9 Abra\u00e3o", charset.displayName()); final String uriExpected = String.format( "https://somehost.com/stuff?parameter1=value1¶meter2=%s¶meter3=%s", encodedData1, encodedData2); final HttpUriRequest request = requestBuilder.build(); Assert.assertEquals(uriExpected, request.getURI().toString()); }
/** Generates a cURL command equivalent to the given request. */ private static String toCurl(HttpUriRequest request) throws IOException { StringBuilder builder = new StringBuilder(); builder.append("curl "); for (Header header : request.getAllHeaders()) { builder.append("--header \""); builder.append(header.toString().trim()); builder.append("\" "); } URI uri = request.getURI(); // If this is a wrapped request, use the URI from the original // request instead. getURI() on the wrapper seems to return a // relative URI. We want an absolute URI. if (request instanceof RequestWrapper) { HttpRequest original = ((RequestWrapper) request).getOriginal(); if (original instanceof HttpUriRequest) { uri = ((HttpUriRequest) original).getURI(); } } builder.append("\""); builder.append(uri); builder.append("\""); if (request instanceof HttpEntityEnclosingRequest) { HttpEntityEnclosingRequest entityRequest = (HttpEntityEnclosingRequest) request; HttpEntity entity = entityRequest.getEntity(); if (entity != null && entity.isRepeatable()) { if (entity.getContentLength() < 1024) { ByteArrayOutputStream stream = new ByteArrayOutputStream(); entity.writeTo(stream); String entityString = stream.toString(); // TODO: Check the content type, too. builder.append(" --data-ascii \"").append(entityString).append("\""); } else { builder.append(" [TOO MUCH DATA TO INCLUDE]"); } } } return builder.toString(); }
private void callMethod(HttpUriRequest request, Operation operation) throws IOException { // Specify GData protocol version 2.0. request.addHeader("GData-Version", "2"); // Indicate support for gzip-compressed responses. request.addHeader("Accept-Encoding", "gzip"); // Specify authorization token if provided. String authToken = mAuthToken; if (!TextUtils.isEmpty(authToken)) { request.addHeader("Authorization", "GoogleLogin auth=" + authToken); } // Specify the ETag of a prior response, if available. String etag = operation.inOutEtag; if (etag != null) { request.addHeader("If-None-Match", etag); } // Execute the HTTP request. HttpResponse httpResponse = null; try { httpResponse = mHttpClient.execute(request); } catch (IOException e) { Log.w(TAG, "Request failed: " + request.getURI()); throw e; } // Get the status code and response body. int status = httpResponse.getStatusLine().getStatusCode(); InputStream stream = null; HttpEntity entity = httpResponse.getEntity(); if (entity != null) { // Wrap the entity input stream in a GZIP decoder if necessary. stream = entity.getContent(); if (stream != null) { Header header = entity.getContentEncoding(); if (header != null) { if (header.getValue().contains("gzip")) { stream = new GZIPInputStream(stream); } } } } // Return the stream if successful. Header etagHeader = httpResponse.getFirstHeader("ETag"); operation.outStatus = status; operation.inOutEtag = etagHeader != null ? etagHeader.getValue() : null; operation.outBody = stream; }
/** * 执行请求,返回字节 * * @param charset * @param httpUriRequest * @return */ public byte[] execute_byte(HttpUriRequest httpUriRequest, Map<String, String> header) { byte[] data = null; HttpEntity entity = null; try { CloseableHttpResponse httpResponse = httpclient.execute(httpUriRequest); int statusCode = httpResponse.getStatusLine().getStatusCode(); entity = httpResponse.getEntity(); Header heade = entity.getContentType(); if (heade != null) { log.info("statusCode : " + statusCode + " ContentType : " + heade.getValue()); setContent_type(heade.getValue()); } else { log.info("statusCode : " + statusCode + " ContentType : unknown ."); } setStatusCode(statusCode); if (statusCode == 200) { data = EntityUtils.toByteArray(entity); } else if (statusCode == 302 || statusCode == 300 || statusCode == 301) { URL referer = httpUriRequest.getURI().toURL(); httpUriRequest.abort(); Header location = httpResponse.getFirstHeader("Location"); String locationurl = location.getValue(); if (!locationurl.startsWith("http")) { URL u = new URL(referer, locationurl); locationurl = u.toExternalForm(); } data = GetImg(locationurl, header); } else { data = EntityUtils.toByteArray(entity); } } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { if (httpUriRequest != null) { httpUriRequest.abort(); } if (entity != null) { EntityUtils.consumeQuietly(entity); } } return data; }
@Test public void shouldProxyTheRequestMethodUriBodyAndContentType() throws ServletException, IOException, URISyntaxException { CloseableHttpClient mockHttpClient = mock(CloseableHttpClient.class, Mockito.RETURNS_DEEP_STUBS); AbstractLightblueProxyServlet servlet = getTestServlet(mockHttpClient, null, "http://myservice.com", null); HttpServletRequest stubRequest = new StubHttpServletRequest( "http://my.site.com/app/get/the/thing?foo=bar", "GET", "{test:0}", "application/json", "/get/*"); HttpServletResponse mockResponse = mock(HttpServletResponse.class); ServletOutputStream outputStream = new FakeServletOutputStream(new ByteArrayOutputStream()); when(mockResponse.getOutputStream()).thenReturn(outputStream); servlet.service(stubRequest, mockResponse); ArgumentCaptor<HttpUriRequest> requestCaptor = ArgumentCaptor.forClass(HttpUriRequest.class); verify(mockHttpClient).execute(requestCaptor.capture()); HttpUriRequest request = requestCaptor.getValue(); assertEquals("GET", request.getMethod()); assertEquals(new URI("http://myservice.com/the/thing?foo=bar"), request.getURI()); assertThat(request, instanceOf(HttpEntityEnclosingRequest.class)); assertEquals(1, request.getHeaders("content-type").length); assertEquals("application/json", request.getHeaders("content-type")[0].getValue()); HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest) request; ByteArrayOutputStream entityOutStream = new ByteArrayOutputStream(); entityEnclosingRequest.getEntity().writeTo(entityOutStream); byte[] expectedEntityBytes = new byte[stubRequest.getContentLength()]; stubRequest.getInputStream().read(expectedEntityBytes, 0, stubRequest.getContentLength()); assertEquals(new String(expectedEntityBytes), entityOutStream.toString()); }