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