Exemple #1
0
        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;
            }
        }
        private async Task ReceiveLoopAsync(IWriteOnlyChannel <TransportMessage> output, CancellationToken cancellationToken)
        {
            while (true)
            {
                var maybeData = await _connection.TryReadAsync().ConfigureAwait(false);

                if (!maybeData.HasValue)
                {
                    break;
                }
                ITransportHeader header;
                using (var serializedHeader = maybeData.Value)
                {
                    header = _deserializer.Deserialize(maybeData.Value);
                }
                try
                {
                    var body = Maybe <IPooledBuffer> .Nothing;
                    var expectedBodyLength = GetBodyLengthHandler.Instance.Handle(header);
                    if (expectedBodyLength.HasValue)
                    {
                        body = await _connection.TryReadAsync().ConfigureAwait(false);

                        if (!body.HasValue)
                        {
                            break;
                        }
                        if (body.Value.Count != expectedBodyLength.Value)
                        {
                            try
                            {
                                throw new InvalidOperationException($"Received body length {body.Value.Count} does not equal to the specified in header: {header}");
                            }
                            finally
                            {
                                body.Value.Dispose();
                            }
                        }
                    }
                    try
                    {
                        var transportMessage = new TransportMessage(header, body);
                        _log.Debug("Message received: {0}", transportMessage);
                        await output.WriteAsync(transportMessage).ConfigureAwait(false);
                    }
                    catch
                    {
                        if (body.HasValue)
                        {
                            body.Value.Dispose();
                        }
                        throw;
                    }
                }
                catch
                {
                    header.Dispose();
                    throw;
                }
            }
            _log.Debug("Incoming messages completed");
        }