How to use

HttpRequest

in

org.apache.shindig.gadgets.http

 public boolean matches(Object obj) {
  HttpRequest match = (HttpRequest)obj;
  return (match.getMethod().equals(req.getMethod()) &&
    match.getUri().equals(req.getUri()) &&
    match.getAuthType().equals(req.getAuthType()) &&
    match.getPostBodyAsString().equals(req.getPostBodyAsString()) &&
    Objects.equal(match.getOAuthArguments(), req.getOAuthArguments()) &&
    match.getHeaders().equals(req.getHeaders()));
 }
}

@Override
public String getContainer() {
 return request.getContainer();
}

public Config get(HttpRequest request) {
 return get(request.getGadget());
}

protected boolean isCacheable(HttpRequest request) {
 if (request.getIgnoreCache()) {
  return false;
 }
 return ("GET".equals(request.getMethod()) ||
     "GET".equals(request.getHeader("X-Method-Override")));
}

protected static String getServiceName(HttpRequest request) {
 if ((request.getAuthType() != AuthType.NONE) && (request.getAuthType() != AuthType.OAUTH2)) {
  return request.getOAuthArguments().getServiceName();
 }
 // Requests that don't use authentication can share the result.
 return null;
}

protected static String getAppUrl(HttpRequest request) {
 if (request.getAuthType() != AuthType.NONE) {
  return request.getSecurityToken().getAppUrl();
 }
 // Requests that don't use authentication can share the result.
 return null;
}

oauthArguments.setSignOwner(false);
oauthArguments.setSignViewer(true);
HttpRequest request = new HttpRequest(DEFAULT_URI)
  .setCacheTtl(100)
  .addHeader(TEST_HEADER_KEY, TEST_HEADER_VALUE)
  .setContainer("container")
  .setGadget(DEFAULT_URI)
  .setMethod("POST")
  .setPostBody(POST_BODY.getBytes())
  .setRewriteMimeType("text/fake")
  .setSecurityToken(new AnonymousSecurityToken())
  .setOAuthArguments(oauthArguments)
  .setAuthType(AuthType.OAUTH)
  .setFollowRedirects(false)
  .setInternalRequest(true);
HttpRequest request2 = new HttpRequest(request).setUri(Uri.parse("http://example.org/foo"));
assertEquals(request.getCacheTtl(), request2.getCacheTtl());
assertEquals(request.getHeaders(), request2.getHeaders());
assertEquals(request.getContainer(), request2.getContainer());
assertEquals(request.getGadget(), request2.getGadget());
assertEquals(request.getMethod(), request2.getMethod());
assertEquals(request.getPostBodyAsString(), request2.getPostBodyAsString());
assertEquals(request.getRewriteMimeType(), request2.getRewriteMimeType());
assertEquals(request.getSecurityToken(), request2.getSecurityToken());
assertEquals(request.getOAuthArguments().getSignOwner(),
  request2.getOAuthArguments().getSignOwner());
assertEquals(request.getOAuthArguments().getSignViewer(),

HttpUriRequest httpMethod = null;
Preconditions.checkNotNull(request);
final String methodType = request.getMethod();
Uri uri = request.getUri();
if (Strings.isNullOrEmpty(uri.getAuthority())) {
 throw new GadgetException(GadgetException.Code.INVALID_USER_DATA,
   : new HttpPut(requestUri);
  if (request.getPostBodyLength() > 0) {
   enclosingMethod.setEntity(new InputStreamEntity(request.getPostBody(), request.getPostBodyLength()));
  httpMethod = new HttpDelete(requestUri);
 for (Map.Entry<String, List<String>> entry : request.getHeaders().entrySet()) {
  httpMethod.addHeader(entry.getKey(), Joiner.on(',').join(entry.getValue()));
 if (!request.getFollowRedirects()) {
  httpMethod.getParams().setBooleanParameter(ClientPNames.HANDLE_REDIRECTS, false);
   LOG.logp(Level.INFO, classname, "fetch", MessageKeys.TIMEOUT_EXCEPTION, new Object[] {request.getUri(),classname,e.getMessage(),now-started});
   LOG.logp(Level.INFO, classname, "fetch", MessageKeys.EXCEPTION_OCCURRED, new Object[] {request.getUri(),now-started});
   LOG.logp(Level.INFO, classname, "fetch", "", e);

private void expectPostAndReturnBody(AuthType authType, String postData, String response)
  throws Exception {
 HttpRequest req = new HttpRequest(REQUEST_URL).setMethod("POST")
   .setPostBody(postData.getBytes("UTF-8"))
   .setAuthType(authType)
   .addHeader("Content-Type", "application/x-www-form-urlencoded");
 expect(pipeline.execute(req)).andReturn(new HttpResponse(response));
 expect(request.getParameter(MakeRequestHandler.METHOD_PARAM)).andReturn("POST");
 expect(request.getParameter(MakeRequestHandler.POST_DATA_PARAM))
   .andReturn(postData);
}

 public FetchedData fetch(ExternalReference ref, String mimeType) throws UriFetchException {
  Uri resourceUri = Uri.fromJavaUri(ref.getUri());
  if (contextUri != null) {
   resourceUri = contextUri.resolve(resourceUri);
  }
  HttpRequest request = new HttpRequest(resourceUri)
      .setContainer(req.getContainer())
      .setGadget(req.getGadget());
  
  try {
   HttpResponse response = requestPipeline.execute(request);
   byte[] responseBytes = IOUtils.toByteArray(response.getResponse());
   return FetchedData.fromBytes(responseBytes, mimeType, response.getEncoding(),
     new InputSource(ref.getUri()));
  } catch (GadgetException e) {
   LOG.info("Failed to retrieve: " + ref.toString());
   return null;
  } catch (IOException e) {
   LOG.info("Failed to read: " + ref.toString());
   return null;
  }
 }
};

@Test
public void getHeader() throws Exception {
 Map<String, List<String>> headers = Maps.newHashMap();
 headers.put(TEST_HEADER_KEY, Arrays.asList(TEST_HEADER_VALUE));
 HttpRequest request = new HttpRequest(DEFAULT_URI)
   .addHeader(TEST_HEADER_KEY, TEST_HEADER_VALUE);
 assertEquals(TEST_HEADER_VALUE, request.getHeader(TEST_HEADER_KEY));
}

@Test
public void getHeaders() throws Exception {
 HttpRequest request = new HttpRequest(DEFAULT_URI)
   .addHeader(TEST_HEADER_KEY, TEST_HEADER_VALUE)
   .addHeader(TEST_HEADER_KEY, TEST_HEADER_VALUE2);
 Collection<String> expected = Arrays.asList(TEST_HEADER_VALUE, TEST_HEADER_VALUE2);
 assertTrue(request.getHeaders(TEST_HEADER_KEY).containsAll(expected));
}

@Test
public void ignoreCacheAddsPragmaHeader() throws Exception {
 HttpRequest request = new HttpRequest(DEFAULT_URI).setIgnoreCache(true);
 assertTrue("Pragma: no-cache not added when ignoreCache == true",
   request.getHeaders("Pragma").contains("no-cache"));
}

private void checkRequest(HttpRequest request) {
 assertEquals(context.getContainer(), request.getContainer());
 assertEquals(GADGET_URL.toString(), request.getGadget().toString());
 assertEquals(context.getToken().getAppId(), request.getSecurityToken().getAppId());
}

@Override
public boolean equals(Object obj) {
 if (obj == this) {
  return true;
 }
 if (!(obj instanceof HttpRequest)) {
  return false;
 }
 HttpRequest req = (HttpRequest)obj;
 return super.equals(obj) && req.getCacheTtl() == getCacheTtl() &&
     req.getIgnoreCache() == getIgnoreCache();
}

@Test
public void getResponseUsingMethodOverride() {
 HttpRequest request = new HttpRequest(DEFAULT_URI)
   .setMethod("POST")
   .addHeader("X-Method-Override", "GET");
 String key = cache.createKey(request);
 HttpResponse response = new HttpResponse("result");
 cache.map.put(key, response);
 assertEquals(response, cache.getResponse(request));
}

@Test
public void testJsWithoutCaja() throws Exception {
 Gadget gadget = mockGadget();
 control.replay();
 HttpRequest req = new HttpRequest(CONTENT_URI);
 req.setRewriteMimeType("text/javascript");
 req.setCajaRequested(false);
 HttpResponse response = new HttpResponseBuilder().setResponseString("var a;").create();
 String sanitized = "var a;";
 assertTrue(rewrite(req, response).contains(sanitized));
 assertTrue(rewrite(req, response, gadget).contains(sanitized));
}

@Test
public void dosPreventionHeaderAdded() {
 HttpRequest request = new HttpRequest(DEFAULT_URI);
 assertNotNull("DoS prevention header not present in request.",
   request.getHeader(HttpRequest.DOS_PREVENTION_HEADER));
}

protected static String getOwnerId(HttpRequest request) {
 if (request.getAuthType() != AuthType.NONE &&
   request.getOAuthArguments().getSignOwner()) {
  Preconditions.checkState(request.getSecurityToken() != null, "No Security Token set for request");
  String ownerId = request.getSecurityToken().getOwnerId();
  return Objects.firstNonNull(ownerId, "");
 }
 // Requests that don't use authentication can share the result.
 return null;
}

@Test
public void testCreateNewHttpRequest() throws Exception {
 Gadget gadget = createMock(Gadget.class);
 Uri uri = Uri.parse(GADGET);
 GadgetSpec gadgetSpec = createMock(GadgetSpec.class);
 expect(gadgetSpec.getUrl()).andReturn(uri);
 expect(gadget.getSpec()).andReturn(gadgetSpec);
 GadgetContext context = createMock(GadgetContext.class);
 expect(context.getContainer()).andReturn(CONTAINER);
 expect(gadget.getContext()).andReturn(context);
 replay(gadgetSpec);
 replay(context);
 replay(gadget);
 CacheEnforcementVisitor visitor = new CacheEnforcementVisitor(
   null, null, null, null, CacheEnforcementVisitor.Tags.ALL_RESOURCES);
 HttpRequest newRequest = visitor.createNewHttpRequest(gadget, IMG_URL);
 assertEquals(CONTAINER, newRequest.getContainer());
 assertEquals("1", newRequest.getParam(CacheEnforcementVisitor.CACHE_ENFORCEMENT_FETCH_PARAM));
 assertEquals(uri, newRequest.getGadget());
}