Example usage for org.apache.http.protocol HTTP CONN_DIRECTIVE

List of usage examples for org.apache.http.protocol HTTP CONN_DIRECTIVE

Introduction

In this page you can find the example usage for org.apache.http.protocol HTTP CONN_DIRECTIVE.

Prototype

String CONN_DIRECTIVE

To view the source code for org.apache.http.protocol HTTP CONN_DIRECTIVE.

Click Source Link

Usage

From source file:org.archive.modules.fetcher.FetchHTTPRequest.java

protected void configureRequestHeaders() {
    if (fetcher.getAcceptCompression()) {
        request.addHeader("Accept-Encoding", "gzip,deflate");
    }/*from www .j av a 2 s . co  m*/

    String from = fetcher.getUserAgentProvider().getFrom();
    if (StringUtils.isNotBlank(from)) {
        request.setHeader(HttpHeaders.FROM, from);
    }

    if (fetcher.getMaxLengthBytes() > 0 && fetcher.getSendRange()) {
        String rangeEnd = Long.toString(fetcher.getMaxLengthBytes() - 1);
        request.setHeader(HttpHeaders.RANGE, "bytes=0-" + rangeEnd);
    }

    if (fetcher.getSendConnectionClose()) {
        request.setHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE);
    }

    // referer
    if (fetcher.getSendReferer() && !LinkContext.PREREQ_MISC.equals(curi.getViaContext())) {
        // RFC2616 says no referer header if referer is https and the url is not
        String via = Processor.flattenVia(curi);
        if (!StringUtils.isEmpty(via) && !(curi.getVia().getScheme().equals(FetchHTTP.HTTPS_SCHEME)
                && curi.getUURI().getScheme().equals(FetchHTTP.HTTP_SCHEME))) {
            request.setHeader(HttpHeaders.REFERER, via);
        }
    }

    if (!curi.isPrerequisite()) {
        maybeAddConditionalGetHeader(fetcher.getSendIfModifiedSince(), A_LAST_MODIFIED_HEADER,
                "If-Modified-Since");
        maybeAddConditionalGetHeader(fetcher.getSendIfNoneMatch(), A_ETAG_HEADER, "If-None-Match");
    }

    // TODO: What happens if below method adds a header already added above,
    // e.g. Connection, Range, or Referer?
    for (String headerString : fetcher.getAcceptHeaders()) {
        String[] nameValue = headerString.split(": +");
        if (nameValue.length == 2) {
            request.addHeader(nameValue[0], nameValue[1]);
        } else {
            logger.warning("Invalid accept header: " + headerString);
        }
    }

    if (curi.getViaContext() != null && "a[data-remote='true']/@href".equals(curi.getViaContext().toString())) {
        request.addHeader("X-Requested-With", "XMLHttpRequest");
    }

    /*
     * set custom request headers in last interceptor, so they override
     * anything else (this could just as well belong in
     * configureHttpClientBuilder())
     */
    httpClientBuilder.addInterceptorLast(new HttpRequestInterceptor() {
        @Override
        public void process(HttpRequest request, HttpContext context) throws HttpException, IOException {
            @SuppressWarnings("unchecked")
            Map<String, String> uriCustomHeaders = (Map<String, String>) curi.getData()
                    .get("customHttpRequestHeaders");
            if (uriCustomHeaders != null) {
                for (Entry<String, String> h : uriCustomHeaders.entrySet()) {
                    request.setHeader(h.getKey(), h.getValue());
                }
            }
        }
    });

}

From source file:org.apache.synapse.transport.nhttp.HttpCoreNIOSender.java

/**
 * Remove unwanted headers from the given header map.
 *
 * @param headers Header map/*from   www.ja  v  a 2s. co m*/
 * @param nHttpConfiguration NHttp transporter base configurations
 */
private void removeUnwantedHeadersFromHeaderMap(Map headers, NHttpConfiguration nHttpConfiguration) {

    Iterator iter = headers.keySet().iterator();
    while (iter.hasNext()) {
        String headerName = (String) iter.next();
        if (HTTP.CONN_DIRECTIVE.equalsIgnoreCase(headerName)
                || HTTP.TRANSFER_ENCODING.equalsIgnoreCase(headerName)
                || HTTP.CONTENT_TYPE.equalsIgnoreCase(headerName)
                || HTTP.CONTENT_LEN.equalsIgnoreCase(headerName)) {
            iter.remove();
        }

        if (HTTP.SERVER_HEADER.equalsIgnoreCase(headerName)
                && !nHttpConfiguration.isPreserveHttpHeader(HTTP.SERVER_HEADER)) {
            iter.remove();
        }

        if (HTTP.USER_AGENT.equalsIgnoreCase(headerName)
                && !nHttpConfiguration.isPreserveHttpHeader(HTTP.USER_AGENT)) {
            iter.remove();
        }

        if (HTTP.DATE_HEADER.equalsIgnoreCase(headerName)
                && !nHttpConfiguration.isPreserveHttpHeader(HTTP.DATE_HEADER)) {
            iter.remove();
        }

    }
}

From source file:org.apache.synapse.message.senders.blocking.BlockingMsgSenderUtils.java

private static boolean isSkipTransportHeader(String headerName) {

    return HTTP.CONN_DIRECTIVE.equalsIgnoreCase(headerName)
            || HTTP.TRANSFER_ENCODING.equalsIgnoreCase(headerName)
            || HTTP.DATE_HEADER.equalsIgnoreCase(headerName) || HTTP.CONTENT_TYPE.equalsIgnoreCase(headerName)
            || HTTP.CONTENT_LEN.equalsIgnoreCase(headerName) || HTTP.SERVER_HEADER.equalsIgnoreCase(headerName)
            || HTTP.USER_AGENT.equalsIgnoreCase(headerName) || "SOAPAction".equalsIgnoreCase(headerName);

}

From source file:net.yacy.cora.federate.solr.instance.RemoteInstance.java

/**
 * @param solraccount eventual user name used to authenticate on the target Solr
 * @param solraccount eventual password used to authenticate on the target Solr
 * @param trustSelfSignedCertificates when true, https connections to an host providing a self-signed certificate are accepted
* @param maxBytesPerReponse/*from  w ww  .  ja v a2  s  .  co  m*/
*            maximum acceptable decompressed size in bytes for a response from
*            the remote Solr server. Negative value or Long.MAX_VALUE means no
*            limit.
 * @return a new apache HttpClient instance usable as a custom http client by SolrJ
 */
private static HttpClient buildCustomHttpClient(final int timeout, final MultiProtocolURL u,
        final String solraccount, final String solrpw, final String host,
        final boolean trustSelfSignedCertificates, final long maxBytesPerResponse) {

    /* Important note : use of deprecated Apache classes is required because SolrJ still use them internally (see HttpClientUtil). 
     * Upgrade only when Solr implementation will become compatible */

    org.apache.http.impl.client.DefaultHttpClient result = new org.apache.http.impl.client.DefaultHttpClient(
            CONNECTION_MANAGER) {
        @Override
        protected HttpContext createHttpContext() {
            HttpContext context = super.createHttpContext();
            AuthCache authCache = new org.apache.http.impl.client.BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            HttpHost targetHost = new HttpHost(u.getHost(), u.getPort(), u.getProtocol());
            authCache.put(targetHost, basicAuth);
            context.setAttribute(org.apache.http.client.protocol.HttpClientContext.AUTH_CACHE, authCache);
            if (trustSelfSignedCertificates && SCHEME_REGISTRY != null) {
                context.setAttribute(ClientContext.SCHEME_REGISTRY, SCHEME_REGISTRY);
            }
            this.setHttpRequestRetryHandler(
                    new org.apache.http.impl.client.DefaultHttpRequestRetryHandler(0, false)); // no retries needed; we expect connections to fail; therefore we should not retry
            return context;
        }
    };
    org.apache.http.params.HttpParams params = result.getParams();
    /* Set the maximum time to establish a connection to the remote server */
    org.apache.http.params.HttpConnectionParams.setConnectionTimeout(params, timeout);
    /* Set the maximum time between data packets reception one a connection has been established */
    org.apache.http.params.HttpConnectionParams.setSoTimeout(params, timeout);
    /* Set the maximum time to get a connection from the shared connections pool */
    HttpClientParams.setConnectionManagerTimeout(params, timeout);
    result.addRequestInterceptor(new HttpRequestInterceptor() {
        @Override
        public void process(final HttpRequest request, final HttpContext context) throws IOException {
            if (!request.containsHeader(HeaderFramework.ACCEPT_ENCODING))
                request.addHeader(HeaderFramework.ACCEPT_ENCODING, HeaderFramework.CONTENT_ENCODING_GZIP);
            if (!request.containsHeader(HTTP.CONN_DIRECTIVE))
                request.addHeader(HTTP.CONN_DIRECTIVE, "close"); // prevent CLOSE_WAIT
        }

    });
    result.addResponseInterceptor(new HttpResponseInterceptor() {
        @Override
        public void process(final HttpResponse response, final HttpContext context) throws IOException {
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                Header ceheader = entity.getContentEncoding();
                if (ceheader != null) {
                    HeaderElement[] codecs = ceheader.getElements();
                    for (HeaderElement codec : codecs) {
                        if (codec.getName().equalsIgnoreCase(HeaderFramework.CONTENT_ENCODING_GZIP)) {
                            response.setEntity(new GzipDecompressingEntity(response.getEntity()));
                            return;
                        }
                    }
                }
            }
        }
    });
    if (solraccount != null && !solraccount.isEmpty()) {
        org.apache.http.impl.client.BasicCredentialsProvider credsProvider = new org.apache.http.impl.client.BasicCredentialsProvider();
        credsProvider.setCredentials(new AuthScope(host, AuthScope.ANY_PORT),
                new UsernamePasswordCredentials(solraccount, solrpw));
        result.setCredentialsProvider(credsProvider);
    }

    if (maxBytesPerResponse >= 0 && maxBytesPerResponse < Long.MAX_VALUE) {
        /*
         * Add in last position the eventual interceptor limiting the response size, so
         * that this is the decompressed amount of bytes that is considered
         */
        result.addResponseInterceptor(new StrictSizeLimitResponseInterceptor(maxBytesPerResponse),
                result.getResponseInterceptorCount());
    }

    return result;
}

From source file:org.wso2.carbon.bpel.core.ode.integration.utils.AxisServiceUtils.java

public static void addCustomHeadersToMessageContext(MessageContext mctx) {

    List<Header> headers = null;

    BPELServerConfiguration bpelServerConfiguration = BPELServiceComponent.getBPELServer()
            .getBpelServerConfiguration();

    if (!bpelServerConfiguration.isKeepAlive()) {

        headers = new ArrayList();
        headers.add(new Header(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE));
    }//from  w  w w . j ava  2 s.  c om

    //Add more custom header values in the future
    if ((headers != null) && (headers.size() > 0)) {
        mctx.setProperty(HTTPConstants.HTTP_HEADERS, headers);
    }
}

From source file:com.clustercontrol.hub.session.FluentdTransferFactory.java

/**
 * ?????????/*from w w  w .j a  v  a 2 s .co m*/
 * 
 */
@Override
public Transfer createTansfer(final TransferInfo info, final PropertyBinder binder) throws TransferException {
    // HTTP ?????
    TransferDestProp urlProp = null;
    TransferDestProp connectTimeoutProp = null;
    TransferDestProp requestTimeoutProp = null;
    for (TransferDestProp prop : info.getDestProps()) {
        switch (prop.getName()) {
        case prop_url:
            urlProp = prop;
            break;
        case prop_connect_timeout:
            connectTimeoutProp = prop;
            break;
        case prop_request_timeout:
            requestTimeoutProp = prop;
            break;
        default:
            logger.warn(String.format("createTansfer() : unknown property(%s)", prop.getValue()));
            break;
        }
    }

    if (urlProp == null || urlProp.getValue() == null)
        throw new TransferException(String.format("createTansfer() : Value of \"%s\" must be set.", prop_url));

    if (!urlPattern.matcher(urlProp.getValue()).matches())
        throw new TransferException(
                String.format("createTansfer() : invalid url format. url=%s", urlProp.getValue()));

    final String urlStr = urlProp.getValue();

    Integer timeout;
    try {
        timeout = Integer.valueOf(connectTimeoutProp.getValue());
    } catch (NumberFormatException e) {
        timeout = DEFAULT_CONNECT_TIMEOUT;
        logger.warn(String.format("createTansfer() : can't regognize connectTimeout(%s) as number.",
                connectTimeoutProp.getValue()));
    } catch (NullPointerException e) {
        timeout = DEFAULT_CONNECT_TIMEOUT;
        logger.warn(String.format(
                "createTansfer() : connectTimeout is null, then use default value as connectTimeout(%s).",
                timeout));
    }
    final Integer connectTimeout = timeout;

    try {
        timeout = Integer.valueOf(requestTimeoutProp.getValue());
    } catch (NumberFormatException e) {
        timeout = DEFAULT_REQUEST_TIMEOUT;
        logger.warn(String.format("createTansfer() : can't regognize requestTimeout(%s) as number.",
                requestTimeoutProp.getValue()));
    } catch (NullPointerException e) {
        timeout = DEFAULT_CONNECT_TIMEOUT;
        logger.warn(String.format(
                "createTansfer() : requestTimeout is null, then use default value as requestTimeout(%s).",
                timeout));
    }
    final Integer requestTimeout = timeout;

    // ??
    return new Transfer() {
        private static final int BUFF_SIZE = 1024 * 1024;
        private static final int BODY_MAX_SIZE = 5 * BUFF_SIZE;

        private CloseableHttpClient client = null;

        /*
         * ??
         * 
         */
        @Override
        public TransferNumericData transferNumerics(Iterable<TransferNumericData> numerics,
                TrasferCallback<TransferNumericData> callback) throws TransferException {
            TransferNumericData lastPosition = null;
            for (TransferNumericData numeric : numerics) {
                ObjectNode root = JsonNodeFactory.instance.objectNode();
                root.put("item_name", numeric.key.getItemName());
                root.put("display_name", numeric.key.getDisplayName());
                root.put("monitor_id", numeric.key.getMonitorId());
                root.put("facility_id", numeric.key.getFacilityid());
                root.put("time", numeric.data.getTime());
                root.put("value", numeric.data.getValue());
                root.put("position", numeric.data.getPosition());

                String url = binder.bind(numeric.key, numeric.data, urlStr);
                String data = root.toString();
                try {
                    send(url, data);
                    lastPosition = numeric;

                    if (callback != null)
                        callback.onTransferred(lastPosition);
                } catch (Exception e) {
                    logger.warn(e.getMessage(), e);
                    internalError_monitor(numeric.key.getMonitorId(), data, e, url);
                    break;
                }
            }
            return lastPosition;
        }

        /*
         * ??
         * 
         */
        @Override
        public TransferStringData transferStrings(Iterable<TransferStringData> strings,
                TrasferCallback<TransferStringData> callback) throws TransferException {
            TransferStringData lastPosition = null;
            for (TransferStringData string : strings) {
                ObjectNode root = JsonNodeFactory.instance.objectNode();
                root.put("target_name", string.key.getTargetName());
                root.put("monitor_id", string.key.getMonitorId());
                root.put("facility_id", string.key.getFacilityId());
                root.put("log_format_id", string.data.getLogformatId());
                root.put("time", string.data.getTime());
                root.put("source", string.data.getValue());

                for (CollectDataTag t : string.data.getTagList()) {
                    root.put(t.getKey(), t.getValue());
                }

                root.put("position", string.data.getDataId());

                String url = binder.bind(string.key, string.data, urlStr);
                String data = root.toString();
                try {
                    send(url, data);
                    lastPosition = string;

                    if (callback != null)
                        callback.onTransferred(lastPosition);
                } catch (Exception e) {
                    logger.warn(e.getMessage(), e);
                    internalError_monitor(string.key.getMonitorId(), data, e, url);
                    break;
                }
            }
            return lastPosition;
        }

        /*
         * ??
         * 
         */
        @Override
        public JobSessionEntity transferJobs(Iterable<JobSessionEntity> sessions,
                TrasferCallback<JobSessionEntity> callback) throws TransferException {
            JobSessionEntity lastPosition = null;
            for (JobSessionEntity session : sessions) {
                ObjectNode sessionNode = JsonNodeFactory.instance.objectNode();
                sessionNode.put("ssession_id", session.getSessionId());
                sessionNode.put("job_id", session.getJobId());
                sessionNode.put("jobunit_id", session.getJobunitId());
                sessionNode.put("schedule_date", session.getScheduleDate());
                sessionNode.put("position", session.getPosition());

                ArrayNode jobArray = sessionNode.putArray("jobs");
                for (JobSessionJobEntity job : session.getJobSessionJobEntities()) {
                    ObjectNode jobNode = jobArray.addObject();
                    jobNode.put("job_id", job.getId().getJobId());
                    jobNode.put("jobunit_id", job.getId().getJobunitId());
                    if (job.getScopeText() != null)
                        jobNode.put("scope_text", job.getScopeText());
                    if (job.getStatus() != null)
                        jobNode.put("status", job.getStatus());
                    if (job.getStartDate() != null)
                        jobNode.put("start_date", job.getStartDate());
                    if (job.getEndDate() != null)
                        jobNode.put("end_date", job.getEndDate());
                    if (job.getEndValue() != null)
                        jobNode.put("end_value", job.getEndValue());
                    if (job.getEndStatus() != null)
                        jobNode.put("end_status", job.getEndStatus());
                    if (job.getResult() != null)
                        jobNode.put("result", job.getResult());
                    if (job.getJobInfoEntity() != null)
                        jobNode.put("job_type", job.getJobInfoEntity().getJobType());

                    if (!job.getJobSessionNodeEntities().isEmpty()) {
                        ArrayNode nodeArray = jobNode.putArray("nodes");
                        for (JobSessionNodeEntity node : job.getJobSessionNodeEntities()) {
                            ObjectNode nodeNode = nodeArray.addObject();
                            nodeNode.put("facility_id", node.getId().getFacilityId());
                            nodeNode.put("node_name", node.getNodeName());
                            nodeNode.put("status", node.getStatus());
                            nodeNode.put("start_date", node.getStartDate());
                            nodeNode.put("end_date", node.getEndDate());
                            nodeNode.put("end_value", node.getEndValue());
                            nodeNode.put("message", node.getMessage());
                            nodeNode.put("result", node.getResult());
                            nodeNode.put("start_date", node.getStartDate());
                            nodeNode.put("startup_time", node.getStartupTime());
                            nodeNode.put("instance_id", node.getInstanceId());
                        }
                    }
                }

                String url = binder.bind(session, urlStr);
                String data = sessionNode.toString();
                try {
                    send(url, data);
                    lastPosition = session;

                    if (callback != null)
                        callback.onTransferred(lastPosition);
                } catch (Exception e) {
                    logger.warn(e.getMessage(), e);
                    internalError_session(session.getSessionId(), data, e, url);
                    break;
                }
            }
            return lastPosition;
        }

        /*
         * ??
         * 
         */
        @Override
        public EventLogEntity transferEvents(Iterable<EventLogEntity> events,
                TrasferCallback<EventLogEntity> callback) throws TransferException {
            EventLogEntity lastPosition = null;
            for (EventLogEntity event : events) {
                ObjectNode eventNode = JsonNodeFactory.instance.objectNode();
                eventNode.put("monitor_id", event.getId().getMonitorId());
                eventNode.put("monitor_detail_id", event.getId().getMonitorDetailId());
                eventNode.put("plugin_id", event.getId().getPluginId());
                eventNode.put("generation_date", event.getGenerationDate());
                eventNode.put("facility_id", event.getId().getFacilityId());
                eventNode.put("scope_text", event.getScopeText());
                eventNode.put("application", event.getApplication());
                eventNode.put("message", event.getMessage());
                eventNode.put("message_org", event.getMessageOrg());
                eventNode.put("priority", event.getPriority());
                eventNode.put("confirm_flg", event.getConfirmFlg());
                eventNode.put("confirm_date", event.getCommentDate());
                eventNode.put("confirm_user", event.getCommentUser());
                eventNode.put("duplication_count", event.getDuplicationCount());
                eventNode.put("output_date", event.getId().getOutputDate());
                eventNode.put("inhibited_flg", event.getInhibitedFlg());
                eventNode.put("comment_date", event.getCommentDate());
                eventNode.put("comment_user", event.getCommentUser());
                eventNode.put("comment", event.getComment());
                eventNode.put("position", event.getPosition());

                String url = binder.bind(event, urlStr);
                String data = eventNode.toString();
                try {
                    send(url, data);
                    lastPosition = event;

                    if (callback != null)
                        callback.onTransferred(lastPosition);
                } catch (Exception e) {
                    logger.warn(e.getMessage(), e);
                    internalError_monitor(event.getId().getMonitorId(), data, e, url);
                    break;
                }
            }
            return lastPosition;
        }

        /*
         *  ID ??
         * 
         */
        @Override
        public String getDestTypeId() {
            return transfer_id;
        }

        /*
         * Fluentd ?????? HttpClient ??
         * ?????????
         * 
         */
        private CloseableHttpClient getHttpClient() {
            if (client == null) {
                client = createHttpClient();
            }
            return client;
        }

        /*
         * Fluentd ?????? HttpClient ??
         * 
         */
        private CloseableHttpClient createHttpClient() {
            String proxyHost = null;
            Integer proxyPort = null;
            CredentialsProvider cledentialProvider = null;
            List<String> ignoreHostList = new ArrayList<>();

            try {
                // Hinemos ???
                proxyHost = HinemosPropertyUtil.getHinemosPropertyStr("hub.fluentd.proxy.host", null);
                Long proxyPortLong = HinemosPropertyUtil.getHinemosPropertyNum("hub.fluentd.proxy.port", null);
                if (proxyPortLong != null)
                    proxyPort = proxyPortLong.intValue();
                if (proxyPort == null)
                    proxyPort = 80;
                String proxyUser = HinemosPropertyUtil.getHinemosPropertyStr("hub.fluentd.proxy.user", null);
                String proxyPassword = HinemosPropertyUtil.getHinemosPropertyStr("hub.fluentd.proxy.password",
                        null);

                if (proxyHost != null && proxyPort != null) {
                    logger.debug(
                            "initializing fluentd proxy : proxyHost = " + proxyHost + ", port = " + proxyPort);
                    String ignoreHostStr = HinemosPropertyUtil
                            .getHinemosPropertyStr("hub.fluentd.proxy.ignorehosts", null);
                    if (ignoreHostStr != null) {
                        ignoreHostList = Arrays.asList(ignoreHostStr.split(","));
                    }

                    if (proxyUser != null && proxyPassword != null) {
                        cledentialProvider = new BasicCredentialsProvider();
                        cledentialProvider.setCredentials(new AuthScope(proxyHost, proxyPort),
                                new UsernamePasswordCredentials(proxyUser, proxyPassword));
                    }
                }
            } catch (Throwable t) {
                logger.warn("invalid proxy configuration.", t);
                proxyHost = null;
                proxyPort = null;
                cledentialProvider = null;
                ignoreHostList = Collections.emptyList();
            }

            List<Header> headers = new ArrayList<>();
            HttpClientBuilder builder = HttpClients.custom().setDefaultCredentialsProvider(cledentialProvider)
                    .setDefaultHeaders(headers);

            Builder requestBuilder = RequestConfig.custom().setCookieSpec(CookieSpecs.DEFAULT);
            if (connectTimeout != null)
                requestBuilder.setConnectTimeout(connectTimeout);
            if (connectTimeout != null)
                requestBuilder.setSocketTimeout(requestTimeout);

            builder.setDefaultRequestConfig(requestBuilder.build());

            if (proxyHost != null) {
                Matcher m = urlPattern.matcher(urlStr);
                if (!m.matches())
                    throw new InternalError(String.format("invalid url(%s)", urlStr));

                m.toMatchResult();

                boolean ignore = false;
                String host = m.group("host");
                for (String ignoreHost : ignoreHostList) {
                    if (ignoreHost.equals(host)) {
                        ignore = true;
                        break;
                    }
                }

                if (!ignore) {
                    HttpHost proxy = new HttpHost(proxyHost, proxyPort, "http");
                    builder.setProxy(proxy);
                }
            }

            if (keepAlive) {
                headers.add(new BasicHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE));
            } else {
                headers.add(new BasicHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE));
            }
            return builder.build();
        }

        /*
         * ?? URL ???
         * 
         */
        private void send(String url, String data) throws Exception {
            // URL  ?
            Matcher m = urlPattern.matcher(url);
            if (!m.matches())
                throw new InternalError(String.format("invalid url(%s)", urlStr));
            m.toMatchResult();
            String path = m.group("path");
            if (path != null && !path.isEmpty()) {
                String host = m.group("host");
                String port = m.group("port");

                String[] paths = path.split("/");
                for (int i = 1; i < paths.length; ++i) {
                    paths[i] = URLEncoder.encode(paths[i], "utf-8");
                }
                url = "http://" + host + (port == null || port.isEmpty() ? "" : (":" + port));
                for (int i = 1; i < paths.length; ++i) {
                    url += "/" + paths[i];
                }
            }

            HttpPost requestPost = new HttpPost(url);
            requestPost.addHeader("content-type", "application/json");
            requestPost.setEntity(new StringEntity(data, StandardCharsets.UTF_8));

            logger.debug(String.format("send() : request start. url=%s", url));

            int count = 0;
            int maxTryCount = PropertyConstants.hub_transfer_max_try_count.number();

            while (count < maxTryCount) {
                try {
                    long start = HinemosTime.currentTimeMillis();
                    try (CloseableHttpResponse response = getHttpClient().execute(requestPost)) {
                        long responseTime = HinemosTime.currentTimeMillis() - start;
                        logger.debug(String.format("send() : url=%s, responseTime=%d", url, responseTime));

                        int statusCode = response.getStatusLine().getStatusCode();
                        logger.debug(String.format("send() : url=%s, code=%d", url, statusCode));
                        if (statusCode == HttpStatus.SC_OK) {
                            logger.debug(String.format("send() : url=%s, success=%s", url,
                                    response.getStatusLine().toString()));
                            if (logger.isDebugEnabled()) {
                                ByteArrayOutputStream out = new ByteArrayOutputStream();
                                try (InputStream in = response.getEntity().getContent()) {
                                    byte[] buffer = new byte[BUFF_SIZE];
                                    while (out.size() < BODY_MAX_SIZE) {
                                        int len = in.read(buffer);
                                        if (len < 0) {
                                            break;
                                        }
                                        out.write(buffer, 0, len);
                                    }
                                }
                                String res = new String(out.toByteArray(), "UTF-8");
                                if (!res.isEmpty())
                                    logger.debug(String.format("send() : url=%s, response=%s", url, res));
                            }
                        } else {
                            throw new RuntimeException(
                                    String.format("http status code isn't 200. code=%d, message=%s", statusCode,
                                            response.getStatusLine().toString()));
                        }
                    }

                    logger.debug(String.format("send() : success. url=%s, count=%d", url, count));
                    break;
                } catch (RuntimeException e) {
                    ++count;

                    if (count < maxTryCount) {
                        logger.debug(e.getMessage(), e);
                        logger.debug(String.format(
                                "send() : fail to send, and then wait to retry. url=%s, count=%d", url, count));
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e1) {
                            logger.debug(e.getMessage());
                        }
                    } else {
                        throw new TransferException(
                                String.format("send() : fail to send. url=%s, retry count=%d, error=\"%s\"",
                                        url, count, e.getMessage()));
                    }
                }
            }
        }

        @Override
        public void close() throws Exception {
            if (client != null)
                client.close();
        }

        private void internalError_session(String sessionId, String data, Exception error, String url) {
            internalError_session(sessionId, data,
                    error.getMessage() == null || error.getMessage().isEmpty()
                            ? error.getClass().getSimpleName()
                            : error.getMessage(),
                    url);
        }

        private void internalError_session(String sessionId, String data, String error, String url) {
            AplLogger.put(PriorityConstant.TYPE_WARNING, HinemosModuleConstant.HUB_TRANSFER,
                    MessageConstant.MESSAGE_HUB_DATA_TRANSFER_FAILED, new String[] { info.getTransferId() },
                    String.format("error=%s%ntransferId=%s%ndestTypeId=%s%nsessionId=%s%ndata=%s%nurl=%s",
                            error, info.getTransferId(), info.getDestTypeId(), sessionId, data, url));
        }

        private void internalError_monitor(String sessionId, String data, Exception error, String url) {
            internalError_monitor(sessionId, data,
                    error.getMessage() == null || error.getMessage().isEmpty()
                            ? error.getClass().getSimpleName()
                            : error.getMessage(),
                    url);
        }

        private void internalError_monitor(String monitorId, String data, String error, String url) {
            AplLogger.put(PriorityConstant.TYPE_WARNING, HinemosModuleConstant.HUB_TRANSFER,
                    MessageConstant.MESSAGE_HUB_DATA_TRANSFER_FAILED, new String[] { info.getTransferId() },
                    String.format("error=%s%ntransferId=%s%ndestTypeId=%s%nmonitorId=%s%ndata=%s%nurl=%s",
                            error, info.getTransferId(), info.getDestTypeId(), monitorId, data, url));
        }
    };
}

From source file:com.clustercontrol.http.util.GetHttpResponse.java

private CloseableHttpClient getHttpClient()
        throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {
    if (m_client == null) {
        List<Header> headers = new ArrayList<>();

        HttpClientBuilder builder = HttpClients.custom().setDefaultCredentialsProvider(m_cledentialProvider)
                .setDefaultHeaders(headers);

        if (!this.m_needAuthSSLCert) {
            // SSL ??
            TrustStrategy trustStrategy = new TrustStrategy() {
                @Override//from   w w w  . ja v a 2 s. c  o  m
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            };
            builder.setSSLSocketFactory(new SSLConnectionSocketFactory(
                    new SSLContextBuilder().loadTrustMaterial(null, trustStrategy).build(),
                    new NoopHostnameVerifier()));
        }
        RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.DEFAULT)
                .setConnectTimeout(m_connectTimeout).setSocketTimeout(m_requestTimeout).build();
        builder.setDefaultRequestConfig(requestConfig);

        if (m_proxyHost != null) {
            HttpHost proxy = new HttpHost(m_proxyHost, m_proxyPort,
                    m_proxyScheme == null ? "https" : m_proxyScheme);
            if (m_proxyUser != null && m_proxyPassword != null) {
                m_cledentialProvider.setCredentials(new AuthScope(proxy.getHostName(), proxy.getPort()),
                        new UsernamePasswordCredentials(m_proxyUser, m_proxyPassword));
            }
            builder.setProxy(proxy);
        }

        if (m_userAgent != null) {
            headers.add(new BasicHeader(HTTP.USER_AGENT, m_userAgent));
        }

        if (m_cancelProxyCache) {
            // ?
            // https://www.ipa.go.jp/security/awareness/vendor/programmingv2/contents/405.html
            headers.add(new BasicHeader("Cache-Control", "no-cache"));
            headers.add(new BasicHeader("Pragma", "no-cache"));
        }

        if (keepAlive) {
            headers.add(new BasicHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE));
        } else {
            headers.add(new BasicHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE));
        }
        m_client = builder.build();
    }

    return m_client;
}

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

/**
 * Remove unwanted headers from the transport headers map of outgoing request. These are headers which
 * should be dictated by the transport and not the user. We remove these as these may get
 * copied from the request messages/*from w  w  w .  j a v a  2  s.c  o  m*/
 *
 * @param msgContext the Axis2 Message context from which these headers should be removed
 */
private void removeUnwantedHeaders(MessageContext msgContext) {
    Map headers = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS);

    if (headers == null || headers.isEmpty()) {
        return;
    }

    Iterator iter = headers.keySet().iterator();
    while (iter.hasNext()) {
        String headerName = (String) iter.next();
        if (HTTP.CONN_DIRECTIVE.equalsIgnoreCase(headerName)
                || HTTP.TRANSFER_ENCODING.equalsIgnoreCase(headerName)
                || HTTP.DATE_HEADER.equalsIgnoreCase(headerName)
                || HTTP.CONTENT_TYPE.equalsIgnoreCase(headerName)
                || HTTP.CONTENT_LEN.equalsIgnoreCase(headerName)) {
            iter.remove();
        }
    }
}