Examples with BasicLineParser org.apache.http.message.BasicLineParser used on opensource projects

Example 1 with BasicLineParser

use of org.apache.http.message.BasicLineParser in project commoncrawl-examples by commoncrawl.

the class ArcRecord method getHttpResponse.

/**
 * <p>Returns an HTTP response object parsed from the ARC record payload.<p>
 * <p>Note: The payload is parsed on-demand, but is only parsed once.  The
 * parsed data is saved for subsequent calls.</p>
 *
 * @return The ARC record payload as an HTTP response object.  See the Apache
 * HttpComponents project.
 */
public HttpResponse getHttpResponse() throws IOException, HttpException {
    if (this._httpResponse != null)
        return this._httpResponse;
    if (this._payload == null) {
        LOG.error("Unable to parse HTTP response: Payload has not been set");
        return null;
    }
    if (this._url != null && !this._url.startsWith("http://") && !this._url.startsWith("https://")) {
        LOG.error("Unable to parse HTTP response: URL protocol is not HTTP");
        return null;
    }
    this._httpResponse = null;
    // Find where the HTTP headers stop
    int end = this._searchForCRLFCRLF(this._payload);
    if (end == -1) {
        LOG.error("Unable to parse HTTP response: End of HTTP headers not found");
        return null;
    }
    // Parse the HTTP status line and headers
    DefaultHttpResponseParser parser = new DefaultHttpResponseParser(new ByteArraySessionInputBuffer(this._payload, 0, end), new BasicLineParser(), new DefaultHttpResponseFactory(), new BasicHttpParams());
    this._httpResponse = parser.parse();
    if (this._httpResponse == null) {
        LOG.error("Unable to parse HTTP response");
        return null;
    }
    // Set the reset of the payload as the HTTP entity.  Use an InputStreamEntity
    // to avoid a memory copy.
    InputStreamEntity entity = new InputStreamEntity(new ByteArrayInputStream(this._payload, end, this._payload.length - end), this._payload.length - end);
    entity.setContentType(this._httpResponse.getFirstHeader("Content-Type"));
    entity.setContentEncoding(this._httpResponse.getFirstHeader("Content-Encoding"));
    this._httpResponse.setEntity(entity);
    return this._httpResponse;
}

Example 2 with BasicLineParser

use of org.apache.http.message.BasicLineParser in project gateway-dubbox by zhuzhong.

the class OpenApiHttpAsynClientServiceImpl method initHttpAsynClient.

private void initHttpAsynClient() throws IOReactorException {
    // Use custom message parser / writer to customize the way HTTP
    // messages are parsed from and written out to the data stream.
    NHttpMessageParserFactory<HttpResponse> responseParserFactory = new DefaultHttpResponseParserFactory() {

        @Override
        public NHttpMessageParser<HttpResponse> create(final SessionInputBuffer buffer, final MessageConstraints constraints) {
            LineParser lineParser = new BasicLineParser() {

                @Override
                public Header parseHeader(final CharArrayBuffer buffer) {
                    try {
                        return super.parseHeader(buffer);
                    } catch (ParseException ex) {
                        return new BasicHeader(buffer.toString(), null);
                    }
                }
            };
            return new DefaultHttpResponseParser(buffer, lineParser, DefaultHttpResponseFactory.INSTANCE, constraints);
        }
    };
    NHttpMessageWriterFactory<HttpRequest> requestWriterFactory = new DefaultHttpRequestWriterFactory();
    // Use a custom connection factory to customize the process of
    // initialization of outgoing HTTP connections. Beside standard
    // connection
    // configuration parameters HTTP connection factory can define message
    // parser / writer routines to be employed by individual connections.
    NHttpConnectionFactory<ManagedNHttpClientConnection> connFactory = new ManagedNHttpClientConnectionFactory(requestWriterFactory, responseParserFactory, HeapByteBufferAllocator.INSTANCE);
    // Client HTTP connection objects when fully initialized can be bound to
    // an arbitrary network socket. The process of network socket
    // initialization,
    // its connection to a remote address and binding to a local one is
    // controlled
    // by a connection socket factory.
    // SSL context for secure connections can be created either based on
    // system or application specific properties.
    // SSLContext sslcontext = org.apache.http.ssl.SSLContexts.createSystemDefault();
    // SSLContext sslcontext = org.apache.http.ssl.SSLContexts.createDefault();
    SSLContext sslcontext = null;
    try {
        sslcontext = this.createIgnoreVerifySSL();
    } catch (KeyManagementException | NoSuchAlgorithmException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    // Use custom hostname verifier to customize SSL hostname verification.
    HostnameVerifier hostnameVerifier = new DefaultHostnameVerifier();
    // Create a registry of custom connection session strategies for
    // supported
    // protocol schemes.
    Registry<SchemeIOSessionStrategy> sessionStrategyRegistry = RegistryBuilder.<SchemeIOSessionStrategy>create().register("http", NoopIOSessionStrategy.INSTANCE).register("https", new SSLIOSessionStrategy(sslcontext)).build();
    // .register("https", SSLConnectionSocketFactory.getSystemSocketFactory()).build();
    // Use custom DNS resolver to override the system DNS resolution.
    DnsResolver dnsResolver = new SystemDefaultDnsResolver() {

        @Override
        public InetAddress[] resolve(final String host) throws UnknownHostException {
            if (host.equalsIgnoreCase("myhost")) {
                return new InetAddress[] { InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 }) };
            } else {
                return super.resolve(host);
            }
        }
    };
    // Create I/O reactor configuration
    IOReactorConfig ioReactorConfig = IOReactorConfig.custom().setIoThreadCount(Runtime.getRuntime().availableProcessors()).setConnectTimeout(30000).setSoTimeout(30000).build();
    // Create a custom I/O reactort
    ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
    // Create a connection manager with custom configuration.
    PoolingNHttpClientConnectionManager connManager = new PoolingNHttpClientConnectionManager(ioReactor, connFactory, sessionStrategyRegistry, dnsResolver);
    // Create message constraints
    MessageConstraints messageConstraints = MessageConstraints.custom().setMaxHeaderCount(200).setMaxLineLength(2000).build();
    // Create connection configuration
    ConnectionConfig connectionConfig = ConnectionConfig.custom().setMalformedInputAction(CodingErrorAction.IGNORE).setUnmappableInputAction(CodingErrorAction.IGNORE).setCharset(Consts.UTF_8).setMessageConstraints(messageConstraints).build();
    // Configure the connection manager to use connection configuration
    // either
    // by default or for a specific host.
    connManager.setDefaultConnectionConfig(connectionConfig);
    // connManager.setConnectionConfig(new HttpHost("somehost", 80),
    // ConnectionConfig.DEFAULT);
    // Configure total max or per route limits for persistent connections
    // that can be kept in the pool or leased by the connection manager.
    connManager.setMaxTotal(100);
    connManager.setDefaultMaxPerRoute(10);
    // connManager.setMaxPerRoute(new HttpRoute(new HttpHost("somehost",
    // 80)), 20);
    // Use custom cookie store if necessary.
    CookieStore cookieStore = new BasicCookieStore();
    // Use custom credentials provider if necessary.
    // CredentialsProvider credentialsProvider = new
    // BasicCredentialsProvider();
    // credentialsProvider.setCredentials(new AuthScope("localhost", 8889),
    // new UsernamePasswordCredentials("squid", "nopassword"));
    // Create global request configuration
    RequestConfig defaultRequestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.DEFAULT).setExpectContinueEnabled(true).setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM, AuthSchemes.DIGEST)).setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC)).build();
    // Create an HttpClient with the given custom dependencies and
    // configuration.
    // CloseableHttpAsyncClient
    httpAsyncClient = HttpAsyncClients.custom().setConnectionManager(connManager).build();
}

Example 3 with BasicLineParser

use of org.apache.http.message.BasicLineParser in project indy by Commonjava.

the class ProxyRequestReader method handleEvent.

// TODO: May need to tune this to preserve request body.
// TODO: NONE of the request headers (except authorization) are passed through!
@Override
public void handleEvent(final ConduitStreamSourceChannel sourceChannel) {
    boolean sendResponse = false;
    try {
        final int read = doRead(sourceChannel);
        if (read <= 0) {
            logger.debug("Reads: {} ", read);
            return;
        }
        byte[] bytes = bReq.toByteArray();
        if (sslTunnel != null) {
            logger.debug("Send to ssl tunnel, {}, bytes:\n\n {}\n", new String(bytes), Hex.encodeHexString(bytes));
            directTo(sslTunnel);
            return;
        }
        logger.debug("Request in progress is:\n\n{}", new String(bytes));
        if (headDone) {
            logger.debug("Request done. parsing.");
            MessageConstraints mc = MessageConstraints.DEFAULT;
            SessionInputBufferImpl inbuf = new SessionInputBufferImpl(new HttpTransportMetricsImpl(), 1024);
            HttpRequestFactory requestFactory = new DefaultHttpRequestFactory();
            LineParser lp = new BasicLineParser();
            DefaultHttpRequestParser requestParser = new DefaultHttpRequestParser(inbuf, lp, requestFactory, mc);
            inbuf.bind(new ByteArrayInputStream(bytes));
            try {
                logger.debug("Passing parsed http request off to response writer.");
                HttpRequest request = requestParser.parse();
                Optional<SpanAdapter> span;
                if (traceManager.isPresent())
                    span = traceManager.get().startServiceRootSpan("httprox-get", contextExtractor(request));
                else
                    span = Optional.empty();
                logger.debug("Request contains {} header: '{}'", ApplicationHeader.authorization.key(), request.getHeaders(ApplicationHeader.authorization.key()));
                writer.setHttpRequest(request);
                writer.setSpan(span);
                sendResponse = true;
            } catch (ConnectionClosedException e) {
                logger.warn("Client closed connection. Aborting proxy request.");
                sendResponse = false;
                sourceChannel.shutdownReads();
            } catch (HttpException e) {
                logger.error("Failed to parse http request: " + e.getMessage(), e);
                writer.setError(e);
            }
        } else {
            logger.debug("Request not finished. Pausing until more reads are available.");
            sourceChannel.resumeReads();
        }
    } catch (final IOException e) {
        writer.setError(e);
        sendResponse = true;
    }
    if (sendResponse) {
        sinkChannel.resumeWrites();
    }
}

Example 4 with BasicLineParser

use of org.apache.http.message.BasicLineParser in project zm-mailbox by Zimbra.

the class SoapServlet method sendResponse.

private void sendResponse(HttpServletRequest req, HttpServletResponse resp, Element envelope) throws IOException {
    SoapProtocol soapProto = SoapProtocol.determineProtocol(envelope);
    int statusCode = soapProto.hasFault(envelope) ? HttpServletResponse.SC_INTERNAL_SERVER_ERROR : HttpServletResponse.SC_OK;
    boolean chunkingEnabled = LC.soap_response_chunked_transfer_encoding_enabled.booleanValue();
    if (chunkingEnabled) {
        // disable chunking if proto < HTTP 1.1
        String proto = req.getProtocol();
        try {
            ProtocolVersion httpVer = BasicLineParser.parseProtocolVersion(proto, new BasicLineParser());
            chunkingEnabled = !httpVer.lessEquals(HttpVersion.HTTP_1_0);
        } catch (ParseException e) {
            ZimbraLog.soap.warn("cannot parse http version in request: %s, http chunked transfer encoding disabled", proto, e);
            chunkingEnabled = false;
        }
    }
    // use jetty default if the LC key is not set
    int responseBufferSize = soapResponseBufferSize();
    if (responseBufferSize != -1)
        resp.setBufferSize(responseBufferSize);
    resp.setContentType(soapProto.getContentType());
    resp.setStatus(statusCode);
    resp.setHeader("Cache-Control", "no-store, no-cache");
    if (chunkingEnabled) {
        // Let jetty chunk the response if applicable.
        ZimbraServletOutputStream out = new ZimbraServletOutputStream(resp.getOutputStream());
        envelope.output(out);
        out.flush();
    } else {
        // serialize the envelope to a byte array and send the response with Content-Length header.
        byte[] soapBytes = envelope.toUTF8();
        resp.setContentLength(soapBytes.length);
        resp.getOutputStream().write(soapBytes);
        resp.getOutputStream().flush();
    }
    envelope.destroy();
}