/// <summary> /// Declares a queue and binds it to an exchange. Exchanges allow messages to be sent to more than one queue. Exchange-bound queues are useful when a /// receiver needs to consume broadcast messages. /// </summary> /// <param name="channel"></param> /// <param name="queueName"></param> internal static TQueueType CreateExchangeBoundMessageQueue <TQueueType>(MessageClientBase parentMessageClient, IModel channel, string clientName, string exchangeName, string queueName, bool durable, bool autoDelete, MessageTagCollection subscriptionTags) where TQueueType : MessageQueue, new() { var queue = new TQueueType() { Channel = channel, queueInfo = channel.QueueDeclare( queue: queueName, durable: durable, exclusive: true, autoDelete: autoDelete), _clientName = clientName, ParentMessageClient = parentMessageClient, boundExchangeName = exchangeName }; if (!subscriptionTags.Any()) { channel.QueueBind(queueName, exchangeName, ""); } else { var map = new Dictionary <string, object>(); map.Add("x-match", "any"); foreach (var item in subscriptionTags) { map.Add(item.GetMangledTagAndValue(), ""); } channel.QueueBind(queueName, exchangeName, "", map); } return(queue); }
public static LoggerConfiguration DistributedWorkersSink( this LoggerSinkConfiguration loggerConfiguration, MessageClientBase client, IFormatProvider formatProvider = null) { if (loggerConfiguration == null) { throw new ArgumentNullException(nameof(loggerConfiguration)); } return(loggerConfiguration.Sink(new DistributedWorkersSerilogSink(client, formatProvider))); }
internal static TQueueType CreateExchangeBoundMessageQueue <TQueueType>(MessageClientBase parentMessageClient, IModel channel, string clientName, string exchangeName, string queueName, bool durable, bool autoDelete, params MessageTag[] subscriptionTags) where TQueueType : MessageQueue, new() { return(CreateExchangeBoundMessageQueue <TQueueType>( parentMessageClient, channel, clientName, exchangeName, queueName, durable, autoDelete, new MessageTagCollection(subscriptionTags))); }
internal static TQueueType CreateMessageQueue <TQueueType>(MessageClientBase parentMessageClient, IModel channel, string clientName, string queueName, bool durable, bool autoDelete) where TQueueType : MessageQueue, new() { var queue = new TQueueType() { Channel = channel, queueInfo = channel.QueueDeclare( queue: queueName, durable: durable, exclusive: false, autoDelete: autoDelete), _clientName = clientName, ParentMessageClient = parentMessageClient }; return(queue); }
/// <summary> /// Serializes the message into a binary format. /// </summary> /// <returns></returns> internal byte[] Serialize(MessageClientBase messageClient, string clientName, EncryptionOption encryptionOption) { var formatter = new BinaryFormatter(); byte[] data; using (MemoryStream stream = new MemoryStream()) { formatter.Serialize(stream, this); stream.Seek(0, SeekOrigin.Begin); data = new byte[stream.Length]; if (stream.Read(data, 0, data.Length) != data.Length) { throw new Exception(); } } byte[] iv = null; MessageSerializationWrapper header; if (encryptionOption == EncryptionOption.EncryptWithPrivateKey) { (data, iv) = messageClient.EncryptDataWithClientKey(data, clientName); } else if (encryptionOption == EncryptionOption.EncryptWithSystemSharedKey) { (data, iv) = messageClient.EncryptDataWithSystemSharedKey(data); } byte[] signature = messageClient.SignData(data); if (encryptionOption != EncryptionOption.None) { header = new MessageSerializationWrapper(signature, iv, encryptionOption); } else { header = new MessageSerializationWrapper(signature); } byte[] output = new byte[header.Length + data.Length]; header.CopyTo(output, 0); data.CopyTo(output, header.Length); return(output); }
public MessageClientRegisteredEventArgs(MessageClientBase messageClient) { MessageClient = messageClient; }
private static MessageEnvelope Deserialize(byte[] bytes, string exchange, ulong deliveryTag, bool redelivered, string routingKey, IBasicProperties basicProperties, MessageClientBase messageClient) { var envelope = MessageEnvelope.Deserialize(bytes, messageClient); envelope.Exchange = exchange; envelope.DeliveryTag = deliveryTag; envelope.Redelivered = redelivered; envelope.RoutingKey = routingKey; envelope.BasicProperties = basicProperties; if (basicProperties != null && basicProperties.Headers != null) { List <MessageTag> tags = new List <MessageTag>(); foreach (var key in basicProperties.Headers.Keys) { tags.Add(MessageTag.DemangleTag(key)); } envelope.Tags = tags.ToArray(); } return(envelope); }
/// <summary> /// /// </summary> /// <param name="bytes"></param> /// <returns></returns> /// <remarks> /// Message Wrapper Format: /// /// [ Info Bits ][ Info Numbers ][ Sender Name ][ IV - Optional][ Serialized Message (encryption optional)][ Signature ] /// /// </remarks> private static MessageEnvelope Deserialize(byte[] bytes, MessageClientBase messageClient) { var envelope = new MessageEnvelope(); try { var bits = new BitVector32(BitConverter.ToInt32(bytes, 0)); //var isClientAnnounce = bits[isClientAnnounceMask]; //var isClientAnnounceResponse = bits[isClientAnnounceResponseMask]; var numbers = new BitVector32(BitConverter.ToInt32(bytes, 4)); var signatureLength = numbers[signatureLengthSection]; envelope._encryptionOption = (EncryptionOption)numbers[encryptionOptionSection]; var senderIdentityLength = numbers[senderNameLengthSection]; var ivLength = numbers[ivLengthSection]; var sharedKeyId = numbers[sharedKeyIdSection]; int index = 8; envelope.Timestamp = new DateTime(BitConverter.ToInt64(bytes, index)); index += sizeof(long); envelope.SenderIdentityHash = Encoding.UTF8.GetString(bytes, index, senderIdentityLength); index += senderIdentityLength; //var iv = bytes[(index)..(index + ivLength)]; var iv = bytes.RangeByLength(index, ivLength); index += ivLength; var signature = bytes.RangeFromEnd(signatureLength); if (signatureLength != messageClient.SignatureLength) { throw new NotImplementedException("Signautre length is invalid."); } envelope.SignatureVerificationStatus = messageClient.ValidateSignature(bytes.RangeExcludeLast(signatureLength), signature, envelope.SenderIdentityHash); if (envelope.SignatureVerificationStatus != SignatureVerificationStatus.SignatureValid) { //TODO: Add back: throw new IdentityException(envelope.SignatureVerificationStatus.ToString()); } // Get the bytes representing the message //byte[] messageBytes = bytes[index..^signatureLength]; byte[] messageBytes = bytes.RangeExcludeLast(index, signatureLength); // Decrypt the bytes if necessary if (envelope._encryptionOption == EncryptionOption.EncryptWithPrivateKey) { messageBytes = messageClient.DecryptDataWithClientKey(messageBytes, envelope.SenderIdentityHash, iv); } else if (envelope._encryptionOption == EncryptionOption.EncryptWithSystemSharedKey) { messageBytes = messageClient.DecryptDataWithSystemSharedKey(messageBytes, iv, envelope.Timestamp); } // Deserialize the message envelope.Message = MessageBase.Deserialize(messageBytes); return(envelope); } catch (Exception e) { throw; } }
internal static MessageEnvelope Deserialize(byte[] bytes, BasicGetResult result, MessageClientBase messageClient) { if (result == null) { throw new ArgumentNullException(nameof(result)); } var envelope = Deserialize( bytes, result.Exchange, result.DeliveryTag, result.Redelivered, result.RoutingKey, result.BasicProperties, messageClient); return(envelope); }
internal static MessageEnvelope Deserialize(byte[] bytes, BasicDeliverEventArgs e, MessageClientBase messageClient) { if (e == null) { throw new ArgumentNullException(nameof(e)); } var envelope = Deserialize( bytes, e.Exchange, e.DeliveryTag, e.Redelivered, e.RoutingKey, e.BasicProperties, messageClient); return(envelope); }
public static MessageEnvelope WrapMessage(MessageBase message, string recipientIdentityHash, MessageClientBase messageClient, EncryptionOption encryptionOption) { if (string.IsNullOrEmpty(recipientIdentityHash) && encryptionOption == EncryptionOption.EncryptWithPrivateKey) { throw new ArgumentOutOfRangeException(nameof(recipientIdentityHash), $"{nameof(recipientIdentityHash)} cannot be empty if encryption is set to private key."); } if (messageClient == null) { throw new ArgumentNullException(nameof(messageClient)); } var wrapper = new MessageEnvelope(); wrapper.Message = message; wrapper.SenderIdentityHash = messageClient.Identity.IdentityHash; wrapper._messageClient = messageClient; wrapper._encryptionOption = encryptionOption; wrapper.RecipientIdentityHash = recipientIdentityHash; wrapper.Timestamp = DateTime.Now; return(wrapper); }
public DistributedWorkersSerilogSink(MessageClientBase client, IFormatProvider formatProvider) { messageClient = client; _formatProvider = formatProvider; }
internal static MessageBase Deserialize(MessageEnvelope wrapper, BasicGetResult result, MessageClientBase messageClient) { if (result == null) { throw new ArgumentNullException(nameof(result)); } return(Deserialize( wrapper, result.Exchange, result.DeliveryTag, result.Redelivered, result.RoutingKey, result.BasicProperties, messageClient)); }
internal static MessageBase Deserialize(MessageEnvelope wrapper, BasicDeliverEventArgs e, MessageClientBase messageClient) { if (e == null) { throw new ArgumentNullException(nameof(e)); } return(Deserialize( wrapper, e.Exchange, e.DeliveryTag, e.Redelivered, e.RoutingKey, e.BasicProperties, messageClient)); }
internal void RegisterClient(MessageClientBase client) { MessageClient = client; MessageClientRegistered?.Invoke(this, new MessageClientRegisteredEventArgs(client)); }