ClientToProxyConnection (Zodiac Server Proxy 1.5.6 API)

java.lang.Object
- io.netty.channel.ChannelHandlerAdapter
- - io.netty.channel.ChannelInboundHandlerAdapter
  - - io.netty.channel.SimpleChannelInboundHandler<I>
    - - org.zodiac.server.proxy.impl.ProxyConnection<Object>
      - org.zodiac.server.proxy.impl.HttpProxyConnection<HttpRequestWrapper>
        
        org.zodiac.server.proxy.impl.ClientToProxyConnection

所有已实现的接口:

ChannelHandler, ChannelInboundHandler

直接已知子类:

ClientToProxyConnectionWithWebSocket
```
public class ClientToProxyConnection
extends HttpProxyConnection<HttpRequestWrapper>
```
Represents a connection from a client to our proxy. Each ClientToProxyConnection can have multiple ProxyToServerConnections, at most one per outbound host:port.

Once a ProxyToServerConnection has been created for a given server, it is continually reused. The ProxyToServerConnection goes through its own lifecycle of connects and disconnects, with different underlying Channels, but only a single ProxyToServerConnection object is used per server. The one exception to this is CONNECT tunneling - if a connection has been used for CONNECT tunneling, that connection will never be reused.

As the ProxyToServerConnections receive responses from their servers, they feed these back to the client by calling respond(ProxyToServerConnection, HttpFilters, HttpRequest, HttpResponse, HttpObject) .

嵌套类概要
- 从类继承的嵌套类/接口 org.zodiac.server.proxy.impl.HttpProxyConnection
  HttpProxyConnection.RequestReadMonitor, HttpProxyConnection.RequestWrittenMonitor, HttpProxyConnection.ResponseReadMonitor, HttpProxyConnection.ResponseWrittenMonitor
- 从接口继承的嵌套类/接口 io.netty.channel.ChannelHandler
  ChannelHandler.Sharable

字段概要

字段
限定符和类型	字段和说明
`private SSLSession`	`clientSslSession`
`private HttpFilters`	`currentFilters`
`private ProxyToServerConnection`	`currentServerConnection`
`private io.netty.handler.traffic.GlobalTrafficShapingHandler`	`globalTrafficShapingHandler`
`private HttpProxyConfigOptions`	`httpProxyConfigOptions`
`private static String`	`LOWERCASE_TRANSFER_ENCODING_HEADER`
`private AtomicInteger`	`numberOfCurrentlyConnectingServers`
`private ProxyConfigOptions`	`proxyConfigOptions`
`private HttpProxyConnection.RequestReadMonitor`	`requestReadMonitor` Activity Tracking/Statistics We track statistics on bytes, requests and responses by adding handlers at the appropriate parts of the pipeline (see initChannelPipeline()).
`private HttpProxyConnection.ResponseWrittenMonitor`	`responseWrittenMonitor`
`private Map<InetSocketAddress,ProxyToServerConnection>`	`serverConnectionsMap`

从类继承的字段 org.zodiac.server.proxy.impl.HttpProxyConnection
log, proxyManager

从类继承的字段 org.zodiac.server.proxy.impl.ProxyConnection
channel, ctx, lastReadTime, logger, sslEngine

构造器概要

构造器
构造器和说明
`ClientToProxyConnection(ProxyConfigOptions proxyConfigOptions, HttpProxyConfigOptions httpProxyConfigOptions, HttpProxyManager httpProxyManager, String applicationName, SslEngineSource sslEngineSource, ChannelPipeline pipeline, io.netty.handler.traffic.GlobalTrafficShapingHandler globalTrafficShapingHandler)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`private InetSocketAddress`	`addressFor(ProxyRuleOption proxy, HttpProxyManager proxyServer)` Build an `InetSocketAddress` for the given hostAndPort.
`protected void`	`becameSaturated()` When the ClientToProxyConnection becomes saturated, stop reading on all associated ProxyToServerConnections.
`protected void`	`becameWritable()` When the ClientToProxyConnection becomes writable, resume reading on all associated ProxyToServerConnections.
`private void`	`closeConnectionsAfterWriteIfNecessary(ProxyToServerConnection serverConnection, io.netty.handler.codec.http.HttpRequest currentHttpRequest, io.netty.handler.codec.http.HttpResponse currentHttpResponse, io.netty.handler.codec.http.HttpObject httpObject)` This method takes care of closing client to proxy and/or proxy to server connections after finishing a write.
`protected void`	`connected()` On connect of the client, start waiting for an initial `HttpRequest`.
`private void`	`connectionFailedUnrecoverably(HttpRequestWrapper initialRequest, ProxyToServerConnection serverConnection)`
`private void`	`createCorsHandler(ChannelPipeline pipeline)`
`protected void`	`disconnected()` On disconnect of the client, disconnect all server connections.
`private ConnectionState`	`doReadHTTPInitial(HttpRequestWrapper httpRequest)` Reads an `HttpRequest`.
`protected void`	`exceptionCaught(Throwable cause)` Override this to handle exceptions that occurred during asynchronous processing on the `Channel`.
`private void`	`fixHttpVersionHeaderIfNecessary(io.netty.handler.codec.http.HttpResponse httpResponse)` Chunked encoding is an HTTP 1.1 feature, but sometimes we get a chunked response that reports its HTTP version as 1.0.
`private FlowContext`	`flowContext()`
`private void`	`forceDisconnect(ProxyToServerConnection serverConnection)`
`InetSocketAddress`	`getClientAddress()`
`protected HttpProxyConfigOptions`	`getHttpConfigOptions()`
`protected ProxyConfigOptions`	`getProxyConfigOptions()`
`protected void`	`initChannelPipeline(ChannelPipeline pipeline)` Initialize the `ChannelPipeline` for the client to proxy channel.
`private void`	`modifyRequestHeadersToReflectProxying(io.netty.handler.codec.http.HttpRequest httpRequest)` If and only if our proxy is not running in transparent mode, modify the request headers to reflect that it was proxied.
`private void`	`modifyResponseHeadersToReflectProxying(io.netty.handler.codec.http.HttpResponse httpResponse)` If and only if our proxy is not running in transparent mode, modify the response headers to reflect that it was proxied.
`protected void`	`readHTTPChunk(io.netty.handler.codec.http.HttpContent chunk)` Implement this to handle reading a chunk in a chunked transfer.
`protected ConnectionState`	`readHTTPInitial(HttpRequestWrapper httpRequest)` Reading
`private void`	`recordClientConnected()`
`private void`	`recordClientDisconnected()`
`private void`	`recordClientSSLHandshakeSucceeded()`
`(专用程序包) void`	`respond(ProxyToServerConnection serverConnection, HttpFilters filters, io.netty.handler.codec.http.HttpRequest currentHttpRequest, io.netty.handler.codec.http.HttpResponse currentHttpResponse, io.netty.handler.codec.http.HttpObject httpObject)` Send a response to the client.
`private boolean`	`respondWithShortCircuitResponse(io.netty.handler.codec.http.HttpResponse httpResponse)` Responds to the client with the specified "short-circuit" response.
`private void`	`resumeReadingIfNecessary()`
`protected void`	`serverBecameSaturated(ProxyToServerConnection serverConnection)` When a server becomes saturated, we stop reading from the client.
`protected void`	`serverBecameWriteable(ProxyToServerConnection serverConnection)` When a server becomes writeable, we check to see if all servers are writeable and if they are, we resume reading.
`protected boolean`	`serverConnectionFailed(ProxyToServerConnection serverConnection, ConnectionState lastStateBeforeFailure, Throwable cause)` If the `ProxyToServerConnection` fails to complete its connection lifecycle successfully, this method is called to let us know about it.
`protected void`	`serverConnectionFlowStarted(ProxyToServerConnection serverConnection)` Called when `ProxyToServerConnection` starts its connection flow.
`protected void`	`serverConnectionSucceeded(ProxyToServerConnection serverConnection, boolean shouldForwardInitialRequest)` If the `ProxyToServerConnection` completes its connection lifecycle successfully, this method is called to let us know about it.
`protected void`	`serverDisconnected(ProxyToServerConnection serverConnection)` On disconnect of the server, track that we have one fewer connected servers and then disconnect the client if necessary.
`private boolean`	`shouldCloseClientConnection(io.netty.handler.codec.http.HttpRequest req, io.netty.handler.codec.http.HttpResponse res, io.netty.handler.codec.http.HttpObject httpObject)` Determine whether or not the client connection should be closed.
`private boolean`	`shouldCloseServerConnection(io.netty.handler.codec.http.HttpRequest req, io.netty.handler.codec.http.HttpResponse res, io.netty.handler.codec.http.HttpObject msg)` Determines if the remote connection should be closed based on the request and response pair.
`private void`	`stripConnectionTokens(io.netty.handler.codec.http.HttpHeaders headers)` RFC2616 Section 14.10 HTTP/1.1 proxies MUST parse the Connection header field before a message is forwarded and, for each connection-token in this field, remove any header field(s) from the message with the same name as the connection-token.
`private void`	`stripHopByHopHeaders(io.netty.handler.codec.http.HttpHeaders headers)` Removes all headers that should not be forwarded.
`private void`	`switchProxyConnectionHeader(io.netty.handler.codec.http.HttpHeaders headers)` Switch the de-facto standard "Proxy-Connection" header to "Connection" when we pass it along to the remote host.
`protected void`	`timedOut()` This method is called when the underlying `Channel` times out due to an idle timeout.
`(专用程序包) void`	`timedOut(ProxyToServerConnection serverConnection)`
`private boolean`	`writeBadGateway(HttpRequestWrapper httpRequest)` Tells the client that something went wrong trying to proxy its request.
`private void`	`writeEmptyBuffer()` Write an empty buffer at the end of a chunked transfer.
`private boolean`	`writeGatewayTimeout()` Tells the client that the connection to the server, or possibly to some intermediary service (such as DNS), timed out.

从类继承的方法 org.zodiac.server.proxy.impl.HttpProxyConnection
disconnect, doWrite, encrypt, encrypt, getHttpFiltersFromProxyServer, getLOG, getSslEngine, isSaturated, readProxyIncoming, resumeReading, stopReading, write, writeHttp, writeRaw, writeToChannel, writeToChannelNoFlush

从类继承的方法 org.zodiac.server.proxy.impl.ProxyConnection
become, channelActive, channelInactive, channelRead0, channelRegistered, channelRegistered0, channelWritabilityChanged, exceptionCaught, getApplicationName, getChannel, getCurrentState, is, isConnecting, readIncoming, userEventTriggered

从类继承的方法 io.netty.channel.SimpleChannelInboundHandler
acceptInboundMessage, channelRead

从类继承的方法 io.netty.channel.ChannelInboundHandlerAdapter
channelReadComplete, channelUnregistered

从类继承的方法 io.netty.channel.ChannelHandlerAdapter
ensureNotSharable, handlerAdded, handlerRemoved, isSharable

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 io.netty.channel.ChannelHandler
handlerAdded, handlerRemoved

- 字段详细资料
  - LOWERCASE_TRANSFER_ENCODING_HEADER
```
private static final String LOWERCASE_TRANSFER_ENCODING_HEADER
```
  - serverConnectionsMap
```
private volatile Map<InetSocketAddress,ProxyToServerConnection> serverConnectionsMap
```
  - numberOfCurrentlyConnectingServers
```
private final AtomicInteger numberOfCurrentlyConnectingServers
```
  - currentServerConnection
```
private volatile ProxyToServerConnection currentServerConnection
```
  - currentFilters
```
private volatile HttpFilters currentFilters
```
  - clientSslSession
```
private volatile SSLSession clientSslSession
```
  - globalTrafficShapingHandler
```
private final io.netty.handler.traffic.GlobalTrafficShapingHandler globalTrafficShapingHandler
```
  - proxyConfigOptions
```
private final ProxyConfigOptions proxyConfigOptions
```
  - httpProxyConfigOptions
```
private final HttpProxyConfigOptions httpProxyConfigOptions
```
  - requestReadMonitor
```
private HttpProxyConnection.RequestReadMonitor requestReadMonitor
```
    Activity Tracking/Statistics We track statistics on bytes, requests and responses by adding handlers at the appropriate parts of the pipeline (see initChannelPipeline()).
  - responseWrittenMonitor
```
private HttpProxyConnection.ResponseWrittenMonitor responseWrittenMonitor
```
- 构造器详细资料
  - ClientToProxyConnection
```
public ClientToProxyConnection(ProxyConfigOptions proxyConfigOptions,
                               HttpProxyConfigOptions httpProxyConfigOptions,
                               HttpProxyManager httpProxyManager,
                               String applicationName,
                               SslEngineSource sslEngineSource,
                               ChannelPipeline pipeline,
                               io.netty.handler.traffic.GlobalTrafficShapingHandler globalTrafficShapingHandler)
```
- 方法详细资料
  - readHTTPInitial
```
protected ConnectionState readHTTPInitial(HttpRequestWrapper httpRequest)
```
    Reading
    
    指定者:
    
    readHTTPInitial 在类中 HttpProxyConnection<HttpRequestWrapper>
    
    参数:
    
    httpRequest - http object
    
    返回:
    
    connection state
  - doReadHTTPInitial
```
private ConnectionState doReadHTTPInitial(HttpRequestWrapper httpRequest)
```
    Reads an HttpRequest.
    
    If we don't yet have a ProxyToServerConnection for the desired server, this takes care of creating it.
    
    Note - the "server" could be a chained proxy, not the final endpoint for the request.
    
    参数:
    
    httpRequest - request
    
    返回:
    
    state
  - readHTTPChunk
```
protected void readHTTPChunk(io.netty.handler.codec.http.HttpContent chunk)
```
    从类复制的说明: HttpProxyConnection
    
    Implement this to handle reading a chunk in a chunked transfer.
    
    指定者:
    
    readHTTPChunk 在类中 HttpProxyConnection<HttpRequestWrapper>
    
    参数:
    
    chunk - http content
  - respond
```
void respond(ProxyToServerConnection serverConnection,
             HttpFilters filters,
             io.netty.handler.codec.http.HttpRequest currentHttpRequest,
             io.netty.handler.codec.http.HttpResponse currentHttpResponse,
             io.netty.handler.codec.http.HttpObject httpObject)
```
    Send a response to the client.
    
    参数:
    
    serverConnection - the ProxyToServerConnection that's responding
    
    filters - the filters to apply to the response
    
    currentHttpRequest - the HttpRequest that prompted this response
    
    currentHttpResponse - the HttpResponse corresponding to this data (when doing chunked transfers, this is the initial HttpResponse object that came in before the other chunks)
    
    httpObject - the data with which to respond
  - connected
```
protected void connected()
```
    On connect of the client, start waiting for an initial HttpRequest.
    
    覆盖:
    
    connected 在类中 HttpProxyConnection<HttpRequestWrapper>
  - timedOut
```
void timedOut(ProxyToServerConnection serverConnection)
```
  - timedOut
```
protected void timedOut()
```
    从类复制的说明: HttpProxyConnection
    
    This method is called when the underlying Channel times out due to an idle timeout.
    
    覆盖:
    
    timedOut 在类中 HttpProxyConnection<HttpRequestWrapper>
  - disconnected
```
protected void disconnected()
```
    On disconnect of the client, disconnect all server connections.
    
    覆盖:
    
    disconnected 在类中 HttpProxyConnection<HttpRequestWrapper>
  - serverConnectionFlowStarted
```
protected void serverConnectionFlowStarted(ProxyToServerConnection serverConnection)
```
    Called when ProxyToServerConnection starts its connection flow.
    
    参数:
    
    serverConnection - connection
  - serverConnectionSucceeded
```
protected void serverConnectionSucceeded(ProxyToServerConnection serverConnection,
                                         boolean shouldForwardInitialRequest)
```
    If the ProxyToServerConnection completes its connection lifecycle successfully, this method is called to let us know about it.
    
    参数:
    
    serverConnection - connection
    
    shouldForwardInitialRequest - should forward request
  - serverConnectionFailed
```
protected boolean serverConnectionFailed(ProxyToServerConnection serverConnection,
                                         ConnectionState lastStateBeforeFailure,
                                         Throwable cause)
```
    If the ProxyToServerConnection fails to complete its connection lifecycle successfully, this method is called to let us know about it.
    After failing to connect to the server, one of two things can happen:
    1. If the server was a chained proxy, we fall back to connecting to the ultimate endpoint directly.
    2. If the server was the ultimate endpoint, we return a 502 Bad Gateway to the client.
    参数:
    
    serverConnection - connection
    
    lastStateBeforeFailure - failure state
    
    cause - what caused the failure
    
    返回:
    
    true if we're falling back to a another chained proxy (or direct connection) and trying again
  - connectionFailedUnrecoverably
```
private void connectionFailedUnrecoverably(HttpRequestWrapper initialRequest,
                                           ProxyToServerConnection serverConnection)
```
  - resumeReadingIfNecessary
```
private void resumeReadingIfNecessary()
```
  - serverDisconnected
```
protected void serverDisconnected(ProxyToServerConnection serverConnection)
```
    On disconnect of the server, track that we have one fewer connected servers and then disconnect the client if necessary.
    
    参数:
    
    serverConnection - connection
  - becameSaturated
```
protected void becameSaturated()
```
    When the ClientToProxyConnection becomes saturated, stop reading on all associated ProxyToServerConnections.
    
    覆盖:
    
    becameSaturated 在类中 HttpProxyConnection<HttpRequestWrapper>
  - becameWritable
```
protected void becameWritable()
```
    When the ClientToProxyConnection becomes writable, resume reading on all associated ProxyToServerConnections.
    
    覆盖:
    
    becameWritable 在类中 HttpProxyConnection<HttpRequestWrapper>
  - serverBecameSaturated
```
protected void serverBecameSaturated(ProxyToServerConnection serverConnection)
```
    When a server becomes saturated, we stop reading from the client.
    
    参数:
    
    serverConnection - connection
  - serverBecameWriteable
```
protected void serverBecameWriteable(ProxyToServerConnection serverConnection)
```
    When a server becomes writeable, we check to see if all servers are writeable and if they are, we resume reading.
    
    参数:
    
    serverConnection - connection
  - exceptionCaught
```
protected void exceptionCaught(Throwable cause)
```
    从类复制的说明: HttpProxyConnection
    
    Override this to handle exceptions that occurred during asynchronous processing on the Channel.
    
    覆盖:
    
    exceptionCaught 在类中 HttpProxyConnection<HttpRequestWrapper>
    
    参数:
    
    cause - raised error
  - initChannelPipeline
```
protected void initChannelPipeline(ChannelPipeline pipeline)
```
    Initialize the ChannelPipeline for the client to proxy channel. Proxy acts like a server here. A ChannelPipeline invokes the read (Inbound) handlers in ascending ordering of the list and then the write (Outbound) handlers in descending ordering. Regarding the Javadoc of HttpObjectAggregator it's needed to have the HttpResponseEncoder or HttpRequestEncoder before the HttpObjectAggregator in the ChannelPipeline.
    
    参数:
    
    pipeline - channel pipeline
  - getProxyConfigOptions
```
protected final ProxyConfigOptions getProxyConfigOptions()
```
  - getHttpConfigOptions
```
protected final HttpProxyConfigOptions getHttpConfigOptions()
```
  - createCorsHandler
```
private void createCorsHandler(ChannelPipeline pipeline)
```
  - closeConnectionsAfterWriteIfNecessary
```
private void closeConnectionsAfterWriteIfNecessary(ProxyToServerConnection serverConnection,
                                                   io.netty.handler.codec.http.HttpRequest currentHttpRequest,
                                                   io.netty.handler.codec.http.HttpResponse currentHttpResponse,
                                                   io.netty.handler.codec.http.HttpObject httpObject)
```
    This method takes care of closing client to proxy and/or proxy to server connections after finishing a write.
    
    参数:
    
    serverConnection - connection
    
    currentHttpRequest - current request
    
    currentHttpResponse - current response
    
    httpObject - htp object
  - forceDisconnect
```
private void forceDisconnect(ProxyToServerConnection serverConnection)
```
  - shouldCloseClientConnection
```
private boolean shouldCloseClientConnection(io.netty.handler.codec.http.HttpRequest req,
                                            io.netty.handler.codec.http.HttpResponse res,
                                            io.netty.handler.codec.http.HttpObject httpObject)
```
    Determine whether or not the client connection should be closed.
    
    参数:
    
    req - http request
    
    res - http response
    
    httpObject - http object
    
    返回:
    
    should it be closed or not
  - shouldCloseServerConnection
```
private boolean shouldCloseServerConnection(io.netty.handler.codec.http.HttpRequest req,
                                            io.netty.handler.codec.http.HttpResponse res,
                                            io.netty.handler.codec.http.HttpObject msg)
```
    Determines if the remote connection should be closed based on the request and response pair. If the request is HTTP 1.0 with no keep-alive header, for example, the connection should be closed. This in part determines if we should close the connection. Here's the relevant section of RFC 2616: "HTTP/1.1 defines the "close" connection option for the sender to signal that the connection will be closed after completion of the response. For example, Connection: close in either the request or the response header fields indicates that the connection SHOULD NOT be considered `persistent' (section 8.1) after the current request/response is complete."
    
    参数:
    
    req - The request.
    
    res - The response.
    
    msg - The message.
    
    返回:
    
    Returns true if the connection should close.
  - fixHttpVersionHeaderIfNecessary
```
private void fixHttpVersionHeaderIfNecessary(io.netty.handler.codec.http.HttpResponse httpResponse)
```
    Chunked encoding is an HTTP 1.1 feature, but sometimes we get a chunked response that reports its HTTP version as 1.0. In this case, we change it to 1.1.
    
    参数:
    
    httpResponse - http response
  - modifyRequestHeadersToReflectProxying
```
private void modifyRequestHeadersToReflectProxying(io.netty.handler.codec.http.HttpRequest httpRequest)
```
    If and only if our proxy is not running in transparent mode, modify the request headers to reflect that it was proxied.
    
    参数:
    
    httpRequest - http request
  - modifyResponseHeadersToReflectProxying
```
private void modifyResponseHeadersToReflectProxying(io.netty.handler.codec.http.HttpResponse httpResponse)
```
    If and only if our proxy is not running in transparent mode, modify the response headers to reflect that it was proxied.
    
    参数:
    
    httpResponse - http response
  - switchProxyConnectionHeader
```
private void switchProxyConnectionHeader(io.netty.handler.codec.http.HttpHeaders headers)
```
    Switch the de-facto standard "Proxy-Connection" header to "Connection" when we pass it along to the remote host. This is largely undocumented but seems to be what most browsers and servers expect.
    
    参数:
    
    headers - The headers to modify
  - stripConnectionTokens
```
private void stripConnectionTokens(io.netty.handler.codec.http.HttpHeaders headers)
```
    RFC2616 Section 14.10 HTTP/1.1 proxies MUST parse the Connection header field before a message is forwarded and, for each connection-token in this field, remove any header field(s) from the message with the same name as the connection-token.
    
    参数:
    
    headers - The headers to modify
  - stripHopByHopHeaders
```
private void stripHopByHopHeaders(io.netty.handler.codec.http.HttpHeaders headers)
```
    Removes all headers that should not be forwarded. See RFC 2616 13.5.1 End-to-end and Hop-by-hop Headers.
    
    参数:
    
    headers - The headers to modify
  - writeBadGateway
```
private boolean writeBadGateway(HttpRequestWrapper httpRequest)
```
    Tells the client that something went wrong trying to proxy its request. If the Bad Gateway is a response to an HTTP HEAD request, the response will contain no body, but the Content-Length header will be set to the value it would have been if this 502 Bad Gateway were in response to a GET.
    
    参数:
    
    httpRequest - the HttpRequest that is resulting in the Bad Gateway response
    
    返回:
    
    true if the connection will be kept open, or false if it will be disconnected
  - writeGatewayTimeout
```
private boolean writeGatewayTimeout()
```
    Tells the client that the connection to the server, or possibly to some intermediary service (such as DNS), timed out. If the Gateway Timeout is a response to an HTTP HEAD request, the response will contain no body, but the Content-Length header will be set to the value it would have been if this 504 Gateway Timeout were in response to a GET.
    
    返回:
    
    true if the connection will be kept open, or false if it will be disconnected
  - respondWithShortCircuitResponse
```
private boolean respondWithShortCircuitResponse(io.netty.handler.codec.http.HttpResponse httpResponse)
```
    Responds to the client with the specified "short-circuit" response. The response will be sent through the HttpFilters.proxyToClientResponse(HttpObject) filter method before writing it to the client. The client will not be disconnected, unless the response includes a "Connection: close" header, or the filter returns a null HttpResponse (in which case no response will be written to the client and the connection will be disconnected immediately). If the response is not a Bad Gateway or Gateway Timeout response, the response's headers will be modified to reflect proxying, including adding a Via header, Date header, etc.
    
    参数:
    
    httpResponse - the response to return to the client
    
    返回:
    
    true if the connection will be kept open, or false if it will be disconnected.
  - writeEmptyBuffer
```
private void writeEmptyBuffer()
```
    Write an empty buffer at the end of a chunked transfer. We need to do this to handle the way Netty creates HttpChunks from responses that aren't in fact chunked from the remote server using Transfer-Encoding: chunked. Netty turns these into pseudo-chunked responses in cases where the response would otherwise fill up too much memory or where the bufLength of the response body is unknown. This is handy because it means we can start streaming response bodies back to the client without reading the entire response. The problem is that in these pseudo-cases the last chunk is encoded to null, and this thwarts normal ChannelFutures from propagating operationComplete events on writes to appropriate channel listeners. We work around this by writing an empty buffer in those cases and using the empty buffer's future instead to handle any operations we need to when responses are fully written back to clients.
  - recordClientConnected
```
private void recordClientConnected()
```
  - recordClientSSLHandshakeSucceeded
```
private void recordClientSSLHandshakeSucceeded()
```
  - recordClientDisconnected
```
private void recordClientDisconnected()
```
  - getClientAddress
```
public InetSocketAddress getClientAddress()
```
  - flowContext
```
private FlowContext flowContext()
```
  - addressFor
```
private InetSocketAddress addressFor(ProxyRuleOption proxy,
                                     HttpProxyManager proxyServer)
                              throws UnknownHostException
```
    Build an InetSocketAddress for the given hostAndPort.
    
    参数:
    
    proxy - rule option
    
    proxyServer - proxu server
    
    返回:
    
    a resolved InetSocketAddress for the specified hostAndPort
    
    抛出:
    
    UnknownHostException - if hostAndPort could not be resolved, or if the input string could not be parsed into a host and port.

类 ClientToProxyConnection

嵌套类概要

从类继承的嵌套类/接口 org.zodiac.server.proxy.impl.HttpProxyConnection

从接口继承的嵌套类/接口 io.netty.channel.ChannelHandler

字段概要

从类继承的字段 org.zodiac.server.proxy.impl.HttpProxyConnection

从类继承的字段 org.zodiac.server.proxy.impl.ProxyConnection

构造器概要

方法概要

从类继承的方法 org.zodiac.server.proxy.impl.HttpProxyConnection

从类继承的方法 org.zodiac.server.proxy.impl.ProxyConnection

从类继承的方法 io.netty.channel.SimpleChannelInboundHandler

从类继承的方法 io.netty.channel.ChannelInboundHandlerAdapter

从类继承的方法 io.netty.channel.ChannelHandlerAdapter

从类继承的方法 java.lang.Object

从接口继承的方法 io.netty.channel.ChannelHandler

字段详细资料

LOWERCASE_TRANSFER_ENCODING_HEADER

serverConnectionsMap

numberOfCurrentlyConnectingServers

currentServerConnection

currentFilters

clientSslSession

globalTrafficShapingHandler

proxyConfigOptions

httpProxyConfigOptions

requestReadMonitor

responseWrittenMonitor

构造器详细资料

ClientToProxyConnection

方法详细资料

readHTTPInitial

doReadHTTPInitial

readHTTPChunk

respond

connected

timedOut

timedOut

disconnected

serverConnectionFlowStarted

serverConnectionSucceeded

serverConnectionFailed

connectionFailedUnrecoverably

resumeReadingIfNecessary

serverDisconnected

becameSaturated

becameWritable

serverBecameSaturated

serverBecameWriteable

exceptionCaught

initChannelPipeline

getProxyConfigOptions

getHttpConfigOptions

createCorsHandler

closeConnectionsAfterWriteIfNecessary

forceDisconnect

shouldCloseClientConnection

shouldCloseServerConnection

fixHttpVersionHeaderIfNecessary

modifyRequestHeadersToReflectProxying

modifyResponseHeadersToReflectProxying

switchProxyConnectionHeader

stripConnectionTokens

stripHopByHopHeaders

writeBadGateway

writeGatewayTimeout

respondWithShortCircuitResponse

writeEmptyBuffer

recordClientConnected

recordClientSSLHandshakeSucceeded

recordClientDisconnected

getClientAddress

flowContext

addressFor