Package org.littleshoot.proxy.impl

Class ConnectionFlow

java.lang.Object

org.littleshoot.proxy.impl.ConnectionFlow

class ConnectionFlow
extends Object

Coordinates the various steps involved in establishing a connection, such as establishing a socket connection, SSL handshaking, HTTP CONNECT request processing, and so on.

Field Summary

Fields

Modifier and Type	Field	Description
private ClientToProxyConnection	clientConnection
private Object	connectLock
private ConnectionFlowStep	currentStep
private ProxyToServerConnection	serverConnection
private Deque<ConnectionFlowStep>	steps
private boolean	suppressInitialRequest

Constructor Summary

Constructors

Constructor	Description
ConnectionFlow(ClientToProxyConnection clientConnection, ProxyToServerConnection serverConnection, Object connectLock)	Construct a new ConnectionFlow for the given client and server connections.

Method Summary

Modifier and Type	Method	Description
(package private) void	advance()	Advances the flow.
private void	doProcessCurrentStep(ProxyConnectionLogger LOG)	Does the work of processing the current step, checking the result and handling success/failure.
(package private) void	fail()	Like fail(Throwable) but with no cause.
(package private) void	fail(Throwable cause)	Called when the flow fails at some ConnectionFlowStep.
(package private) ConnectionFlow	first(ConnectionFlowStep step)	Add a ConnectionFlowStep to the beginning of this flow.
private ProxyProtocolMessage	getHAProxyMessage(InetSocketAddress clientAddress, InetSocketAddress remoteAddress)
private void	notifyThreadsWaitingForConnection()	Once we've finished recording our connection and written our initial request, we can notify anyone who is waiting on the connection that it's okay to proceed.
private void	processCurrentStep()	Process the current ConnectionFlowStep.
(package private) void	read(Object msg)	While we're in the process of connecting, any messages read by the ProxyToServerConnection are passed to this method, which passes it on to ConnectionFlowStep.read(ConnectionFlow, Object) for the current ConnectionFlowStep.
private void	relayProxyInformation()
(package private) void	start()	Starts the connection flow, notifying the ClientToProxyConnection that we've started.
(package private) void	succeed()	Called when the flow is complete and successful.
(package private) ConnectionFlow	then(ConnectionFlowStep step)	Add a ConnectionFlowStep to the end of this flow.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

steps

private final Deque<ConnectionFlowStep> steps

clientConnection

private final ClientToProxyConnection clientConnection

serverConnection

private final ProxyToServerConnection serverConnection

currentStep

private volatile ConnectionFlowStep currentStep

suppressInitialRequest

private volatile boolean suppressInitialRequest

connectLock

private final Object connectLock

Constructor Detail

ConnectionFlow

ConnectionFlow(ClientToProxyConnection clientConnection,
               ProxyToServerConnection serverConnection,
               Object connectLock)

Construct a new ConnectionFlow for the given client and server connections.

Parameters:

clientConnection -

serverConnection -

connectLock - an object that's shared by ConnectionFlow and ProxyToServerConnection and that is used for synchronizing the reader and writer threads that are both involved during the establishing of a connection.

Method Detail

first

ConnectionFlow first(ConnectionFlowStep step)

Add a ConnectionFlowStep to the beginning of this flow.

then

ConnectionFlow then(ConnectionFlowStep step)

Add a ConnectionFlowStep to the end of this flow.

read

void read(Object msg)

While we're in the process of connecting, any messages read by the ProxyToServerConnection are passed to this method, which passes it on to ConnectionFlowStep.read(ConnectionFlow, Object) for the current ConnectionFlowStep.

start

void start()

Starts the connection flow, notifying the ClientToProxyConnection that we've started.

advance

void advance()

Advances the flow. advance() will be called until we're either out of steps, or a step has failed.

processCurrentStep

private void processCurrentStep()

Process the current ConnectionFlowStep. With each step, we:

1. Change the state of the associated ProxyConnection to the value of ConnectionFlowStep.getState()
2. Call ConnectionFlowStep.execute()
3. On completion of the Future returned by ConnectionFlowStep.execute(), check the success.
4. If successful, we call back into ConnectionFlowStep.onSuccess(ConnectionFlow).
5. If unsuccessful, we call fail(), stopping the connection flow

doProcessCurrentStep

private void doProcessCurrentStep(ProxyConnectionLogger LOG)

Does the work of processing the current step, checking the result and handling success/failure.

succeed

void succeed()

Called when the flow is complete and successful. Notifies the ProxyToServerConnection that we succeeded.

relayProxyInformation

private void relayProxyInformation()

getHAProxyMessage

private ProxyProtocolMessage getHAProxyMessage(InetSocketAddress clientAddress,
                                               InetSocketAddress remoteAddress)

fail

void fail(Throwable cause)

Called when the flow fails at some ConnectionFlowStep. Disconnects the ProxyToServerConnection and informs the ClientToProxyConnection that our connection failed.

fail

void fail()

Like fail(Throwable) but with no cause.

notifyThreadsWaitingForConnection

private void notifyThreadsWaitingForConnection()

Once we've finished recording our connection and written our initial request, we can notify anyone who is waiting on the connection that it's okay to proceed.