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; }