/// <summary>
/// Queues a write request.
/// </summary>
protected void BeginWriteMessage(BufferCollection buffers, object state)
{
ServiceResult error = ServiceResult.Good;
IMessageSocketAsyncEventArgs args = m_socket.MessageSocketEventArgs();
try
{
args.BufferList = buffers;
args.Completed += OnWriteComplete;
args.UserToken = state;
if (m_socket == null ||
!m_socket.SendAsync(args))
{
// I/O completed synchronously
if (args.IsSocketError || (args.BytesTransferred < buffers.TotalSize))
{
error = ServiceResult.Create(StatusCodes.BadConnectionClosed, args.SocketErrorString);
HandleWriteComplete(buffers, state, args.BytesTransferred, error);
args.Dispose();
}
else
{
OnWriteComplete(null, args);
}
}
}
catch (Exception ex)
{
error = ServiceResult.Create(ex, StatusCodes.BadTcpInternalError, "Unexpected error during write operation.");
HandleWriteComplete(buffers, state, args.BytesTransferred, error);
args.Dispose();
}
}
/// <summary>
/// Queues a write request.
/// </summary>
protected void BeginWriteMessage(ArraySegment <byte> buffer, object state)
{
ServiceResult error = ServiceResult.Good;
IMessageSocketAsyncEventArgs args = m_socket.MessageSocketEventArgs();
try
{
args.SetBuffer(buffer.Array, buffer.Offset, buffer.Count);
args.Completed += OnWriteComplete;
args.UserToken = state;
if (!m_socket.SendAsync(args))
{
// I/O completed synchronously
if (args.IsSocketError || (args.BytesTransferred < buffer.Count))
{
error = ServiceResult.Create(StatusCodes.BadConnectionClosed, args.SocketErrorString);
HandleWriteComplete(null, state, args.BytesTransferred, error);
args.Dispose();
}
else
{
// success, call Complete
OnWriteComplete(null, args);
}
}
}
catch (Exception ex)
{
error = ServiceResult.Create(ex, StatusCodes.BadTcpInternalError, "Unexpected error during write operation.");
HandleWriteComplete(null, state, args.BytesTransferred, error);
args.Dispose();
}
}
/// <summary>
/// Handles a write complete event.
/// </summary>
protected virtual void OnWriteComplete(object sender, IMessageSocketAsyncEventArgs e)
{
lock (DataLock)
{
ServiceResult error = ServiceResult.Good;
try
{
Utils.TraceDebug("Bytes written: {0}", e.BytesTransferred);
if (e.BytesTransferred == 0)
{
error = ServiceResult.Create(StatusCodes.BadConnectionClosed, "The socket was closed by the remote application.");
}
if (e.Buffer != null)
{
BufferManager.ReturnBuffer(e.Buffer, "OnWriteComplete");
}
HandleWriteComplete((BufferCollection)e.BufferList, e.UserToken, e.BytesTransferred, error);
}
catch (Exception ex)
{
error = ServiceResult.Create(ex, StatusCodes.BadTcpInternalError, "Unexpected error during write operation.");
HandleWriteComplete((BufferCollection)e.BufferList, e.UserToken, e.BytesTransferred, error);
}
}
e.Dispose();
}
/// <summary>
/// Sends a buffer.
/// </summary>
public bool SendAsync(IMessageSocketAsyncEventArgs args) {
if (!(args is ProxyMessageSocketAsyncEventArgs eventArgs)) {
throw new ArgumentNullException(nameof(args));
}
if (ProxySocket == null) {
throw new InvalidOperationException("The socket is not connected.");
}
eventArgs._args.SocketError = SocketError.Unknown;
return ProxySocket.SendAsync(eventArgs._args);
}
/// <summary>
/// Reverse client is connected, send reverse hello message.
/// </summary>
private void OnReverseConnectComplete(object sender, IMessageSocketAsyncEventArgs result)
{
var ar = (ReverseConnectAsyncResult)result.UserToken;
if (ar == null || m_pendingReverseHello != null)
{
return;
}
if (result.IsSocketError)
{
ar.Exception = new ServiceResultException(StatusCodes.BadNotConnected, result.SocketErrorString);
ar.OperationCompleted();
return;
}
byte[] buffer = BufferManager.TakeBuffer(SendBufferSize, "OnReverseConnectConnectComplete");
try
{
// start reading messages.
ar.Socket.ReadNextMessage();
// send reverse hello message.
BinaryEncoder encoder = new BinaryEncoder(buffer, 0, SendBufferSize, Quotas.MessageContext);
encoder.WriteUInt32(null, TcpMessageType.ReverseHello);
encoder.WriteUInt32(null, 0);
encoder.WriteString(null, EndpointDescription.Server.ApplicationUri);
encoder.WriteString(null, EndpointDescription.EndpointUrl);
int size = encoder.Close();
UpdateMessageSize(buffer, 0, size);
// set state to waiting for hello.
State = TcpChannelState.Connecting;
m_pendingReverseHello = ar;
BeginWriteMessage(new ArraySegment <byte>(buffer, 0, size), null);
buffer = null;
}
catch (Exception e)
{
ar.Exception = e;
ar.OperationCompleted();
}
finally
{
if (buffer != null)
{
BufferManager.ReturnBuffer(buffer, "OnReverseConnectComplete");
}
}
}
/// <inheritdoc/>
public bool SendAsync(IMessageSocketAsyncEventArgs args)
{
if (!(args is WebSocketAsyncEventArgs eventArgs))
{
throw new ArgumentException(nameof(args));
}
if (_open.IsCancellationRequested)
{
throw new InvalidOperationException("The websocket connection is closed.");
}
_sendTask = SendBuffersAsync(args.BufferList)
.ContinueWith(t => eventArgs.CompleteSend(this, t));
return(true);
}
/// <summary>
/// Sends a buffer.
/// </summary>
public bool SendAsync(IMessageSocketAsyncEventArgs args)
{
TcpMessageSocketAsyncEventArgs eventArgs = args as TcpMessageSocketAsyncEventArgs;
if (eventArgs == null)
{
throw new ArgumentNullException(nameof(args));
}
if (m_socket == null)
{
throw new InvalidOperationException("The socket is not connected.");
}
eventArgs.m_args.SocketError = SocketError.NotConnected;
return(m_socket.SendAsync(eventArgs.m_args));
}
