mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
322 lines
12 KiB
Java
322 lines
12 KiB
Java
/*
|
|
* ====================================================================
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
* ====================================================================
|
|
*
|
|
* This software consists of voluntary contributions made by many
|
|
* individuals on behalf of the Apache Software Foundation. For more
|
|
* information on the Apache Software Foundation, please see
|
|
* <http://www.apache.org/>.
|
|
*
|
|
*/
|
|
|
|
package ch.boye.httpclientandroidlib.impl;
|
|
|
|
import java.io.IOException;
|
|
|
|
import ch.boye.httpclientandroidlib.HttpClientConnection;
|
|
import ch.boye.httpclientandroidlib.HttpConnectionMetrics;
|
|
import ch.boye.httpclientandroidlib.HttpEntity;
|
|
import ch.boye.httpclientandroidlib.HttpEntityEnclosingRequest;
|
|
import ch.boye.httpclientandroidlib.HttpException;
|
|
import ch.boye.httpclientandroidlib.HttpRequest;
|
|
import ch.boye.httpclientandroidlib.HttpResponse;
|
|
import ch.boye.httpclientandroidlib.HttpResponseFactory;
|
|
import ch.boye.httpclientandroidlib.entity.ContentLengthStrategy;
|
|
import ch.boye.httpclientandroidlib.impl.entity.EntityDeserializer;
|
|
import ch.boye.httpclientandroidlib.impl.entity.EntitySerializer;
|
|
import ch.boye.httpclientandroidlib.impl.entity.LaxContentLengthStrategy;
|
|
import ch.boye.httpclientandroidlib.impl.entity.StrictContentLengthStrategy;
|
|
import ch.boye.httpclientandroidlib.impl.io.HttpRequestWriter;
|
|
import ch.boye.httpclientandroidlib.impl.io.HttpResponseParser;
|
|
import ch.boye.httpclientandroidlib.io.EofSensor;
|
|
import ch.boye.httpclientandroidlib.io.HttpMessageParser;
|
|
import ch.boye.httpclientandroidlib.io.HttpMessageWriter;
|
|
import ch.boye.httpclientandroidlib.io.HttpTransportMetrics;
|
|
import ch.boye.httpclientandroidlib.io.SessionInputBuffer;
|
|
import ch.boye.httpclientandroidlib.io.SessionOutputBuffer;
|
|
import ch.boye.httpclientandroidlib.message.LineFormatter;
|
|
import ch.boye.httpclientandroidlib.message.LineParser;
|
|
import ch.boye.httpclientandroidlib.params.HttpParams;
|
|
|
|
/**
|
|
* Abstract client-side HTTP connection capable of transmitting and receiving
|
|
* data using arbitrary {@link SessionInputBuffer} and
|
|
* {@link SessionOutputBuffer} implementations.
|
|
* <p>
|
|
* The following parameters can be used to customize the behavior of this
|
|
* class:
|
|
* <ul>
|
|
* <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#STRICT_TRANSFER_ENCODING}</li>
|
|
* <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#MAX_HEADER_COUNT}</li>
|
|
* </ul>
|
|
*
|
|
* @since 4.0
|
|
*/
|
|
public abstract class AbstractHttpClientConnection implements HttpClientConnection {
|
|
|
|
private final EntitySerializer entityserializer;
|
|
private final EntityDeserializer entitydeserializer;
|
|
|
|
private SessionInputBuffer inbuffer = null;
|
|
private SessionOutputBuffer outbuffer = null;
|
|
private EofSensor eofSensor = null;
|
|
private HttpMessageParser responseParser = null;
|
|
private HttpMessageWriter requestWriter = null;
|
|
private HttpConnectionMetricsImpl metrics = null;
|
|
|
|
/**
|
|
* Creates an instance of this class.
|
|
* <p>
|
|
* This constructor will invoke {@link #createEntityDeserializer()}
|
|
* and {@link #createEntitySerializer()} methods in order to initialize
|
|
* HTTP entity serializer and deserializer implementations for this
|
|
* connection.
|
|
*/
|
|
public AbstractHttpClientConnection() {
|
|
super();
|
|
this.entityserializer = createEntitySerializer();
|
|
this.entitydeserializer = createEntityDeserializer();
|
|
}
|
|
|
|
/**
|
|
* Asserts if the connection is open.
|
|
*
|
|
* @throws IllegalStateException if the connection is not open.
|
|
*/
|
|
protected abstract void assertOpen() throws IllegalStateException;
|
|
|
|
/**
|
|
* Creates an instance of {@link EntityDeserializer} with the
|
|
* {@link LaxContentLengthStrategy} implementation to be used for
|
|
* de-serializing entities received over this connection.
|
|
* <p>
|
|
* This method can be overridden in a super class in order to create
|
|
* instances of {@link EntityDeserializer} using a custom
|
|
* {@link ContentLengthStrategy}.
|
|
*
|
|
* @return HTTP entity deserializer
|
|
*/
|
|
protected EntityDeserializer createEntityDeserializer() {
|
|
return new EntityDeserializer(new LaxContentLengthStrategy());
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of {@link EntitySerializer} with the
|
|
* {@link StrictContentLengthStrategy} implementation to be used for
|
|
* serializing HTTP entities sent over this connection.
|
|
* <p>
|
|
* This method can be overridden in a super class in order to create
|
|
* instances of {@link EntitySerializer} using a custom
|
|
* {@link ContentLengthStrategy}.
|
|
*
|
|
* @return HTTP entity serialzier.
|
|
*/
|
|
protected EntitySerializer createEntitySerializer() {
|
|
return new EntitySerializer(new StrictContentLengthStrategy());
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of {@link DefaultHttpResponseFactory} to be used
|
|
* for creating {@link HttpResponse} objects received by over this
|
|
* connection.
|
|
* <p>
|
|
* This method can be overridden in a super class in order to provide
|
|
* a different implementation of the {@link HttpResponseFactory} interface.
|
|
*
|
|
* @return HTTP response factory.
|
|
*/
|
|
protected HttpResponseFactory createHttpResponseFactory() {
|
|
return new DefaultHttpResponseFactory();
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of {@link HttpMessageParser} to be used for parsing
|
|
* HTTP responses received over this connection.
|
|
* <p>
|
|
* This method can be overridden in a super class in order to provide
|
|
* a different implementation of the {@link HttpMessageParser} interface or
|
|
* to pass a different implementation of {@link LineParser} to the
|
|
* the default implementation {@link HttpResponseParser}.
|
|
*
|
|
* @param buffer the session input buffer.
|
|
* @param responseFactory the HTTP response factory.
|
|
* @param params HTTP parameters.
|
|
* @return HTTP message parser.
|
|
*/
|
|
protected HttpMessageParser createResponseParser(
|
|
final SessionInputBuffer buffer,
|
|
final HttpResponseFactory responseFactory,
|
|
final HttpParams params) {
|
|
return new HttpResponseParser(buffer, null, responseFactory, params);
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of {@link HttpMessageWriter} to be used for
|
|
* writing out HTTP requests sent over this connection.
|
|
* <p>
|
|
* This method can be overridden in a super class in order to provide
|
|
* a different implementation of the {@link HttpMessageWriter} interface or
|
|
* to pass a different implementation of {@link LineFormatter} to the
|
|
* the default implementation {@link HttpRequestWriter}.
|
|
*
|
|
* @param buffer the session output buffer
|
|
* @param params HTTP parameters
|
|
* @return HTTP message writer
|
|
*/
|
|
protected HttpMessageWriter createRequestWriter(
|
|
final SessionOutputBuffer buffer,
|
|
final HttpParams params) {
|
|
return new HttpRequestWriter(buffer, null, params);
|
|
}
|
|
|
|
/**
|
|
* @since 4.1
|
|
*/
|
|
protected HttpConnectionMetricsImpl createConnectionMetrics(
|
|
final HttpTransportMetrics inTransportMetric,
|
|
final HttpTransportMetrics outTransportMetric) {
|
|
return new HttpConnectionMetricsImpl(inTransportMetric, outTransportMetric);
|
|
}
|
|
|
|
/**
|
|
* Initializes this connection object with {@link SessionInputBuffer} and
|
|
* {@link SessionOutputBuffer} instances to be used for sending and
|
|
* receiving data. These session buffers can be bound to any arbitrary
|
|
* physical output medium.
|
|
* <p>
|
|
* This method will invoke {@link #createHttpResponseFactory()},
|
|
* {@link #createRequestWriter(SessionOutputBuffer, HttpParams)}
|
|
* and {@link #createResponseParser(SessionInputBuffer, HttpResponseFactory, HttpParams)}
|
|
* methods to initialize HTTP request writer and response parser for this
|
|
* connection.
|
|
*
|
|
* @param inbuffer the session input buffer.
|
|
* @param outbuffer the session output buffer.
|
|
* @param params HTTP parameters.
|
|
*/
|
|
protected void init(
|
|
final SessionInputBuffer inbuffer,
|
|
final SessionOutputBuffer outbuffer,
|
|
final HttpParams params) {
|
|
if (inbuffer == null) {
|
|
throw new IllegalArgumentException("Input session buffer may not be null");
|
|
}
|
|
if (outbuffer == null) {
|
|
throw new IllegalArgumentException("Output session buffer may not be null");
|
|
}
|
|
this.inbuffer = inbuffer;
|
|
this.outbuffer = outbuffer;
|
|
if (inbuffer instanceof EofSensor) {
|
|
this.eofSensor = (EofSensor) inbuffer;
|
|
}
|
|
this.responseParser = createResponseParser(
|
|
inbuffer,
|
|
createHttpResponseFactory(),
|
|
params);
|
|
this.requestWriter = createRequestWriter(
|
|
outbuffer, params);
|
|
this.metrics = createConnectionMetrics(
|
|
inbuffer.getMetrics(),
|
|
outbuffer.getMetrics());
|
|
}
|
|
|
|
public boolean isResponseAvailable(int timeout) throws IOException {
|
|
assertOpen();
|
|
return this.inbuffer.isDataAvailable(timeout);
|
|
}
|
|
|
|
public void sendRequestHeader(final HttpRequest request)
|
|
throws HttpException, IOException {
|
|
if (request == null) {
|
|
throw new IllegalArgumentException("HTTP request may not be null");
|
|
}
|
|
assertOpen();
|
|
this.requestWriter.write(request);
|
|
this.metrics.incrementRequestCount();
|
|
}
|
|
|
|
public void sendRequestEntity(final HttpEntityEnclosingRequest request)
|
|
throws HttpException, IOException {
|
|
if (request == null) {
|
|
throw new IllegalArgumentException("HTTP request may not be null");
|
|
}
|
|
assertOpen();
|
|
if (request.getEntity() == null) {
|
|
return;
|
|
}
|
|
this.entityserializer.serialize(
|
|
this.outbuffer,
|
|
request,
|
|
request.getEntity());
|
|
}
|
|
|
|
protected void doFlush() throws IOException {
|
|
this.outbuffer.flush();
|
|
}
|
|
|
|
public void flush() throws IOException {
|
|
assertOpen();
|
|
doFlush();
|
|
}
|
|
|
|
public HttpResponse receiveResponseHeader()
|
|
throws HttpException, IOException {
|
|
assertOpen();
|
|
HttpResponse response = (HttpResponse) this.responseParser.parse();
|
|
if (response.getStatusLine().getStatusCode() >= 200) {
|
|
this.metrics.incrementResponseCount();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
public void receiveResponseEntity(final HttpResponse response)
|
|
throws HttpException, IOException {
|
|
if (response == null) {
|
|
throw new IllegalArgumentException("HTTP response may not be null");
|
|
}
|
|
assertOpen();
|
|
HttpEntity entity = this.entitydeserializer.deserialize(this.inbuffer, response);
|
|
response.setEntity(entity);
|
|
}
|
|
|
|
protected boolean isEof() {
|
|
return this.eofSensor != null && this.eofSensor.isEof();
|
|
}
|
|
|
|
public boolean isStale() {
|
|
if (!isOpen()) {
|
|
return true;
|
|
}
|
|
if (isEof()) {
|
|
return true;
|
|
}
|
|
try {
|
|
this.inbuffer.isDataAvailable(1);
|
|
return isEof();
|
|
} catch (IOException ex) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public HttpConnectionMetrics getMetrics() {
|
|
return this.metrics;
|
|
}
|
|
|
|
}
|