private async Task SendAsync(IPooledBuffer datagram)
{
try
{
var length = datagram.Count;
_log.Trace("Sending message {0} of length: {1}", _sendCount, length);
await WriteLengthAsync(datagram.Count).ConfigureAwait(false);
await _stream.WriteAsync(datagram.Array, datagram.Offset, length).ConfigureAwait(false);
await _stream.FlushAsync().ConfigureAwait(false);
_log.Trace("Sent message {0} of length {1}", _sendCount, length);
_sendCount++;
}
catch
{
_receiver.TryTerminate();
throw;
}
finally
{
datagram.Dispose();
}
}
public ITransportHeader Deserialize(IPooledBuffer datagram)
{
using (var proto = Header.Rent())
{
proto.MergeFrom(datagram);
var contentCase = proto.ContentCase;
ITransportHeader header;
switch (contentCase)
{
case Header.ContentOneofCase.MessageFrame:
header = ConvertFromProto(proto.MessageFrame);
break;
case Header.ContentOneofCase.ChannelOpen:
header = ConvertFromProto(proto.ChannelOpen);
break;
case Header.ContentOneofCase.ChannelClose:
header = ConvertFromProto(proto.ChannelClose);
break;
case Header.ContentOneofCase.Open:
header = ConvertFromProto(proto.Open);
break;
case Header.ContentOneofCase.Close:
header = ConvertFromProto(proto.Close);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(header);
}
}
/// <summary>
/// Returns a buffer to the pool.
/// if limit crosses, buffer won't be returned to the Pool.
/// It return false , if buffer is not returned.
/// </summary>
/// <param name="buffer"></param>
public bool ReturnBuffer(IPooledBuffer buffer)
{
var segment = ((PooledBuffer)buffer);
//Return the buffer
return(this.bufferPool.Return(segment));
}
public static void MergeFrom <T>(this T message, IPooledBuffer datagram) where T : IMessage <T>
{
// We don't need to dispose stream here because it throws on disposing if created from array.
var stream = new CodedInputStream(datagram.Array, datagram.Offset, datagram.Count);
message.MergeFrom(stream);
}
private async Task SendAsync(IPooledBuffer msg)
{
using (msg)
{
_log.Trace("Sending message of length {0}", msg.Count);
await _webSocket.Send(msg.ToArray()).WithCancellation(_cancellationToken).ConfigureAwait(false);
}
}
private void Send(IPooledBuffer msg)
{
using (msg)
{
_log.Trace("Sending message of length {0}", msg.Count);
_webSocket.Send(msg.Array, msg.Offset, msg.Count);
}
}
public IInvocationStarting DeserializeInvocationStarting(IPooledBuffer message)
{
using (var proto = InvocationStarting.Rent())
{
proto.MergeFrom(message);
return(_messageFactory.CreateInvocationStarting());
}
}
public IServiceDiscoveryResponse DeserializeServiceDiscoveryResponse(IPooledBuffer message)
{
using (var obj = ServiceDiscoveryResponse.Rent())
{
obj.MergeFrom(message);
return(_messageFactory.CreateServiceDiscoveryResponse(obj.Services.Select(ConvertFromProto).ToList()));
}
}
public IMethodDiscoveryResponse DeserializeMethodDiscoveryResponse(IPooledBuffer message)
{
using (var proto = MethodDiscoveryResponse.Rent())
{
proto.MergeFrom(message);
return(_messageFactory.CreateMethodDiscoveryResponse(proto.Methods.Select(ConvertFromProto).ToList()));
}
}
public IConnectResponse DeserializeConnectResponse(IPooledBuffer msg)
{
using (var obj = ConnectResponse.Rent())
{
obj.MergeFrom(msg);
return(_messageFactory.CreateConnectResponse(obj.ConnectionId.ConvertFromProtoStrict()));
}
}
private Task SendInternalAsync(IPooledBuffer msg)
{
using (msg)
{
_log.Trace("Sending message of length {0}", msg.Count);
_socket.Send(msg.Array, msg.Offset, msg.Count);
}
return(TaskConstants.Completed);
}
public IConnectRequest DeserializeConnectRequest(IPooledBuffer msg)
{
using (var obj = ConnectRequest.Rent())
{
obj.MergeFrom(msg);
return(_messageFactory.CreateConnectRequest(
obj.ApplicationId,
obj.ApplicationInstanceId.ConvertFromProtoStrict()));
}
}
public static byte[] ToArray(this IPooledBuffer data)
{
if (data.Array == null)
{
return(null);
}
var array = new byte[data.Count];
Array.Copy(data.Array, data.Offset, array, 0, data.Count);
return(array);
}
private async Task SendAsync(IPooledBuffer message)
{
try
{
await _connection.Out.WriteAsync(message).ConfigureAwait(false);
}
catch
{
message.Dispose();
throw;
}
}
private void Initialize()
{
this.canWrite = true;
this.canRead = false;
this.canSeek = false;
this.position = 0;
this.writeBuffers = new List <IPooledBuffer>(1);
this.currentBuffer = this.bufferPoolManager.TakeBuffer();
this.writeBuffers.Add(this.currentBuffer);
this.bufferSize = this.writeBuffers[0].Value.Count;
this.currentBufferOffset = 0;
}
private async Task SendAsync(IPooledBuffer message, IWriteOnlyChannel <IPooledBuffer> output)
{
try
{
await output.WriteAsync(message).ConfigureAwait(false);
}
catch
{
message.Dispose();
throw;
}
}
private async Task WriteDatagram(IPooledBuffer datagram)
{
try
{
await _buffer.Out.WriteAsync(datagram, _cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_log.Warn(ex, $"Caught exception during attempt to write datagram of length {datagram.Count}");
datagram.Dispose();
throw;
}
}
private async Task SendAsync(IPooledBuffer msg)
{
using (msg)
{
await _webSocket
.SendAsync(
new ArraySegment <byte>(msg.Array, msg.Offset, msg.Count),
WebSocketMessageType.Binary,
true,
_cancellationToken)
.ConfigureAwait(false);
}
}
private async Task SendInternalAsync(IPooledBuffer msg)
{
using (msg)
{
_log.Trace("Sending message of length {0}", msg.Count);
await _webSocket
.SendAsync(
new ArraySegment <byte>(msg.Array, msg.Offset, msg.Count),
WebSocketMessageType.Binary,
true,
CancellationToken.None)
.ConfigureAwait(false);
}
}
private async Task SendAsync(IPooledBuffer message, TransportMessage originalMessage, bool isHeader)
{
try
{
await _connection.Out.WriteAsync(message).ConfigureAwait(false);
}
catch (Exception ex)
{
var payloadType = isHeader ? "header" : "payload";
_log.Warn(ex, $"Exception occurred while sending {payloadType} of message: {originalMessage}");
message.Dispose();
throw;
}
}
public override void WriteByte(byte value)
{
var i = this.currentBufferOffset + 1;
if (i > this.bufferSize)
{
this.currentBuffer = this.bufferPoolManager.TakeBuffer();
this.writeBuffers.Add(this.currentBuffer);
this.currentBufferOffset = 0;
}
this.currentBuffer.Value.Array[this.currentBufferOffset] = value;
this.currentBuffer.ContentLength += 1;
this.position += 1;
}
private async Task SendAsync(IPooledBuffer datagram)
{
using (datagram)
{
var length = datagram.Count;
_log.Trace("Sending message {0} of length: {1}", _count, length);
await WriteLengthAsync(length).ConfigureAwait(false);
await _stream.WriteAsync(datagram.Array, datagram.Offset, length, _cancellationToken)
.ConfigureAwait(false);
await _stream.FlushAsync(_cancellationToken).ConfigureAwait(false);
_log.Trace("Sent message {0} of length {1}", _count, length);
_count++;
}
}
public OutgoingMessageHeader(IEnumerable <IPooledBuffer> pooledBuffers)
{
if (pooledBuffers.Count() > 1)
{
ServiceTrace.Source.WriteInfo("OutgoingMessageHeader", "PooledBuffer for header is more than one, which might affect the performance");
this.outgoingBuffer = this.CreateAndReleaseBuffer(pooledBuffers);
this.pooledBuffer = null;
}
else
{
var pooledBuffer = pooledBuffers.ElementAt(0);
this.outgoingBuffer = new ArraySegment <byte>(
pooledBuffer.Value.Array,
pooledBuffer.Value.Offset,
pooledBuffer.ContentLength);
this.pooledBuffer = pooledBuffer;
}
}
private async Task HandleReceivedAsync(IPooledBuffer item)
{
ITransportHeader header;
using (item)
{
header = _deserializer.Deserialize(item);
}
try
{
var payload = Maybe <IPooledBuffer> .Nothing;
var expectedBodyLength = GetBodyLengthHandler.Instance.Handle(header);
if (expectedBodyLength.HasValue)
{
var body = await _connection.ReadAsync().ConfigureAwait(false);
if (body.Count != expectedBodyLength.Value)
{
body.Dispose();
throw new InvalidOperationException(
$"Received body length {body.Count} does not equal to the specified in header: {header}");
}
payload = new Maybe <IPooledBuffer>(body);
}
try
{
var transportMessage = new TransportMessage(header, payload);
_log.Debug("Message received: {0}", transportMessage);
await _buffer.Out.WriteAsync(transportMessage).ConfigureAwait(false);
}
catch
{
payload.GetValueOrDefault()?.Dispose();
throw;
}
}
catch
{
header.Dispose();
throw;
}
}
public IBrokerToClientRequest DeserializeBrokerToClientRequest(IPooledBuffer message)
{
using (var envelope = BrokerToClientRequestEnvelope.Rent())
{
envelope.MergeFrom(message);
switch (envelope.PayloadCase)
{
case BrokerToClientRequestEnvelope.PayloadOneofCase.InvocationStartRequested:
var msg = envelope.InvocationStartRequested;
return(_messageFactory.CreateInvocationStartRequested(
msg.ServiceId.ConvertFromProtoStrict(),
msg.MethodId.ConvertFromProtoStrict(),
msg.ServiceAlias.ConvertFromProto(),
msg.ConsumerApplicationId.ConvertFromProtoStrict(),
msg.ConsumerConnectionId.ConvertFromProtoStrict()));
default:
throw new InvalidOperationException();
}
}
}
public IInvocationMessage DeserializeInvocationMessage(IPooledBuffer message)
{
using (var envelope = InvocationMessageEnvelope.Rent())
{
envelope.MergeFrom(message);
switch (envelope.PayloadCase)
{
case InvocationMessageEnvelope.PayloadOneofCase.Message:
return(_messageFactory.CreateInvocationMessageHeader());
case InvocationMessageEnvelope.PayloadOneofCase.Confirmation:
return(_messageFactory.CreateInvocationMessageReceived());
case InvocationMessageEnvelope.PayloadOneofCase.SendCompletion:
return(_messageFactory.CreateInvocationSendCompletion());
default:
throw new InvalidOperationException($"Unexpected payload case: {envelope.PayloadCase}");
}
}
}
public IClientToBrokerRequest DeserializeClientToBrokerRequest(IPooledBuffer message)
{
using (var envelope = ClientToBrokerRequestEnvelope.Rent())
{
envelope.MergeFrom(message);
switch (envelope.PayloadCase)
{
case ClientToBrokerRequestEnvelope.PayloadOneofCase.InvocationStartRequest:
var invocationRequest = envelope.InvocationStartRequest;
IInvocationTarget target;
switch (invocationRequest.TargetCase)
{
case InvocationStartRequest.TargetOneofCase.ConsumedMethod:
target = ConvertFromProtoStrict(invocationRequest.ConsumedMethod);
break;
case InvocationStartRequest.TargetOneofCase.ProvidedMethod:
target = ConvertFromProtoStrict(invocationRequest.ProvidedMethod);
break;
default:
throw new InvalidOperationException($"Unexpected target payload: {invocationRequest.TargetCase}");
}
var contextLinkageOptions = ConvertFromProtoStrict(invocationRequest.ContextLinkageOptions);
return(_messageFactory.CreateInvocationStartRequest(target, contextLinkageOptions));
case ClientToBrokerRequestEnvelope.PayloadOneofCase.ServiceDiscoveryRequest:
return(ConvertFromProtoStrict(envelope.ServiceDiscoveryRequest));
case ClientToBrokerRequestEnvelope.PayloadOneofCase.MethodDiscoveryRequest:
return(ConvertFromProtoStrict(envelope.MethodDiscoveryRequest));
default:
throw new InvalidOperationException();
}
}
}
public TransportMessageFrame(IPooledBuffer data, bool hasMore = false)
{
Payload = data;
HasMore = hasMore;
}
private Task SendAsync(ITransportChannelHeader header, IPooledBuffer body) => SendAsync(header, new Maybe <IPooledBuffer>(body));
public FrameMessage(ITransportFrameHeader header, IPooledBuffer payload)
{
Header = header;
Payload = payload;
}
