public async Task <ResponseMessage> ReceiveMessageAsync(
int responseTo,
IMessageEncoderSelector encoderSelector,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(encoderSelector, nameof(encoderSelector));
ThrowIfDisposedOrNotOpen();
var helper = new ReceiveMessageHelper(this, responseTo, messageEncoderSettings, _compressorSource);
try
{
helper.ReceivingMessage();
using (var buffer = await ReceiveBufferAsync(responseTo, cancellationToken).ConfigureAwait(false))
{
var message = helper.DecodeMessage(buffer, encoderSelector, cancellationToken);
helper.ReceivedMessage(buffer, message);
return(message);
}
}
catch (Exception ex)
{
helper.FailedReceivingMessage(ex);
throw;
}
}
public void ReceiveMessageAsync_should_throw_an_ArgumentNullException_when_the_encoderSelector_is_null()
{
IMessageEncoderSelector encoderSelector = null;
Action act = () => _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None).Wait();
act.ShouldThrow <ArgumentNullException>();
}
public ResponseMessage ReceiveMessage(
int responseTo,
IMessageEncoderSelector encoderSelector,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(encoderSelector, nameof(encoderSelector));
ThrowIfDisposedOrNotOpen();
var helper = new ReceiveMessageHelper(this, responseTo, messageEncoderSettings);
try
{
helper.ReceivingMessage();
using (var buffer = ReceiveBuffer(responseTo, cancellationToken))
{
var message = helper.DecodeMessage(buffer, encoderSelector, cancellationToken);
helper.ReceivedMessage(buffer, message);
return(message);
}
}
catch (Exception ex)
{
helper.FailedReceivingMessage(ex);
throw;
}
}
public ResponseMessage DecodeMessage(IByteBuffer buffer, IMessageEncoderSelector encoderSelector, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_stopwatch.Stop();
_networkDuration = _stopwatch.Elapsed;
ResponseMessage message;
_stopwatch.Restart();
using (var stream = new ByteBufferStream(buffer, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings, _compressorSource);
var opcode = PeekOpcode(stream);
if (opcode == Opcode.Compressed)
{
var compresedMessageEncoder = encoderFactory.GetCompressedMessageEncoder(encoderSelector);
var compressedMessage = (CompressedMessage)compresedMessageEncoder.ReadMessage();
message = (ResponseMessage)compressedMessage.OriginalMessage;
}
else
{
var encoder = encoderSelector.GetEncoder(encoderFactory);
message = (ResponseMessage)encoder.ReadMessage();
}
}
_stopwatch.Stop();
_deserializationDuration = _stopwatch.Elapsed;
return(message);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompressedMessageBinaryEncoder" /> class.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="originalEncoderSelector">The original encoder selector.</param>
/// <param name="compressorSource">The compressor source.</param>
/// <param name="encoderSettings">The encoder settings.</param>
public CompressedMessageBinaryEncoder(
Stream stream,
IMessageEncoderSelector originalEncoderSelector,
ICompressorSource compressorSource,
MessageEncoderSettings encoderSettings)
: base(stream, encoderSettings)
{
_compressorSource = Ensure.IsNotNull(compressorSource, nameof(compressorSource));
_encoderSettings = encoderSettings; // can be null
_originalEncoderSelector = originalEncoderSelector;
}
// static constructor
static CompressedMessageJsonEncoderTests()
{
var document = new BsonDocument("x", 1);
var sections = new[] { new Type0CommandMessageSection <BsonDocument>(document, BsonDocumentSerializer.Instance) };
var commandMessage = new CommandMessage(__requestId, __responseId, sections, false);
__originalMessage = new CommandResponseMessage(commandMessage);
__jsonMessage = CreateCompressedMessageJson(__originalMessage, __compressorType);
__testMessage = new CompressedMessage(__originalMessage, null, __compressorType);
__originalEncoderSelector = new CommandResponseMessageEncoderSelector();
}
public ResponseMessage ReceiveMessage(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
try
{
return(_connection.ReceiveMessage(responseTo, encoderSelector, messageEncoderSettings, cancellationToken));
}
catch (MongoConnectionException ex)
{
EnrichExceptionDetails(ex);
throw;
}
}
public async Task <ResponseMessage> ReceiveMessageAsync(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
try
{
return(await _connection.ReceiveMessageAsync(responseTo, encoderSelector, messageEncoderSettings, cancellationToken).ConfigureAwait(false));
}
catch (MongoConnectionException ex)
{
EnrichExceptionDetails(ex);
throw;
}
}
public async Task <ResponseMessage> ReceiveMessageAsync(
int responseTo,
IMessageEncoderSelector encoderSelector,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(encoderSelector, nameof(encoderSelector));
ThrowIfDisposedOrNotOpen();
try
{
if (_receivingMessageEventHandler != null)
{
_receivingMessageEventHandler(new ConnectionReceivingMessageEvent(_connectionId, responseTo));
}
ResponseMessage reply;
var stopwatch = Stopwatch.StartNew();
using (var buffer = await ReceiveBufferAsync(responseTo, cancellationToken).ConfigureAwait(false))
{
stopwatch.Stop();
var networkDuration = stopwatch.Elapsed;
cancellationToken.ThrowIfCancellationRequested();
stopwatch.Restart();
using (var stream = new ByteBufferStream(buffer))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, messageEncoderSettings);
var encoder = encoderSelector.GetEncoder(encoderFactory);
reply = (ResponseMessage)encoder.ReadMessage();
}
stopwatch.Stop();
if (_receivedMessageEventHandler != null)
{
_receivedMessageEventHandler(new ConnectionReceivedMessageEvent(_connectionId, responseTo, buffer.Length, networkDuration, stopwatch.Elapsed));
}
}
return(reply);
}
catch (Exception ex)
{
if (_failedReceivingMessageEventHandler != null)
{
_failedReceivingMessageEventHandler(new ConnectionReceivingMessageFailedEvent(_connectionId, responseTo, ex));
}
throw;
}
}
public async Task <ResponseMessage> ReceiveMessageAsync(
int responseTo,
IMessageEncoderSelector encoderSelector,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(encoderSelector, "encoderSelector");
ThrowIfDisposedOrNotOpen();
try
{
if (_listener != null)
{
_listener.ConnectionBeforeReceivingMessage(new ConnectionBeforeReceivingMessageEvent(_connectionId, responseTo));
}
var stopwatch = Stopwatch.StartNew();
ResponseMessage 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 = encoderSelector.GetEncoder(encoderFactory);
reply = (ResponseMessage)encoder.ReadMessage();
}
}
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionAfterReceivingMessage(new ConnectionAfterReceivingMessageEvent(_connectionId, reply, length, stopwatch.Elapsed));
}
return(reply);
}
catch (Exception ex)
{
if (_listener != null)
{
_listener.ConnectionErrorReceivingMessage(new ConnectionErrorReceivingMessageEvent(_connectionId, responseTo, ex));
}
throw;
}
}
public void ReceiveMessage_should_throw_an_ArgumentNullException_when_the_encoderSelector_is_null(
[Values(false, true)]
bool async)
{
IMessageEncoderSelector encoderSelector = null;
Action act;
if (async)
{
act = () => _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act = () => _subject.ReceiveMessage(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
act.ShouldThrow <ArgumentNullException>();
}
public ResponseMessage DecodeMessage(IByteBuffer buffer, IMessageEncoderSelector encoderSelector, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_stopwatch.Stop();
_networkDuration = _stopwatch.Elapsed;
ResponseMessage message;
_stopwatch.Restart();
using (var stream = new ByteBufferStream(buffer, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings);
var encoder = encoderSelector.GetEncoder(encoderFactory);
message = (ResponseMessage)encoder.ReadMessage();
}
_stopwatch.Stop();
_deserializationDuration = _stopwatch.Elapsed;
return(message);
}
public async Task<ResponseMessage> ReceiveMessageAsync(
int responseTo,
IMessageEncoderSelector encoderSelector,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(encoderSelector, nameof(encoderSelector));
ThrowIfDisposedOrNotOpen();
var helper = new ReceiveMessageHelper(this, responseTo, messageEncoderSettings);
try
{
helper.ReceivingMessage();
using (var buffer = await ReceiveBufferAsync(responseTo, cancellationToken).ConfigureAwait(false))
{
var message = helper.DecodeMessage(buffer, encoderSelector, cancellationToken);
helper.ReceivedMessage(buffer, message);
return message;
}
}
catch (Exception ex)
{
helper.FailedReceivingMessage(ex);
throw;
}
}
public Task <ResponseMessage> ReceiveMessageAsync(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
return(Task.FromResult((ResponseMessage)_replyMessages.Dequeue()));
}
public ResponseMessage ReceiveMessage(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
return((ResponseMessage)_replyMessages.Dequeue());
}
public ResponseMessage DecodeMessage(IByteBuffer buffer, IMessageEncoderSelector encoderSelector, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_stopwatch.Stop();
_networkDuration = _stopwatch.Elapsed;
ResponseMessage message;
_stopwatch.Restart();
using (var stream = new ByteBufferStream(buffer, ownsBuffer: false))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings);
var encoder = encoderSelector.GetEncoder(encoderFactory);
message = (ResponseMessage)encoder.ReadMessage();
}
_stopwatch.Stop();
_deserializationDuration = _stopwatch.Elapsed;
return message;
}
public Task<ResponseMessage> ReceiveMessageAsync(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
return _connection.ReceiveMessageAsync(responseTo, encoderSelector, messageEncoderSettings, cancellationToken);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="CompressedMessageJsonEncoder"/> class.
/// </summary>
/// <param name="textReader">The text reader.</param>
/// <param name="textWriter">The text writer.</param>
/// <param name="originalEncoderSelector">The original encoder selector.</param>
/// <param name="encoderSettings">The encoder settings.</param>
public CompressedMessageJsonEncoder(TextReader textReader, TextWriter textWriter, IMessageEncoderSelector originalEncoderSelector, MessageEncoderSettings encoderSettings)
: base(textReader, textWriter, encoderSettings)
{
_originalEncoderSelector = originalEncoderSelector;
_encoderSettings = encoderSettings;
}
/// <inheritdoc />
public IMessageEncoder GetCompressedMessageEncoder(IMessageEncoderSelector originalEncoderSelector)
{
return(new CompressedMessageJsonEncoder(_textReader, _textWriter, originalEncoderSelector, _encoderSettings));
}
public Task<ResponseMessage> ReceiveMessageAsync(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
ThrowIfDisposed();
return _reference.Instance.ReceiveMessageAsync(responseTo, encoderSelector, messageEncoderSettings, cancellationToken);
}
public Task <ResponseMessage> ReceiveMessageAsync(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
ThrowIfDisposed();
return(_reference.Instance.ReceiveMessageAsync(responseTo, encoderSelector, messageEncoderSettings, cancellationToken));
}
public Task <ResponseMessage> ReceiveMessageAsync(int responseTo, IMessageEncoderSelector encoderSelector, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken)
{
return(_connection.ReceiveMessageAsync(responseTo, encoderSelector, messageEncoderSettings, cancellationToken));
}
public async Task<ResponseMessage> ReceiveMessageAsync(
int responseTo,
IMessageEncoderSelector encoderSelector,
MessageEncoderSettings messageEncoderSettings,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(encoderSelector, nameof(encoderSelector));
ThrowIfDisposedOrNotOpen();
try
{
if (_receivingMessageEventHandler != null)
{
_receivingMessageEventHandler(new ConnectionReceivingMessageEvent(_connectionId, responseTo, EventContext.OperationId));
}
ResponseMessage reply;
var stopwatch = Stopwatch.StartNew();
using (var buffer = await ReceiveBufferAsync(responseTo, cancellationToken).ConfigureAwait(false))
{
stopwatch.Stop();
var networkDuration = stopwatch.Elapsed;
cancellationToken.ThrowIfCancellationRequested();
stopwatch.Restart();
using (var stream = new ByteBufferStream(buffer))
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, messageEncoderSettings);
var encoder = encoderSelector.GetEncoder(encoderFactory);
reply = (ResponseMessage)encoder.ReadMessage();
}
stopwatch.Stop();
if (_commandEventHelper.ShouldCallAfterReceiving)
{
_commandEventHelper.AfterReceiving(reply, buffer, _connectionId, messageEncoderSettings);
}
if (_receivedMessageEventHandler != null)
{
_receivedMessageEventHandler(new ConnectionReceivedMessageEvent(_connectionId, responseTo, buffer.Length, networkDuration, stopwatch.Elapsed, EventContext.OperationId));
}
}
return reply;
}
catch (Exception ex)
{
if (_commandEventHelper.ShouldCallErrorReceiving)
{
_commandEventHelper.ErrorReceiving(responseTo, _connectionId, ex);
}
if (_failedReceivingMessageEventHandler != null)
{
_failedReceivingMessageEventHandler(new ConnectionReceivingMessageFailedEvent(_connectionId, responseTo, ex, EventContext.OperationId));
}
throw;
}
}
/// <inheritdoc />
public IMessageEncoder GetCompressedMessageEncoder(IMessageEncoderSelector originalEncoderSelector)
{
return(new CompressedMessageBinaryEncoder(_stream, originalEncoderSelector, _compressorSource, _encoderSettings));
}
/// <summary>
/// Represents a compressed message encoder selector.
/// </summary>
/// <param name="originalEncoderSelector">The original encoder.</param>
public CompressedMessageEncoderSelector(IMessageEncoderSelector originalEncoderSelector)
{
_originalEncoderSelector = Ensure.IsNotNull(originalEncoderSelector, nameof(originalEncoderSelector));
}
