示例#1
0
 public MsgBodyReader(IGenericBsonSerializer <T> serializer, ResponseMsgMessage message)
 {
     Serializer   = serializer;
     Message      = message;
     CursorResult = new CursorResult <T>
     {
         MongoCursor = new MongoCursor <T>
         {
             Items = CursorItemsPool <T> .Pool.Get()
         }
     };
 }
示例#2
0
        private async Task StartReadAsync()
        {
            if (_reader is null)
            {
                ThrowHelper.ConnectionException <bool>(_endpoint);
            }

            _logger.LogInformation($"Channel {_channelNum} start reading");
            MongoResponseMessage message;
            // TaskCompletionSourceWithCancellation<MongoResponseMessage>? completion;
            ParserCompletion?completion;

            while (_shutdownToken.IsCancellationRequested == false)
            {
                try
                {
                    var headerResult = await _reader.ReadAsync(MessageHeaderReader, _shutdownToken.Token)
                                       .ConfigureAwait(false);

                    _reader.Advance();

                    _logger.GotMessage(headerResult.Message.ResponseTo);
                    switch (headerResult.Message.Opcode)
                    {
                    case Opcode.Reply:
                        _logger.GotReplyMessage(headerResult.Message.ResponseTo);
                        var replyResult = await _reader.ReadAsync(ReplyMessageReader, _shutdownToken.Token)
                                          .ConfigureAwait(false);

                        _reader.Advance();
                        message = new ReplyMessage(headerResult.Message, replyResult.Message);
                        break;

                    case Opcode.OpMsg:
                        _logger.GotMsgMessage(headerResult.Message.ResponseTo);
                        var msgResult = await _reader.ReadAsync(MsgMessageReader, _shutdownToken.Token)
                                        .ConfigureAwait(false);

                        _reader.Advance();
                        message = new ResponseMsgMessage(headerResult.Message, msgResult.Message);
                        break;

                    case Opcode.Message:
                    case Opcode.Update:
                    case Opcode.Insert:
                    case Opcode.Query:
                    case Opcode.GetMore:
                    case Opcode.Delete:
                    case Opcode.KillCursors:
                    case Opcode.Compressed:
                    default:
                        _logger.UnknownOpcodeMessage(headerResult.Message);
                        if (_completionMap.TryGetValue(headerResult.Message.ResponseTo, out completion))
                        {
                            completion.CompletionSource.TrySetException(
                                new NotSupportedException($"Opcode '{headerResult.Message.Opcode}' not supported"));
                        }

                        continue;
                        //TODO: need to read pipe to end
                        break;
                    }

                    if (_completionMap.TryGetValue(message.Header.ResponseTo, out completion))
                    {
                        var result = await completion.ParseAsync(message).ConfigureAwait(false);

                        completion.CompletionSource.TrySetResult(result);
                    }
                    else
                    {
                        _logger.LogError("Message not found");
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e.ToString());
                }
            }
        }
示例#3
0
 public MsgType0BodyReader(IGenericBsonSerializer <T> serializer, ResponseMsgMessage message)
     : base(serializer, message)
 {
     _payloadLength = message.Header.MessageLength;
     _state         = ParserState.Initial;
 }
 public MsgType1BodyReader(IGenericBsonSerializer <T> serializer, ResponseMsgMessage message)
     : base(serializer, message)
 {
 }