public static boolean authenticate() { DefaultHttpClient httpclient = new DefaultHttpClient(); HttpGet get = new HttpGet(Account.getAuthServer()); get.addHeader("X-Auth-User", Account.getUsername()); get.addHeader("X-Auth-Key", Account.getApiKey()); try { HttpResponse resp = httpclient.execute(get); if (resp.getStatusLine().getStatusCode() == 204) { Account.setAuthToken(resp.getFirstHeader("X-Auth-Token").getValue()); Account.setServerUrl(resp.getFirstHeader("X-Server-Management-Url").getValue()); Account.setStorageUrl(resp.getFirstHeader("X-Storage-Url").getValue()); Account.setStorageToken(resp.getFirstHeader("X-Storage-Token").getValue()); Account.setCdnManagementUrl(resp.getFirstHeader("X-Cdn-Management-Url").getValue()); return true; } else { return false; } } catch (ClientProtocolException cpe) { return false; } catch (IOException e) { return false; } }
@Test public void testXForwardedSsl() throws Exception { setProxyHandler(false, false); TestHttpClient client = new TestHttpClient(); try { client.setSSLContext(DefaultServer.getClientSSLContext()); HttpGet get = new HttpGet(DefaultServer.getDefaultServerSSLAddress() + "/x-forwarded"); HttpResponse result = client.execute(get); Assert.assertEquals(StatusCodes.OK, result.getStatusLine().getStatusCode()); Assert.assertEquals( sslPort, Integer.parseInt(result.getFirstHeader(Headers.X_FORWARDED_PORT.toString()).getValue())); Assert.assertEquals( "https", result.getFirstHeader(Headers.X_FORWARDED_PROTO.toString()).getValue()); Assert.assertEquals( "localhost", result.getFirstHeader(Headers.X_FORWARDED_HOST.toString()).getValue()); Assert.assertEquals( DefaultServer.getDefaultServerAddress().getAddress().getHostAddress(), result.getFirstHeader(Headers.X_FORWARDED_FOR.toString()).getValue()); } finally { client.getConnectionManager().shutdown(); } }
@Test public void testSingletonService(@ArquillianResource(MyServiceServlet.class) URL baseURL) throws IOException, URISyntaxException { // URLs look like "http://IP:PORT/singleton/service" URI defaultURI = MyServiceServlet.createURI(baseURL, MyServiceActivator.DEFAULT_SERVICE_NAME); URI quorumURI = MyServiceServlet.createURI(baseURL, MyServiceActivator.QUORUM_SERVICE_NAME); try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) { HttpResponse response = client.execute(new HttpGet(defaultURI)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(NODE_1, response.getFirstHeader("node").getValue()); } finally { HttpClientUtils.closeQuietly(response); } // Service should be started regardless of whether a quorum was required. response = client.execute(new HttpGet(quorumURI)); try { assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(NODE_1, response.getFirstHeader("node").getValue()); } finally { HttpClientUtils.closeQuietly(response); } } }
@Test @OperateOnDeployment(DEPLOYMENT_1) public void testSerialized(@ArquillianResource(SimpleServlet.class) URL baseURL) throws IOException, URISyntaxException { // returns the URL of the deployment (http://127.0.0.1:8180/distributable) URI uri = SimpleServlet.createURI(baseURL); try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) { HttpResponse response = client.execute(new HttpGet(uri)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(1, Integer.parseInt(response.getFirstHeader("value").getValue())); Assert.assertFalse(Boolean.valueOf(response.getFirstHeader("serialized").getValue())); } finally { HttpClientUtils.closeQuietly(response); } response = client.execute(new HttpGet(uri)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(2, Integer.parseInt(response.getFirstHeader("value").getValue())); // This won't be true unless we have somewhere to which to replicate Assert.assertTrue(Boolean.valueOf(response.getFirstHeader("serialized").getValue())); } finally { HttpClientUtils.closeQuietly(response); } } }
byte[] readBody(HttpResponse httpResponse) throws Exception { if (httpResponse == null) return null; httpEntity = httpResponse.getEntity(); if (httpEntity == null) return null; Header zipHeader = httpResponse.getFirstHeader("zip"); boolean zip = zipHeader != null && "true".equals(zipHeader.getValue()); TimerMonitor timerMonitor = new TimerMonitor(this); timerMonitor.startSession(); contentLengthHeader = httpResponse.getFirstHeader(CONTENT_LENGTH); try { byte[] bytes = readBody(contentLengthHeader); if (zip) bytes = new GZipIO().unzip(bytes); if (bytes == null || bytes.length < 1) return bytes; readData = bytes.length; return decodeResponse(bytes, httpEntity.getContentEncoding()); } finally { if (httpEntity instanceof BasicManagedEntity) { BasicManagedEntity entity = (BasicManagedEntity) httpEntity; // System.out.println(" hihi da thay roi 2 " + entity); entity.releaseConnection(); } else { if (httpEntity.getContent() != null) httpEntity.getContent().close(); } } }
@Test public void testReqriteHostHeader() throws Exception { setProxyHandler(true, false); TestHttpClient client = new TestHttpClient(); try { HttpGet get = new HttpGet(DefaultServer.getDefaultServerURL() + "/x-forwarded"); get.addHeader(Headers.X_FORWARDED_FOR.toString(), "50.168.245.32"); HttpResponse result = client.execute(get); Assert.assertEquals(StatusCodes.OK, result.getStatusLine().getStatusCode()); Assert.assertEquals( port, Integer.parseInt(result.getFirstHeader(Headers.X_FORWARDED_PORT.toString()).getValue())); Assert.assertEquals( "http", result.getFirstHeader(Headers.X_FORWARDED_PROTO.toString()).getValue()); Assert.assertEquals( String.format("localhost:%d", port), result.getFirstHeader(Headers.X_FORWARDED_HOST.toString()).getValue()); Assert.assertEquals( DefaultServer.getDefaultServerAddress().getAddress().getHostAddress(), result.getFirstHeader(Headers.X_FORWARDED_FOR.toString()).getValue()); } finally { client.getConnectionManager().shutdown(); } }
@Test public void testUpdate() throws Exception { Patient patient = new Patient(); patient.addIdentifier().setValue("002"); HttpPut httpPost = new HttpPut("http://localhost:" + ourPort + "/Patient/001"); httpPost.setEntity( new StringEntity( ourCtx.newXmlParser().encodeResourceToString(patient), ContentType.create(Constants.CT_FHIR_XML, "UTF-8"))); HttpResponse status = ourClient.execute(httpPost); String responseContent = IOUtils.toString(status.getEntity().getContent()); IOUtils.closeQuietly(status.getEntity().getContent()); ourLog.info("Response was:\n{}", responseContent); OperationOutcome oo = ourCtx.newXmlParser().parseResource(OperationOutcome.class, responseContent); assertEquals("OODETAILS", oo.getIssueFirstRep().getDetails().getValue()); assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals( "http://localhost:" + ourPort + "/Patient/001/_history/002", status.getFirstHeader("location").getValue()); assertEquals( "http://localhost:" + ourPort + "/Patient/001/_history/002", status.getFirstHeader("content-location").getValue()); }
@Test public void testUpdateWithoutConditionalUrl() throws Exception { Patient patient = new Patient(); patient.addIdentifier().setValue("002"); HttpPut httpPost = new HttpPut("http://localhost:" + ourPort + "/Patient/2"); httpPost.setEntity( new StringEntity( ourCtx.newXmlParser().encodeResourceToString(patient), ContentType.create(Constants.CT_FHIR_XML, "UTF-8"))); HttpResponse status = ourClient.execute(httpPost); String responseContent = IOUtils.toString(status.getEntity().getContent()); IOUtils.closeQuietly(status.getEntity().getContent()); ourLog.info("Response was:\n{}", responseContent); assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals( "http://localhost:" + ourPort + "/Patient/001/_history/002", status.getFirstHeader("location").getValue()); assertEquals( "http://localhost:" + ourPort + "/Patient/001/_history/002", status.getFirstHeader("content-location").getValue()); assertEquals("Patient/2", new IdType(ourLastId).toUnqualified().getValue()); assertEquals("Patient/2", ourLastIdParam.toUnqualified().getValue()); assertNull(ourLastConditionalUrl); }
// TODO hmmm, overide resource? public Representation setRepresentationOf(HttpResponse response) { if (response.getFirstHeader("Location") == null) return this; Logger.getLogger(Representation.class.getName()) .log(Level.INFO, "[Header] Location: " + response.getFirstHeader("Location").getValue()); this.resource = new Resource(response.getFirstHeader("Location").getValue()); return this; }
private void configureAdViewUsingHeadersFromHttpResponse(HttpResponse response) { // Print the ad network type to the console. Header ntHeader = response.getFirstHeader("X-Networktype"); if (ntHeader != null) Log.i("MoPub", "Fetching ad network type: " + ntHeader.getValue()); // Set the redirect URL prefix: navigating to any matching URLs will send us to the browser. Header rdHeader = response.getFirstHeader("X-Launchpage"); if (rdHeader != null) mRedirectUrl = rdHeader.getValue(); else mRedirectUrl = null; // Set the URL that is prepended to links for click-tracking purposes. Header ctHeader = response.getFirstHeader("X-Clickthrough"); if (ctHeader != null) mClickthroughUrl = ctHeader.getValue(); else mClickthroughUrl = null; // Set the fall-back URL to be used if the current request fails. Header flHeader = response.getFirstHeader("X-Failurl"); if (flHeader != null) mFailUrl = flHeader.getValue(); else mFailUrl = null; // Set the URL to be used for impression tracking. Header imHeader = response.getFirstHeader("X-Imptracker"); if (imHeader != null) mImpressionUrl = imHeader.getValue(); else mImpressionUrl = null; // Set the webview's scrollability. Header scHeader = response.getFirstHeader("X-Scrollable"); boolean enabled = false; if (scHeader != null) enabled = scHeader.getValue().equals("1"); setWebViewScrollingEnabled(enabled); // Set the width and height. Header wHeader = response.getFirstHeader("X-Width"); Header hHeader = response.getFirstHeader("X-Height"); if (wHeader != null && hHeader != null) { mWidth = Integer.parseInt(wHeader.getValue().trim()); mHeight = Integer.parseInt(hHeader.getValue().trim()); } else { mWidth = 0; mHeight = 0; } // Set the auto-refresh time. A timer will be scheduled upon ad success or failure. Header rtHeader = response.getFirstHeader("X-Refreshtime"); if (rtHeader != null) { mRefreshTimeMilliseconds = Long.valueOf(rtHeader.getValue()) * 1000; if (mRefreshTimeMilliseconds < MINIMUM_REFRESH_TIME_MILLISECONDS) { mRefreshTimeMilliseconds = MINIMUM_REFRESH_TIME_MILLISECONDS; } } else mRefreshTimeMilliseconds = 0; // Set the allowed orientations for this ad. Header orHeader = response.getFirstHeader("X-Orientation"); mAdOrientation = (orHeader != null) ? orHeader.getValue() : null; }
private LoadUrlTaskResult loadAdFromNetwork(String url) throws Exception { HttpGet httpget = new HttpGet(url); httpget.addHeader("User-Agent", mUserAgent); HttpClient httpclient = getAdViewHttpClient(); mResponse = httpclient.execute(httpget); HttpEntity entity = mResponse.getEntity(); // Anything but a 200 OK is an invalid response. if (mResponse.getStatusLine().getStatusCode() != HttpStatus.SC_OK || entity == null || entity.getContentLength() == 0) { throw new Exception("MoPub server returned invalid response."); } // Ensure that the ad type header is valid and not "clear". Header atHeader = mResponse.getFirstHeader("X-Adtype"); if (atHeader == null || atHeader.getValue().equals("clear")) { throw new Exception("MoPub server returned no ad."); } configureAdViewUsingHeadersFromHttpResponse(mResponse); // Handle custom event ad type. if (atHeader.getValue().equals("custom")) { Log.i("MoPub", "Performing custom event."); Header cmHeader = mResponse.getFirstHeader("X-Customselector"); mIsLoading = false; return new PerformCustomEventTaskResult(cmHeader); } // Handle native SDK ad type. else if (!atHeader.getValue().equals("html")) { Log.i("MoPub", "Loading native ad"); Header npHeader = mResponse.getFirstHeader("X-Nativeparams"); if (npHeader != null) { mIsLoading = false; HashMap<String, String> paramsHash = new HashMap<String, String>(); paramsHash.put("X-Adtype", atHeader.getValue()); paramsHash.put("X-Nativeparams", npHeader.getValue()); Header ftHeader = mResponse.getFirstHeader("X-Fulladtype"); if (ftHeader != null) paramsHash.put("X-Fulladtype", ftHeader.getValue()); return new LoadNativeAdTaskResult(paramsHash); } else throw new Exception("Could not load native ad; MoPub provided no parameters."); } // Handle HTML ad. InputStream is = entity.getContent(); StringBuffer out = new StringBuffer(); byte[] b = new byte[4096]; for (int n; (n = is.read(b)) != -1; ) { out.append(new String(b, 0, n)); } return new LoadHtmlAdTaskResult(out.toString()); }
public static boolean isSupportRange(final HttpResponse response) { if (response == null) return false; Header header = response.getFirstHeader("Accept-Ranges"); if (header != null) { return "bytes".equals(header.getValue()); } header = response.getFirstHeader("Content-Range"); if (header != null) { String value = header.getValue(); return value != null && value.startsWith("bytes"); } return false; }
@Test @OperateOnDeployment(DEPLOYMENT_2) // For change, operate on the 2nd deployment first public void testSessionReplication( @ArquillianResource(SimpleServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1, @ArquillianResource(SimpleServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2) throws IOException, URISyntaxException { URI url1 = SimpleServlet.createURI(baseURL1); URI url2 = SimpleServlet.createURI(baseURL2); try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) { HttpResponse response = client.execute(new HttpGet(url1)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(1, Integer.parseInt(response.getFirstHeader("value").getValue())); } finally { HttpClientUtils.closeQuietly(response); } // Lets do this twice to have more debug info if failover is slow. response = client.execute(new HttpGet(url1)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(2, Integer.parseInt(response.getFirstHeader("value").getValue())); } finally { HttpClientUtils.closeQuietly(response); } // Lets wait for the session to replicate waitForReplication(GRACE_TIME_TO_REPLICATE); // Now check on the 2nd server response = client.execute(new HttpGet(url2)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(3, Integer.parseInt(response.getFirstHeader("value").getValue())); } finally { HttpClientUtils.closeQuietly(response); } // Lets do one more check. response = client.execute(new HttpGet(url2)); try { Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Assert.assertEquals(4, Integer.parseInt(response.getFirstHeader("value").getValue())); } finally { HttpClientUtils.closeQuietly(response); } } }
private String executeUrlWithAnswer(DefaultHttpClient client, String url, String message) throws IOException, InterruptedException { int maxWait = GRACE_TIME; while (maxWait > 0) { HttpResponse response = client.execute(new HttpGet(url)); try { if (response.getStatusLine().getStatusCode() < 400 || response.getStatusLine().getStatusCode() > 500) { assertEquals(200, response.getStatusLine().getStatusCode()); Header header = response.getFirstHeader("answer"); if (header != null) { return header.getValue(); } throw new AssertionError( "assertExecuteUrlWithResult didn't get expected answer from executed url=" + url + ", " + message); } } finally { response.getEntity().getContent().close(); } maxWait -= 100; Thread.sleep(100); } throw new AssertionError( "assertExecuteUrlWithResult Timed out trying to execute url=" + url + ", " + message); }
private void executeRequest(HttpUriRequest request, String url) { HttpClient client = new DefaultHttpClient(); HttpResponse httpResponse; try { httpResponse = client.execute(request); responseCode = httpResponse.getStatusLine().getStatusCode(); message = httpResponse.getStatusLine().getReasonPhrase(); HttpEntity entity = httpResponse.getEntity(); if (entity != null) { InputStream instream = entity.getContent(); Header contentEncoding = httpResponse.getFirstHeader("Content-Encoding"); if (contentEncoding != null && contentEncoding.getValue().equalsIgnoreCase("gzip")) { instream = new GZIPInputStream(instream); } response = convertStreamToString(instream); // Closing the input stream will trigger connection release instream.close(); } } catch (ClientProtocolException e) { client.getConnectionManager().shutdown(); e.printStackTrace(); } catch (IOException e) { client.getConnectionManager().shutdown(); } }
@Test public void testUpdateNoResponse() throws Exception { DiagnosticReport dr = new DiagnosticReport(); dr.setId("001"); dr.addCodedDiagnosis().addCoding().setCode("AAA"); String encoded = ourCtx.newXmlParser().encodeResourceToString(dr); ourLog.info("OUT: {}", encoded); HttpPut httpPost = new HttpPut("http://localhost:" + ourPort + "/DiagnosticReport/001"); httpPost.setEntity( new StringEntity(encoded, ContentType.create(Constants.CT_FHIR_XML, "UTF-8"))); HttpResponse status = ourClient.execute(httpPost); try { ourLog.info(IOUtils.toString(status.getEntity().getContent())); assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals( "http://localhost:" + ourPort + "/DiagnosticReport/001/_history/002", status.getFirstHeader("location").getValue()); } finally { IOUtils.closeQuietly(status.getEntity().getContent()); } }
/** {@inheritDoc} */ @Override public boolean isRedirected( final HttpRequest request, final HttpResponse response, final HttpContext context) throws ProtocolException { if (response == null) { throw new IllegalArgumentException("HTTP response may not be null"); } int statusCode = response.getStatusLine().getStatusCode(); String method = request.getRequestLine().getMethod(); Header locationHeader = response.getFirstHeader("location"); switch (statusCode) { case HttpStatus.SC_MOVED_TEMPORARILY: return (method.equalsIgnoreCase(HttpGet.METHOD_NAME) || method.equalsIgnoreCase(HttpPost.METHOD_NAME) || method.equalsIgnoreCase(HttpHead.METHOD_NAME)) && locationHeader != null; case HttpStatus.SC_MOVED_PERMANENTLY: case HttpStatus.SC_TEMPORARY_REDIRECT: return method.equalsIgnoreCase(HttpGet.METHOD_NAME) || method.equalsIgnoreCase(HttpHead.METHOD_NAME) || method.equalsIgnoreCase(HttpPost.METHOD_NAME); case HttpStatus.SC_SEE_OTHER: return true; default: return false; } // end of switch }
/** Reads the contents of HttpEntity into a byte[]. */ private byte[] entityToBytes(HttpResponse httpResponse) throws IOException, ServerError { // private byte[] entityToBytes(HttpEntity entity) throws IOException, ServerError { HttpEntity entity = httpResponse.getEntity(); PoolingByteArrayOutputStream bytes = new PoolingByteArrayOutputStream(mPool, (int) entity.getContentLength()); byte[] buffer = null; try { // InputStream in = entity.getContent(); Header contentEncoding = httpResponse.getFirstHeader("Content-Encoding"); InputStream in = entity.getContent(); if (contentEncoding != null && contentEncoding.getValue().equalsIgnoreCase("gzip")) { in = new GZIPInputStream(in); } if (in == null) { throw new ServerError(); } buffer = mPool.getBuf(1024); int count; while ((count = in.read(buffer)) != -1) { bytes.write(buffer, 0, count); } return bytes.toByteArray(); } finally { try { // Close the InputStream and release the resources by "consuming the content". entity.consumeContent(); } catch (IOException e) { // This can happen if there was an exception above that left the entity in // an invalid state. VolleyLog.v("Error occured when calling consumingContent"); } mPool.returnBuf(buffer); bytes.close(); } }
private Long retrieveLastUpdateDate(ArtifactVersionBean artifactVersionBean) { HttpClient httpClient = new DefaultHttpClient(); String url = String.format( configurer.getArtifactVersionRepositoryPomUrl(), artifactVersionBean.getGroupId().replace(".", "/"), artifactVersionBean.getArtifactId(), artifactVersionBean.getVersion()); HttpHead httpHead = new HttpHead(url); httpHead.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE); // The possible errors here are considered as secondary and will not be seen by the user // We may want to reconsider it try { HttpResponse response = httpClient.execute(httpHead); Header lastUpdateDate = response.getFirstHeader(LAST_MODIFIED_HEADER); if (lastUpdateDate != null) { return DateUtil.parseDate(lastUpdateDate.getValue()).getTime(); } LOGGER.error( "An error occurred while retrieving the last update date for " + artifactVersionBean.getId()); } catch (Exception e) { LOGGER.error( "An error occurred while retrieving the last update date for " + artifactVersionBean.getId(), e); } return null; }
/** * Gets the destination of a redirection * * @return absolute URL of new location; null if not available */ static URI getLocation(HttpRequest request, HttpResponse response, HttpContext context) { Header locationHdr = response.getFirstHeader("Location"); if (locationHdr == null) { Log.e(TAG, "Received redirection without Location header, ignoring"); return null; } try { URI location = URIUtils.parseURI(locationHdr.getValue(), false); // some servers don't return absolute URLs as required by RFC 2616 if (!location.isAbsolute()) { Log.w(TAG, "Received invalid redirection to relative URL, repairing"); URI originalURI = URIUtils.parseURI(request.getRequestLine().getUri(), false); if (!originalURI.isAbsolute()) { final HttpHost target = HttpClientContext.adapt(context).getTargetHost(); if (target != null) originalURI = org.apache.http.client.utils.URIUtilsHC4.rewriteURI(originalURI, target); else return null; } return originalURI.resolve(location); } return location; } catch (URISyntaxException e) { Log.e(TAG, "Received redirection from/to invalid URI, ignoring", e); } return null; }
@Override public Message callBlockingMethod( @NotNull Descriptors.MethodDescriptor method, @Nullable RpcController controller, @NotNull Message request, @NotNull Message responsePrototype) throws ServiceException { try { final HttpUriRequest httpRequest = createRequest(method, request); final HttpResponse response = client.execute(httpRequest); if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) { try (final InputStream stream = response.getEntity().getContent()) { final Header encoding = response.getFirstHeader(HttpHeaders.CONTENT_ENCODING); final Charset charset; if (encoding != null && Charset.isSupported(encoding.getValue())) { charset = Charset.forName(encoding.getValue()); } else { charset = StandardCharsets.UTF_8; } return format.read(responsePrototype.toBuilder(), stream, charset).build(); } } return null; } catch (Exception e) { throw new ServiceException(e); } }
public static void headerRequest() { try { HttpClient client = HttpClientBuilder.create().build(); HttpGet request = new HttpGet("http://mkyong.com"); HttpResponse response = client.execute(request); System.out.println("Printing Response Header...\n"); Header[] headers = response.getAllHeaders(); for (Header header : headers) { System.out.println("Key : " + header.getName() + " ,Value : " + header.getValue()); } System.out.println("\nGet Response Header By Key ...\n"); String server = response.getFirstHeader("Server").getValue(); if (server == null) { System.out.println("Key 'Server' is not found!"); } else { System.out.println("Server - " + server); } System.out.println("\n Done"); } catch (Exception e) { e.printStackTrace(); } }
/** * 获取跳转路径 * * @param response * @return */ public String getRedirectLocation(HttpResponse response) { Header locationHeader = response.getFirstHeader("Location"); if (locationHeader == null) { return null; } return locationHeader.getValue(); }
@Override public Result<T> list() throws EvrythngException { if (getCommand().getMethod() != Method.GET) { throw new EvrythngClientException("The list() method is only available for GET requests."); } logger.debug("Call list. For type : {}", getCommand().getResponseType().getType()); // Issue the command "manually" to get the response object. TypedResponseWithEntity<T> bundle = getCommand().bundle(); HttpResponse response = bundle.response(); Utils.assertStatus(response, getCommand().getExpectedResponseStatus()); T ret = bundle.entity(); // Parse the total result count. Header header = response.getFirstHeader(ApiConfiguration.HTTP_HEADER_RESULT_COUNT); long n; if (header == null) { throw new EvrythngClientException( "The response contains no " + ApiConfiguration.HTTP_HEADER_RESULT_COUNT + " header."); } try { n = Long.parseLong(header.getValue()); } catch (NumberFormatException e) { throw new EvrythngClientException( "The response's " + ApiConfiguration.HTTP_HEADER_RESULT_COUNT + " header could not be parsed."); } logger.debug("Total number of items: {}", n); return new Result<>(ret, n); }
@Test public void testUpdateWithVersion() throws Exception { DiagnosticReport dr = new DiagnosticReport(); dr.setId("001"); dr.getIdentifier().setValue("001"); HttpPut httpPut = new HttpPut("http://localhost:" + ourPort + "/DiagnosticReport/001"); httpPut.addHeader("Content-Location", "/DiagnosticReport/001/_history/004"); httpPut.setEntity( new StringEntity( ourCtx.newXmlParser().encodeResourceToString(dr), ContentType.create(Constants.CT_FHIR_XML, "UTF-8"))); HttpResponse status = ourClient.execute(httpPut); IOUtils.closeQuietly(status.getEntity().getContent()); // String responseContent = // IOUtils.toString(status.getEntity().getContent()); // ourLog.info("Response was:\n{}", responseContent); assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals( "http://localhost:" + ourPort + "/DiagnosticReport/001/_history/002", status.getFirstHeader("Location").getValue()); }
@RequestMapping(value = "/kkn1234/create", method = RequestMethod.POST) public String formSubmit(@ModelAttribute User user, Model model) throws MalformedURLException, IOException { model.addAttribute("user", user); HttpPost post = new HttpPost( "http://ec2-52-4-138-196.compute-1.amazonaws.com/magento/index.php/customer/account/createpost/"); BasicCookieStore cookieStore = new BasicCookieStore(); CloseableHttpClient httpclient = HttpClients.custom().setDefaultCookieStore(cookieStore).build(); List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(); nameValuePairs.add(new BasicNameValuePair("firstname", user.getFirstName())); nameValuePairs.add(new BasicNameValuePair("lastname", user.getLastName())); nameValuePairs.add(new BasicNameValuePair("email", user.getEmail())); nameValuePairs.add(new BasicNameValuePair("password", user.getPassword())); nameValuePairs.add(new BasicNameValuePair("confirmation", user.getConfirmation())); post.setEntity(new UrlEncodedFormEntity(nameValuePairs)); HttpResponse response = httpclient.execute(post); response = httpclient.execute(post); System.out.println("Status code is " + response.getStatusLine().getStatusCode()); System.out.println(response.toString()); System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++"); System.out.println(response.getFirstHeader("Location")); HttpEntity entity = response.getEntity(); EntityUtils.consume(entity); EntityUtils.consume(response.getEntity()); /*File newTextFile = new File("C:\\Users\\Kris\\Desktop\\temp.html"); FileWriter fileWriter = new FileWriter(newTextFile); fileWriter.write(response.toString()); fileWriter.close();*/ return "result"; }
protected void ssoLogin1(SimpleObject context) { Request req1 = ContextUtil.getRequest(context); Integer scode = (Integer) req1.getExtra(Request.STATUS_CODE); if (HttpUtil.isMovedStatusCode(scode)) { HttpResponse resp = ContextUtil.getResponse(context); Header h1 = resp.getFirstHeader("Location"); String nexturl = h1.getValue(); if (nexturl == null) { logger.error("Error : No Redirect URL"); } else { Request req = new Request(nexturl); req.setCharset(UAM_CHAR_SET); req.addObjservers( new AbstractProcessorObserver(util, WaringConstaint.ZGDX_7) { @Override public void afterRequest(SimpleObject context) { ssoLogin1(context); } }); spider.addRequest(req); } } else { endSSOLogin(context); } }
protected void parseLoginPage(SimpleObject context, final String prefix, final String phone) { Request req1 = ContextUtil.getRequest(context); Integer scode = (Integer) req1.getExtra(Request.STATUS_CODE); // DebugUtil.printCookieData(ContextUtil.getCookieStore(context), null); if (HttpUtil.isMovedStatusCode(scode)) { HttpResponse resp = ContextUtil.getResponse(context); Header h1 = resp.getFirstHeader("Location"); String nexturl = h1.getValue(); if (nexturl == null) { logger.error("Error : No Redirect URL"); } else { nexturl = fixedFullUrl(nexturl); Request req = new Request(nexturl.replaceAll(" ", "%20")); req.setCharset(UAM_CHAR_SET); req.putHeader("Referer", "http://www.189.cn/dqmh/login/loginJT.jsp"); req.addObjservers( new AbstractProcessorObserver(util, WaringConstaint.ZGDX_2) { @Override public void afterRequest(SimpleObject context) { parseLoginPage(context, prefix, phone); } }); spider.addRequest(req); } } else { if (prefix != null) { // com.lkb.debug.DebugUtil.printCookieData(ContextUtil.getCookieStore(context), null); saveVerifyImage(context, prefix, phone); } else { parseLoginStep2(context); } } }
@Override public void backchannelLogout(UserSessionModel userSession, ClientSessionModel clientSession) { ClientModel client = clientSession.getClient(); SamlClient samlClient = new SamlClient(client); String logoutUrl = getLogoutServiceUrl(uriInfo, client, SAML_POST_BINDING); if (logoutUrl == null) { logger.warnv( "Can't do backchannel logout. No SingleLogoutService POST Binding registered for client: {1}", client.getClientId()); return; } SAML2LogoutRequestBuilder logoutBuilder = createLogoutRequest(logoutUrl, clientSession, client); String logoutRequestString = null; try { JaxrsSAML2BindingBuilder binding = createBindingBuilder(samlClient); logoutRequestString = binding.postBinding(logoutBuilder.buildDocument()).encoded(); } catch (Exception e) { logger.warn("failed to send saml logout", e); return; } HttpClient httpClient = session.getProvider(HttpClientProvider.class).getHttpClient(); for (int i = 0; i < 2; i++) { // follow redirects once try { List<NameValuePair> formparams = new ArrayList<NameValuePair>(); formparams.add( new BasicNameValuePair(GeneralConstants.SAML_REQUEST_KEY, logoutRequestString)); formparams.add( new BasicNameValuePair("BACK_CHANNEL_LOGOUT", "BACK_CHANNEL_LOGOUT")); // for Picketlink // todo remove // this UrlEncodedFormEntity form = new UrlEncodedFormEntity(formparams, "UTF-8"); HttpPost post = new HttpPost(logoutUrl); post.setEntity(form); HttpResponse response = httpClient.execute(post); try { int status = response.getStatusLine().getStatusCode(); if (status == 302 && !logoutUrl.endsWith("/")) { String redirect = response.getFirstHeader(HttpHeaders.LOCATION).getValue(); String withSlash = logoutUrl + "/"; if (withSlash.equals(redirect)) { logoutUrl = withSlash; continue; } } } finally { HttpEntity entity = response.getEntity(); if (entity != null) { InputStream is = entity.getContent(); if (is != null) is.close(); } } } catch (IOException e) { logger.warn("failed to send saml logout", e); } break; } }
@Test public void testGetAndCheckKey() throws Exception { HttpClient httpClient = new DefaultHttpClient(); HttpPost post = new HttpPost("http://*****:*****@gmail.com")); nvps.add(new BasicNameValuePair("password", "Purbrick7")); post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8)); HttpResponse response = httpClient.execute(post); assertEquals(200, response.getStatusLine().getStatusCode()); HttpEntity entity = response.getEntity(); String responseContent = IOUtils.toString(entity.getContent()); System.out.println(response.getFirstHeader("Content-Type")); System.out.println(responseContent); JSONObject jsonObj = (JSONObject) new JSONParser().parse(responseContent); HttpPost post2 = new HttpPost("http://*****:*****@gmail.com")); nvps2.add(new BasicNameValuePair("authKey", (String) jsonObj.get("authKey"))); post2.setEntity(new UrlEncodedFormEntity(nvps2, HTTP.UTF_8)); HttpResponse response2 = httpClient.execute(post2); assertEquals(200, response2.getStatusLine().getStatusCode()); }