* © Copyright IBM Corp. 2012

*

* Licensed 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.

*/

* Base class for a REST service client.

*

* @author Philippe Riand

* @author Mark Wallace

*/

  protected Endpoint endpoint;

  // Constants for the methods

  public static final String METHOD_GET = "get"; //$NON-NLS-1$

  public static final String METHOD_PUT = "put"; //$NON-NLS-1$

  public static final String METHOD_POST = "post"; //$NON-NLS-1$

  public static final String METHOD_DELETE = "delete"; //$NON-NLS-1$

  public static final String METHOD_DELETE_BODY = "deleteBody"; //$NON-NLS-1$

  // These represents how the result should be formatted to the caller

  public static final Handler FORMAT_UNKNOWN = null;

  public static final Handler FORMAT_NULL = new HandlerNull();

  public static final Handler FORMAT_TEXT = new HandlerString();

  public static final Handler FORMAT_INPUTSTREAM = new HandlerInputStream();

  public static final Handler FORMAT_XML = new HandlerXml();

  public static final Handler FORMAT_JSON = new HandlerJson();

  // TODO: Should be moved elsewhere? What is it for?

  public static final Handler FORMAT_CONNECTIONS_OUTPUT = new HandlerConnectionHeader();

 

  private static final ProfilerType profilerRequest = new ProfilerType("Executing REST request, "); //$NON-NLS-1$

  private static final String sourceClass = ClientService.class.getName();

  protected static final Logger logger = Logger.getLogger(sourceClass);

  /**

   * Default constructor

   */

  public ClientService() {

  }

  /**

   * Construct a ClientService with the specified Endpoint

   *

   * @param endpoint

   */

  public ClientService(Endpoint endpoint) {

    this.endpoint = endpoint;

  }

  /**

   * Construct a ClientService with the Endpoint with the specified name

   *

   * @param endpoint

   */

  public ClientService(String endpointName) {

    this.endpoint = EndpointFactory.getEndpoint(endpointName);

  }

  /**

   * Return the associated Endpoint

   *

   * @return

   */

  public Endpoint getEndpoint() {

    return endpoint;

  }

  /**

   * Set the associated Endpoint

   *

   * @param endpoint

   */

  public void setEndpoint(Endpoint endpoint) {

    this.endpoint = endpoint;

  }

  /**

   * If there is an associated endpoint then check is authentication required

   * and if so trigger the authentication process.

   *

   * @param args

   * @throws ClientServicesException

   */

  protected void checkAuthentication(Args args) throws ClientServicesException {

    if (endpoint != null) {

      if (endpoint.isRequiresAuthentication() && !endpoint.isAuthenticated()) {

        endpoint.authenticate(false);

      }

    }

  }

  /**

   * Get the URL path for the specified arguments and check it is valid

   * i.e. not null. If it is a null throw a ClientServicesException.

   *

   * @param args

   * @throws ClientServicesException

   */

  protected void checkUrl(Args args) throws ClientServicesException {

    if (StringUtil.isEmpty(getUrlPath(args))) {

      throw new ClientServicesException(null, "The service URL is empty");

    }

  }

  /**

   * Check the read parameters and throw a ClientServicesException if

   * they are invalid.

   *

   * @param parameters

   * @throws ClientServicesException

   */

  protected void checkReadParameters(Map<String, String> parameters) throws ClientServicesException {

    // nothing for now...

  }

  /**

   * Return the URL from the associated endpoint.

   *

   * @return

   */

  public String getBaseUrl() {

    if (endpoint != null) {

      return endpoint.getUrl();

    }

    return null;

  }

  /**

   * Initialize the associated Endpoint with the specified HttpClient.

   *

   * @param httpClient

   * @throws ClientServicesException

   */

    protected void initialize(DefaultHttpClient httpClient) throws ClientServicesException {

        if (endpoint != null) {

            CookieStore cookies = endpoint.getCookies();

            httpClient.setCookieStore(cookies);

            endpoint.initialize(httpClient);

        }

    }

  /**

   * Return true if force trust SSL certificate is set for the associated Endpoint.

   *

   * @return

   * @throws ClientServicesException

   */

  protected boolean isForceTrustSSLCertificate() throws ClientServicesException {

    if (endpoint != null) {

      return endpoint.isForceTrustSSLCertificate();

    }

    return false;

  }

  /**

   * Return true if force trust SSL certificate is set for the associated Endpoint.

   *

   * @return

   * @throws ClientServicesException

   */

  protected boolean isForceDisableExpectedContinue() throws ClientServicesException {

    if (endpoint != null) {

      return endpoint.isForceDisableExpectedContinue();

    }

    return false;

  }

 

  /**

   * Return the proxy info from the associated Endpoint or an empty string

   *

   * @return

   * @throws ClientServicesException

   */

  protected String getHttpProxy() throws ClientServicesException {

    if (endpoint != null) {

      String proxyinfo = endpoint.getHttpProxy();

      if (StringUtil.isEmpty(proxyinfo)) {

        Context context = Context.getUnchecked();

          if (context != null) {

          proxyinfo = Context.get().getProperty("sbt.httpProxy");

          }

      }

      return proxyinfo;

    }

    return ""; // TODO should this be null?

  }

  /**

   * Force authentication for the associated Endpoint.

   *

   * @param args

   * @throws ClientServicesException

   */

  protected void forceAuthentication(Args args) throws ClientServicesException {

    if (endpoint != null) {

      endpoint.authenticate(true);

    } else {

      String msg = StringUtil.format("Authorization needed for service {0}", getUrlPath(args));

      throw new NoAccessSignal(msg);

    }

  }

  // =================================================================

  // Generic access

  // =================================================================

  public static class Args implements Serializable{

    private String serviceUrl; // Service URL to call, relative to the endpoint

    private Map<String, String> parameters; // Query String parameters

    private Map<String, String> headers; // HTTP Headers

    private Handler handler; // Format of the result

    public Args() {

    }

    public String getServiceUrl() {

      return serviceUrl;

    }

    public Args setServiceUrl(String url) {

      this.serviceUrl = url;

      return this;

    }

    public Map<String, String> getParameters() {

      return parameters;

    }

    public Args setParameters(Map<String, String> parameters) {

      this.parameters = parameters;

      return this;

    }

    public Args addParameter(String name, String value) {

      if (parameters == null) {

        this.parameters = new HashMap<String, String>();

      }

      parameters.put(name, value);

      return this;

    }

    public Map<String, String> getHeaders() {

      return headers;

    }

    public Args setHeaders(Map<String, String> headers) {

      this.headers = headers;

      return this;

    }

    public Args addHeader(String name, String value) {

      if (headers == null) {

        this.headers = new HashMap<String, String>();

      }

      headers.put(name, value);

      return this;

    }

    public boolean hasHeader(String name) {

      return (headers == null) ? false : headers.containsKey(name);

    }

    public Handler getHandler() {

      return handler;

    }

    public Args setHandler(Handler handler) {

      this.handler = handler;

      return this;

    }

    @Override

    public String toString() {

      StringBuilder sb = new StringBuilder();

      sb.append("{ serviceUrl:").append(serviceUrl);

      sb.append(", parameters:").append(parameters);

      sb.append(", headers:").append(headers).append("}");

      return sb.toString();

    }

  }

  protected Args createArgs(String serviceUrl, Map<String, String> parameters)

      throws ClientServicesException {

    Args args = new Args();

    args.setServiceUrl(serviceUrl);

    args.setParameters(parameters);

    return args;

  }

  // =================================================================

  // Request content

  // =================================================================

  public static abstract class Content {

    private final String  contentType;

    protected Content(String contentType) {

      this.contentType = contentType;

    }

    protected String getContentType() {

      return contentType;

    }

    public void initRequestContent(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args)

        throws ClientServicesException {

      HttpEntity entity = createEntity();

      // set the http entity to the request, along with its content type

      if (entity != null && (httpRequestBase instanceof HttpEntityEnclosingRequestBase)) {

        setEntity(httpClient, httpRequestBase, args, entity);

      }

    }

    protected void setEntity(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args,

        HttpEntity entity) throws ClientServicesException {

      String contentType = getContentType();

      if (StringUtil.isNotEmpty(contentType)) {

        httpRequestBase.setHeader(CONTENT_TYPE, contentType);

      }

      ((HttpEntityEnclosingRequestBase) httpRequestBase).setEntity(entity);

    }

    protected HttpEntity createEntity() throws ClientServicesException {

      return null;

    }

  }

 

  public static class ContentHttpEntity extends Content {

   

    private final HttpEntity  content;

    public ContentHttpEntity(HttpEntity content) {

      super(content.getContentType().getValue());

      this.content = content;

    }

    public ContentHttpEntity(HttpEntity content, String contentType) {

      super(contentType);

      this.content = content;

    }

    @Override

    protected HttpEntity createEntity() throws ClientServicesException {

      try {

        return content;

      } catch (Exception ex) {

        throw new ClientServicesException(ex);

      }

    }

  }

  public static class ContentString extends Content {

    private final String  content;

    public ContentString(String content, String contentType) {

      super(contentType);

      this.content = content;

    }

    public ContentString(String content) {

      this(content, TEXT_PLAIN);

    }

    @Override

    protected HttpEntity createEntity() throws ClientServicesException {

      try {

        return new StringEntity(content, HTTP.UTF_8);

      } catch (Exception ex) {

        throw new ClientServicesException(ex);

      }

    }

  }

  public static class ContentJson extends Content {

    private final JsonFactory  factory;

    private final Object    content;

    public ContentJson(Object content, String contentType, JsonFactory factory) {

      super(contentType);

      this.content = content;

      this.factory = factory;

    }

    public ContentJson(Object content, String contentType) {

      this(content, contentType, JsonJavaFactory.instanceEx);

    }

    public ContentJson(Object content) {

      this(content, APPLICATION_JSON, JsonJavaFactory.instanceEx);

    }

    public ContentJson(Object content, JsonFactory factory) {

      this(content, APPLICATION_JSON, factory);

    }

    @Override

    protected HttpEntity createEntity() throws ClientServicesException {

      try {

        return new StringEntity(JsonGenerator.toJson(factory, content, true));

      } catch (Exception ex) {

        throw new ClientServicesException(ex);

      }

    }

  }

  public static class ContentXml extends Content {

    private Node  content;

    public ContentXml(Node content, String contentType) {

      super(contentType);

      this.content = content;

    }

    public ContentXml(Node content) {

      this(content, APPLICATION_XML);

      this.content = content;

    }

    @Override

    protected HttpEntity createEntity() throws ClientServicesException {

      try {

        return new StringEntity(DOMUtil.getXMLString(content, true));

      } catch (Exception ex) {

        throw new ClientServicesException(ex);

      }

    }

  }

  public static class ContentFile extends Content {

    private final File    content;

    private final String  name;

    public ContentFile(String name, File content, String contentType) {

      super(contentType);

      this.name = name;

      this.content = content;

    }

    public ContentFile(File content, String contentType) {

      this(content.getName(), content, contentType);

    }

    public ContentFile(File content) {

      this(content, APPLICATION_OCTET_STREAM);

    }

    public ContentFile(String name, File content) {

      this(name, content, APPLICATION_OCTET_STREAM);

    }

    @Override

    public HttpEntity createEntity() throws ClientServicesException {

      FileEntity fileEnt = new FileEntity(content, getContentType());

      fileEnt.setContentEncoding(BINARY); // Is that OK?

      return fileEnt;

    }

    @Override

    protected void setEntity(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args,

        HttpEntity entity) throws ClientServicesException {

      httpRequestBase.setHeader(SLUG, name);

      httpRequestBase.setHeader(CONTENT_TYPE, getContentType());

      super.setEntity(httpClient, httpRequestBase, args, entity);

    }

  }

  public static class ContentStream extends Content {

    private final long          length;

    private final java.io.InputStream  stream;

    private final String        name;

    private final boolean        markSupportedFromWrappedStream;

    public ContentStream(String name, InputStream stream, long length, String contentType) {

      super(contentType);

      this.length = length;

      this.markSupportedFromWrappedStream = stream.markSupported();

      if (stream instanceof BufferedInputStream) {

        this.stream = stream;

      } else {

        this.stream = new BufferedInputStream(stream);

      }

      if (!StringUtil.isEmpty(name)) {

        this.name = name.trim();

      } else {

        this.name = name;

      }

    }

    public ContentStream(InputStream stream) {

      this(null, stream, -1, BINARY_OCTET_STREAM);

    }

    public ContentStream(java.io.InputStream stream, String name) {

      this(name, stream, -1, BINARY_OCTET_STREAM);

    }

    public ContentStream(java.io.InputStream stream, long length, String name) {

      this(name, stream, length, BINARY_OCTET_STREAM);

    }

    @Override

    protected HttpEntity createEntity() throws ClientServicesException {

      InputStreamEntity inputStreamEntity = new InputStreamEntity(stream, length);

      inputStreamEntity.setContentEncoding(BINARY);

      if (length == -1) {

        inputStreamEntity.setChunked(true);

      }

      return inputStreamEntity;

    }

    @Override

    public void initRequestContent(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args)

        throws ClientServicesException {

      // TODO Auto-generated method stub

      super.initRequestContent(httpClient, httpRequestBase, args);

    }

    @Override

    protected void setEntity(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args,

        HttpEntity entity) throws ClientServicesException {

      if (name != null) {

        httpRequestBase.setHeader(SLUG, name);

      }

      httpRequestBase.setHeader(CONTENT_TYPE, getContentType());

      super.setEntity(httpClient, httpRequestBase, args, entity);

    }

  }

  public static class ContentList extends Content {

   

    private List<ContentPart> contentParts;

    protected ContentList(List<ContentPart> content) {

      this(content, MULTIPART_RELATED);

    }

   

    protected ContentList(List<ContentPart> content, String contentType) {

      super(contentType);

     

      this.contentParts = content;

    }

   

    @Override

    protected HttpEntity createEntity() throws ClientServicesException {

      MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();

      for (ContentPart contentPart : contentParts) {

        if (contentPart.getData() instanceof InputStream) {

          entityBuilder.addBinaryBody(contentPart.getName(),

              (InputStream)contentPart.getData(),

              contentPart.getContentType(),

              contentPart.getFileName());

        }

        else if (contentPart.getData() instanceof byte[]) {

          entityBuilder.addBinaryBody(contentPart.getName(),

              (byte[])contentPart.getData(),

              contentPart.getContentType(),

              contentPart.getFileName());

        }

        else if (contentPart.getData() instanceof String) {

          entityBuilder.addTextBody(contentPart.getName(),

              (String)contentPart.getData(),

              contentPart.getContentType());

        }

      }

      return entityBuilder.build();

    }

   

  }

 

  public static class ContentPart {

   

    private String name;

    private Object data;

    private ContentType contentType;

    private String fileName;

   

    public ContentPart(String name, byte[] data, String fileName, String mimeType) {

      this.name = name;

      this.data = data;

      this.fileName = fileName;

      this.contentType = ContentType.create(mimeType);

    }

   

    public ContentPart(String name, InputStream data, String fileName, String mimeType) {

      this.name = name;

      this.data = data;

      this.fileName = fileName;

      this.contentType = ContentType.create(mimeType);

    }

   

    public ContentPart(String name, String data, String mimeType) {

      this.name = name;

      this.data = data;

      this.contentType = ContentType.create(mimeType);

    }

   

    public String getName() {

      return name;

    }

   

    public Object getData() {

      return data;

    }

   

    public ContentType getContentType() {

      return contentType;

    }

   

    public String getFileName() {

      return fileName;

    }

  }

 

  protected Content createRequestContent(Args args, Object content) throws ClientServicesException {

    if (args.getHeaders() != null && args.getHeaders().get(CONTENT_TYPE) != null) {

      String contentType = args.getHeaders().get(CONTENT_TYPE);

      if (content instanceof String) {

        return new ContentString((String) content, contentType);

      }

      if (content instanceof Node) {

        return new ContentXml((Node) content, contentType);

      }

      if ((content instanceof JsonObject) || (content instanceof JsonArray)) {

        return new ContentJson(content, contentType);

      }

      if (content instanceof File) {

        return new ContentFile((File) content, contentType);

      }

      if (content instanceof InputStream) {

        int length = getLength(args, (InputStream)content);

        return new ContentStream(args.getHeaders().get(SLUG), (InputStream)content, length, contentType);

      }

      if (content instanceof List) {

        return new ContentList((List) content, contentType);

      }

      if (content instanceof HttpEntity) {

        return new ContentHttpEntity((HttpEntity) content, contentType);

      }

    } else {

      if (content instanceof String) {

        return new ContentString((String) content);

      }

      if (content instanceof Node) {

        return new ContentXml((Node) content);

      }

      if ((content instanceof JsonObject) || (content instanceof JsonArray)) {

        return new ContentJson(content);

      }

      if (content instanceof File) {

        return new ContentFile((File) content);

      }

      if (content instanceof InputStream) {

        int length = getLength(args, (InputStream)content);

        return new ContentStream((InputStream) content, length, args.getHeaders().get(SLUG));

      }

      if (content instanceof List) {

        return new ContentList((List) content);

      }

      if (content instanceof HttpEntity) {

        return new ContentHttpEntity((HttpEntity) content);

      }

    }

    throw new ClientServicesException(null, "Cannot create HTTP content for object of type {0}",

        content.getClass());

  }

 

  protected int getLength(Args args, InputStream istream) throws ClientServicesException {

    try {

      return args.hasHeader(TRANSFER_ENCODING) ? -1 : istream.available();

    } catch (IOException e) {

      throw new ClientServicesException(e);

    }

  }

  // =================================================================

  // Response Handler

  // =================================================================

  public static abstract class Handler implements Serializable{

    public abstract Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException;

  }

  public static class HandlerNull extends Handler {

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      if (entity != null) {

        InputStream is = getEntityContent(request, response, entity);

        try {

          // Just eat the entire content - requested for persistent http 1.1 sessions

          byte[] buffer = new byte[8192];

          while ((is.read(buffer)) > 0) {}

        } finally {}

      }

      return null;

    }

  }

  public static class HandlerString extends Handler {

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      if (entity != null) {

        String encoding = EntityUtils.getContentCharSet(entity);

        if (encoding == null) {

          encoding = UTF8;

        }

        Reader reader = new InputStreamReader(getEntityContent(request, response, entity), encoding);

        try {

          FastStringBuffer b = new FastStringBuffer();

          b.append(reader);

          return b.toString();

        } finally {

          reader.close();

        }

      }

      return null;

    }

  }

  public static class HandlerJson extends Handler {

    private final JsonFactory  factory;

    public HandlerJson() {

      this.factory = JsonJavaFactory.instanceEx;

    }

    public HandlerJson(JsonFactory factory) {

      this.factory = factory;

    }

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      if (entity != null) {

        String encoding = EntityUtils.getContentCharSet(entity);

        if (encoding == null) {

          encoding = UTF8;

        }

        Reader reader = createReader(request, response, entity, encoding);

        try {

          if(false) {

            String s= StreamUtil.readString(reader);

            try {

              return JsonParser.fromJson(factory, s);

            } catch (JsonException ex) {

              throw ex;

            }

          } else {

            return JsonParser.fromJson(factory, reader);

          }

        } catch (JsonException ex) {

          IOException e = new IOException();

          e.initCause(ex);

          throw e;

        } finally {

          reader.close();

        }

      }

      return null;

    }

    protected Reader createReader(HttpRequestBase request, HttpResponse response, HttpEntity entity,

        String encoding) throws IOException {

      return new InputStreamReader(getEntityContent(request, response, entity), encoding);

    }

  }

  public static class HandlerXml extends Handler {

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      if (entity != null) {

        InputStream is = getEntityContent(request, response, entity);

        try {

          return DOMUtil.createDocument(is);

        } catch (XMLException ex) {

          IOException e = new IOException();

          e.initCause(ex);

          throw e;

        } finally {

          is.close();

        }

      }

      return null;

    }

  }

  public static class HandlerConnectionHeader extends Handler {

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      Header[] headers = response.getHeaders(LOCATION_HEADER);

      if (headers != null) {

        if (headers.length > 0) {

          return headers[0].getValue();

        }

      }

      return null;

    }

  }

  public static class HandlerInputStream extends Handler {

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      if (entity != null) {

        InputStream is = getEntityContent(request, response, entity);

        return is;

      }

      return null;

    }

  }

    @Override

    public Object parseContent(HttpRequestBase request, HttpResponse response, HttpEntity entity)

        throws ClientServicesException, IOException {

      return response;

    }

  }

  protected Handler findErrorHandler(HttpRequestBase request, HttpResponse response)

      throws ClientServicesException, UnsupportedEncodingException, IOException {

    throwClientServicesException(request, response);

    return null;

  }

 

  protected Handler findSuccessHandler(HttpRequestBase request, HttpResponse response)

      throws UnsupportedEncodingException, IOException {

    HttpEntity entity = response.getEntity();

    if (entity != null) {

      Header hd = entity.getContentType();

      if (hd != null) {

        String ct = hd.getValue();

        if (ct.indexOf(JSON) >= 0) {

          return FORMAT_JSON;

        }

        if (ct.indexOf(XML) >= 0) {

          return FORMAT_XML;

        }

        if (ct.indexOf(HTML) >= 0) {

          return FORMAT_TEXT;

        }

      }

    }

    return getDefaultFormat(response, entity);

  }

  // =================================================================

  // GET

  // =================================================================

  public final Response get(String serviceUrl) throws ClientServicesException {

    return get(serviceUrl, null, null);

  }

  public final Response get(String serviceUrl, Map<String, String> parameters) throws ClientServicesException {

    return get(serviceUrl, parameters, null);

  }

  public final Response get(String serviceUrl, Handler format) throws ClientServicesException {

    return get(serviceUrl, null, format);

  }

  public final Response get(String serviceUrl, Map<String, String> parameters, Handler format)

      throws ClientServicesException {

    return get(serviceUrl, parameters, null, format);

  }

  public final Response get(String serviceUrl, Map<String, String> parameters, Map<String, String> headers,

      Handler format) throws ClientServicesException {

    Args args = createArgs(serviceUrl, parameters);

    if (headers != null) {

      args.setHeaders(headers);

    }

    args.setHandler(format);

    return get(args);

  }

  public final Response get(Args args) throws ClientServicesException {

    return xhr(METHOD_GET, args, null);

  }

  // =================================================================

  // POST

  // =================================================================

  public final Response post(String serviceUrl, Object content) throws ClientServicesException {

    return post(serviceUrl, null, content, null);

  }

  public final Response post(String serviceUrl, Map<String, String> parameters, Object content)

      throws ClientServicesException {

    return post(serviceUrl, parameters, content, null);

  }

  public final Response post(String serviceUrl, Map<String, String> parameters, Object content, Handler format)

      throws ClientServicesException {

    Args args = createArgs(serviceUrl, parameters);

    args.setHandler(format);

    return post(args, content);

  }

  public final Response post(String serviceUrl, Map<String, String> parameters, Map<String, String> headers,

      Object content, Handler format) throws ClientServicesException {

    Args args = createArgs(serviceUrl, parameters);

    args.setHandler(format);

    args.setHeaders(headers);

    return post(args, content);

  }

  public final Response post(Args args, Object content) throws ClientServicesException {

    return xhr(METHOD_POST, args, content);

  }

  // =================================================================

  // PUT

  // =================================================================

  public final Response put(String serviceUrl, Object content) throws ClientServicesException {

    return put(serviceUrl, null, content, null);

  }

  public final Response put(String serviceUrl, Map<String, String> parameters, Object content)

      throws ClientServicesException {

    return put(serviceUrl, parameters, content, null);

  }

  public final Response put(String serviceUrl, Map<String, String> parameters, Object content, Handler format)

      throws ClientServicesException {

    Args args = createArgs(serviceUrl, parameters);

    args.setHandler(format);

    return put(args, content);

  }

  public final Response put(String serviceUrl, Map<String, String> parameters, Map<String, String> headers,

      Object content, Handler format) throws ClientServicesException {

    Args args = createArgs(serviceUrl, parameters);

    args.setHandler(format);

    args.setHeaders(headers);

    return put(args, content);

  }

  public final Response put(Args args, Object content) throws ClientServicesException {

    return xhr(METHOD_PUT, args, content);

  }

  // =================================================================

  // DELETE

  // =================================================================

  public final Response delete(String serviceUrl) throws ClientServicesException {

    return delete(serviceUrl, null, null);

  }

  public final Response delete(String serviceUrl, Map<String, String> parameters)

      throws ClientServicesException {

    return delete(serviceUrl, parameters, null);

  }

  public final Response delete(String serviceUrl, Map<String, String> parameters, Handler format)

      throws ClientServicesException {

    Args args = createArgs(serviceUrl, parameters);

    args.setHandler(format);

    return delete(args);

  }

    public final Response delete(String serviceUrl, Map<String, String> parameters, Map<String, String> headers,

            Handler format) throws ClientServicesException {

        Args args = createArgs(serviceUrl, parameters);

        args.setHandler(format);

        args.setHeaders(headers);

        return delete(args);       

    }

   

    public final Response delete(String serviceUrl, Map<String, String> parameters, Map<String, String> headers,

            Handler format,String content)throws ClientServicesException{

      Args args = createArgs(serviceUrl, parameters);

        args.setHandler(format);

        args.setHeaders(headers);

        return xhr(METHOD_DELETE_BODY, args, content);

    }

    public final Response delete(String serviceUrl, Map<String, String> parameters, Map<String, String> headers, Object content,

            Handler format)throws ClientServicesException{

      Args args = createArgs(serviceUrl, parameters);

        args.setHandler(format);

        args.setHeaders(headers);

        return xhr(METHOD_DELETE_BODY, args, content);

    }

  public final Response delete(Args args) throws ClientServicesException {

    return xhr(METHOD_DELETE, args, null);

  }

  // =================================================================

  // Actual request execution

  // =================================================================

  /**

   * Execute an XML Http request with the specified arguments

   *

   * @param method

   * @param args

   * @param content

   * @return

   * @throws ClientServicesException

   */

  public Response xhr(String method, Args args, Object content) throws ClientServicesException {

    if (logger.isLoggable(Level.FINEST)) {

      logger.entering(sourceClass, "xhr", new Object[] { method, args });

    }

    checkAuthentication(args);

    checkUrl(args);

    checkReadParameters(args.parameters);

    String url = composeRequestUrl(args);

    Response response = null;

    if (StringUtil.equalsIgnoreCase(method, METHOD_GET)) {

      HttpGet httpGet = new HttpGet(url);

      response = execRequest(httpGet, args, content);

    } else if (StringUtil.equalsIgnoreCase(method, METHOD_POST)) {

      HttpPost httpPost = new HttpPost(url);

      response = execRequest(httpPost, args, content);

    } else if (StringUtil.equalsIgnoreCase(method, METHOD_PUT)) {

      HttpPut httpPut = new HttpPut(url);

      response = execRequest(httpPut, args, content);

    } else if (StringUtil.equalsIgnoreCase(method, METHOD_DELETE)) {

      HttpDelete httpDelete = new HttpDelete(url);

      response = execRequest(httpDelete, args, content);

    } else if (StringUtil.equalsIgnoreCase(method,METHOD_DELETE_BODY)){

      HttpDeleteWithBody httpDelete = new HttpDeleteWithBody(url);

      response = execRequest(httpDelete, args, content);

    } else {

      throw new ClientServicesException(null, "Unsupported HTTP method {0}", method);

    }

   

    if (logger.isLoggable(Level.FINEST)) {

      logger.exiting(sourceClass, "xhr", response);

    }

    return response;

  }

  /**

   * Execute the specified HttpRequest

   *

   * @param httpRequestBase

   * @param args

   * @param content

   * @return

   * @throws ClientServicesException

   */

  protected Response execRequest(HttpRequestBase httpRequestBase, Args args, Object content) throws ClientServicesException {

    if (Profiler.isEnabled()) {

      String msg = httpRequestBase.getMethod().toUpperCase() + " " + getUrlPath(args);

      ProfilerAggregator agg = Profiler.startProfileBlock(profilerRequest, msg);

      long ts = Profiler.getCurrentTime();

      try {

        return _xhr(httpRequestBase, args, content);

      } finally {

        Profiler.endProfileBlock(agg, ts);

      }

    } else {

      return _xhr(httpRequestBase, args, content);

    }

  }

  /**

   * Allows clients to override the process content section of {@link #_xhr(HttpRequestBase, Args)}. <br/>

   *

   * @param httpRequestBase

   *            the base HTTP request created by the service

   * @param content

   *            the content that is to be sent via the request

   * @param args

   *            the args (such as url params) that have been pushed through by the calling service

   * @return true if the client wants the super class to take care of processing the content

   */

  protected Response _xhr(HttpRequestBase httpRequestBase, Args args, Object content) throws ClientServicesException {

    DefaultHttpClient httpClient = createHttpClient(httpRequestBase, args);

    initialize(httpClient);

    // HttpClient 4.1

    // httpClient.addRequestInterceptor(new RequestAcceptEncoding());

    // httpClient.addResponseInterceptor(new ResponseContentEncoding());

    Content reqContent = null;

    if (content != null) {

      if (content instanceof Content) {

        reqContent = (Content) content;

      } else {

        reqContent = createRequestContent(args, content);

      }

    }

    prepareRequest(httpClient, httpRequestBase, args, reqContent);

    HttpResponse response = executeRequest(httpClient, httpRequestBase, args);

    return processResponse(httpClient, httpRequestBase, response, args);

  }

  protected void prepareRequest(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args,

      Content content) throws ClientServicesException {

    // TODO: add support for gzip content

    // httpClient.addRequestHeader("Accept-Encoding", "gzip");

    if (args.getHeaders() != null) {

      addHeaders(httpClient, httpRequestBase, args);

    }

    if (content != null) {

      content.initRequestContent(httpClient, httpRequestBase, args);

    }

  }

  protected void addHeaders(HttpClient httpClient, HttpRequestBase httpRequestBase, Args args) {

    for (Map.Entry<String, String> e : args.getHeaders().entrySet()) {

      String headerName = e.getKey();

      String headerValue = e.getValue();

      httpRequestBase.addHeader(headerName, headerValue);

    }

  }

  /**

   * Execute the specified the request.

   *

   * @param httpClient

   * @param httpRequestBase

   * @param args

   * @return

   * @throws ClientServicesException

   */

  protected HttpResponse executeRequest(HttpClient httpClient, HttpRequestBase httpRequestBase,

      Args args) throws ClientServicesException {

    try {

      return httpClient.execute(httpRequestBase);

    } catch (Exception ex) {

      if (logger.isLoggable(Level.FINE)) {

        String msg = "Exception ocurred while executing request {0} {1}";

        msg = StringUtil.format(msg, httpRequestBase.getMethod(), args);

        logger.log(Level.FINE, msg, ex);

      }

     

      if (ex instanceof ClientServicesException) {

        throw (ClientServicesException) ex;

      }

      String msg = "Error while executing the REST service {0}";