Example usage for org.apache.http.client.methods HttpRequestBase getRequestLine

List of usage examples for org.apache.http.client.methods HttpRequestBase getRequestLine

Introduction

In this page you can find the example usage for org.apache.http.client.methods HttpRequestBase getRequestLine.

Prototype

public RequestLine getRequestLine() 

Source Link

Usage

From source file:org.apache.jmeter.protocol.http.sampler.HTTPHC4Impl.java

@Override
protected HTTPSampleResult sample(URL url, String method, boolean areFollowingRedirect, int frameDepth) {

    if (log.isDebugEnabled()) {
        log.debug("Start : sample " + url.toString());
        log.debug("method " + method + " followingRedirect " + areFollowingRedirect + " depth " + frameDepth);
    }/* ww  w . ja va 2s. c  o  m*/

    HTTPSampleResult res = createSampleResult(url, method);

    HttpClient httpClient = setupClient(url, res);

    HttpRequestBase httpRequest = null;
    try {
        URI uri = url.toURI();
        if (method.equals(HTTPConstants.POST)) {
            httpRequest = new HttpPost(uri);
        } else if (method.equals(HTTPConstants.GET)) {
            httpRequest = new HttpGet(uri);
        } else if (method.equals(HTTPConstants.PUT)) {
            httpRequest = new HttpPut(uri);
        } else if (method.equals(HTTPConstants.HEAD)) {
            httpRequest = new HttpHead(uri);
        } else if (method.equals(HTTPConstants.TRACE)) {
            httpRequest = new HttpTrace(uri);
        } else if (method.equals(HTTPConstants.OPTIONS)) {
            httpRequest = new HttpOptions(uri);
        } else if (method.equals(HTTPConstants.DELETE)) {
            httpRequest = new HttpDelete(uri);
        } else if (method.equals(HTTPConstants.PATCH)) {
            httpRequest = new HttpPatch(uri);
        } else if (HttpWebdav.isWebdavMethod(method)) {
            httpRequest = new HttpWebdav(method, uri);
        } else {
            throw new IllegalArgumentException("Unexpected method: '" + method + "'");
        }
        setupRequest(url, httpRequest, res); // can throw IOException
    } catch (Exception e) {
        res.sampleStart();
        res.sampleEnd();
        errorResult(e, res);
        return res;
    }

    HttpContext localContext = new BasicHttpContext();
    setupClientContextBeforeSample(localContext);

    res.sampleStart();

    final CacheManager cacheManager = getCacheManager();
    if (cacheManager != null && HTTPConstants.GET.equalsIgnoreCase(method)) {
        if (cacheManager.inCache(url)) {
            return updateSampleResultForResourceInCache(res);
        }
    }

    try {
        currentRequest = httpRequest;
        handleMethod(method, res, httpRequest, localContext);
        // store the SampleResult in LocalContext to compute connect time
        localContext.setAttribute(SAMPLER_RESULT_TOKEN, res);
        // perform the sample
        HttpResponse httpResponse = executeRequest(httpClient, httpRequest, localContext, url);

        // Needs to be done after execute to pick up all the headers
        final HttpRequest request = (HttpRequest) localContext.getAttribute(HttpCoreContext.HTTP_REQUEST);
        extractClientContextAfterSample(localContext);
        // We've finished with the request, so we can add the LocalAddress to it for display
        final InetAddress localAddr = (InetAddress) httpRequest.getParams()
                .getParameter(ConnRoutePNames.LOCAL_ADDRESS);
        if (localAddr != null) {
            request.addHeader(HEADER_LOCAL_ADDRESS, localAddr.toString());
        }
        res.setRequestHeaders(getConnectionHeaders(request));

        Header contentType = httpResponse.getLastHeader(HTTPConstants.HEADER_CONTENT_TYPE);
        if (contentType != null) {
            String ct = contentType.getValue();
            res.setContentType(ct);
            res.setEncodingAndType(ct);
        }
        HttpEntity entity = httpResponse.getEntity();
        if (entity != null) {
            res.setResponseData(readResponse(res, entity.getContent(), (int) entity.getContentLength()));
        }

        res.sampleEnd(); // Done with the sampling proper.
        currentRequest = null;

        // Now collect the results into the HTTPSampleResult:
        StatusLine statusLine = httpResponse.getStatusLine();
        int statusCode = statusLine.getStatusCode();
        res.setResponseCode(Integer.toString(statusCode));
        res.setResponseMessage(statusLine.getReasonPhrase());
        res.setSuccessful(isSuccessCode(statusCode));

        res.setResponseHeaders(getResponseHeaders(httpResponse, localContext));
        if (res.isRedirect()) {
            final Header headerLocation = httpResponse.getLastHeader(HTTPConstants.HEADER_LOCATION);
            if (headerLocation == null) { // HTTP protocol violation, but avoids NPE
                throw new IllegalArgumentException(
                        "Missing location header in redirect for " + httpRequest.getRequestLine());
            }
            String redirectLocation = headerLocation.getValue();
            res.setRedirectLocation(redirectLocation);
        }

        // record some sizes to allow HTTPSampleResult.getBytes() with different options
        HttpConnectionMetrics metrics = (HttpConnectionMetrics) localContext.getAttribute(CONTEXT_METRICS);
        long headerBytes = res.getResponseHeaders().length() // condensed length (without \r)
                + httpResponse.getAllHeaders().length // Add \r for each header
                + 1 // Add \r for initial header
                + 2; // final \r\n before data
        long totalBytes = metrics.getReceivedBytesCount();
        res.setHeadersSize((int) headerBytes);
        res.setBodySize((int) (totalBytes - headerBytes));
        if (log.isDebugEnabled()) {
            log.debug("ResponseHeadersSize=" + res.getHeadersSize() + " Content-Length=" + res.getBodySize()
                    + " Total=" + (res.getHeadersSize() + res.getBodySize()));
        }

        // If we redirected automatically, the URL may have changed
        if (getAutoRedirects()) {
            HttpUriRequest req = (HttpUriRequest) localContext.getAttribute(HttpCoreContext.HTTP_REQUEST);
            HttpHost target = (HttpHost) localContext.getAttribute(HttpCoreContext.HTTP_TARGET_HOST);
            URI redirectURI = req.getURI();
            if (redirectURI.isAbsolute()) {
                res.setURL(redirectURI.toURL());
            } else {
                res.setURL(new URL(new URL(target.toURI()), redirectURI.toString()));
            }
        }

        // Store any cookies received in the cookie manager:
        saveConnectionCookies(httpResponse, res.getURL(), getCookieManager());

        // Save cache information
        if (cacheManager != null) {
            cacheManager.saveDetails(httpResponse, res);
        }

        // Follow redirects and download page resources if appropriate:
        res = resultProcessing(areFollowingRedirect, frameDepth, res);

    } catch (IOException e) {
        log.debug("IOException", e);
        if (res.getEndTime() == 0) {
            res.sampleEnd();
        }
        // pick up headers if failed to execute the request
        if (res.getRequestHeaders() != null) {
            log.debug("Overwriting request old headers: " + res.getRequestHeaders());
        }
        res.setRequestHeaders(
                getConnectionHeaders((HttpRequest) localContext.getAttribute(HttpCoreContext.HTTP_REQUEST)));
        errorResult(e, res);
        return res;
    } catch (RuntimeException e) {
        log.debug("RuntimeException", e);
        if (res.getEndTime() == 0) {
            res.sampleEnd();
        }
        errorResult(e, res);
        return res;
    } finally {
        currentRequest = null;
        JMeterContextService.getContext().getSamplerContext().remove(HTTPCLIENT_TOKEN);
    }
    return res;
}

From source file:org.dasein.cloud.aws.storage.S3Method.java

S3Response invoke(@Nullable String bucket, @Nullable String object, @Nullable String temporaryEndpoint)
        throws S3Exception, CloudException, InternalException {
    if (wire.isDebugEnabled()) {
        wire.debug("");
        wire.debug("----------------------------------------------------------------------------------");
    }/*from   w w w  .ja v a 2  s  . c  o  m*/
    HttpClient client = null;
    boolean leaveOpen = false;
    try {
        StringBuilder url = new StringBuilder();
        HttpRequestBase method;
        int status;

        // Sanitise the parameters as they may have spaces and who knows what else
        if (bucket != null) {
            bucket = AWSCloud.encode(bucket, false);
        }
        if (object != null && !"?location".equalsIgnoreCase(object) && !"?acl".equalsIgnoreCase(object)
                && !"?tagging".equalsIgnoreCase(object)) {
            object = AWSCloud.encode(object, false);
        }
        if (temporaryEndpoint != null) {
            temporaryEndpoint = AWSCloud.encode(temporaryEndpoint, false);
        }
        if (provider.getEC2Provider().isAWS()) {
            url.append("https://");
            String regionId = provider.getContext().getRegionId();

            if (temporaryEndpoint == null) {
                boolean validDomainName = isValidDomainName(bucket);

                if (bucket != null && validDomainName) {
                    url.append(bucket);
                    if (regionId != null && !regionId.isEmpty() && !"us-east-1".equals(regionId)) {
                        url.append(".s3-");
                        url.append(regionId);
                        url.append(".amazonaws.com/");
                    } else {
                        url.append(".s3.amazonaws.com/");
                    }
                } else {
                    if (regionId != null && !regionId.isEmpty() && !"us-east-1".equals(regionId)) {
                        url.append("s3-");
                        url.append(regionId);
                        url.append(".amazonaws.com/");
                    } else {
                        url.append("s3.amazonaws.com/");
                    }
                }
                if (bucket != null && !validDomainName) {
                    url.append(bucket);
                    url.append("/");
                }
            } else {
                url.append(temporaryEndpoint);
                url.append("/");
            }
        } else if (provider.getEC2Provider().isStorage()
                && "google".equalsIgnoreCase(provider.getProviderName())) {
            url.append("https://");
            if (temporaryEndpoint == null) {
                if (bucket != null) {
                    url.append(bucket);
                    url.append(".");
                }
                url.append("commondatastorage.googleapis.com/");
            } else {
                url.append(temporaryEndpoint);
                url.append("/");
            }
        } else {
            int idx = 0;

            if (!provider.getContext().getEndpoint().startsWith("http")) {
                url.append("https://");
            } else {
                idx = provider.getContext().getEndpoint().indexOf("https://");
                if (idx == -1) {
                    idx = "http://".length();
                    url.append("http://");
                } else {
                    idx = "https://".length();
                    url.append("https://");
                }
            }
            String service = "";
            if (provider.getEC2Provider().isEucalyptus()) {
                service = "Walrus/";
            }

            if (temporaryEndpoint == null) {
                url.append(provider.getContext().getEndpoint().substring(idx));
                if (!provider.getContext().getEndpoint().endsWith("/")) {
                    url.append("/").append(service);
                } else {
                    url.append(service);
                }
            } else {
                url.append(temporaryEndpoint);
                url.append("/");
                url.append(service);
            }
            if (bucket != null) {
                url.append(bucket);
                url.append("/");
            }
        }
        if (object != null) {
            url.append(object);
        } else if (parameters != null) {
            boolean first = true;

            if (object != null && object.indexOf('?') != -1) {
                first = false;
            }
            for (Map.Entry<String, String> entry : parameters.entrySet()) {
                String key = entry.getKey();
                String val = entry.getValue();

                if (first) {
                    url.append("?");
                    first = false;
                } else {
                    url.append("&");
                }
                if (val != null) {
                    url.append(AWSCloud.encode(key, false));
                    url.append("=");
                    url.append(AWSCloud.encode(val, false));
                } else {
                    url.append(AWSCloud.encode(key, false));
                }
            }
        }

        if (provider.getEC2Provider().isStorage() && provider.getProviderName().equalsIgnoreCase("Google")) {
            headers.put(AWSCloud.P_GOOG_DATE, getDate());
        } else {
            headers.put(AWSCloud.P_AWS_DATE, provider.getV4HeaderDate(null));
        }
        if (contentType == null && body != null) {
            contentType = "application/xml";
            headers.put("Content-Type", contentType);
        } else if (contentType != null) {
            headers.put("Content-Type", contentType);
        }

        method = action.getMethod(url.toString());
        String host = method.getURI().getHost();
        headers.put("host", host);

        if (action.equals(S3Action.PUT_BUCKET_TAG))
            try {
                headers.put("Content-MD5", toBase64(computeMD5Hash(body)));
            } catch (NoSuchAlgorithmException e) {
                logger.error(e);
            } catch (IOException e) {
                logger.error(e);
            }

        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                method.addHeader(entry.getKey(), entry.getValue());
            }
        }

        if (body != null) {
            ((HttpEntityEnclosingRequestBase) method).setEntity(new StringEntity(body, APPLICATION_XML));
        } else if (uploadFile != null) {
            ((HttpEntityEnclosingRequestBase) method).setEntity(new FileEntity(uploadFile, contentType));
        }
        try {
            String hash = null;
            if (method instanceof HttpEntityEnclosingRequestBase) {
                try {
                    hash = provider.getRequestBodyHash(
                            EntityUtils.toString(((HttpEntityEnclosingRequestBase) method).getEntity()));
                } catch (IOException e) {
                    throw new InternalException(e);
                }
            } else {
                hash = provider.getRequestBodyHash("");
            }

            String signature;
            if (provider.getEC2Provider().isAWS()) {
                // Sign v4 for AWS
                signature = provider.getV4Authorization(new String(provider.getAccessKey()[0]),
                        new String(provider.getAccessKey()[1]), method.getMethod(), url.toString(), SERVICE_ID,
                        headers, hash);
                if (hash != null) {
                    method.addHeader(AWSCloud.P_AWS_CONTENT_SHA256, hash);
                }
            } else {
                // Eucalyptus et al use v2
                signature = provider.signS3(new String(provider.getAccessKey()[0], "utf-8"),
                        provider.getAccessKey()[1], method.getMethod(), null, contentType, headers, bucket,
                        object);
            }
            method.addHeader(AWSCloud.P_CFAUTH, signature);
        } catch (UnsupportedEncodingException e) {
            logger.error(e);
        }

        if (wire.isDebugEnabled()) {
            wire.debug("[" + url.toString() + "]");
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (body != null) {
                try {
                    wire.debug(EntityUtils.toString(((HttpEntityEnclosingRequestBase) method).getEntity()));
                } catch (IOException ignore) {
                }

                wire.debug("");
            } else if (uploadFile != null) {
                wire.debug("-- file upload --");
                wire.debug("");
            }
        }

        attempts++;
        client = provider.getClient(body == null && uploadFile == null);

        S3Response response = new S3Response();
        HttpResponse httpResponse;

        try {
            APITrace.trace(provider, action.toString());
            httpResponse = client.execute(method);
            if (wire.isDebugEnabled()) {
                wire.debug(httpResponse.getStatusLine().toString());
                for (Header header : httpResponse.getAllHeaders()) {
                    wire.debug(header.getName() + ": " + header.getValue());
                }
                wire.debug("");
            }
            status = httpResponse.getStatusLine().getStatusCode();
        } catch (IOException e) {
            logger.error(url + ": " + e.getMessage());
            throw new InternalException(e);
        }
        response.headers = httpResponse.getAllHeaders();

        HttpEntity entity = httpResponse.getEntity();
        InputStream input = null;

        if (entity != null) {
            try {
                input = entity.getContent();
            } catch (IOException e) {
                throw new CloudException(e);
            }
        }
        try {
            if (status == HttpStatus.SC_OK || status == HttpStatus.SC_CREATED
                    || status == HttpStatus.SC_ACCEPTED) {
                Header clen = httpResponse.getFirstHeader("Content-Length");
                long len = -1L;

                if (clen != null) {
                    len = Long.parseLong(clen.getValue());
                }
                if (len != 0L) {
                    try {
                        Header ct = httpResponse.getFirstHeader("Content-Type");

                        if ((ct != null && (ct.getValue().startsWith("application/xml")
                                || ct.getValue().startsWith("text/xml")))
                                || (action.equals(S3Action.GET_BUCKET_TAG) && input != null)) {
                            try {
                                response.document = parseResponse(input);
                                return response;
                            } finally {
                                input.close();
                            }
                        } else if (ct != null && ct.getValue().startsWith("application/octet-stream")
                                && len < 1) {
                            return null;
                        } else {
                            response.contentLength = len;
                            if (ct != null) {
                                response.contentType = ct.getValue();
                            }
                            response.input = input;
                            response.method = method;
                            leaveOpen = true;
                            return response;
                        }
                    } catch (IOException e) {
                        logger.error(e);
                        throw new CloudException(e);
                    }
                } else {
                    return response;
                }
            } else if (status == HttpStatus.SC_NO_CONTENT) {
                return response;
            }
            if (status == HttpStatus.SC_FORBIDDEN) {
                throw new S3Exception(status, "", "AccessForbidden",
                        "Access was denied : " + (url != null ? url.toString() : ""));
            } else if (status == HttpStatus.SC_NOT_FOUND) {
                throw new S3Exception(status, null, null, "Object not found.");
            } else {
                if (status == HttpStatus.SC_SERVICE_UNAVAILABLE
                        || status == HttpStatus.SC_INTERNAL_SERVER_ERROR) {
                    if (attempts >= 5) {
                        String msg;

                        if (status == HttpStatus.SC_SERVICE_UNAVAILABLE) {
                            msg = "Cloud service is currently unavailable.";
                        } else {
                            msg = "The cloud service encountered a server error while processing your request.";
                        }
                        logger.error(msg);
                        throw new CloudException(msg);
                    } else {
                        leaveOpen = true;
                        if (input != null) {
                            try {
                                input.close();
                            } catch (IOException ignore) {
                            }
                        }
                        try {
                            Thread.sleep(5000L);
                        } catch (InterruptedException ignore) {
                        }
                        return invoke(bucket, object);
                    }
                }
                try {
                    Document doc;

                    try {
                        logger.warn("Received error code: " + status);
                        doc = parseResponse(input);
                    } finally {
                        if (input != null) {
                            input.close();
                        }
                    }
                    if (doc != null) {
                        String endpoint = null, code = null, message = null, requestId = null;
                        NodeList blocks = doc.getElementsByTagName("Error");

                        if (blocks.getLength() > 0) {
                            Node error = blocks.item(0);
                            NodeList attrs;

                            attrs = error.getChildNodes();
                            for (int i = 0; i < attrs.getLength(); i++) {
                                Node attr = attrs.item(i);

                                if (attr.getNodeName().equals("Code") && attr.hasChildNodes()) {
                                    code = attr.getFirstChild().getNodeValue().trim();
                                } else if (attr.getNodeName().equals("Message") && attr.hasChildNodes()) {
                                    message = attr.getFirstChild().getNodeValue().trim();
                                } else if (attr.getNodeName().equals("RequestId") && attr.hasChildNodes()) {
                                    requestId = attr.getFirstChild().getNodeValue().trim();
                                } else if (attr.getNodeName().equals("Endpoint") && attr.hasChildNodes()) {
                                    endpoint = attr.getFirstChild().getNodeValue().trim();
                                }
                            }

                        }
                        if (endpoint != null && code.equals("TemporaryRedirect")) {
                            if (temporaryEndpoint != null) {
                                throw new CloudException("Too deep redirect to " + endpoint);
                            } else {
                                return invoke(bucket, object, endpoint);
                            }
                        } else {
                            if (message == null) {
                                throw new CloudException("Unable to identify error condition: " + status + "/"
                                        + requestId + "/" + code);
                            }
                            throw new S3Exception(status, requestId, code, message);
                        }
                    } else {
                        throw new CloudException("Unable to parse error.");
                    }
                } catch (IOException e) {
                    if (status == HttpStatus.SC_FORBIDDEN) {
                        throw new S3Exception(status, "", "AccessForbidden",
                                "Access was denied without explanation.");
                    }
                    throw new CloudException(e);
                } catch (RuntimeException e) {
                    throw new CloudException(e);
                } catch (Error e) {
                    throw new CloudException(e);
                }
            }
        } finally {
            if (!leaveOpen) {
                if (input != null) {
                    try {
                        input.close();
                    } catch (IOException ignore) {
                    }
                }
            }
        }
    } finally {
        if (!leaveOpen && client != null) {
            client.getConnectionManager().shutdown();
        }
        if (wire.isDebugEnabled()) {
            wire.debug("----------------------------------------------------------------------------------");
            wire.debug("");
        }
    }
}

From source file:org.dasein.cloud.azure.AzureStorageMethod.java

@SuppressWarnings("deprecation")
public Document getAsDoc(@Nonnull String httpVerb, @Nonnull String resource,
        @Nullable Map<String, String> queries, @Nullable String body, @Nullable Map<String, String> headerMap,
        boolean authorization) throws CloudException, InternalException {
    if (logger.isTraceEnabled()) {
        logger.trace("enter - " + AzureStorageMethod.class.getName() + "." + httpVerb + "("
                + getStorageAccount() + "," + resource + ")");
    }/*www  .  j a v  a  2s. co m*/
    String endpoint = getStorageEnpoint();

    if (wire.isDebugEnabled()) {
        wire.debug(httpVerb + "--------------------------------------------------------> " + endpoint
                + getStorageAccount() + resource);
        wire.debug("");
    }
    try {
        HttpClient client = getClient();

        if (headerMap == null) {
            headerMap = new HashMap<String, String>();
        }

        HttpRequestBase method = getMethod(httpVerb, buildUrl(resource, queries), queries, headerMap,
                authorization);

        if (wire.isDebugEnabled()) {
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (body != null) {
                wire.debug(body);
                wire.debug("");
            }
        }

        // If it is post or put
        if (method instanceof HttpEntityEnclosingRequestBase) {

            HttpEntityEnclosingRequestBase entityEnclosingMethod = (HttpEntityEnclosingRequestBase) method;

            if (body != null) {
                entityEnclosingMethod.setEntity(new StringEntity(body, "application/xml", "utf-8"));
            }
        }

        HttpResponse response;
        StatusLine status;

        try {
            response = client.execute(method);
            status = response.getStatusLine();
        } catch (IOException e) {
            logger.error("GET(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
            if (logger.isTraceEnabled()) {
                e.printStackTrace();
            }
            throw new CloudException(e);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("GET(): HTTP Status " + status);
        }
        Header[] headers = response.getAllHeaders();
        if (wire.isDebugEnabled()) {
            wire.debug(status.toString());
            for (Header h : headers) {
                if (h.getValue() != null) {
                    wire.debug(h.getName() + ": " + h.getValue().trim());
                } else {
                    wire.debug(h.getName() + ":");
                }
            }
            wire.debug("");
        }

        if (status.getStatusCode() == HttpServletResponse.SC_NOT_FOUND) {
            return null;
        }
        if (status.getStatusCode() != HttpServletResponse.SC_OK
                && status.getStatusCode() != HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION) {
            logger.error(
                    httpVerb + "(): Expected OK for " + httpVerb + "request, got " + status.getStatusCode());

            HttpEntity entity = response.getEntity();
            String result;

            if (entity == null) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), "An error was returned without explanation");
            }
            try {
                result = EntityUtils.toString(entity);
            } catch (IOException e) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), e.getMessage());
            }
            if (wire.isDebugEnabled()) {
                wire.debug(result);
            }
            wire.debug("");
            AzureException.ExceptionItems items = AzureException.parseException(status.getStatusCode(), result);

            if (items == null) {
                return null;
            }

            logger.error(
                    httpVerb + "(): [" + status.getStatusCode() + " : " + items.message + "] " + items.details);
            throw new AzureException(items);
        } else {

            HttpEntity entity = response.getEntity();

            if (entity == null) {
                return null;
            }
            InputStream input;

            try {
                input = entity.getContent();
            } catch (IOException e) {
                logger.error(httpVerb + "(): Failed to read response error due to a cloud I/O error: "
                        + e.getMessage());
                if (logger.isTraceEnabled()) {
                    e.printStackTrace();
                }
                throw new CloudException(e);
            }
            return parseResponse(input, true);
        }
    } catch (UnsupportedEncodingException e) {
        throw new CloudException(e);
    } finally {
        if (logger.isTraceEnabled()) {
            logger.trace("exit - " + AzureMethod.class.getName() + ".getStream()");
        }
        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug("--------------------------------------------------------> ");
        }
    }
}

From source file:org.dasein.cloud.azure.AzureStorageMethod.java

public @Nullable InputStream getAsStream(@Nonnull String strMethod, @Nonnull String resource,
        @Nonnull Map<String, String> queries, @Nullable String body, @Nullable Map<String, String> headerMap,
        boolean authorization) throws CloudException, InternalException {
    if (logger.isTraceEnabled()) {
        logger.trace("enter - " + AzureStorageMethod.class.getName() + "." + strMethod + "("
                + getStorageAccount() + "," + resource + ")");
    }/*from w  w w. j  av a 2 s  .  c  o  m*/
    String endpoint = getStorageEnpoint();
    if (wire.isDebugEnabled()) {
        wire.debug(strMethod + "--------------------------------------------------------> " + endpoint
                + getStorageAccount() + resource);
        wire.debug("");
    }
    try {

        HttpClient client = getClient();

        String contentLength = null;
        if (body != null) {
            contentLength = String.valueOf(body.length());
        } else {
            contentLength = "0";
        }

        HttpRequestBase method = getMethod(strMethod, buildUrl(resource, queries), queries, headerMap,
                authorization);

        if (wire.isDebugEnabled()) {
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (body != null) {
                wire.debug(body);
                wire.debug("");
            }
        }

        // If it is post or put
        if (method instanceof HttpEntityEnclosingRequestBase) {

            HttpEntityEnclosingRequestBase entityEnclosingMethod = (HttpEntityEnclosingRequestBase) method;

            if (body != null) {
                entityEnclosingMethod.setEntity(new StringEntity(body, "application/xml", "utf-8"));
            }
        }

        HttpResponse response;
        StatusLine status;

        try {
            response = client.execute(method);
            status = response.getStatusLine();
        } catch (IOException e) {
            logger.error("post(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
            if (logger.isTraceEnabled()) {
                e.printStackTrace();
            }
            throw new CloudException(e);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("post(): HTTP Status " + status);
        }
        Header[] headers = response.getAllHeaders();

        if (wire.isDebugEnabled()) {
            wire.debug(status.toString());
            for (Header h : headers) {
                if (h.getValue() != null) {
                    wire.debug(h.getName() + ": " + h.getValue().trim());
                } else {
                    wire.debug(h.getName() + ":");
                }
            }
            wire.debug("");
        }

        if (status.getStatusCode() == HttpServletResponse.SC_NOT_FOUND) {
            return null;
        }
        if (status.getStatusCode() != HttpServletResponse.SC_OK
                && status.getStatusCode() != HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION) {
            logger.error(
                    strMethod + "(): Expected OK for " + strMethod + "request, got " + status.getStatusCode());

            HttpEntity entity = response.getEntity();
            String result;

            if (entity == null) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), "An error was returned without explanation");
            }
            try {
                result = EntityUtils.toString(entity);
            } catch (IOException e) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), e.getMessage());
            }
            if (wire.isDebugEnabled()) {
                wire.debug(result);
            }
            wire.debug("");
            AzureException.ExceptionItems items = AzureException.parseException(status.getStatusCode(), result);

            if (items == null) {
                return null;
            }

            logger.error(strMethod + "(): [" + status.getStatusCode() + " : " + items.message + "] "
                    + items.details);
            throw new AzureException(items);
        } else {

            HttpEntity entity = response.getEntity();

            if (entity == null) {
                return null;
            }
            InputStream input;

            try {
                input = entity.getContent();
            } catch (IOException e) {
                logger.error(strMethod + "(): Failed to read response error due to a cloud I/O error: "
                        + e.getMessage());
                if (logger.isTraceEnabled()) {
                    e.printStackTrace();
                }
                throw new CloudException(e);
            }
            return input;
        }
    } catch (UnsupportedEncodingException e) {
        throw new CloudException(e);
    } finally {
        if (logger.isTraceEnabled()) {
            logger.trace("exit - " + AzureMethod.class.getName() + ".getStream()");
        }
        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug("--------------------------------------------------------> ");
        }
    }
}

From source file:org.dasein.cloud.azure.AzureStorageMethod.java

public String getBlobProperty(@Nonnull String strMethod, @Nonnull String resource,
        @Nonnull Map<String, String> queries, String body, @Nullable Map<String, String> headerMap,
        boolean authorization, String propertyName) throws CloudException, InternalException {
    if (logger.isTraceEnabled()) {
        logger.trace("enter - " + AzureStorageMethod.class.getName() + "." + strMethod + "("
                + getStorageAccount() + "," + resource + ")");
    }/*w  w  w  . j a v a  2s  .c  o  m*/
    String endpoint = getStorageEnpoint();

    if (wire.isDebugEnabled()) {
        wire.debug(strMethod + "--------------------------------------------------------> " + endpoint
                + getStorageAccount() + resource);
        wire.debug("");
    }
    try {

        HttpClient client = getClient();

        if (headerMap == null) {
            headerMap = new HashMap<String, String>();
        }

        HttpRequestBase method = getMethod(strMethod, buildUrl(resource, queries), queries, headerMap,
                authorization);

        if (wire.isDebugEnabled()) {
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (body != null) {
                wire.debug(body);
                wire.debug("");
            }
        }

        // If it is post or put
        if (method instanceof HttpEntityEnclosingRequestBase) {

            HttpEntityEnclosingRequestBase entityEnclosingMethod = (HttpEntityEnclosingRequestBase) method;

            if (body != null) {
                entityEnclosingMethod.setEntity(new StringEntity(body, "application/xml", "utf-8"));
            }
        }

        HttpResponse response;
        StatusLine status;

        try {
            response = client.execute(method);
            status = response.getStatusLine();
        } catch (IOException e) {
            logger.error("post(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
            if (logger.isTraceEnabled()) {
                e.printStackTrace();
            }
            throw new CloudException(e);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("get(): HTTP Status " + status);
        }

        if (wire.isDebugEnabled()) {
            Header[] headers = response.getAllHeaders();
            wire.debug(status.toString());
            for (Header h : headers) {
                if (h.getValue() != null) {
                    wire.debug(h.getName() + ": " + h.getValue().trim());
                } else {
                    wire.debug(h.getName() + ":");
                }
            }
            wire.debug("");
        }
        if (status.getStatusCode() == HttpServletResponse.SC_NOT_FOUND) {
            return null;
        }
        if ((status.getStatusCode() != HttpServletResponse.SC_CREATED
                && status.getStatusCode() != HttpServletResponse.SC_ACCEPTED
                && status.getStatusCode() != HttpServletResponse.SC_OK)
                && status.getStatusCode() != HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION) {
            logger.error(
                    strMethod + "(): Expected OK for " + strMethod + "request, got " + status.getStatusCode());

            HttpEntity entity = response.getEntity();
            String result;

            if (entity == null) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), "An error was returned without explanation");
            }
            try {
                result = EntityUtils.toString(entity);

                int index = result.indexOf("<");
                // The result may not be a stardard xml format
                if (index > 0) {
                    result = result.substring(index);
                }
            } catch (IOException e) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), e.getMessage());
            }
            if (wire.isDebugEnabled()) {
                wire.debug(result);
            }
            wire.debug("");
            AzureException.ExceptionItems items = AzureException.parseException(status.getStatusCode(), result);
            logger.error(strMethod + "(): [" + status.getStatusCode() + " : " + items.message + "] "
                    + items.details);
            throw new AzureException(items);
        } else {
            Header header = response.getFirstHeader(propertyName);
            if (header != null) {
                return header.getValue();
            } else {
                return null;
            }
        }
    } catch (UnsupportedEncodingException e) {
        throw new CloudException(e);
    } finally {
        if (logger.isTraceEnabled()) {
            logger.trace("exit - " + AzureMethod.class.getName() + ".getStream()");
        }
        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug("--------------------------------------------------------> ");
        }
    }
}

From source file:org.dasein.cloud.azure.AzureStorageMethod.java

public void invoke(@Nonnull String strMethod, @Nonnull String resource, @Nonnull Map<String, String> queries,
        @Nullable String body, @Nullable Map<String, String> headerMap, boolean authorization)
        throws CloudException, InternalException {
    if (logger.isTraceEnabled()) {
        logger.trace("enter - " + AzureStorageMethod.class.getName() + "." + strMethod + "("
                + getStorageAccount() + "," + resource + ")");
    }/* w  ww .  j a  v  a2s.  c  o  m*/
    String endpoint = getStorageEnpoint();

    if (wire.isDebugEnabled()) {
        wire.debug(strMethod + "--------------------------------------------------------> " + endpoint
                + getStorageAccount() + resource);
        wire.debug("");
    }
    try {
        HttpClient client = getClient();

        if (headerMap == null) {
            headerMap = new HashMap<String, String>();
        }

        HttpRequestBase method = getMethod(strMethod, buildUrl(resource, queries), queries, headerMap,
                authorization);

        if (wire.isDebugEnabled()) {
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (body != null) {
                wire.debug(body);
                wire.debug("");
            }
        }

        // If it is post or put
        if (method instanceof HttpEntityEnclosingRequestBase) {

            HttpEntityEnclosingRequestBase entityEnclosingMethod = (HttpEntityEnclosingRequestBase) method;

            if (body != null) {
                entityEnclosingMethod.setEntity(new StringEntity(body, "application/xml", "utf-8"));
            }
        }

        HttpResponse response;
        StatusLine status;

        try {
            response = client.execute(method);
            status = response.getStatusLine();
        } catch (IOException e) {
            logger.error("post(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
            if (logger.isTraceEnabled()) {
                e.printStackTrace();
            }
            throw new CloudException(e);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("post(): HTTP Status " + status);
        }
        Header[] headers = response.getAllHeaders();

        if (wire.isDebugEnabled()) {
            wire.debug(status.toString());
            for (Header h : headers) {
                if (h.getValue() != null) {
                    wire.debug(h.getName() + ": " + h.getValue().trim());
                } else {
                    wire.debug(h.getName() + ":");
                }
            }
            wire.debug("");
        }

        if ((status.getStatusCode() != HttpServletResponse.SC_CREATED
                && status.getStatusCode() != HttpServletResponse.SC_ACCEPTED
                && status.getStatusCode() != HttpServletResponse.SC_OK)
                && status.getStatusCode() != HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION) {
            logger.error(
                    strMethod + "(): Expected OK for " + strMethod + "request, got " + status.getStatusCode());

            HttpEntity entity = response.getEntity();
            String result;

            if (entity == null) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), "An error was returned without explanation");
            }
            try {
                result = EntityUtils.toString(entity);
            } catch (IOException e) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), e.getMessage());
            }
            if (wire.isDebugEnabled()) {
                wire.debug(result);
            }
            wire.debug("");
            AzureException.ExceptionItems items = AzureException.parseException(status.getStatusCode(), result);

            if (items != null) {
                logger.error(strMethod + "(): [" + status.getStatusCode() + " : " + items.message + "] "
                        + items.details);
                throw new AzureException(items);
            } else {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(), "UnknownError",
                        result);
            }
        }
    } catch (UnsupportedEncodingException e) {
        throw new CloudException(e);
    } finally {
        if (logger.isTraceEnabled()) {
            logger.trace("exit - " + AzureMethod.class.getName() + ".getStream()");
        }
        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug("--------------------------------------------------------> ");
        }
    }
}

From source file:org.dasein.cloud.azure.AzureStorageMethod.java

public void putWithFile(@Nonnull String strMethod, @Nonnull String resource, Map<String, String> queries,
        File file, Map<String, String> headerMap, boolean authorization)
        throws CloudException, InternalException {
    if (logger.isTraceEnabled()) {
        logger.trace("enter - " + AzureStorageMethod.class.getName() + "." + strMethod + "("
                + getStorageAccount() + "," + resource + ")");
    }/*from  w  ww.java  2 s. c om*/
    String endpoint = getStorageEnpoint();

    if (wire.isDebugEnabled()) {
        wire.debug(strMethod + "--------------------------------------------------------> " + endpoint
                + getStorageAccount() + resource);
        wire.debug("");
    }

    long begin = System.currentTimeMillis();
    try {

        HttpClient client = getClient();

        String contentLength = null;

        if (file != null) {
            contentLength = String.valueOf(file.length());
        } else {
            contentLength = "0";
        }

        HttpRequestBase method = getMethod(strMethod, buildUrl(resource, queries), queries, headerMap,
                authorization);

        if (wire.isDebugEnabled()) {
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (file != null) {
                wire.debug(file);
                wire.debug("");
            }
        }

        // If it is post or put
        if (method instanceof HttpEntityEnclosingRequestBase) {

            HttpEntityEnclosingRequestBase entityEnclosingMethod = (HttpEntityEnclosingRequestBase) method;

            if (file != null) {
                entityEnclosingMethod.setEntity(new FileEntity(file, ContentType.APPLICATION_OCTET_STREAM));
            }
        }

        HttpResponse response;
        StatusLine status;

        try {
            response = client.execute(method);
            status = response.getStatusLine();
        } catch (IOException e) {
            logger.error("post(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
            if (logger.isTraceEnabled()) {
                e.printStackTrace();
            }

            long end = System.currentTimeMillis();
            logger.debug("Totoal time -> " + (end - begin));
            throw new CloudException(e);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("post(): HTTP Status " + status);
        }
        Header[] headers = response.getAllHeaders();

        if (wire.isDebugEnabled()) {
            wire.debug(status.toString());
            for (Header h : headers) {
                if (h.getValue() != null) {
                    wire.debug(h.getName() + ": " + h.getValue().trim());
                } else {
                    wire.debug(h.getName() + ":");
                }
            }
            wire.debug("");
        }

        if ((status.getStatusCode() != HttpServletResponse.SC_CREATED
                && status.getStatusCode() != HttpServletResponse.SC_ACCEPTED
                && status.getStatusCode() != HttpServletResponse.SC_OK)
                && status.getStatusCode() != HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION) {
            logger.error(
                    strMethod + "(): Expected OK for " + strMethod + "request, got " + status.getStatusCode());

            HttpEntity entity = response.getEntity();
            String result;

            if (entity == null) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), "An error was returned without explanation");
            }
            try {
                result = EntityUtils.toString(entity);
            } catch (IOException e) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), e.getMessage());
            }
            if (wire.isDebugEnabled()) {
                wire.debug(result);
            }
            wire.debug("");
            AzureException.ExceptionItems items = AzureException.parseException(status.getStatusCode(), result);
            logger.error(strMethod + "(): [" + status.getStatusCode() + " : " + items.message + "] "
                    + items.details);
            throw new AzureException(items);
        }
    } finally {
        if (logger.isTraceEnabled()) {
            logger.trace("exit - " + AzureMethod.class.getName() + ".getStream()");
        }
        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug("--------------------------------------------------------> ");
        }
    }
}

From source file:org.dasein.cloud.azure.AzureStorageMethod.java

public void putWithBytes(@Nonnull String strMethod, @Nonnull String resource, Map<String, String> queries,
        byte[] body, Map<String, String> headerMap, boolean authorization)
        throws CloudException, InternalException {
    if (logger.isTraceEnabled()) {
        logger.trace("enter - " + AzureStorageMethod.class.getName() + "." + strMethod + "("
                + getStorageAccount() + "," + resource + ")");
    }//from w w  w  .  j  a va2s.c  o  m
    String endpoint = getStorageEnpoint();

    if (wire.isDebugEnabled()) {
        wire.debug(strMethod + "--------------------------------------------------------> " + endpoint
                + getStorageAccount() + resource);
        wire.debug("");
    }
    try {

        HttpClient client = getClient();

        String contentLength = null;
        if (body != null) {
            contentLength = String.valueOf(body.length);
        } else {
            contentLength = "0";
        }

        HttpRequestBase method = getMethod(strMethod, buildUrl(resource, queries), queries, headerMap,
                authorization);

        if (wire.isDebugEnabled()) {
            wire.debug(method.getRequestLine().toString());
            for (Header header : method.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");
            if (body != null) {
                wire.debug(body);
                wire.debug("");
            }
        }

        // If it is post or put
        if (method instanceof HttpEntityEnclosingRequestBase) {

            HttpEntityEnclosingRequestBase entityEnclosingMethod = (HttpEntityEnclosingRequestBase) method;

            if (body != null) {
                entityEnclosingMethod.setEntity(new ByteArrayEntity(body));
            }
        }

        HttpResponse response;
        StatusLine status;

        try {
            response = client.execute(method);
            status = response.getStatusLine();
        } catch (IOException e) {
            logger.error("post(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
            if (logger.isTraceEnabled()) {
                e.printStackTrace();
            }
            throw new CloudException(e);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("post(): HTTP Status " + status);
        }
        Header[] headers = response.getAllHeaders();

        if (wire.isDebugEnabled()) {
            wire.debug(status.toString());
            for (Header h : headers) {
                if (h.getValue() != null) {
                    wire.debug(h.getName() + ": " + h.getValue().trim());
                } else {
                    wire.debug(h.getName() + ":");
                }
            }
            wire.debug("");
        }

        if ((status.getStatusCode() != HttpServletResponse.SC_CREATED
                && status.getStatusCode() != HttpServletResponse.SC_ACCEPTED
                && status.getStatusCode() != HttpServletResponse.SC_OK)
                && status.getStatusCode() != HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION) {

            logger.error(
                    strMethod + "(): Expected OK for " + strMethod + "request, got " + status.getStatusCode());

            HttpEntity entity = response.getEntity();
            String result;

            if (entity == null) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), "An error was returned without explanation");
            }
            try {
                result = EntityUtils.toString(entity);
            } catch (IOException e) {
                throw new AzureException(CloudErrorType.GENERAL, status.getStatusCode(),
                        status.getReasonPhrase(), e.getMessage());
            }
            if (wire.isDebugEnabled()) {
                wire.debug(result);
            }
            wire.debug("");
            AzureException.ExceptionItems items = AzureException.parseException(status.getStatusCode(), result);
            logger.error(strMethod + "(): [" + status.getStatusCode() + " : " + items.message + "] "
                    + items.details);
            throw new AzureException(items);
        }
    } finally {
        if (logger.isTraceEnabled()) {
            logger.trace("exit - " + AzureMethod.class.getName() + ".getStream()");
        }
        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug("--------------------------------------------------------> ");
        }
    }
}

From source file:org.dasein.cloud.digitalocean.models.rest.DigitalOceanModelFactory.java

/**
 * Sent http request to the server/*from  w  w w  .  ja v a  2s  .  c om*/
 * @return Http response
 * @throws CloudException
 */
private static HttpResponse sendRequest(org.dasein.cloud.digitalocean.DigitalOcean provider, RESTMethod method,
        String token, String strUrl, DigitalOceanAction action) throws CloudException, InternalException {
    HttpRequestBase req = null;
    if (method == RESTMethod.GET) {
        req = new HttpGet(strUrl);
    } else if (method == RESTMethod.POST) {
        req = new HttpPost(strUrl);
    } else if (method == RESTMethod.PUT) {
        req = new HttpPut(strUrl);
    } else if (method == RESTMethod.DELETE) {
        req = new HttpDelete(strUrl);
    } else if (method == RESTMethod.HEAD) {
        req = new HttpHead(strUrl);
    }

    try {
        req.setHeader("Authorization", "Bearer " + token);
        req.setHeader("Accept", "application/json");
        req.setHeader("Content-Type", "application/json;charset=UTF-8");

        StringEntity requestEntity = null;
        if (req instanceof HttpEntityEnclosingRequestBase && action != null) {
            JSONObject jsonToPost = action.getParameters();
            if (jsonToPost != null) {
                requestEntity = new StringEntity(jsonToPost.toString(), ContentType.APPLICATION_JSON);
                ((HttpEntityEnclosingRequestBase) req).setEntity(requestEntity);
            }
        }

        HttpClient httpClient = provider.getClient();

        if (wire.isDebugEnabled()) {
            wire.debug("");
            wire.debug(
                    "--------------------------------------------------------------------------------------");
        }

        if (wire.isDebugEnabled()) {
            wire.debug(req.getRequestLine().toString());
            for (Header header : req.getAllHeaders()) {
                wire.debug(header.getName() + ": " + header.getValue());
            }
            wire.debug("");

            if (requestEntity != null) {
                try {
                    wire.debug(EntityUtils.toString(requestEntity));
                    wire.debug("");
                } catch (IOException ignore) {
                }
            }
        }

        HttpResponse response = null;
        int retryCount = 0;

        while (retryCount < 6) {
            response = httpClient.execute(req);

            if (wire.isDebugEnabled()) {
                wire.debug(response.getStatusLine().toString());
            }

            if (method == RESTMethod.DELETE) {
                if ((response.getStatusLine().getStatusCode() == 204)) {
                    break;
                } else {
                    retryCount++;
                    Thread.sleep(5000);
                }
            } else {
                break;
            }
        }
        if (method == RESTMethod.DELETE && (response.getStatusLine().getStatusCode() != 204)) {
            //Error occurred
            throw new CloudException("Delete method returned unexpected code, despite retrying.");
        }
        return response;
    } catch (JSONException e) {
        throw new CloudException("Problem sending request.", e);
    } catch (InterruptedException e) {
        throw new CloudException("Problem sending request.", e);
    } catch (ClientProtocolException e) {
        throw new CloudException("Problem sending request.", e);
    } catch (IOException e) {
        throw new CloudException("Problem sending request.", e);
    } finally {
        try {
            //                req.releaseConnection();
        } catch (Exception e) {
        }

    }
}