void OnAcceptInnerTransport(TransportAsyncCallbackArgs innerArgs)
{
Fx.Assert(innerArgs.Exception == null, "Should not be called with an exception.");
Fx.Assert(innerArgs.Transport != null, "Should be called with a transport.");
Utils.Trace(TraceLevel.Info, "{0}: Tls listener accepted an inner transport {1}", this, innerArgs.Transport);
try
{
// upgrade transport
innerArgs.Transport = new TlsTransport(innerArgs.Transport, this.transportSettings);
IAsyncResult result = innerArgs.Transport.BeginOpen(
innerArgs.Transport.DefaultOpenTimeout,
this.onTransportOpened,
innerArgs);
if (result.CompletedSynchronously)
{
this.HandleTransportOpened(result);
return;
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
innerArgs.Transport.TryClose(exception);
}
}
void HandleInnerTransportConnected(TransportAsyncCallbackArgs innerArgs)
{
this.callbackArgs.CompletedSynchronously = innerArgs.CompletedSynchronously;
if (innerArgs.Exception != null)
{
this.callbackArgs.Exception = innerArgs.Exception;
this.Complete();
}
else
{
Fx.Assert(innerArgs.Transport != null, "must have a valid inner transport");
// upgrade transport
this.callbackArgs.Transport = new TlsTransport(innerArgs.Transport, this.transportSettings);
try
{
IAsyncResult result = this.callbackArgs.Transport.BeginOpen(this.timeoutHelper.RemainingTime(), onTransportOpened, this);
if (result.CompletedSynchronously)
{
this.HandleTransportOpened(result);
this.Complete();
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.callbackArgs.Exception = exception;
this.Complete();
}
}
}
protected void OnTransportAccepted(TransportAsyncCallbackArgs args)
{
if (args.CompletedSynchronously)
{
ActionItem.Schedule(this.notifyAccept, args);
}
else
{
this.NotifyAccept(args);
}
}
public sealed override bool WriteAsync(TransportAsyncCallbackArgs args)
{
IAsyncResult result = this.sslStream.BeginWrite(args.Buffer, args.Offset, args.Count, this.onWriteComplete, args);
if (result.CompletedSynchronously)
{
this.HandleWriteComplete(result);
return false;
}
else
{
return true;
}
}
public sealed override bool ReadAsync(TransportAsyncCallbackArgs args)
{
Fx.Assert(args.Buffer != null, "must have buffer to read");
IAsyncResult result = this.sslStream.BeginRead(args.Buffer, args.Offset, args.Count, this.onReadComplete, args);
if (result.CompletedSynchronously)
{
this.HandleReadComplete(result);
return false;
}
else
{
return true;
}
}
void OnHandleTransportComplete(TransportAsyncCallbackArgs args)
{
args.SetBuffer(null, 0, 0);
args.CompletedCallback = null;
if (args.Exception != null)
{
args.Transport.TryClose(args.Exception);
}
else
{
this.OnTransportAccepted(args);
}
}
public sealed override bool ReadAsync(TransportAsyncCallbackArgs args)
{
Fx.Assert(args.Buffer != null, "must have buffer(s) to read");
Fx.Assert(args.CompletedCallback != null, "must have a valid callback");
this.receiveEventArgs.SetBuffer(args.Buffer, args.Offset, args.Count);
this.receiveEventArgs.UserToken = args;
if (!this.socket.ReceiveAsync(this.receiveEventArgs))
{
this.OperationComplete(this.receiveEventArgs, true);
return false;
}
return true;
}
public void WriteFrame(Performative command, bool needReply)
{
try
{
Frame frame = new Frame(FrameType.Sasl, 0, command);
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.SetBuffer(frame.Buffer);
args.CompletedCallback = this.onWriteFrameComplete;
args.UserToken = needReply;
this.writer.WriteBuffer(args);
}
catch (Exception exception)
{
this.HandleException(exception);
}
}
public override bool ConnectAsync(TimeSpan timeout, TransportAsyncCallbackArgs callbackArgs)
{
Utils.Trace(TraceLevel.Info, "{0}: Tls initiator start connecting...", this);
this.callbackArgs = callbackArgs;
this.timeoutHelper = new TimeoutHelper(timeout);
TransportInitiator innerInitiator = this.transportSettings.InnerTransportSettings.CreateInitiator();
TransportAsyncCallbackArgs innerArgs = new TransportAsyncCallbackArgs();
innerArgs.CompletedCallback = OnInnerTransportConnected;
innerArgs.UserToken = this;
if (innerInitiator.ConnectAsync(timeout, innerArgs))
{
// pending
return true;
}
else
{
this.HandleInnerTransportConnected(innerArgs);
return !this.callbackArgs.CompletedSynchronously;
}
}
public override bool ConnectAsync(TimeSpan timeout, TransportAsyncCallbackArgs callbackArgs)
{
// TODO: set socket connect timeout to timeout
this.callbackArgs = callbackArgs;
// TODO: IPv6 support for DnsEndPoint
EndPoint endPoint = this.transportSettings.EndPoint;
AddressFamily addressFamily = endPoint is DnsEndPoint ? AddressFamily.InterNetwork : endPoint.AddressFamily;
Socket socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
SocketAsyncEventArgs connectEventArgs = new SocketAsyncEventArgs();
connectEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnConnectComplete);
connectEventArgs.AcceptSocket = socket;
connectEventArgs.RemoteEndPoint = endPoint;
connectEventArgs.UserToken = this;
if (socket.ConnectAsync(connectEventArgs))
{
return true;
}
else
{
this.Complete(connectEventArgs, true);
return false;
}
}
void OnWriteFrameComplete(TransportAsyncCallbackArgs args)
{
if (args.Exception != null)
{
this.HandleException(args.Exception);
}
else
{
bool readFrame = (bool)args.UserToken;
if (readFrame)
{
this.ReadFrame();
}
}
}
void NotifyAccept(object state)
{
TransportAsyncCallbackArgs args = (TransportAsyncCallbackArgs)state;
this.acceptCallback(args);
}
void OnAcceptTransport(TransportAsyncCallbackArgs args)
{
Fx.Assert(args.Exception == null, "Should not be failed.");
Fx.Assert(args.Transport != null, "Should have a transport");
AmqpConnectionSettings settings = this.connectionSettings.Clone();
settings.OnOpenCallback = this.OnReceiveConnectionOpen;
AmqpConnection connection = null;
try
{
connection = this.CreateConnection(
args.Transport,
(ProtocolHeader)args.UserToken,
false,
this.amqpSettings.Clone(),
settings);
connection.BeginOpen(connection.DefaultOpenTimeout, this.onConnectionOpenComplete, connection);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
if (connection != null)
{
connection.TryClose(ExceptionHelper.ToAmqpException(ex));
}
}
}
public abstract bool WriteAsync(TransportAsyncCallbackArgs args);
static void OnInnerTransportConnected(TransportAsyncCallbackArgs innerArgs)
{
TlsTransportInitiator thisPtr = (TlsTransportInitiator)innerArgs.UserToken;
thisPtr.HandleInnerTransportConnected(innerArgs);
}
static void OnTransport(TransportAsyncCallbackArgs args)
{
OpenContainerAsyncResult thisPtr = (OpenContainerAsyncResult)args.UserToken;
AmqpSettings settings = new AmqpSettings();
TransportProvider provider = new AmqpTransportProvider();
provider.Versions.Add(new AmqpVersion(1, 0, 0));
settings.TransportProviders.Add(provider);
thisPtr.connection = new AmqpConnection(args.Transport, settings, new AmqpConnectionSettings() { ContainerId = thisPtr.parent.id });
thisPtr.connection.BeginOpen(TimeSpan.MaxValue, thisPtr.PrepareAsyncCompletion(onConnectionOpen), thisPtr);
}
bool HandleWriteComplete(TransportAsyncCallbackArgs args)
{
bool done = true;
Exception exception = null;
if (args.Exception != null)
{
exception = args.Exception;
}
else if (args.BytesTransfered == 0)
{
exception = new ObjectDisposedException(this.transport.ToString());
}
else if (args.BytesTransfered < args.Count)
{
args.SetBuffer(args.Buffer, args.Offset + args.BytesTransfered, args.Count - args.BytesTransfered);
done = false;
}
TransportAsyncCallbackArgs innerArgs = (TransportAsyncCallbackArgs)args.UserToken;
if (done && innerArgs.CompletedCallback != null)
{
innerArgs.Exception = exception;
innerArgs.BytesTransfered = innerArgs.Count;
innerArgs.CompletedCallback(innerArgs);
}
return done;
}
void OnWriteComplete(TransportAsyncCallbackArgs args)
{
if (!this.HandleWriteComplete(args) && !args.CompletedSynchronously)
{
this.Write(args);
}
}
void OnAcceptTransport(TransportAsyncCallbackArgs args)
{
this.listener.Close();
if (args.Exception != null)
{
this.Complete(false, args.Exception);
return;
}
this.OnTransport(args.Transport);
}
void OnEstablishTransport(TransportAsyncCallbackArgs args)
{
if (args.Exception != null)
{
this.Complete(false, args.Exception);
return;
}
this.OnTransport(args.Transport);
}
protected override void Start(TransportSettings transportSettings)
{
this.initiator = transportSettings.CreateInitiator();
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = this.OnEstablishTransport;
if (!initiator.ConnectAsync(this.TimeoutHelper.RemainingTime(), args))
{
this.OnEstablishTransport(args);
}
}
public abstract bool ReadAsync(TransportAsyncCallbackArgs args);
public OpenContainerAsyncResult(Container parent, AsyncCallback callback, object state)
: base(callback, state)
{
this.parent = parent;
int port = this.parent.addressUri.Port;
if (port == -1)
{
port = AmqpConstants.DefaultPort;
}
TcpTransportSettings tcpSettings = new TcpTransportSettings();
tcpSettings.TcpBacklog = 20;
tcpSettings.TcpBufferSize = 4096;
tcpSettings.SetEndPoint(this.parent.addressUri.Host, port, false);
TransportSettings transportSettings = tcpSettings;
TransportInitiator initiator = transportSettings.CreateInitiator();
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = onTransport;
args.UserToken = this;
if (!initiator.ConnectAsync(TimeSpan.MaxValue, args))
{
OnTransport(args);
}
}
bool HandleAcceptComplete(SocketAsyncEventArgs e, bool completedSynchronously)
{
if (e.SocketError == SocketError.Success)
{
TcpTransport transport = new TcpTransport(e.AcceptSocket, this.transportSettings);
transport.Open();
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.Transport = transport;
args.CompletedSynchronously = completedSynchronously;
this.OnTransportAccepted(args);
return true;
}
else
{
e.Dispose();
this.TryClose(new SocketException((int)e.SocketError));
return false;
}
}
void OnAcceptTransport(TransportAsyncCallbackArgs args)
{
if (args.Exception != null)
{
return;
}
AmqpConnection connection = new AmqpConnection(args.Transport, this.settings, new AmqpConnectionSettings() { ContainerId = this.container.id });
connection.Closed += new EventHandler(connection_Closed);
lock (this.syncRoot)
{
this.connections.Add(connection);
}
connection.Open();
}
void Write(TransportAsyncCallbackArgs args)
{
try
{
while (true)
{
if (this.transport.WriteAsync(args))
{
break;
}
if (this.HandleWriteComplete(args))
{
break;
}
}
}
catch(Exception exception)
{
args.Exception = exception;
this.HandleWriteComplete(args);
}
}
public WriteAsyncResult(TransportBase transport)
{
this.transport = transport;
this.args = new TransportAsyncCallbackArgs();
this.args.CompletedCallback = OnWriteComplete;
this.args.UserToken = this;
}
static void OnWriteComplete(TransportAsyncCallbackArgs args)
{
WriteAsyncResult thisPtr = (WriteAsyncResult)args.UserToken;
thisPtr.completedSynchronously = args.CompletedSynchronously;
thisPtr.Complete();
}
public ReadAsyncResult(TransportBase transport)
{
this.transport = transport;
this.readBuffer = new byte[AmqpConstants.AsyncBufferSize];
this.readArgs = new TransportAsyncCallbackArgs();
this.readArgs.SetBuffer(this.readBuffer, 0, this.readBuffer.Length);
this.readArgs.CompletedCallback = OnReadComplete;
this.readArgs.UserToken = this;
}
public AsyncReader(
AsyncIO parent,
int readBufferSize,
Action<ByteBuffer> receiveBufferHandler)
{
this.parent = parent;
this.receiveBufferHandler = receiveBufferHandler;
this.readAsyncEventArgs = new TransportAsyncCallbackArgs();
this.readAsyncEventArgs.CompletedCallback = this.OnBufferReadComplete;
this.readBuffer = ByteBuffer.Wrap(new byte[readBufferSize]);
}
static void OnReadComplete(TransportAsyncCallbackArgs args)
{
ReadAsyncResult thisPtr = (ReadAsyncResult)args.UserToken;
thisPtr.bufferOffset = 0;
thisPtr.bufferEnd = args.BytesTransfered;
thisPtr.completedSynchronously = args.CompletedSynchronously;
thisPtr.Complete();
}
private void HandleReadComplete(TransportAsyncCallbackArgs args, bool fromCache, bool completedSynchronously)
{
if (this.receiveEventArgs.SocketError != SocketError.Success)
{
args.Exception = new SocketException((int)this.receiveEventArgs.SocketError);
}
else
{
try
{
int num = (fromCache ? this.receiveEventArgs.ReadBuffer.Length : this.receiveEventArgs.BytesTransferred);
int count = num;
if (num > 0)
{
if (!this.receiveEventArgs.IsSegment)
{
ByteBuffer readBuffer = this.receiveEventArgs.ReadBuffer;
if (readBuffer != null)
{
if (!fromCache)
{
readBuffer.Append(num);
}
if (num > args.Count)
{
Buffer.BlockCopy(readBuffer.Buffer, readBuffer.Offset, args.Buffer, args.Offset, args.Count);
count = args.Count;
readBuffer.Complete(args.Count);
}
else
{
Buffer.BlockCopy(readBuffer.Buffer, readBuffer.Offset, args.Buffer, args.Offset, num);
readBuffer.Reset();
}
}
else
{
count = 0;
}
}
else
{
Buffer.BlockCopy(this.receiveEventArgs.Buffer, this.receiveEventArgs.Offset, args.Buffer, args.Offset, num);
ArraySegment <byte> nums = new ArraySegment <byte>(this.receiveEventArgs.Buffer, this.receiveEventArgs.Offset, this.receiveEventArgs.Count);
TcpTransport.SmallBufferPool.ReturnBuffer(nums);
}
}
args.BytesTransfered = count;
args.Exception = null;
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
args.Exception = exception;
}
}
args.CompletedSynchronously = completedSynchronously;
try
{
this.receiveEventArgs.Reset();
}
catch (ObjectDisposedException objectDisposedException)
{
args.Exception = objectDisposedException;
}
if (!completedSynchronously)
{
args.CompletedCallback(args);
}
}