protected Object execute(Request request, HttpUriRequest httpReq) throws Exception {
for (Map.Entry<String, String> entry : request.entrySet()) {
httpReq.setHeader(entry.getKey(), entry.getValue());
}
HttpResponse resp = executeRequestWithTimeout(httpReq);
HttpEntity entity = resp.getEntity();
int status = resp.getStatusLine().getStatusCode();
if (entity == null) {
if (status < 400) {
return null;
}
throw new RemoteException(status, "ServerError", "Server Error", (Throwable) null);
}
Header ctypeHeader = entity.getContentType();
if (ctypeHeader == null) { // handle broken responses with no ctype
if (status != 200) {
// this may happen when login failed
throw new RemoteException(status, "ServerError", "Server Error", (Throwable) null);
}
return null; // cannot handle responses with no ctype
}
String ctype = ctypeHeader.getValue();
String disp = null;
Header[] hdisp = resp.getHeaders("Content-Disposition");
if (hdisp != null && hdisp.length > 0) {
disp = hdisp[0].getValue();
}
return request.handleResult(status, ctype, disp, entity.getContent());
}
@Test
public void contentType() throws Exception {
server.enqueue(
new MockResponse()
.setBody("<html><body><h1>Hello, World!</h1></body></html>")
.setHeader("Content-Type", "text/html"));
server.enqueue(
new MockResponse()
.setBody("{\"Message\": { \"text\": \"Hello, World!\" } }")
.setHeader("Content-Type", "application/json"));
server.enqueue(new MockResponse().setBody("Hello, World!"));
HttpGet request1 = new HttpGet(server.getUrl("/").toURI());
HttpResponse response1 = client.execute(request1);
Header[] headers1 = response1.getHeaders("Content-Type");
assertEquals(1, headers1.length);
assertEquals("text/html", headers1[0].getValue());
assertNotNull(response1.getEntity().getContentType());
assertEquals("text/html", response1.getEntity().getContentType().getValue());
HttpGet request2 = new HttpGet(server.getUrl("/").toURI());
HttpResponse response2 = client.execute(request2);
Header[] headers2 = response2.getHeaders("Content-Type");
assertEquals(1, headers2.length);
assertEquals("application/json", headers2[0].getValue());
assertNotNull(response2.getEntity().getContentType());
assertEquals("application/json", response2.getEntity().getContentType().getValue());
HttpGet request3 = new HttpGet(server.getUrl("/").toURI());
HttpResponse response3 = client.execute(request3);
Header[] headers3 = response3.getHeaders("Content-Type");
assertEquals(0, headers3.length);
assertNull(response3.getEntity().getContentType());
}
private void retrieveMonitorDetails(final HttpResponse res) {
Header[] headers = res.getHeaders(HttpHeader.LOCATION);
if (ArrayUtils.isNotEmpty(headers)) {
this.location = URI.create(headers[0].getValue());
} else {
throw new AsyncRequestException(
"Invalid async request response. Monitor URL '" + headers[0].getValue() + "'");
}
headers = res.getHeaders(HttpHeader.RETRY_AFTER);
if (ArrayUtils.isNotEmpty(headers)) {
this.retryAfter = Integer.parseInt(headers[0].getValue());
}
headers = res.getHeaders(HttpHeader.PREFERENCE_APPLIED);
if (ArrayUtils.isNotEmpty(headers)) {
for (Header header : headers) {
if (header.getValue().equalsIgnoreCase(new ODataPreferences().respondAsync())) {
preferenceApplied = true;
}
}
}
try {
EntityUtils.consume(res.getEntity());
} catch (IOException ex) {
Logger.getLogger(AsyncRequestWrapperImpl.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Test
public void inMemorySessionTest() throws IOException {
TestHttpClient client = new TestHttpClient();
client.setCookieStore(new BasicCookieStore());
final CookieHandler cookieHandler = new CookieHandler();
try {
final SessionCookieConfig sessionConfig = new SessionCookieConfig();
final SessionAttachmentHandler handler =
new SessionAttachmentHandler(new InMemorySessionManager(), sessionConfig);
handler.setNext(
new HttpHandler() {
@Override
public void handleRequest(final HttpServerExchange exchange) throws Exception {
final SessionManager manager = exchange.getAttachment(SessionManager.ATTACHMENT_KEY);
Session session = manager.getSession(exchange, sessionConfig);
if (session == null) {
session = manager.createSession(exchange, sessionConfig);
session.setAttribute(COUNT, 0);
}
Integer count = (Integer) session.getAttribute(COUNT);
exchange.getResponseHeaders().add(new HttpString(COUNT), count.toString());
session.setAttribute(COUNT, ++count);
HttpHandlers.executeHandler(ResponseCodeHandler.HANDLE_200, exchange);
}
});
cookieHandler.setNext(handler);
DefaultServer.setRootHandler(cookieHandler);
HttpGet get = new HttpGet(DefaultServer.getDefaultServerURL() + "/notamatchingpath");
HttpResponse result = client.execute(get);
Assert.assertEquals(200, result.getStatusLine().getStatusCode());
HttpClientUtils.readResponse(result);
Header[] header = result.getHeaders(COUNT);
Assert.assertEquals("0", header[0].getValue());
get = new HttpGet(DefaultServer.getDefaultServerURL() + "/notamatchingpath");
result = client.execute(get);
Assert.assertEquals(200, result.getStatusLine().getStatusCode());
HttpClientUtils.readResponse(result);
header = result.getHeaders(COUNT);
Assert.assertEquals("1", header[0].getValue());
get = new HttpGet(DefaultServer.getDefaultServerURL() + "/notamatchingpath");
result = client.execute(get);
Assert.assertEquals(200, result.getStatusLine().getStatusCode());
HttpClientUtils.readResponse(result);
header = result.getHeaders(COUNT);
Assert.assertEquals("2", header[0].getValue());
} finally {
client.getConnectionManager().shutdown();
}
}
// retrieves a group, by ID, from the server
public static boolean fromServer(String id) {
HttpResponse resp = Connection.getRequest("/" + tableName + "/" + id);
if (resp == null || resp.getStatusLine().getStatusCode() != 200) return false;
Group g = new Group();
g._id = Integer.parseInt(resp.getHeaders("Id")[0].getValue());
g.name = resp.getHeaders("Name")[0].getValue();
g.desc = resp.getHeaders("Desc")[0].getValue();
g.website = resp.getHeaders("Website")[0].getValue();
g.globalSaved = true;
return g.saveLocally();
}
public HttpGet addCookiesToChannel(HttpResponse login, HttpGet getChannel) {
for (Header singleHeader : login.getHeaders("Set-Cookie")) {
for (HeaderElement element : singleHeader.getElements()) {
System.out.println(element.getName() + " : " + element.getValue());
}
}
getChannel.addHeader("X-Reguested-With", "XMLHttpReguest");
HeaderElement phpElement = login.getHeaders("Set-Cookie")[0].getElements()[0];
String php = phpElement.getName() + "=" + phpElement.getValue();
HeaderElement netviElement = login.getHeaders("Set-Cookie")[1].getElements()[1];
String netvi = netviElement.getName() + "=" + netviElement.getValue();
getChannel.addHeader("Cookie", php);
getChannel.addHeader("Cookie", netvi);
return getChannel;
}
@Test
public void contentEncoding() throws Exception {
String text = "{\"Message\": { \"text\": \"Hello, World!\" } }";
ByteArrayOutputStream bodyBytes = new ByteArrayOutputStream();
OutputStreamWriter body =
new OutputStreamWriter(new GZIPOutputStream(bodyBytes), Charset.forName("UTF-8"));
body.write(text);
body.close();
server.enqueue(
new MockResponse().setBody(bodyBytes.toByteArray()).setHeader("Content-Encoding", "gzip"));
byte[] tmp = new byte[32];
HttpGet request1 = new HttpGet(server.getUrl("/").toURI());
request1.setHeader("Accept-encoding", "gzip"); // not transparent gzip
HttpResponse response1 = client.execute(request1);
Header[] headers1 = response1.getHeaders("Content-Encoding");
assertEquals(1, headers1.length);
assertEquals("gzip", headers1[0].getValue());
assertNotNull(response1.getEntity().getContentEncoding());
assertEquals("gzip", response1.getEntity().getContentEncoding().getValue());
InputStream content = new GZIPInputStream(response1.getEntity().getContent());
ByteArrayOutputStream rspBodyBytes = new ByteArrayOutputStream();
for (int len = content.read(tmp); len >= 0; len = content.read(tmp)) {
rspBodyBytes.write(tmp, 0, len);
}
String decodedContent = rspBodyBytes.toString("UTF-8");
assertEquals(text, decodedContent);
}
public String publishMessage(String topic, String tenant, String continuationGuid, byte[] data)
throws MessagePublishException {
final HttpPost method = new HttpPost(this.url + topic);
final String authToken = tenant == null ? this.capabilityToken : tenantTokens.get(tenant);
method.addHeader(
new BasicHeader(
HttpHeaders.AUTHORIZATION, "Bearer " + (authToken == null ? tenant : authToken)));
method.addHeader(new BasicHeader(HttpHeaders.CONTENT_TYPE, "avro/binary"));
if (continuationGuid != null) {
method.addHeader(new BasicHeader("X-XC-MESSAGE-GUID-CONTINUATION", continuationGuid));
}
method.setEntity(new ByteArrayEntity(data));
try {
final HttpResponse response = this.client.execute(method);
if (response.getStatusLine().getStatusCode() != 200) {
throw new MessagePublishException(response.getStatusLine().toString());
}
response.getEntity().getContent().close(); // needed to be able to
// reuse the connection
return response.getHeaders("X-XC-MESSAGE-GUID")[0].getValue();
} catch (ClientProtocolException e) {
throw new MessagePublishException(e);
} catch (IOException e) {
throw new MessagePublishException(e);
}
}
private int parseClockSkewOffset(
org.apache.http.HttpResponse response, AmazonServiceException exception) {
Date deviceDate = new Date();
Date serverDate = null;
String serverDateStr = null;
Header[] responseDateHeader = response.getHeaders("Date");
try {
if (responseDateHeader.length == 0) {
// SQS doesn't return Date header
serverDateStr = getServerDateFromException(exception.getMessage());
serverDate = DateUtils.parseCompressedISO8601Date(serverDateStr);
} else {
serverDateStr = responseDateHeader[0].getValue();
serverDate = DateUtils.parseRFC822Date(serverDateStr);
}
} catch (RuntimeException e) {
log.warn("Unable to parse clock skew offset from response: " + serverDateStr, e);
return 0;
}
long diff = deviceDate.getTime() - serverDate.getTime();
return (int) (diff / 1000);
}
// create datastream
public Datastream createDatastream(Integer feedid, Datastream datastream) throws CosmException {
try {
HttpPost request =
new HttpPost(
API_BASE_URL_V2
+ API_RESOURCE_FEEDS
+ "/"
+ feedid
+ "/datastreams"
+ JSON_FILE_EXTENSION);
JSONObject jo = new JSONObject();
jo.put("version", Cosm.VERSION);
JSONArray ja = new JSONArray();
ja.put(datastream.toJSONObject());
jo.put("datastreams", ja);
request.setEntity(new StringEntity(jo.toString()));
HttpResponse response = this.client.execute(request);
StatusLine statusLine = response.getStatusLine();
if (statusLine.getStatusCode() == 201) {
String a[] = response.getHeaders(HEADER_PARAM_LOCATION)[0].getValue().split("/");
String datastreamid = a[a.length - 1];
this.client.getBody(response);
return this.getDatastream(feedid, datastreamid);
}
throw new HttpException(response.getStatusLine().toString());
} catch (Exception e) {
e.printStackTrace();
throw new CosmException("Caught exception in create Datastream" + e.getMessage());
}
}
@Override
public R getODataResponse() {
HttpResponse res = null;
for (int i = 0; response == null && i < MAX_RETRY; i++) {
res = checkMonitor(location);
if (res.getStatusLine().getStatusCode() == HttpStatusCode.ACCEPTED.getStatusCode()) {
final Header[] headers = res.getHeaders(HttpHeader.RETRY_AFTER);
if (ArrayUtils.isNotEmpty(headers)) {
this.retryAfter = Integer.parseInt(headers[0].getValue());
}
try {
// wait for retry-after
Thread.sleep(retryAfter * 1000);
} catch (InterruptedException ignore) {
// ignore
}
} else {
location = null;
return instantiateResponse(res);
}
}
if (response == null) {
throw new ODataClientErrorException(res == null ? null : res.getStatusLine());
}
return response;
}
public String getCookie(String url) {
final CookieManager cookieManager = CookieManager.getInstance();
String cookie = cookieManager.getCookie(url);
if (cookie == null || cookie.length() == 0) {
final HttpHead head = new HttpHead(url);
HttpEntity entity = null;
try {
final HttpResponse response = HttpManager.execute(head);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
entity = response.getEntity();
final Header[] cookies = response.getHeaders("set-cookie");
for (Header cooky : cookies) {
cookieManager.setCookie(url, cooky.getValue());
}
CookieSyncManager.getInstance().sync();
cookie = cookieManager.getCookie(url);
}
} catch (IOException e) {
Log.e(LOG_TAG, "Could not retrieve cookie", e);
} finally {
if (entity != null) {
try {
entity.consumeContent();
} catch (IOException e) {
Log.e(LOG_TAG, "Could not retrieve cookie", e);
}
}
}
}
return cookie;
}
@Test
public void should_head_all_resource() throws IOException {
runWithConfiguration("rest/rest.json");
org.apache.http.HttpResponse httpResponse = helper.headForResponse(remoteUrl("/all-resources"));
assertThat(httpResponse.getStatusLine().getStatusCode(), is(200));
assertThat(httpResponse.getHeaders("ETag")[0].getValue(), is("Moco"));
}
private void performAuthentication(DefaultHttpClient httpClient, AuthToken authToken)
throws IOException, AuthenticationException {
HttpResponse resp;
final ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair(PARAM_USERNAME, authToken.username));
params.add(new BasicNameValuePair(PARAM_PASSWORD, authToken.password));
params.add(new BasicNameValuePair(PARAM_USER_TIME, "dummy"));
final HttpEntity entity;
try {
entity = new UrlEncodedFormEntity(params);
} catch (final UnsupportedEncodingException e) {
// this should never happen.
throw new IllegalStateException(e);
}
String uri =
BASE_URL
+ "?"
+ URLEncodedUtils.format(
Arrays.asList(new BasicNameValuePair(XML_ID, AUTH_XML_ID)), ENCODING);
Log.i(TAG, "Authenticating to: " + uri);
final HttpPost post = new HttpPost(uri);
post.addHeader(entity.getContentType());
post.setHeader("Accept", "*/*");
post.setEntity(entity);
resp = httpClient.execute(post);
// check for bad status
if (resp.getStatusLine().getStatusCode() != HttpStatus.SC_MOVED_TEMPORARILY) {
throw new ParseException(
"status after auth: "
+ resp.getStatusLine().getStatusCode()
+ " "
+ resp.getStatusLine().getReasonPhrase());
}
// check header redirect
Header[] locations = resp.getHeaders(HEADER_LOCATION);
if (locations.length != 1) {
throw new ParseException(locations.length + " header locations received!");
}
String location = "https://" + DOMAIN + locations[0].getValue();
Log.v(TAG, "location=" + location);
UrlQuerySanitizer sanitizer = new UrlQuerySanitizer(location);
authToken.userId = sanitizer.getValue(PARAM_USER_ID);
authToken.sessionId = sanitizer.getValue(PARAM_SESSION_ID);
String redirectedXmlId = sanitizer.getValue(XML_ID);
if (authToken.userId == null
|| authToken.userId.length() == 0
|| authToken.sessionId == null
|| authToken.sessionId.length() == 0
|| AUTH_XML_ID.equalsIgnoreCase(redirectedXmlId)) {
checkAuthError(sanitizer);
}
}
@Test
public void headers() throws Exception {
server.enqueue(new MockResponse().addHeader("Foo", "Bar"));
server.enqueue(new MockResponse().addHeader("Foo", "Bar").addHeader("Foo", "Baz"));
HttpGet request1 = new HttpGet(server.getUrl("/").toURI());
HttpResponse response1 = client.execute(request1);
Header[] headers1 = response1.getHeaders("Foo");
assertEquals(1, headers1.length);
assertEquals("Bar", headers1[0].getValue());
HttpGet request2 = new HttpGet(server.getUrl("/").toURI());
HttpResponse response2 = client.execute(request2);
Header[] headers2 = response2.getHeaders("Foo");
assertEquals(2, headers2.length);
assertEquals("Bar", headers2[0].getValue());
assertEquals("Baz", headers2[1].getValue());
}
/**
* Creates request against SPNEGO protected web-app with FORM fallback. It doesn't try to login
* using SPNEGO - it uses FORM authn directly.
*
* @param contextUrl
* @param page
* @param user
* @param pass
* @param expectedStatusCode
* @return
* @throws IOException
* @throws URISyntaxException
* @throws PrivilegedActionException
* @throws LoginException
*/
public static String makeHttpCallWoSPNEGO(
final String contextUrl,
final String page,
final String user,
final String pass,
final int expectedStatusCode)
throws IOException, URISyntaxException, PrivilegedActionException, LoginException {
final String strippedContextUrl = StringUtils.stripEnd(contextUrl, "/");
final String url = strippedContextUrl + page;
LOGGER.info("Requesting URL: " + url);
final DefaultHttpClient httpClient = new DefaultHttpClient();
httpClient.setRedirectStrategy(REDIRECT_STRATEGY);
String unauthorizedPageBody = null;
try {
final HttpGet httpGet = new HttpGet(url);
HttpResponse response = httpClient.execute(httpGet);
int statusCode = response.getStatusLine().getStatusCode();
if (HttpServletResponse.SC_UNAUTHORIZED != statusCode || StringUtils.isEmpty(user)) {
assertEquals("Unexpected HTTP response status code.", expectedStatusCode, statusCode);
return EntityUtils.toString(response.getEntity());
}
final Header[] authnHeaders = response.getHeaders("WWW-Authenticate");
assertTrue(
"WWW-Authenticate header is present", authnHeaders != null && authnHeaders.length > 0);
final Set<String> authnHeaderValues = new HashSet<String>();
for (final Header header : authnHeaders) {
authnHeaderValues.add(header.getValue());
}
assertTrue(
"WWW-Authenticate: Negotiate header is missing", authnHeaderValues.contains("Negotiate"));
LOGGER.debug("HTTP response was SC_UNAUTHORIZED, let's authenticate the user " + user);
unauthorizedPageBody = EntityUtils.toString(response.getEntity());
assertNotNull(unauthorizedPageBody);
LOGGER.info(unauthorizedPageBody);
assertTrue(unauthorizedPageBody.contains("j_security_check"));
HttpPost httpPost = new HttpPost(strippedContextUrl + "/j_security_check");
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
nameValuePairs.add(new BasicNameValuePair("j_username", user));
nameValuePairs.add(new BasicNameValuePair("j_password", pass));
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
response = httpClient.execute(httpPost);
statusCode = response.getStatusLine().getStatusCode();
assertEquals(
"Unexpected status code returned after the authentication.",
expectedStatusCode,
statusCode);
return EntityUtils.toString(response.getEntity());
} finally {
// When HttpClient instance is no longer needed,
// shut down the connection manager to ensure
// immediate deallocation of all system resources
httpClient.getConnectionManager().shutdown();
}
}
/**
* Helper method to check that a response has the default X-FRAME-OPTIONS and
* Content-Security-Policy headers. If your test doesn't use the default security policy, you get
* to roll your own validation of that, of course.
*
* <p>Asserts if anything is wrong.
*
* <p>As a safety provision, if the config adapter *isn't* recognized as "ours," we don't check
* anything. (This covers the fact that inside SFDC, we have a different config adapter with a
* different default CSP.)
*
* @param response
* @param guarded If {@code true}, check that we HAVE headers. If {@code false}, check that they
* are absent.
* @param allowInline Allows inline script-src and style-src
*/
protected void assertDefaultAntiClickjacking(
HttpResponse response, boolean guarded, boolean allowInline) {
String adapterClassName = Aura.getConfigAdapter().getClass().getName();
if (adapterClassName.equals("org.auraframework.impl.adapter.ConfigAdapterImpl")
|| adapterClassName.equals("org.auraframework.impl.adapter.MockConfigAdapterImpl")) {
Header[] headers = response.getHeaders("X-FRAME-OPTIONS");
if (guarded) {
Map<String, String> csp = getCSP(response);
assertEquals("frame-ancestors is wrong", "'self'", csp.get("frame-ancestors"));
if (allowInline) {
assertEquals(
"script-src is wrong",
"'self' chrome-extension: 'unsafe-eval' 'unsafe-inline'",
csp.get("script-src"));
assertEquals(
"style-src is wrong",
"'self' chrome-extension: 'unsafe-inline'",
csp.get("style-src"));
} else {
assertEquals("script-src is wrong", "'self' chrome-extension:", csp.get("script-src"));
assertEquals("style-src is wrong", "'self' chrome-extension:", csp.get("style-src"));
}
// These maybe aren't strictly "anti-clickjacking", but since we're testing the rest of the
// default CSP:
assertEquals("font-src is wrong", "*", csp.get("font-src"));
assertEquals("img-src is wrong", "*", csp.get("img-src"));
assertEquals("media-src is wrong", "*", csp.get("media-src"));
assertEquals("default-src is wrong", "'self'", csp.get("default-src"));
assertEquals("object-src is wrong", "'self'", csp.get("object-src"));
assertEquals(
"connect-src is wrong",
"'self' http://invalid.salesforce.com http://offline https://offline",
csp.get("connect-src"));
assertEquals("wrong number of X-FRAME-OPTIONS header lines", 1, headers.length);
assertEquals("SAMEORIGIN", headers[0].getValue());
} else {
headers = response.getHeaders("Content-Security-Policy");
assertEquals(0, headers.length);
// Check X-FRAME-OPTIONS vis-a-vis CSP
assertEquals("wrong number of X-FRAME-OPTIONS header lines", 0, headers.length);
}
}
}
@Then("^the user should receive a specified JSON content$")
public void jsonResponse() throws Exception {
assertThat(response.getHeaders("Content-Type"))
.extracting(Header::getValue)
.containsExactly(org.apache.http.entity.ContentType.APPLICATION_JSON.toString());
DocumentContext jsonPath = JsonPath.parse(response.getEntity().getContent());
assertThat(jsonPath.<String>read("blobId")).isEqualTo(_1M_ZEROED_FILE_BLOB_ID);
assertThat(jsonPath.<String>read("type")).isEqualTo("application/octet-stream");
assertThat(jsonPath.<Integer>read("size")).isEqualTo(_1M);
}
private static Set<String> getConnectionTokensFromResponse(HttpResponse resp) {
Set<String> result = new HashSet<String>();
for (Header header : resp.getHeaders(CONNECTION_HEADER)) {
for (HeaderElement element : header.getElements()) {
// RFC 2616 14.10: connection tokens don't have values
result.add(element.getName().toLowerCase());
}
}
return result;
}
private void runPathTest(
TestHttpClient client,
String path,
String expectedMatch,
String expectedRemaining,
Map<String, String> queryParams)
throws IOException {
HttpResponse result;
HttpGet get = new HttpGet(DefaultServer.getDefaultServerAddress() + path);
result = client.execute(get);
Assert.assertEquals(200, result.getStatusLine().getStatusCode());
Header[] header = result.getHeaders(MATCHED);
Assert.assertEquals(expectedMatch, header[0].getValue());
header = result.getHeaders(PATH);
Assert.assertEquals(expectedRemaining, header[0].getValue());
HttpClientUtils.readResponse(result);
for (Map.Entry<String, String> entry : queryParams.entrySet()) {
header = result.getHeaders(entry.getKey());
Assert.assertEquals(entry.getValue(), header[0].getValue());
}
}
@Test
public void should_head() throws IOException {
runWithConfiguration("rest/rest.json");
final Plain resource1 = new Plain();
resource1.code = 1;
resource1.message = "hello";
org.apache.http.HttpResponse httpResponse = helper.headForResponse(remoteUrl("/targets/1"));
assertThat(httpResponse.getStatusLine().getStatusCode(), is(200));
assertThat(httpResponse.getHeaders("ETag")[0].getValue(), is("Moco"));
}
/**
* Helper to take the Content-Security-Policy header and break it into its individual components.
* If the header is missing, this will fail the test with an assertion. Otherwise, a map keyed by
* the various CSP directives (script-src, style-src, etc.) with the literal values of each
* directive is returned.
*
* @param response
* @return a map of directive to value.
*/
protected Map<String, String> getCSP(HttpResponse response) {
Header[] headers = response.getHeaders("Content-Security-Policy");
assertEquals("wrong number of CSP header lines", 1, headers.length);
String[] split = headers[0].getValue().split(";");
Map<String, String> csp = new HashMap<>();
for (String term : split) {
term = term.trim();
String word = term.substring(0, term.indexOf(' '));
csp.put(word, term.substring(word.length() + 1));
}
return csp;
}
/**
* post方式请求数据.发送的是json数据
*
* @param url
* @param params
* @return
*/
public static String sendhttpByPost(String url, String params) {
HttpPost httpRequest = new HttpPost(url);
httpRequest.addHeader("Accept-Encoding", "gzip");
httpRequest.addHeader("Content-Type", "application/json");
String strResult = null;
try {
// 发出HTTP request
// httpRequest.setEntity(new StringEntity(params, "UTF-8"));
// System.out.println("post发送的params是:" + params);
// url =
HttpClient httpClient = null;
// 判断请求协议方式
if (url.startsWith("https://")) {
// 取得HTTP response
httpClient = HttpUtil.wrapClient(new DefaultHttpClient());
} else {
httpClient = new DefaultHttpClient();
}
// https请求方式
HttpResponse httpResponse = httpClient.execute(httpRequest);
// 若状态码为200 ok
// Content-Encoding
if (httpResponse.getStatusLine().getStatusCode() == 200) {
Header[] headers = httpResponse.getHeaders("Content-Encoding");
boolean isUseGzip = false;
for (Header header : headers) {
if ("Content-Encoding".equals(header.getName())) {
if ("gzip".equalsIgnoreCase(header.getValue())) {
isUseGzip = true;
}
}
}
if (isUseGzip) {
strResult =
IoUtil.convertStreamToString(
new GZIPInputStream(httpResponse.getEntity().getContent()));
} else {
strResult = EntityUtils.toString(httpResponse.getEntity());
}
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
return strResult;
}
public <T extends QiitaResponse> PageableResponse<T> getPageableContents(
URI uri, Class<T> responseType) throws IOException, QiitaException {
HttpGet request = new HttpGet(uri);
HttpResponse response = execute(request);
verifyStatusCode(response, SC_OK);
String[] linkHeaderValues = getHeaderValues(response.getHeaders("Link"));
try (InputStream in = response.getEntity().getContent()) {
@SuppressWarnings("unchecked")
T[] contents = JSON.decode(in, (Class<T[]>) Array.newInstance(responseType, 0).getClass());
return new PageableResponse<>(this, responseType, contents, linkHeaderValues);
}
}
// Interface to AsyncHttpRequest
@Override
protected void sendResponseMessage(HttpResponse response) {
StatusLine status = response.getStatusLine();
Header[] contentTypeHeaders = response.getHeaders("Content-Type");
byte[] responseBody = null;
if (contentTypeHeaders.length != 1) {
// malformed/ambiguous HTTP Header, ABORT!
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
new HttpResponseException(
status.getStatusCode(), "None, or more than one, Content-Type Header found!"),
(String) null);
return;
}
Header contentTypeHeader = contentTypeHeaders[0];
boolean foundAllowedContentType = false;
for (String anAllowedContentType : mAllowedContentTypes) {
if (Pattern.matches(anAllowedContentType, contentTypeHeader.getValue())) {
foundAllowedContentType = true;
}
}
if (!foundAllowedContentType) {
// Content-Type not in allowed list, ABORT!
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
new HttpResponseException(status.getStatusCode(), "Content-Type not allowed!"),
(String) null);
return;
}
try {
HttpEntity entity = null;
HttpEntity temp = response.getEntity();
if (temp != null) {
entity = new BufferedHttpEntity(temp);
}
responseBody = EntityUtils.toByteArray(entity);
} catch (IOException e) {
sendFailureMessage(status.getStatusCode(), response.getAllHeaders(), e, (byte[]) null);
}
if (status.getStatusCode() >= 300) {
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()),
responseBody);
} else {
sendSuccessMessage(status.getStatusCode(), responseBody);
}
}
public static final void assert110WarningFound(HttpResponse response) {
boolean found110Warning = false;
for (Header h : response.getHeaders("Warning")) {
for (HeaderElement elt : h.getElements()) {
String[] parts = elt.getName().split("\\s");
if ("110".equals(parts[0])) {
found110Warning = true;
break;
}
}
}
Assert.assertTrue(found110Warning);
}
@Test
public void jsonTransparentGzipResponse() throws Exception {
String text = "{\"Message\": { \"text\": \"Hello, World!\" } }";
ByteArrayOutputStream bodyBytes = new ByteArrayOutputStream();
OutputStreamWriter body =
new OutputStreamWriter(new GZIPOutputStream(bodyBytes), Charset.forName("UTF-8"));
body.write(text);
body.close();
server.enqueue(
new MockResponse()
.setBody(bodyBytes.toByteArray())
.setHeader("Content-Encoding", "gzip")
.setHeader("Content-Type", "application/json"));
byte[] tmp = new byte[32];
HttpGet request1 = new HttpGet(server.getUrl("/").toURI());
// expecting transparent gzip response by not adding header "Accept-encoding: gzip"
HttpResponse response1 = client.execute(request1);
Header[] headers1a = response1.getHeaders("Content-Encoding");
assertEquals(0, headers1a.length);
assertNull(response1.getEntity().getContentEncoding());
// content length should also be absent
Header[] headers1b = response1.getHeaders("Content-Length");
assertEquals(0, headers1b.length);
assertTrue(response1.getEntity().getContentLength() < 0);
Header[] headers1c = response1.getHeaders("Content-Type");
assertEquals(1, headers1c.length);
assertEquals("application/json", headers1c[0].getValue());
assertNotNull(response1.getEntity().getContentType());
assertEquals("application/json", response1.getEntity().getContentType().getValue());
InputStream content = response1.getEntity().getContent();
ByteArrayOutputStream rspBodyBytes = new ByteArrayOutputStream();
for (int len = content.read(tmp); len >= 0; len = content.read(tmp)) {
rspBodyBytes.write(tmp, 0, len);
}
String decodedContent = rspBodyBytes.toString("UTF-8");
assertEquals(text, decodedContent);
}
/** Access http://localhost/ */
public static String hitRootContext(Logger log, URL url, String serverName) throws Exception {
HttpGet httpget = new HttpGet(url.toURI());
DefaultHttpClient httpclient = new DefaultHttpClient();
httpget.setHeader("Host", serverName);
log.info("executing request" + httpget.getRequestLine());
HttpResponse response = httpclient.execute(httpget);
int statusCode = response.getStatusLine().getStatusCode();
Header[] errorHeaders = response.getHeaders("X-Exception");
assertTrue("Wrong response code: " + statusCode, statusCode == HttpURLConnection.HTTP_OK);
assertTrue(
"X-Exception(" + Arrays.toString(errorHeaders) + ") is null", errorHeaders.length == 0);
return EntityUtils.toString(response.getEntity());
}
public void runTest(final String theMessage) throws IOException {
ContentEncodingHttpClient client = new ContentEncodingHttpClient();
try {
message = theMessage;
HttpGet get = new HttpGet(DefaultServer.getDefaultServerURL() + "/path");
get.setHeader(Headers.ACCEPT_ENCODING_STRING, "deflate");
HttpResponse result = client.execute(get);
Assert.assertEquals(200, result.getStatusLine().getStatusCode());
Header[] header = result.getHeaders(Headers.CONTENT_ENCODING_STRING);
Assert.assertEquals("deflate", header[0].getValue());
final String body = HttpClientUtils.readResponse(result);
Assert.assertEquals(theMessage, body);
} finally {
client.getConnectionManager().shutdown();
}
}
private void showUpdatesStatus(Future<HttpResponse> status) {
String versionMsg = "<h3 align=center>Cannot get version information </h3>";
try {
HttpResponse response = status.get();
updateStatusLabel.setText("");
String file = null;
for (Header header : response.getHeaders("Content-Disposition")) {
Matcher matcher = Pattern.compile("filename=\"([^\"]+)\"").matcher(header.getValue());
while (matcher.find()) {
file = matcher.group(1);
}
}
if (file != null) {
String[] installerPatterns = {
"PdfMetadataEditor-(\\d+)\\.(\\d+)\\.(\\d+)-installer.jar",
"pdf-metadata-edit-(\\d+)\\.(\\d+)\\.(\\d+)-installer.jar",
};
Version.VersionTuple current = Version.get();
Version.VersionTuple latest = null;
for (String pattern : installerPatterns) {
latest = new Version.VersionTuple(file, pattern);
if (latest.parseSuccess) {
break;
}
}
if (current.cmp(latest) < 0) {
versionMsg =
"<h3 align=center>New version available: <a href='http://broken-by.me/pdf-metadata-editor/#download'>"
+ latest.getAsString()
+ "</a> , current: "
+ current.getAsString()
+ "</h3>";
updateStatusLabel.setText("Newer version available:" + latest.getAsString());
} else {
versionMsg =
"<h3 align=center>Version " + current.getAsString() + " is the latest version</h3>";
}
}
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (ExecutionException e1) {
versionMsg += "<h4 align=center>Error: " + e1.getCause().getLocalizedMessage() + "</h4>";
} finally {
txtpnDf.setText(aboutMsg + versionMsg);
}
}
