public RemoteHost( INetworkFacade networkFacade )
{
Contract.Requires(networkFacade!=null);
Connection = networkFacade;
Parser = new HttpStreamParser();
HasDisconnected = false;
HasStoppedSendingData = false;
}
private void HttpsServerConnect( bool success, INetworkFacade server )
{
try
{
if ( success )
{
_sslTunnel = new SslTunnel();
_sslTunnel.TunnelClosed += HttpsTunnelClosed;
_sslTunnel.EstablishTunnel( _clientConnection, server, _lastRequest.Version );
}
else
{
ServiceLog.Logger.Warning( "{0} Unable to connect to remote HTTPS host", Id );
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception( string.Format( "{0} Unhandled exception in HTTPS session.", Id ), ex );
Reset();
}
}
private void HandleSendToClient( bool success, INetworkFacade facade )
{
//_sendingDataToClientLock.Set();
ServiceLog.Logger.Verbose( "{0} ClientSession -- handle send data to client", Id );
if ( !success )
{
ServiceLog.Logger.Warning( "{0} Unable to send to client", Id );
Reset();
}
}
private void HandleClose( bool success, INetworkFacade client )
{
ServiceLog.Logger.Verbose( "{0} ClientSession -- client closing socket", Id );
try
{
// Not much we can do here if unsuccessful...
if ( !success )
{
ServiceLog.Logger.Warning( "{0} Unable to shutdown client session", Id );
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception( string.Format( "{0} Unhandled exception closing client connection", Id ), ex );
}
}
public void Start( INetworkFacade connection )
{
Contract.Ensures( _clientConnection != null );
Contract.Ensures( _parser != null );
ServiceLog.Logger.Info( "{0} Starting new proxy client session with client ID {1}", Id, connection.Id );
_parser = new HttpStreamParser();
_parser.AdditionalDataRequested += HandleParserAdditionalDataRequested;
_parser.ReadRequestHeaderComplete += HandleParserReadRequestHeaderComplete;
_parser.PartialDataAvailable += HandleParserPartialDataAvailable;
_clientConnection = connection;
_clientConnection.ConnectionClosed += HandleClientConnectionClosed;
_clientConnection.BeginReceive( ReceiveDataFromClient );
_hasClientStoppedSendingData = false;
}
public void Start( INetworkFacade connection )
{
Contract.Requires(connection != null);
Contract.Requires(ClientConnection == null);
Contract.Requires(ServerConnection == null);
}
public void SetupServerConnection( INetworkFacade serverConnection )
{
}
private void HandleClientConnected( INetworkFacade clientConnection )
{
try
{
//ServiceLog.Logger.Info("ProxyService notified of new client connect. Pool size: {0}", _sessionPool.AvailablePoolSize);
IProxySession session = _sessionPool.Get();
lock (_activeSessions)
{
_activeSessions.Add(session);
}
session.SessionEnded += HandleSessionEnded;
session.Start(clientConnection);
}
catch ( InvalidOperationException ex )
{
ServiceLog.Logger.Exception(
"No more clients can be accepted; the pool of available sessions was exhausted. Increase the pool maximum number of clients in the proxy server settings.",
ex );
}
}
private void SetupServerConnection( INetworkFacade serverConnection )
{
ServiceLog.Logger.Verbose( "{0} SessionContext::SetupServerConnection", Id );
try
{
lock ( _changeServerConnectionMutex )
{
//UnwireServerParserEvents();
//if ( ServerConnection != null )
//{
// ServerConnection.BeginClose(
// ( s, f ) => ServiceLog.Logger.Info( "{0} Server connection closed", Id ) );
//}
ServerConnection = serverConnection;
if ( serverConnection != null )
{
_remoteHosts.Add( new RemoteHost(){ Connection = serverConnection, HasDisconnected = false, HasStoppedSendingData = false} );
ServerParser = new HttpStreamParser();
ServerParser.AdditionalDataRequested += HandleServerParserAdditionalDataRequested;
ServerParser.PartialDataAvailable += HandleServerParserPartialDataAvailable;
ServerParser.ReadResponseHeaderComplete += HandleServerParserReadResponseHeaderComplete;
ServerParser.MessageReadComplete += HandleServerParserMessageReadComplete;
ServerConnection.ConnectionClosed += HandleServerConnectionConnectionClosed;
HasServerBegunShutdown = false;
ServerConnection.BeginReceive( HandleServerReceive );
}
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception(
string.Format( "{0} Unhandled exception setting up server connection", Id ), ex );
ChangeState( SessionStateType.Error );
}
}
private void SetupClientConnection( INetworkFacade clientConnection )
{
ServiceLog.Logger.Info( "{0} SessionContext::SetupClientConnection", Id );
try
{
lock ( _changeClientConnectionMutex )
{
if (ClientParser != null)
{
ClientParser.AdditionalDataRequested -= HandleClientParserAdditionalDataRequested;
ClientParser.PartialDataAvailable -= HandleClientParserPartialDataAvailable;
ClientParser.ReadRequestHeaderComplete -= HandleClientParserReadRequestHeaderComplete;
ClientParser = null;
}
if (ClientConnection != null)
{
ClientConnection.ConnectionClosed -= HandleClientConnectionClosed;
ClientConnection.BeginClose(
( s, f ) => ServiceLog.Logger.Info( "{0} Client connection closed", Id ) );
}
ClientConnection = clientConnection;
if ( ClientConnection != null )
{
ClientParser = new HttpStreamParser();
ClientParser.AdditionalDataRequested += HandleClientParserAdditionalDataRequested;
ClientParser.PartialDataAvailable += HandleClientParserPartialDataAvailable;
ClientParser.ReadRequestHeaderComplete += HandleClientParserReadRequestHeaderComplete;
ClientConnection.ConnectionClosed += HandleClientConnectionClosed;
HasClientBegunShutdown = false;
ClientConnection.BeginReceive( HandleClientReceive );
}
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception(
string.Format( "{0} Unhandled exception setting up client connection", Id ), ex );
ChangeState( SessionStateType.Error );
}
}
private void HandleServerReceive( bool success, byte[] data, INetworkFacade client )
{
Contract.Requires( client != null );
ServiceLog.Logger.Verbose( "{0} SessionContext::HandleServerReceive", Id );
try
{
if ( success && ServerParser != null )
{
if ( data == null )
{
ServiceLog.Logger.Info(
"{0} Server has shutdown the socket and will not be sending more data.", Id );
HasServerBegunShutdown = true;
State.AcknowledgeServerShutdown( this );
}
else
{
LastNetworkActivity = DateTime.Now;
ServerParser.AppendData( data );
}
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception(
string.Format( "{0} Unhandled exception receiving data from server", Id ), ex );
ChangeState( SessionStateType.Error );
}
}
private void HandleClientReceive( bool success, byte[] data, INetworkFacade client )
{
Contract.Requires( client != null );
ServiceLog.Logger.Verbose( "{0} SessionContext::HandleClientReceive", Id );
try
{
if ( success && ClientParser != null )
{
if ( data == null )
{
ServiceLog.Logger.Info( "{0} Client is still active but has stopped sending data.",
Id );
HasClientBegunShutdown = true;
State.AcknowledgeClientShutdown( this );
}
else
{
LastNetworkActivity = DateTime.Now;
ClientParser.AppendData( data );
}
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception(
string.Format( "{0} Unhandled exception receiving data from client", Id ), ex );
ChangeState( SessionStateType.Error );
}
}
private void DataSent( bool success, INetworkFacade facade )
{
Contract.Requires( facade != null );
ServiceLog.Logger.Verbose( "{0} SessionContext::DataSent", Id );
if ( !success )
{
Reset();
}
}
private void ConnectionEstablished( bool success, INetworkFacade server )
{
ServiceLog.Logger.Verbose( "{0} SessionContext::ConnectionEstablished", Id );
if ( success )
{
//SetupServerConnection( server );
State.ServerConnectionEstablished( this );
// Free the HTTP parsers to send HTTP body data
_serverConnectingEvent.Set();
}
else
{
ServiceLog.Logger.Warning( "{0} Unable to connect to remote host {1} {2}", Id, Host, Port );
ChangeState( SessionStateType.Error );
}
}
public void Start( INetworkFacade connection )
{
ServiceLog.Logger.Info( "{0} Starting new client session", Id );
ChangeState( SessionStateType.ClientConnecting );
// Wire up events for the client
SetupClientConnection( connection );
}
private void ReceiveDataFromClient( bool success, byte[] rawData, INetworkFacade client )
{
ServiceLog.Logger.Verbose( "{0} ClientSession -- received data from client", Id );
try
{
if ( success )
{
if ( rawData == null )
{
ServiceLog.Logger.Info( "{0} Client socket has stopped sending data.", Id );
_hasClientStoppedSendingData = true;
ServiceLog.Logger.Verbose( "{0} Pipeline depth = {1}", Id, _dispatcher.PipeLineDepth );
if ( _dispatcher.PipeLineDepth == 0 )
{
ServiceLog.Logger.Info( "{0} No active servers remain and client shutdown socket. Resetting.", Id );
Reset();
}
}
else
{
_parser.AppendData( rawData );
}
}
else
{
ServiceLog.Logger.Info( "{0} Client receive reported failure. Resetting client.", Id );
Reset();
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception( string.Format( "{0} Unhandled exception receiving data from client.", Id ), ex );
Reset();
}
}
public void Reset()
{
Contract.Ensures( _clientConnection == null );
ServiceLog.Logger.Info( "{0} Session reset", Id );
try
{
lock ( _resetMutex )
{
ResetParser();
if ( _clientConnection != null )
{
_clientConnection.ConnectionClosed -= HandleClientConnectionClosed;
_clientConnection.BeginClose( HandleClose );
_clientConnection = null;
_dispatcher.Reset();
EventHandler sessionEnded = SessionEnded;
if ( sessionEnded != null )
{
SessionEnded( this, new EventArgs() );
}
_hasClientStoppedSendingData = false;
}
}
}
catch ( Exception ex )
{
ServiceLog.Logger.Exception( string.Format( "{0} Unhandled exception resetting client session.", Id ), ex );
Reset();
}
}
public void SetupClientConnection( INetworkFacade clientConnection )
{
}
