| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. The ASF licenses this file to You |
| * under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. For additional information regarding |
| * copyright in this work, please see the NOTICE file in the top level |
| * directory of this distribution. |
| */ |
| package org.apache.abdera2.protocol.client; |
| |
| import java.io.InputStream; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.apache.abdera2.common.http.Method; |
| import org.apache.abdera2.common.http.ResponseType; |
| import org.apache.abdera2.common.protocol.ProtocolException; |
| import org.apache.http.HttpEntity; |
| import org.apache.http.HttpHost; |
| import org.apache.http.HttpResponse; |
| import org.apache.http.NameValuePair; |
| import org.apache.http.auth.AuthScope; |
| import org.apache.http.client.AuthCache; |
| import org.apache.http.client.HttpClient; |
| import org.apache.http.client.entity.UrlEncodedFormEntity; |
| import org.apache.http.client.methods.HttpPost; |
| import org.apache.http.client.methods.HttpUriRequest; |
| import org.apache.http.client.protocol.ClientContext; |
| import org.apache.http.entity.InputStreamEntity; |
| import org.apache.http.impl.auth.BasicScheme; |
| import org.apache.http.impl.client.BasicAuthCache; |
| import org.apache.http.message.BasicNameValuePair; |
| import org.apache.http.protocol.BasicHttpContext; |
| import org.apache.http.protocol.HTTP; |
| import org.apache.http.protocol.HttpContext; |
| import org.apache.http.util.EntityUtils; |
| |
| /** |
| * A client session. Session's MUST NOT be used by more |
| * than one Thread of execution as a time as multiple threads would stomp |
| * all over the shared session context. It is critical to completely |
| * consume each ClientResponse before executing an additional request on |
| * the same session. |
| */ |
| public class Session { |
| |
| protected final Client client; |
| protected final HttpContext localContext; |
| |
| protected Session(Client client) { |
| this.client = client; |
| this.localContext = |
| new BasicHttpContext(); |
| } |
| |
| private HttpClient getClient() { |
| return client.getClient(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| protected <T extends ClientResponse>T wrap(ClientResponse resp) { |
| return (T)resp; |
| } |
| |
| /** |
| * Sends an HTTP HEAD request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T head(String uri, RequestOptions options) { |
| return wrap(execute("HEAD", uri, (HttpEntity)null, options)); |
| } |
| |
| /** |
| * Sends an HTTP GET request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T get(String uri, RequestOptions options) { |
| return wrap(execute("GET", uri, (HttpEntity)null, options)); |
| } |
| |
| /** |
| * Sends an HTTP POST request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param entity A RequestEntity object providing the payload of the request |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T post(String uri, HttpEntity entity, RequestOptions options) { |
| return wrap(execute("POST", uri, entity, options)); |
| } |
| |
| /** |
| * Sends an HTTP POST request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param in An InputStream providing the payload of the request |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T post(String uri, InputStream in, RequestOptions options) { |
| return wrap(execute("POST", uri, new InputStreamEntity(in,-1), options)); |
| } |
| |
| /** |
| * Sends an HTTP PUT request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param entity A RequestEntity object providing the payload of the request |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T put(String uri, HttpEntity entity, RequestOptions options) { |
| return wrap(execute("PUT", uri, entity, options)); |
| } |
| |
| /** |
| * Sends an HTTP PUT request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param in An InputStream providing the payload of the request |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T put(String uri, InputStream in, RequestOptions options) { |
| return wrap(execute("PUT", uri, new InputStreamEntity(in,-1), options)); |
| } |
| |
| /** |
| * Sends an HTTP DELETE request to the specified URI. |
| * |
| * @param uri The request URI |
| * @param options The request options |
| */ |
| public <T extends ClientResponse>T delete(String uri, RequestOptions options) { |
| return wrap(execute("DELETE", uri, (HttpEntity)null, options)); |
| } |
| |
| /** |
| * Sends an HTTP HEAD request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| */ |
| public <T extends ClientResponse>T head(String uri) { |
| return wrap(head(uri, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends an HTTP GET request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| */ |
| public <T extends ClientResponse>T get(String uri) { |
| return wrap(get(uri, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends an HTTP POST request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| * @param entity A RequestEntity object providing the payload of the request |
| */ |
| public <T extends ClientResponse>T post(String uri, HttpEntity entity) { |
| return wrap(post(uri, entity, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends an HTTP POST request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| * @param in An InputStream providing the payload of the request |
| */ |
| public <T extends ClientResponse>T post(String uri, InputStream in) { |
| return wrap(post(uri, in, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends an HTTP PUT request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| * @param entity A RequestEntity object providing the payload of the request |
| */ |
| public <T extends ClientResponse>T put(String uri, HttpEntity entity) { |
| return wrap(put(uri, entity, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends an HTTP PUT request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| * @param in An InputStream providing the payload of the request |
| */ |
| public <T extends ClientResponse>T put(String uri, InputStream in) { |
| return wrap(put(uri, in, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends an HTTP DELETE request to the specified URI using the default options |
| * |
| * @param uri The request URI |
| */ |
| public <T extends ClientResponse>T delete(String uri) { |
| return wrap(delete(uri, getDefaultRequestOptions())); |
| } |
| |
| /** |
| * Sends the specified method request to the specified URI. This can be used to send extension HTTP methods to a |
| * server (e.g. PATCH, LOCK, etc) |
| * |
| * @param method The HTTP method |
| * @param uri The request URI |
| * @param in An InputStream providing the payload of the request |
| * @param options The Request Options |
| */ |
| public <T extends ClientResponse>T execute( |
| String method, |
| String uri, |
| InputStream in, |
| RequestOptions options) { |
| if (options == null) |
| options = getDefaultRequestOptions(); |
| InputStreamEntity re = |
| new InputStreamEntity(in, -1); |
| re.setContentType( |
| options.getContentType().toString()); |
| return wrap(execute( |
| method, uri, re, options)); |
| } |
| |
| /** |
| * Sends the specified method request to the specified URI. This can be used to send extension HTTP methods to a |
| * server (e.g. PATCH, LOCK, etc) |
| * |
| * @param method The HTTP method |
| * @param uri The request URI |
| * @param in An InputStream providing the payload of the request |
| * @param options The Request Options |
| */ |
| public <T extends ClientResponse>T execute( |
| Method method, |
| String uri, |
| InputStream in, |
| RequestOptions options) { |
| return wrap(execute(method.name(),uri,in,options)); |
| } |
| |
| public <T extends ClientResponse>T execute( |
| Method method, |
| String uri, |
| HttpEntity entity, |
| RequestOptions options) { |
| return wrap(execute(method.name(),uri,entity,options)); |
| } |
| |
| /** |
| * Sends the specified method request to the specified URI. This can be used to send extension HTTP methods to a |
| * server (e.g. PATCH, LOCK, etc) |
| * |
| * @param method The HTTP method |
| * @param uri The request URI |
| * @param entity A RequestEntity object providing the payload for the request |
| * @param options The Request Options |
| */ |
| public <T extends ClientResponse>T execute( |
| String method, |
| String uri, |
| HttpEntity entity, |
| RequestOptions options) { |
| options = |
| options != null ? |
| options : |
| getDefaultRequestOptions(); |
| try { |
| HttpUriRequest request = |
| RequestHelper.createRequest( |
| method, uri, entity, options); |
| HttpResponse response = |
| getClient().execute(request, localContext); |
| ClientResponse resp = |
| wrap(new ClientResponseImpl( |
| this, response, method, localContext)); |
| return checkRequestException(resp, options); |
| } catch (RuntimeException r) { |
| throw r; |
| } catch (Throwable t) { |
| throw new RuntimeException(t); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| protected <T extends ClientResponse>T checkRequestException(ClientResponse response, RequestOptions options) { |
| if (response == null) |
| return (T)response; |
| ResponseType type = response.getType(); |
| if ((type.equals(ResponseType.CLIENT_ERROR) && options.is4xxRequestException()) || (type |
| .equals(ResponseType.SERVER_ERROR) && options.is5xxRequestException())) { |
| throw new ProtocolException(response.getStatus(),response.getStatusText()); |
| } |
| return (T)response; |
| } |
| |
| /** |
| * Get a copy of the default request options |
| */ |
| public RequestOptions getDefaultRequestOptions() { |
| return RequestHelper.createDefaultRequestOptions(); |
| } |
| |
| public void usePreemptiveAuthentication(String target, String realm) throws URISyntaxException { |
| AuthCache cache = (AuthCache) localContext.getAttribute(ClientContext.AUTH_CACHE); |
| if (cache == null) { |
| String host = AuthScope.ANY_HOST; |
| int port = AuthScope.ANY_PORT; |
| if (target != null) { |
| URI uri = new URI(target); |
| host = uri.getHost(); |
| port = uri.getPort(); |
| } |
| BasicScheme basicAuth = new BasicScheme(); |
| HttpHost targetHost = |
| new HttpHost(host,port,basicAuth.getSchemeName()); |
| cache = new BasicAuthCache(); |
| cache.put(targetHost, basicAuth); |
| localContext.setAttribute(ClientContext.AUTH_CACHE, cache); |
| } |
| } |
| |
| public void doFormLogin(String uri, String userid, String password) { |
| doFormLogin(uri, "j_username", userid, "j_password", password); |
| } |
| |
| public void doFormLogin(String uri, String userfield, String userid, String passfield, String password) { |
| try { |
| HttpPost httpost = new HttpPost(uri); |
| List <NameValuePair> nvps = new ArrayList <NameValuePair>(); |
| nvps.add(new BasicNameValuePair(userfield, userid)); |
| nvps.add(new BasicNameValuePair(passfield, password)); |
| httpost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8)); |
| HttpResponse response = getClient().execute(httpost,localContext); |
| HttpEntity entity = response.getEntity(); |
| EntityUtils.consume(entity); |
| } catch (Throwable t) { |
| throw new RuntimeException(t); |
| } |
| } |
| } |