Example usage for org.apache.commons.httpclient HttpMethod getRequestHeaders

List of usage examples for org.apache.commons.httpclient HttpMethod getRequestHeaders

Introduction

In this page you can find the example usage for org.apache.commons.httpclient HttpMethod getRequestHeaders.

Prototype

public abstract Header[] getRequestHeaders();

Source Link

Usage

From source file:com.mobilefirst.fiberlink.WebServiceRequest.java

/**
  * Description: Send Request method/*from w  w w.  j a  v a 2s  . co m*/
 * @param method: the type of HTTP Method to send
 * @param responseToVerify: string to verify in the response
 * @return whether the response was verified 
 * @throws Exception
 */
private boolean sendRequest(HttpMethod method, String responseToVerify) throws Exception {
    boolean isResponseVerified = false;
    try {
        statusCode = client.executeMethod(method);
        responseBody = method.getResponseBodyAsString();
        System.out.println("Request URL :: " + method.getURI());
        System.out.println(
                "------------------------------------Begin Debug: Request Headers----------------------------------------------------------\n");
        Header[] requestHeaders = method.getRequestHeaders();
        for (int cn = 0; cn < requestHeaders.length; cn++) {
            System.out.println(requestHeaders[cn].toString());
        }
        System.out.println(
                "------------------------------------Begin Debug: Response Headers----------------------------------------------------------\n");
        Header[] responseHeaders = method.getResponseHeaders();
        for (int cn = 0; cn < responseHeaders.length; cn++) {
            System.out.println(responseHeaders[cn].toString());
        }
        System.out.println(
                "------------------------------------End Debug----------------------------------------------------------\n");
        if (statusCode != HttpStatus.SC_OK) {
            throw new Exception("POST method failed :: " + statusCode + " and ResponseBody :: " + responseBody);
        } else {
            System.out.println(
                    "------------------------------------Response Start----------------------------------------------------------\n");
            System.out.println(responseBody + "\n");
            System.out.println(
                    "------------------------------------Resoonse End----------------------------------------------------------");
            if (null == jsessionId) {
                for (int cnt = 0; cnt < responseHeaders.length; cnt++) {
                    //                  System.out.println(headers[cnt].toString());
                    if (responseHeaders[cnt].toString().contains("Set-Cookie: JSESSIONID=")) {
                        jsessionId = getPatternMatches("JSESSIONID=(.+); Path", responseHeaders[cnt].toString(),
                                false);
                        System.out.println("JESSIONID: " + jsessionId);
                        break;
                    }
                }
            }
            if (responseBody.toLowerCase().contains(responseToVerify.toLowerCase())) {
                System.out.println("RESPONSE VERIFIED. Contains: " + responseToVerify);
                isResponseVerified = true;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new Exception("Exception in sendRequest method..." + e.getMessage());
    }
    return isResponseVerified;
}

From source file:com.zimbra.qa.unittest.TestAccessKeyGrant.java

private void executeHttpMethod(HttpClient client, HttpMethod method) throws Exception {
    try {//  ww  w. j a v  a 2 s .  c om

        int respCode = HttpClientUtil.executeMethod(client, method);

        if (respCode != HttpStatus.SC_OK) {
            System.out.println("failed, respCode=" + respCode);
        } else {

            boolean chunked = false;
            boolean textContent = false;

            System.out.println("Headers:");
            System.out.println("--------");
            for (Header header : method.getRequestHeaders()) {
                System.out.print("    " + header.toString());
            }
            System.out.println();

            System.out.println("Body:");
            System.out.println("-----");
            String respBody = method.getResponseBodyAsString();
            System.out.println(respBody);
        }
    } finally {
        // Release the connection.
        method.releaseConnection();
    }
}

From source file:com.wordpress.metaphorm.authProxy.httpClient.impl.OAuthProxyConnectionApacheHttpCommonsClientImpl.java

/**
 * Executes the {@link HttpMethod} passed in and sends the proxy response
 * back to the client via the given {@link HttpServletResponse}
 * @param httpMethodProxyRequest An object representing the proxy request to be made
 * @param httpServletResponse An object by which we can send the proxied
 *                             response back to the client
 * @throws IOException Can be thrown by the {@link HttpClient}.executeMethod
 * @throws ServletException Can be thrown to indicate that another error has occurred
 *///from   w w w .  j  a v a 2 s. c  om
private void executeProxyRequest(HttpMethod httpMethodProxyRequest)
        throws IOException, RedirectRequiredException {

    //Utils.traceRequest(httpServletRequest);

    // Create a default HttpClient
    HttpClient httpClient = new HttpClient();
    httpMethodProxyRequest.setFollowRedirects(false);

    _log.debug("Sending request to " + httpMethodProxyRequest.getURI());

    for (Header header : httpMethodProxyRequest.getRequestHeaders()) {
        _log.debug("  Header \"" + header.getName() + "\" = \"" + header.getValue() + "\"");
    }

    // Execute the request
    int intProxyResponseCode = httpClient.executeMethod(httpMethodProxyRequest);

    // Persist the respose headers
    this.responseHeaderMap = new HashMap<String, List<String>>();
    for (Header header : this.httpMethod.getResponseHeaders()) {

        responseHeaderMap.put(header.getName(), Arrays.asList(header.getValue()));
    }

    // Check if the proxy response is a redirect
    // The following code is adapted from org.tigris.noodle.filters.CheckForRedirect
    // Hooray for open source software
    if (intProxyResponseCode >= HttpServletResponse.SC_MULTIPLE_CHOICES /* 300 */
            && intProxyResponseCode < HttpServletResponse.SC_NOT_MODIFIED /* 304 */) {
        String stringStatusCode = Integer.toString(intProxyResponseCode);
        String stringLocation = httpMethodProxyRequest.getResponseHeader(HttpConstants.STRING_LOCATION_HEADER)
                .getValue();
        if (stringLocation == null) {
            throw new IOException("Recieved status code: " + stringStatusCode + " but no "
                    + HttpConstants.STRING_LOCATION_HEADER + " header was found in the response");
        }

        throw new RedirectRequiredException(new URL(stringLocation));

    } else if (intProxyResponseCode == HttpServletResponse.SC_NOT_MODIFIED) {
        // 304 needs special handling.  See:
        // http://www.ics.uci.edu/pub/ietf/http/rfc1945.html#Code304
        // We get a 304 whenever passed an 'If-Modified-Since'
        // header and the data on disk has not changed; server
        // responds w/ a 304 saying I'm not going to send the
        // body because the file has not changed.
        //httpServletResponse.setIntHeader(HttpConstants.STRING_CONTENT_LENGTH_HEADER_NAME, 0);
        //httpServletResponse.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
    }

    // Pass the response code back to the client
    this.httpStatusCode = intProxyResponseCode;

    _log.debug("Response code was " + this.httpStatusCode);

    // Pass response headers back to the client
    // TODO: Implement support for proxying response headers
    //Header[] headerArrayResponse = httpMethodProxyRequest.getResponseHeaders();
    //for(Header header : headerArrayResponse) {
    //   httpServletResponse.setHeader(header.getName(), header.getValue());
    //}

    // Send the content to the client
    //InputStream inputStreamProxyResponse = httpMethodProxyRequest.getResponseBodyAsStream();
    //BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStreamProxyResponse);
    //OutputStream outputStreamClientResponse = httpServletResponse.getOutputStream();
    //int intNextByte;
    //while ( ( intNextByte = bufferedInputStream.read() ) != -1 ) {
    //   outputStreamClientResponse.write(intNextByte);
    //}
}

From source file:edu.caltech.ipac.firefly.server.network.HttpServices.java

/**
 * Execute the given HTTP method with the given parameters.
 * @param method    the function or method to perform
 * @param cookies   optional, sent with request if present.
 * @return  true is the request was successfully received, understood, and accepted (code 2xx).
 *///from w ww.j av a2  s . c om
public static boolean executeMethod(HttpMethod method, String userId, String password,
        Map<String, String> cookies) {
    try {
        if (!StringUtils.isEmpty(userId)) {
            UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(userId, password);
            httpClient.getState().setCredentials(AuthScope.ANY, credentials);
        } else {
            // check to see if the userId and password is in the url
            userId = URLDownload.getUserFromUrl(method.toString());
            if (userId != null) {
                password = URLDownload.getPasswordFromUrl(method.toString());
                UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(userId, password);
                httpClient.getState().setCredentials(AuthScope.ANY, credentials);
            }
        }

        if (cookies != null) {
            StringBuilder sb = new StringBuilder();
            for (Map.Entry<String, String> entry : cookies.entrySet()) {
                if (sb.length() > 0)
                    sb.append("; ");
                sb.append(entry.getKey());
                sb.append("=");
                sb.append(entry.getValue());
            }
            if (sb.length() > 0) {
                method.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
                method.setRequestHeader("Cookie", sb.toString());
            }
        }

        int status = httpClient.executeMethod(method);
        boolean isSuccess = status >= 200 && status < 300;
        String reqDesc = "URL:" + method.getURI();
        if (isSuccess) {
            LOG.info(reqDesc);
        } else {
            reqDesc = reqDesc + "\nREQUEST HEADERS: "
                    + CollectionUtil.toString(method.getRequestHeaders()).replaceAll("\\r|\\n", "")
                    + "\nPARAMETERS:\n " + getDesc(method.getParams()) + "\nRESPONSE HEADERS: "
                    + CollectionUtil.toString(method.getResponseHeaders()).replaceAll("\\r|\\n", "");

            LOG.error("HTTP request failed with status:" + status + "\n" + reqDesc);
        }
        return isSuccess;
    } catch (Exception e) {
        LOG.error(e, "Unable to connect to:" + method.toString());
    }
    return false;
}

From source file:net.adamcin.httpsig.http.apache3.Http3SignatureAuthScheme.java

public String authenticate(Credentials credentials, HttpMethod method) throws AuthenticationException {
    if (credentials instanceof SignerCredentials) {
        SignerCredentials creds = (SignerCredentials) credentials;
        String headers = this.getParameter(Constants.HEADERS);
        String algorithms = this.getParameter(Constants.ALGORITHMS);

        Challenge challenge = new Challenge(this.getRealm(), Constants.parseTokens(headers),
                Challenge.parseAlgorithms(algorithms));

        Signer signer = creds.getSigner();
        if (signer != null) {

            if (this.rotate) {
                this.rotate = false;
                if (!signer.rotateKeys(challenge, this.lastAuthz)) {
                    signer.rotateKeys(challenge);
                    return null;
                }/*from   ww w  .j ava  2s.  c  o  m*/
            }

            RequestContent.Builder sigBuilder = new RequestContent.Builder();

            sigBuilder.setRequestTarget(method.getName(),
                    method.getPath() + (method.getQueryString() != null ? "?" + method.getQueryString() : ""));

            for (Header header : method.getRequestHeaders()) {
                sigBuilder.addHeader(header.getName(), header.getValue());
            }

            if (sigBuilder.build().getDate() == null) {
                sigBuilder.addDateNow();
                method.addRequestHeader(Constants.HEADER_DATE, sigBuilder.build().getDate());
            }

            Authorization authorization = creds.getSigner().sign(sigBuilder.build());
            this.lastAuthz = authorization;
            if (authorization != null) {
                return authorization.getHeaderValue();
            }
        }
    }

    return null;
}

From source file:com.zenkey.net.prowser.Tab.java

/**************************************************************************
 * Writes tracing information that traces the request/response activity.
 * /* w  ww  .ja  va 2s.  c om*/
 * @param traceLevel
 *        Indicates how much trace info to produce.
 * @param traceStream
 *        An output stream where trace statements will be written.
 * @param httpMethod
 *        The HttpMethod object of the request.
 */
private static void writeTrace(int traceLevel, PrintStream traceStream, HttpMethod httpMethod) {

    try {
        if (traceLevel >= TRACE_URI) {
            // Show trace output of the request URI
            traceStream
                    .println("-------------------------------------------------------------------------------");
            traceStream.println(httpMethod.getURI() + "\n");
        }

        if (traceLevel >= TRACE_REQUEST_RESPONSE_LINES) {
            // Show trace output of the HTTP request line
            traceStream.println(httpMethod.getName() + " " + httpMethod.getPath()
                    + (httpMethod.getQueryString() == null ? "" : "?" + httpMethod.getQueryString()) + " "
                    + httpMethod.getParams().getVersion().toString());
        }

        if (traceLevel >= TRACE_HEADERS) {
            // Show trace output of the HTTP request headers
            for (Header header : httpMethod.getRequestHeaders()) {
                traceStream.println(header.getName() + ": " + header.getValue());
            }
            // Show trace of request entity body
            if (httpMethod instanceof PostMethod) {
                NameValuePair[] parameters = ((PostMethod) httpMethod).getParameters();
                if (parameters != null) {
                    // StringBuffer parameterString = new StringBuffer();
                    // for (NameValuePair parameter : parameters) {
                    //       parameterString.append(parameter.getName() + "=" + parameter.getValue() + "&");
                    // }
                    // parameterString.deleteCharAt(parameterString.length() - 1);
                    String parameterString = new String(
                            ((ByteArrayRequestEntity) ((PostMethod) httpMethod).getRequestEntity())
                                    .getContent(),
                            "UTF-8");
                    traceStream.println("    |");
                    traceStream.println("    +-- " + parameterString);
                }
            }
            traceStream.println();
        }

        if (traceLevel >= TRACE_REQUEST_RESPONSE_LINES) {
            // Show trace output of the HTTP status line
            traceStream.println(httpMethod.getStatusLine().toString());
        }

        if (traceLevel >= TRACE_HEADERS) {
            // Show trace output of the HTTP response headers
            for (Header header : httpMethod.getResponseHeaders()) {
                traceStream.println(header.getName() + ": " + header.getValue());
            }
            traceStream.println();
        }

        if (traceLevel >= TRACE_BODY) {
            // Show trace output of the HTTP response body
            traceStream.println(httpMethod.getResponseBodyAsString());
            traceStream.println();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:com.twinsoft.convertigo.beans.connectors.HttpConnector.java

private byte[] executeMethod(HttpMethod method, final Context context)
        throws IOException, URIException, MalformedURLException, EngineException {
    Header[] requestHeaders, responseHeaders = null;
    byte[] result = null;
    String contents = null;//from w ww.j  a v  a 2s  . co m
    int statuscode = -1;

    if (!context.requestedObject.runningThread.bContinue)
        return null;

    Engine.logBeans
            .debug("(HttpConnector) Executing method - " + method.getName() + "(" + method.getPath() + ")");

    try {
        requestHeaders = method.getRequestHeaders();
        if (Engine.logBeans.isTraceEnabled())
            Engine.logBeans
                    .trace("(HttpConnector) Request headers :\n" + Arrays.asList(requestHeaders).toString());

        statuscode = doExecuteMethod(method, context);

        Engine.logBeans.debug("(HttpConnector) Status: " + method.getStatusLine().toString());

        responseHeaders = method.getResponseHeaders();
        context.setResponseHeaders(responseHeaders);
        if (Engine.logBeans.isTraceEnabled())
            Engine.logBeans
                    .trace("(HttpConnector) Response headers:\n" + Arrays.asList(responseHeaders).toString());

        if (statuscode != -1) {
            InputStream in = method.getResponseBodyAsStream();
            if (in != null) {

                /**
                 * Retrieve response charset if available in responseHeaders
                 */
                charset = null;
                boolean checkGZip = false; // add GZip support #320

                for (int i = 0; i < responseHeaders.length && (charset == null || !checkGZip); i++) {
                    Header head = responseHeaders[i];
                    if (HeaderName.ContentType.is(head)) {
                        context.contentType = head.getValue();
                        HeaderElement[] els = head.getElements();
                        for (int j = 0; j < els.length && charset == null; j++) {
                            NameValuePair nvp = els[j].getParameterByName("charset");
                            if (nvp != null)
                                charset = nvp.getValue();
                        }
                    } else if (HeaderName.ContentEncoding.is(head)) {
                        checkGZip = true;
                        HeaderElement[] els = head.getElements();
                        for (int j = 0; j < els.length; j++)
                            if ("gzip".equals(els[j].getName())) {
                                Engine.logBeans.debug("(HttpConnector) Decode GZip stream");
                                in = new GZIPInputStream(in);
                            }
                    }
                }

                if (context.contentType != null && context.contentType.startsWith("multipart/")
                        && context.requestedObject instanceof AbstractHttpTransaction) {
                    Engine.logBeans.debug("(HttpConnector) Decoding multipart contentType");

                    try {
                        AbstractHttpTransaction transaction = (AbstractHttpTransaction) context.requestedObject;

                        BigMimeMultipart mp = new BigMimeMultipart(new BufferedInputStream(in),
                                context.contentType);

                        ByteArrayOutputStream bos = new ByteArrayOutputStream();
                        mp.nextPart(bos);
                        result = bos.toByteArray();

                        if (transaction.getAllowDownloadAttachment()) {
                            Document doc = context.outputDocument;
                            Element attInfo = null;

                            File file = File.createTempFile("c8o_", ".part");

                            for (MimePart bp = mp.nextPart(file); bp != null; bp = mp.nextPart(file)) {
                                try {
                                    file.deleteOnExit();

                                    if (attInfo == null) {
                                        Engine.logBeans.debug("(HttpConnector) Saving attachment(s)");

                                        attInfo = doc.createElement("AttachmentInfo");
                                        doc.getDocumentElement().appendChild(attInfo);
                                    }

                                    Element att = doc.createElement("attachment");
                                    attInfo.appendChild(att);

                                    String cid = bp.getContentID();

                                    if (cid != null) {
                                        cid = cid.replaceFirst("^<?(.*?)>?$", "$1");
                                        att.setAttribute("cid", "cid:" + cid);
                                    }

                                    Engine.logBeans.debug("(HttpConnector) Saving the attachment cid: " + cid
                                            + " in file: " + file.getAbsolutePath());

                                    att.setAttribute("filepath", file.getAbsolutePath());

                                    Enumeration<javax.mail.Header> headers = GenericUtils
                                            .cast(bp.getAllHeaders());
                                    while (headers.hasMoreElements()) {
                                        javax.mail.Header header = headers.nextElement();
                                        Element eHeader = doc.createElement("header");
                                        att.appendChild(eHeader);

                                        eHeader.setAttribute("name", header.getName());
                                        eHeader.setAttribute("value", header.getValue());
                                    }
                                } catch (Exception e1) {
                                    Engine.logBeans
                                            .error("(HttpConnector) Failed to retrieve the attachment in "
                                                    + file.getAbsolutePath(), e1);
                                }

                                file = File.createTempFile("c8o_", ".part");
                            }

                            file.delete();
                            in.close();
                        }
                    } catch (Exception e) {
                        Engine.logBeans.error("(HttpConnector) Failed to retrieve attachments", e);
                    }
                } else {
                    result = IOUtils.toByteArray(in);
                    in.close();
                }
            }

            if (Engine.logBeans.isTraceEnabled()) {
                contents = new String((result != null) ? result : new byte[] {});
                Engine.logBeans.trace("(HttpConnector) Response content:\n" + contents);
            }

            String redirectUrl, newuri;
            GetMethod redirectMethod = null;

            // Handles REDIRECTION through Location header
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY)
                    || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER)
                    || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {

                Header location = method.getResponseHeader("Location");
                if (location != null) {
                    newuri = location.getValue();
                    if ((newuri == null) || (newuri.equals(""))) {
                        newuri = "/";
                    }

                    // ignore any data after the ";" character
                    int split = newuri.indexOf(';');
                    if (split != -1) {
                        newuri = newuri.substring(0, split);
                    }

                    redirectUrl = getAbsoluteUrl(method, newuri);
                    Engine.logBeans.debug("(HttpConnector) Redirecting to : " + redirectUrl);
                    redirectMethod = new GetMethod(redirectUrl);

                    // set headers
                    for (int i = 0; i < requestHeaders.length; i++)
                        redirectMethod.setRequestHeader(requestHeaders[i]);

                    referer = redirectUrl.startsWith("http") ? redirectUrl
                            : (hostConfiguration.getHostURL() + redirectUrl);

                    result = executeMethod(redirectMethod, context); // recurse
                } else {
                    Engine.logBeans.debug("(HttpConnector) Invalid redirect!");
                }
            } else {
                /*
                 * String lwContents = contents.toLowerCase(); int index, i,
                 * j, k, z; // Handles REDIRECTION through META Refresh if
                 * (((index = lwContents.indexOf("http-equiv='refresh'")) !=
                 * -1) || ((index =
                 * lwContents.indexOf("http-equiv=\"refresh\"")) != -1)) {
                 * if ((i = lwContents.indexOf("content=", index + 20)) !=
                 * -1) { char c = lwContents.charAt(i+8); if ((j =
                 * lwContents.indexOf("url=", i)) != -1) { if ((k =
                 * lwContents.indexOf(c, j + 1)) != -1) { newuri =
                 * lwContents.substring(j+4, k); redirectUrl =
                 * getAbsoluteUrl(method,newuri);
                 * Engine.logBeans.debug("(HttpConnector) Redirecting to : "
                 * + redirectUrl); redirectMethod = new
                 * GetMethod(redirectUrl);
                 * 
                 * // set headers for (z=0; z<requestHeaders.length; z++)
                 * redirectMethod.setRequestHeader(requestHeaders[z]);
                 * 
                 * referer = redirectUrl; result =
                 * executeMethod(redirectMethod, context); // recurse } } }
                 * } // Handles FRAMESET else if
                 * (lwContents.indexOf("frameset") != -1) {
                 * Engine.logBeans.debug
                 * ("(HttpConnector) Analyzing frameset...");
                 * StringTokenizer st = new StringTokenizer(lwContents);
                 * StringEx newcontents = new StringEx(lwContents); while
                 * (st.hasMoreTokens()) { String token = st.nextToken();
                 * String uri; if (token.startsWith("src=")) { if
                 * ((token.indexOf("\"") != -1) || (token.indexOf("'") !=
                 * -1)) { token = token.substring(5); uri =
                 * token.substring(0,token.length()-1); newuri =
                 * getAbsoluteUrl(method,uri);
                 * Engine.logBeans.trace("(HttpConnector) Replaced uri ("+
                 * uri +") with newuri("+ newuri +")");
                 * 
                 * newcontents.replaceAll(token,newuri); } } }
                 * Engine.logBeans
                 * .trace("(HttpConnector) New response content:\n"+
                 * newcontents); result = newcontents.toString().getBytes();
                 * }
                 */
            }
        }
        //Added by julienda - #3433 - 04/03/2013
        AbstractHttpTransaction abstractHttpTransaction = (AbstractHttpTransaction) context.transaction;

        if (abstractHttpTransaction.getHttpInfo()) {
            Document doc = context.outputDocument;

            //Remove the node HTTPInfo if we have a redirect
            NodeList nodeList = XMLUtils.findElements(context.outputDocument.getDocumentElement(),
                    abstractHttpTransaction.getHttpInfoTagName());
            if (nodeList != null) {
                XMLUtils.removeNodeListContent(nodeList);
            }

            //Parent Element
            httpInfoElement = doc.createElement(abstractHttpTransaction.getHttpInfoTagName());

            //Add requested URL
            Element urlElement = doc.createElement("url");
            urlElement.setTextContent(method.getURI().toString());
            httpInfoElement.appendChild(urlElement);

            //Add status code
            Element httpStatusElement = doc.createElement("status");

            httpStatusElement.setAttribute("code", Integer.toString(statuscode));
            httpStatusElement.setAttribute("text", method.getStatusText());
            httpInfoElement.appendChild(httpStatusElement);

            //We add headers informations

            List<Header> headers = Arrays.asList(requestHeaders);
            if (!headers.isEmpty()) {
                Element httpHeadersElement = doc.createElement("headers");

                for (int i = 0; i < headers.size(); i++) {
                    Element elt = doc.createElement("header");
                    elt.setAttribute("name", headers.get(i).getName());
                    elt.setAttribute("value", headers.get(i).getValue());
                    httpHeadersElement.appendChild(elt);
                }
                httpInfoElement.appendChild(httpHeadersElement);
            }

            // we add response header information
            if (responseHeaders.length != 0) {
                Element httpHeadersElement = doc.createElement("responseHeaders");

                for (int i = 0; i < responseHeaders.length; i++) {
                    Element elt = doc.createElement("header");
                    elt.setAttribute("name", responseHeaders[i].getName());
                    elt.setAttribute("value", responseHeaders[i].getValue());
                    httpHeadersElement.appendChild(elt);
                }
                httpInfoElement.appendChild(httpHeadersElement);
            }

            doc.getDocumentElement().appendChild(httpInfoElement);
        }
    } finally {
        method.releaseConnection();
    }

    return result;
}

From source file:org.alfresco.jive.impl.JiveOpenClientImpl.java

/**
 * Debugging method for obtaining the state of a request as a String.
 * // ww w . ja  v  a2s.com
 * @param method The method to retrieve the request state from <i>(may be null)</i>.
 * @return The request state as a human-readable string value <i>(will not be null)</i>.
 */
private String requestToString(final HttpMethod method, final String body) {
    StringBuffer result = new StringBuffer(128);

    if (method != null) {
        result.append("\n\tMethod: ");
        result.append(method.getName());
        result.append("\n\tURL: ");

        try {
            result.append(String.valueOf(method.getURI()));
        } catch (final URIException ue) {
            result.append("unknown, due to: " + ue.getMessage());
        }

        result.append("\n\tHeaders: ");

        for (final Header header : method.getRequestHeaders()) {
            result.append("\n\t\t");
            result.append(header.getName());
            result.append(" : ");
            result.append(header.getValue());
        }

        result.append("\n\tAuthenticating? " + method.getDoAuthentication());

        if (body != null) {
            result.append("\n\tBody: ");
            result.append(body);
        }
    } else {
        result.append("(null)");
    }

    return (result.toString());
}

From source file:org.apache.axis2.transport.http.AbstractHTTPSender.java

public void addCustomHeaders(HttpMethod method, MessageContext msgContext) {

    boolean isCustomUserAgentSet = false;
    // set the custom headers, if available
    Object httpHeadersObj = msgContext.getProperty(HTTPConstants.HTTP_HEADERS);
    if (httpHeadersObj != null) {
        if (httpHeadersObj instanceof ArrayList) {
            ArrayList httpHeaders = (ArrayList) httpHeadersObj;
            Header header;/*w  w w . ja  v a2  s . co  m*/
            for (int i = 0; i < httpHeaders.size(); i++) {
                header = (Header) httpHeaders.get(i);
                if (HTTPConstants.HEADER_USER_AGENT.equals(header.getName())) {
                    isCustomUserAgentSet = true;
                }
                method.addRequestHeader(header);
            }

        }
        if (httpHeadersObj instanceof Map) {
            Map httpHeaders = (Map) httpHeadersObj;
            for (Iterator iterator = httpHeaders.entrySet().iterator(); iterator.hasNext();) {
                Map.Entry entry = (Map.Entry) iterator.next();
                String key = (String) entry.getKey();
                String value = (String) entry.getValue();
                if (HTTPConstants.HEADER_USER_AGENT.equals(key)) {
                    isCustomUserAgentSet = true;
                }
                method.addRequestHeader(key, value);
            }
        }
    }

    // we have to consider the TRANSPORT_HEADERS map as well
    Map transportHeaders = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS);
    if (transportHeaders != null) {
        removeUnwantedHeaders(msgContext);

        Set headerEntries = transportHeaders.entrySet();

        for (Object headerEntry : headerEntries) {
            if (headerEntry instanceof Map.Entry) {
                Header[] headers = method.getRequestHeaders();

                boolean headerAdded = false;
                for (Header header : headers) {
                    if (header.getName() != null) {
                        Object headerKey = ((Map.Entry) headerEntry).getKey();
                        if (headerKey instanceof String
                                && header.getName().equalsIgnoreCase((String) headerKey)) {
                            // According to RFC2626 http headers are case insensitive.
                            // So need to ignore case
                            headerAdded = true;
                            break;
                        }
                    }
                }

                if (!headerAdded) {
                    method.addRequestHeader(((Map.Entry) headerEntry).getKey().toString(),
                            ((Map.Entry) headerEntry).getValue().toString());
                }
            }
        }
    }

    if (!isCustomUserAgentSet) {
        String userAgentString = getUserAgent(msgContext);
        method.setRequestHeader(HTTPConstants.HEADER_USER_AGENT, userAgentString);
    }

}

From source file:org.apache.axis2.transport.http.impl.httpclient3.HTTPSenderImpl.java

public void addCustomHeaders(HttpMethod method, MessageContext msgContext) {

    boolean isCustomUserAgentSet = false;
    // set the custom headers, if available
    Object httpHeadersObj = msgContext.getProperty(HTTPConstants.HTTP_HEADERS);
    if (httpHeadersObj != null) {
        if (httpHeadersObj instanceof List) {
            List httpHeaders = (List) httpHeadersObj;
            for (int i = 0; i < httpHeaders.size(); i++) {
                NamedValue nv = (NamedValue) httpHeaders.get(i);
                if (nv != null) {
                    Header header = new Header(nv.getName(), nv.getValue());
                    if (HTTPConstants.HEADER_USER_AGENT.equals(header.getName())) {
                        isCustomUserAgentSet = true;
                    }//from   w w w  .j a v  a  2 s. com
                    method.addRequestHeader(header);
                }
            }

        }
        if (httpHeadersObj instanceof Map) {
            Map httpHeaders = (Map) httpHeadersObj;
            for (Iterator iterator = httpHeaders.entrySet().iterator(); iterator.hasNext();) {
                Map.Entry entry = (Map.Entry) iterator.next();
                String key = (String) entry.getKey();
                String value = (String) entry.getValue();
                if (HTTPConstants.HEADER_USER_AGENT.equals(key)) {
                    isCustomUserAgentSet = true;
                }
                method.addRequestHeader(key, value);
            }
        }
    }

    // we have to consider the TRANSPORT_HEADERS map as well
    Map transportHeaders = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS);
    if (transportHeaders != null) {
        removeUnwantedHeaders(msgContext);

        Set headerEntries = transportHeaders.entrySet();

        for (Object headerEntry : headerEntries) {
            if (headerEntry instanceof Map.Entry) {
                Header[] headers = method.getRequestHeaders();

                boolean headerAdded = false;
                for (Header header : headers) {
                    if (header.getName() != null
                            && header.getName().equals(((Map.Entry) headerEntry).getKey())) {
                        headerAdded = true;
                        break;
                    }
                }

                if (!headerAdded) {
                    method.addRequestHeader(((Map.Entry) headerEntry).getKey().toString(),
                            ((Map.Entry) headerEntry).getValue().toString());
                }
            }
        }
    }

    if (!isCustomUserAgentSet) {
        String userAgentString = getUserAgent(msgContext);
        method.setRequestHeader(HTTPConstants.HEADER_USER_AGENT, userAgentString);
    }

}