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); }