public async Task <CommandResponseMessage> DecryptFieldsAsync(CommandResponseMessage encryptedResponseMessage, CancellationToken cancellationToken)
{
var encryptedDocumentBytes = GetEncryptedDocumentBytes(encryptedResponseMessage);
var unencryptedDocumentBytes = await _documentFieldDecryptor.DecryptFieldsAsync(encryptedDocumentBytes, cancellationToken).ConfigureAwait(false);
return(CreateUnencryptedResponseMessage(encryptedResponseMessage, unencryptedDocumentBytes));
}
public RabbitMQCommandSender(RabbitMQBusContext context)
{
Channel = context.Connection.CreateModel();
_replyQueueName = Channel.QueueDeclare("", false, false, true).QueueName;
_logger = NijnLogger.CreateLogger <RabbitMQCommandSender>();
_consumer = new EventingBasicConsumer(Channel);
_consumer.Received += (model, ea) =>
{
if (!_callbackMapper.TryRemove(ea.BasicProperties.CorrelationId, out var tcs))
{
return;
}
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
_logger.LogInformation("Received command answer with correlation id {0}", ea.BasicProperties.CorrelationId);
var commandResponse =
new CommandResponseMessage(message, ea.BasicProperties.Type, ea.BasicProperties.CorrelationId);
tcs.TrySetResult(commandResponse);
};
_logger.LogInformation("Created response queue with name {0}", _replyQueueName);
}
// public methods
public CommandResponseMessage DecryptFields(CommandResponseMessage encryptedResponseMessage, CancellationToken cancellationToken)
{
var encryptedDocumentBytes = GetEncryptedDocumentBytes(encryptedResponseMessage);
var unencryptedDocumentBytes = _documentFieldDecryptor.DecryptFields(encryptedDocumentBytes, cancellationToken);
return(CreateUnencryptedResponseMessage(encryptedResponseMessage, unencryptedDocumentBytes));
}
private byte[] GetEncryptedDocumentBytes(CommandResponseMessage encryptedResponseMessage)
{
var encryptedCommandMessage = encryptedResponseMessage.WrappedMessage;
var encryptedSections = encryptedCommandMessage.Sections;
var encryptedType0Section = (Type0CommandMessageSection <RawBsonDocument>)encryptedSections.Single();
var encryptedDocumentSlice = encryptedType0Section.Document.Slice;
var encryptedDocumentBytes = new byte[encryptedDocumentSlice.Length];
encryptedDocumentSlice.GetBytes(0, encryptedDocumentBytes, 0, encryptedDocumentBytes.Length);
return(encryptedDocumentBytes);
}
public void StartReceivingCommands(CommandReceivedCallback callback)
{
CheckDisposed();
var consumer = new EventingBasicConsumer(_channel);
_channel.BasicConsume(queue: QueueName,
autoAck: false,
consumerTag: "",
noLocal: false,
exclusive: false,
arguments: null,
consumer: consumer);
consumer.Received += (s, ea) =>
{
var body = ea.Body;
var props = ea.BasicProperties;
var replyProps = _channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
_logger.LogInformation("Received command request with correlation id {0}", ea.BasicProperties.CorrelationId);
var message = Encoding.UTF8.GetString(body);
CommandResponseMessage response = null;
try
{
response = callback(new CommandRequestMessage(message, props.CorrelationId)).Result;
replyProps.Type = response.MessageType.ToString();
}
catch (Exception e)
{
var realException = e.InnerException;
if (realException is TargetInvocationException)
{
realException = realException.InnerException;
}
response = new CommandResponseMessage(realException.Message, realException.GetType().FullName,
props.CorrelationId);
replyProps.Type = realException.GetType().FullName;
}
finally
{
_channel.BasicPublish(exchange: "",
routingKey: props.ReplyTo,
mandatory: false,
basicProperties: replyProps,
body: response?.EncodeMessage());
_channel.BasicAck(deliveryTag: ea.DeliveryTag,
multiple: false);
}
};
}
// 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();
}
private CommandResponseMessage AutoDecryptFieldsIfNecessary(CommandResponseMessage encryptedResponseMessage, CancellationToken cancellationToken)
{
if (_documentFieldDecryptor == null)
{
return(encryptedResponseMessage);
}
else
{
var messageFieldDecryptor = new CommandMessageFieldDecryptor(_documentFieldDecryptor, _messageEncoderSettings);
return(messageFieldDecryptor.DecryptFields(encryptedResponseMessage, cancellationToken));
}
}
private void ProcessCommandResponseMessage(CommandState state, CommandResponseMessage message, IByteBuffer buffer, ConnectionId connectionId, ObjectId?serviceId, MessageEncoderSettings encoderSettings)
{
var wrappedMessage = message.WrappedMessage;
var type0Section = wrappedMessage.Sections.OfType <Type0CommandMessageSection <RawBsonDocument> >().Single();
var reply = (BsonDocument)type0Section.Document;
BsonValue ok;
if (!reply.TryGetValue("ok", out ok))
{
// this is a degenerate case with the server and
// we don't really know what to do here...
return;
}
if (state.ShouldRedactReply)
{
reply = new BsonDocument();
}
if (ok.ToBoolean())
{
if (_succeededEvent != null)
{
_succeededEvent(new CommandSucceededEvent(
state.CommandName,
reply,
state.OperationId,
message.ResponseTo,
connectionId,
serviceId,
state.Stopwatch.Elapsed));
}
}
else
{
if (_failedEvent != null)
{
_failedEvent(new CommandFailedEvent(
state.CommandName,
new MongoCommandException(
connectionId,
string.Format("{0} command failed", state.CommandName),
null,
reply),
state.OperationId,
message.ResponseTo,
connectionId,
serviceId,
state.Stopwatch.Elapsed));
}
}
}
// private methods
private CommandResponseMessage CreateUnencryptedResponseMessage(CommandResponseMessage encryptedResponseMessage, byte[] unencryptedDocumentBytes)
{
var unencryptedDocument = new RawBsonDocument(unencryptedDocumentBytes);
var unencryptedSections = new[] { new Type0CommandMessageSection <RawBsonDocument>(unencryptedDocument, RawBsonDocumentSerializer.Instance) };
var encryptedCommandMessage = encryptedResponseMessage.WrappedMessage;
var unencryptedCommandMessage = new CommandMessage(
encryptedCommandMessage.RequestId,
encryptedCommandMessage.ResponseTo,
unencryptedSections,
encryptedCommandMessage.MoreToCome);
return(new CommandResponseMessage(unencryptedCommandMessage));
}
private static string CreateCompressedMessageJson(CommandResponseMessage message, CompressorType compressorType)
{
var textReader = new StringReader("");
var textWriter = new StringWriter();
var encoderSettings = new MessageEncoderSettings();
var commandMessageEncoder = new CommandMessageJsonEncoder(textReader, textWriter, encoderSettings);
var commandResponseMessageEncoder = new CommandResponseMessageJsonEncoder(commandMessageEncoder);
commandResponseMessageEncoder.WriteMessage(message);
var originalMessage = BsonDocument.Parse(textWriter.ToString());
return(CreateCompressedMessageJson(originalMessage, compressorType));
}
public void WriteMessage_should_delegate_to_wrapped_encoder()
{
var stream = new MemoryStream();
var subject = CreateSubject(stream);
var document = new BsonDocument("x", 1);
var sections = new[] { new Type0CommandMessageSection <BsonDocument>(document, BsonDocumentSerializer.Instance) };
var wrappedMessage = new CommandMessage(1, 2, sections, false);
var message = new CommandResponseMessage(wrappedMessage);
var expectedBytes = CreateMessageBytes(wrappedMessage);
subject.WriteMessage(message);
var result = stream.ToArray();
result.Should().Equal(expectedBytes);
}
public void WriteMessage_should_delegate_to_wrapped_encoder()
{
var textWriter = new StringWriter();
var subject = CreateSubject(textWriter: textWriter);
var document = new BsonDocument("x", 1);
var sections = new[] { new Type0CommandMessageSection <BsonDocument>(document, BsonDocumentSerializer.Instance) };
var wrappedMessage = new CommandMessage(1, 2, sections, false);
var message = new CommandResponseMessage(wrappedMessage);
var expectedJson = CreateMessageJson(wrappedMessage);
subject.WriteMessage(message);
var result = textWriter.ToString();
result.Should().Be(expectedJson);
}
public void StartReceivingCommands(CommandReceivedCallback callback)
{
if (_isListening)
{
throw new BusConfigurationException("Already listening to queuename " + QueueName);
}
new Task(() =>
{
var queue = Context.CommandQueues[QueueName];
while (true)
{
if (queue.Count == 0)
{
Thread.Sleep(250);
continue;
}
CommandResponseMessage response = null;
var command = queue.Dequeue();
string type = command.Props.Type;
try
{
response = callback.Invoke(command.Message as CommandRequestMessage).Result;
}
catch (Exception e)
{
var realException = e.InnerException;
response = new CommandResponseMessage(realException.Message, realException.GetType().ToString(), command.Props.CorrelationId);
type = realException.GetType().FullName;
}
finally
{
Context.CommandQueues[command.Props.ReplyTo].Enqueue(new TestBusCommandMessage(response,
new BasicProperties()
{
CorrelationId = command.Props.CorrelationId,
Type = type
}));
}
}
}).Start();
_isListening = true;
}
public async Task Handle(object s, BasicDeliverEventArgs ea, CommandReceivedCallback callback)
{
var body = ea.Body;
var props = ea.BasicProperties;
var replyProps = _channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
var message = Encoding.UTF8.GetString(body);
CommandResponseMessage response = null;
try
{
response = await callback(new CommandRequestMessage(message, props.CorrelationId));
replyProps.Type = response.MessageType.ToString();
}
catch (Exception e)
{
var realException = e.InnerException;
response = new CommandResponseMessage(realException.Message, realException.GetType().ToString(),
props.CorrelationId);
replyProps.Type = realException.GetType().ToString();
}
finally
{
_channel.BasicPublish(exchange: "",
routingKey: props.ReplyTo,
mandatory: false,
basicProperties: replyProps,
body: response?.EncodeMessage());
_channel.BasicAck(deliveryTag: ea.DeliveryTag,
multiple: false);
}
_log.LogInformation("Started listening for commands on queue {0} ", QueueName);
}
private async Task <CommandResponseMessage> AutoDecryptFieldsIfNecessaryAsync(CommandResponseMessage encryptedResponseMessage, CancellationToken cancellationToken)
{
if (_documentFieldDecryptor == null)
{
return(encryptedResponseMessage);
}
else
{
var messageFieldDecryptor = new CommandMessageFieldDecryptor(_documentFieldDecryptor, _messageEncoderSettings);
return(await messageFieldDecryptor.DecryptFieldsAsync(encryptedResponseMessage, cancellationToken).ConfigureAwait(false));
}
}
private void SaveResponseInfo(CommandResponseMessage response)
{
_previousRequestId = response.RequestId;
_moreToCome = response.WrappedMessage.MoreToCome;
}
/// <summary>
/// Writes the message.
/// </summary>
/// <param name="message">The message.</param>
public void WriteMessage(CommandResponseMessage message)
{
var wrappedMessage = message.WrappedMessage;
_wrappedEncoder.WriteMessage(wrappedMessage);
}
