public async Task <ReplyMessage <TDocument> > ReceiveMessageAsync <TDocument>(
int responseTo,
IBsonSerializer <TDocument> serializer,
MessageEncoderSettings messageEncoderSettings,
TimeSpan timeout,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(serializer, "serializer");
Ensure.IsInfiniteOrGreaterThanOrEqualToZero(timeout, "timeout");
ThrowIfDisposedOrNotOpen();
var slidingTimeout = new SlidingTimeout(timeout);
try
{
if (_listener != null)
{
_listener.ConnectionBeforeReceivingMessage(_connectionId, responseTo);
}
var stopwatch = Stopwatch.StartNew();
var buffer = await _inboundDropbox.ReceiveAsync(responseTo, slidingTimeout, cancellationToken).ConfigureAwait(false);
int length = buffer.Length;
ReplyMessage <TDocument> reply;
using (var stream = new ByteBufferStream(buffer, ownsByteBuffer: true))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, messageEncoderSettings);
var encoder = encoderFactory.GetReplyMessageEncoder <TDocument>(serializer);
reply = encoder.ReadMessage();
}
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionAfterReceivingMessage <TDocument>(_connectionId, reply, length, stopwatch.Elapsed);
}
return(reply);
}
catch (Exception ex)
{
if (_listener != null)
{
_listener.ConnectionErrorReceivingMessage(_connectionId, responseTo, ex);
}
throw;
}
}
public async Task <ReplyMessage <TDocument> > ReceiveMessageAsync <TDocument>(
int responseTo,
IBsonSerializer <TDocument> serializer,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(serializer, "serializer");
ThrowIfDisposedOrNotOpen();
try
{
if (_listener != null)
{
_listener.ConnectionBeforeReceivingMessage(new ConnectionBeforeReceivingMessageEvent(_connectionId, responseTo));
}
var stopwatch = Stopwatch.StartNew();
ReplyMessage <TDocument> reply;
int length;
using (var buffer = await ReceiveBufferAsync(responseTo, cancellationToken).ConfigureAwait(false))
{
cancellationToken.ThrowIfCancellationRequested();
length = buffer.Length;
using (var stream = new ByteBufferStream(buffer))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, messageEncoderSettings);
var encoder = encoderFactory.GetReplyMessageEncoder <TDocument>(serializer);
reply = (ReplyMessage <TDocument>)encoder.ReadMessage();
}
}
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionAfterReceivingMessage <TDocument>(new ConnectionAfterReceivingMessageEvent <TDocument>(_connectionId, reply, length, stopwatch.Elapsed));
}
return(reply);
}
catch (Exception ex)
{
if (_listener != null)
{
_listener.ConnectionErrorReceivingMessage(new ConnectionErrorReceivingMessageEvent(_connectionId, responseTo, ex));
}
throw;
}
}
private TCommandResult ProcessReply(ConnectionId connectionId, ReplyMessage <RawBsonDocument> reply)
{
if (reply.NumberReturned == 0)
{
throw new MongoCommandException(connectionId, "Command returned no documents.", _command);
}
if (reply.NumberReturned > 1)
{
throw new MongoCommandException(connectionId, "Command returned multiple documents.", _command);
}
if (reply.QueryFailure)
{
var failureDocument = reply.QueryFailureDocument;
throw ExceptionMapper.Map(connectionId, failureDocument) ?? new MongoCommandException(connectionId, "Command failed.", _command, failureDocument);
}
using (var rawDocument = reply.Documents[0])
{
if (!rawDocument.GetValue("ok", false).ToBoolean())
{
var binaryReaderSettings = new BsonBinaryReaderSettings();
if (_messageEncoderSettings != null)
{
binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict);
binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy);
}
;
var materializedDocument = rawDocument.Materialize(binaryReaderSettings);
var commandName = _command.GetElement(0).Name;
if (commandName == "$query")
{
commandName = _command["$query"].AsBsonDocument.GetElement(0).Name;
}
var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, materializedDocument, "errmsg");
if (notPrimaryOrNodeIsRecoveringException != null)
{
throw notPrimaryOrNodeIsRecoveringException;
}
string message;
BsonValue errmsgBsonValue;
if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString)
{
var errmsg = errmsgBsonValue.ToString();
message = string.Format("Command {0} failed: {1}.", commandName, errmsg);
}
else
{
message = string.Format("Command {0} failed.", commandName);
}
var mappedException = ExceptionMapper.Map(connectionId, materializedDocument);
if (mappedException != null)
{
throw mappedException;
}
throw new MongoCommandException(connectionId, message, _command, materializedDocument);
}
using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings);
var encoder = (ReplyMessageBinaryEncoder <TCommandResult>)encoderFactory.GetReplyMessageEncoder <TCommandResult>(_resultSerializer);
using (var reader = encoder.CreateBinaryReader())
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_resultSerializer.Deserialize(context));
}
}
}
}
private void ProcessReplyMessage(CommandState state, ResponseMessage message, IByteBuffer buffer, ConnectionId connectionId, MessageEncoderSettings encoderSettings)
{
state.Stopwatch.Stop();
bool disposeOfDocuments = false;
var replyMessage = message as ReplyMessage <RawBsonDocument>;
if (replyMessage == null)
{
// ReplyMessage is generic, which means that we can't use it here, so, we need to use a different one...
using (var stream = new ByteBufferStream(buffer, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, encoderSettings);
replyMessage = (ReplyMessage <RawBsonDocument>)encoderFactory
.GetReplyMessageEncoder(RawBsonDocumentSerializer.Instance)
.ReadMessage();
disposeOfDocuments = true;
}
}
try
{
if (replyMessage.CursorNotFound ||
replyMessage.QueryFailure ||
(state.ExpectedResponseType != ExpectedResponseType.Query && replyMessage.Documents.Count == 0))
{
var queryFailureDocument = replyMessage.QueryFailureDocument;
if (__securitySensitiveCommands.Contains(state.CommandName))
{
queryFailureDocument = new BsonDocument();
}
if (_failedEvent != null)
{
_failedEvent(new CommandFailedEvent(
state.CommandName,
new MongoCommandException(
connectionId,
string.Format("{0} command failed", state.CommandName),
null,
queryFailureDocument),
state.OperationId,
replyMessage.ResponseTo,
connectionId,
state.Stopwatch.Elapsed));
}
}
else
{
switch (state.ExpectedResponseType)
{
case ExpectedResponseType.Command:
ProcessCommandReplyMessage(state, replyMessage, connectionId);
break;
case ExpectedResponseType.GLE:
ProcessGLEReplyMessage(state, replyMessage, connectionId);
break;
case ExpectedResponseType.Query:
ProcessQueryReplyMessage(state, replyMessage, connectionId);
break;
}
}
}
finally
{
if (disposeOfDocuments && replyMessage.Documents != null)
{
replyMessage.Documents.ForEach(d => d.Dispose());
}
}
}
private void ProcessReplyMessage(CommandState state, ResponseMessage message, IByteBuffer buffer, ConnectionId connectionId, MessageEncoderSettings encoderSettings)
{
state.Stopwatch.Stop();
bool disposeOfDocuments = false;
var replyMessage = message as ReplyMessage<RawBsonDocument>;
if (replyMessage == null)
{
// ReplyMessage is generic, which means that we can't use it here, so, we need to use a different one...
using (var stream = new ByteBufferStream(buffer, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, encoderSettings);
replyMessage = (ReplyMessage<RawBsonDocument>)encoderFactory
.GetReplyMessageEncoder(RawBsonDocumentSerializer.Instance)
.ReadMessage();
disposeOfDocuments = true;
}
}
try
{
if (replyMessage.CursorNotFound ||
replyMessage.QueryFailure ||
(state.ExpectedResponseType != ExpectedResponseType.Query && replyMessage.Documents.Count == 0))
{
var queryFailureDocument = replyMessage.QueryFailureDocument;
if (__securitySensitiveCommands.Contains(state.CommandName))
{
queryFailureDocument = new BsonDocument();
}
if (_failedEvent != null)
{
_failedEvent(new CommandFailedEvent(
state.CommandName,
new MongoCommandException(
connectionId,
string.Format("{0} command failed", state.CommandName),
null,
queryFailureDocument),
state.OperationId,
replyMessage.ResponseTo,
connectionId,
state.Stopwatch.Elapsed));
}
}
else
{
switch (state.ExpectedResponseType)
{
case ExpectedResponseType.Command:
ProcessCommandReplyMessage(state, replyMessage, connectionId);
break;
case ExpectedResponseType.GLE:
ProcessGLEReplyMessage(state, replyMessage, connectionId);
break;
case ExpectedResponseType.Query:
ProcessQueryReplyMessage(state, replyMessage, connectionId);
break;
}
}
}
finally
{
if (disposeOfDocuments && replyMessage.Documents != null)
{
replyMessage.Documents.ForEach(d => d.Dispose());
}
}
}
private TCommandResult ProcessReply(ConnectionId connectionId, ReplyMessage <RawBsonDocument> reply)
{
if (reply.NumberReturned == 0)
{
throw new MongoCommandException(connectionId, "Command returned no documents.", _command);
}
if (reply.NumberReturned > 1)
{
throw new MongoCommandException(connectionId, "Command returned multiple documents.", _command);
}
if (reply.QueryFailure)
{
var failureDocument = reply.QueryFailureDocument;
throw ExceptionMapper.Map(connectionId, failureDocument) ?? new MongoCommandException(connectionId, "Command failed.", _command, failureDocument);
}
using (var rawDocument = reply.Documents[0])
{
var binaryReaderSettings = new BsonBinaryReaderSettings();
if (_messageEncoderSettings != null)
{
binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict);
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy);
}
#pragma warning restore 618
}
;
BsonValue clusterTime;
if (rawDocument.TryGetValue("$clusterTime", out clusterTime))
{
// note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime
// and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also
var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings);
_session.AdvanceClusterTime(materializedClusterTime);
}
BsonValue operationTime;
if (rawDocument.TryGetValue("operationTime", out operationTime))
{
_session.AdvanceOperationTime(operationTime.AsBsonTimestamp);
}
if (!rawDocument.GetValue("ok", false).ToBoolean())
{
var materializedDocument = rawDocument.Materialize(binaryReaderSettings);
var commandName = _command.GetElement(0).Name;
if (commandName == "$query")
{
commandName = _command["$query"].AsBsonDocument.GetElement(0).Name;
}
var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, _command, materializedDocument, "errmsg");
if (notPrimaryOrNodeIsRecoveringException != null)
{
throw notPrimaryOrNodeIsRecoveringException;
}
string message;
BsonValue errmsgBsonValue;
if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString)
{
var errmsg = errmsgBsonValue.ToString();
message = string.Format("Command {0} failed: {1}.", commandName, errmsg);
}
else
{
message = string.Format("Command {0} failed.", commandName);
}
var mappedException = ExceptionMapper.Map(connectionId, materializedDocument);
if (mappedException != null)
{
throw mappedException;
}
throw new MongoCommandException(connectionId, message, _command, materializedDocument);
}
if (rawDocument.Contains("writeConcernError"))
{
var materializedDocument = rawDocument.Materialize(binaryReaderSettings);
var writeConcernError = materializedDocument["writeConcernError"].AsBsonDocument;
var message = writeConcernError.AsBsonDocument.GetValue("errmsg", null)?.AsString;
var writeConcernResult = new WriteConcernResult(materializedDocument);
throw new MongoWriteConcernException(connectionId, message, writeConcernResult);
}
using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings);
var encoder = (ReplyMessageBinaryEncoder <TCommandResult>)encoderFactory.GetReplyMessageEncoder <TCommandResult>(_resultSerializer);
using (var reader = encoder.CreateBinaryReader())
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_resultSerializer.Deserialize(context));
}
}
}
}
public void GetReplyMessageEncoder_should_return_a_ReplyMessageBinaryEncoder()
{
using (var stream = new MemoryStream())
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, null);
var encoder = encoderFactory.GetReplyMessageEncoder<BsonDocument>(BsonDocumentSerializer.Instance);
encoder.Should().BeOfType<ReplyMessageBinaryEncoder<BsonDocument>>();
}
}