public void Send(IMessage msg, MessageQueueTransactionType transactionType)
{
switch (transactionType)
{
case MessageQueueTransactionType.Single:
using (IMessageQueueTransaction tx = provider.CreateMessageQueueTransaction())
{
try
{
Send(msg, tx);
tx.Commit();
}
catch (Exception e)
{
tx.Abort();
throw new MonoMessagingException(e.Message, e);
}
}
break;
case MessageQueueTransactionType.None:
Send(msg);
break;
case MessageQueueTransactionType.Automatic:
throw new NotSupportedException("Automatic transaction types not supported");
}
}
private IMessage DoReceive(IMessageQueueTransaction transaction,
TimeSpan timeout, IsMatch matcher, bool ack)
{
RabbitMQMessageQueueTransaction tx = (RabbitMQMessageQueueTransaction)transaction;
return(DoReceive((IMessagingContext)tx, timeout, matcher, ack));
}
private IMessage Run (IMessageQueueTransaction transaction,
RecieveDelegate r)
{
TxReceiver txr = new TxReceiver (this, r);
RabbitMQMessageQueueTransaction tx =
(RabbitMQMessageQueueTransaction) transaction;
return tx.RunReceive (txr.ReceiveInContext);
}
public EventPublisher(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_identityGenerator = serviceProvider.GetRequiredService <IIdentityGenerator>();
_publishedEventPersistenter = serviceProvider.GetRequiredService <IPublishedEventPersistenter>();
_messageQueueTransaction = serviceProvider.GetRequiredService <IMessageQueueTransaction>();
_messageSerializer = serviceProvider.GetRequiredService <IMessageSerializer>();
_logger = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <EventPublisher>();
TransactID = _identityGenerator.NextIdentity();
}
public void Send (IMessage msg, IMessageQueueTransaction transaction)
{
if (QRef == QueueReference.DEFAULT)
throw new MonoMessagingException ("Path has not been specified");
if (msg.BodyStream == null)
throw new ArgumentException ("Message is not serialized properly");
RabbitMQMessageQueueTransaction tx = (RabbitMQMessageQueueTransaction) transaction;
tx.RunSend (SendInContext, msg);
}
public void Send(IMessage msg, IMessageQueueTransaction transaction)
{
if (QRef == QueueReference.DEFAULT)
{
throw new MonoMessagingException("Path has not been specified");
}
if (msg.BodyStream == null)
{
throw new ArgumentException("Message is not serialized properly");
}
RabbitMQMessageQueueTransaction tx = (RabbitMQMessageQueueTransaction)transaction;
SetDeliveryInfo(msg, tx.Id);
tx.Send(QRef, msg);
}
private void SendMessage <T>(T message, IMessageQueueTransaction messageQueueTransaction)
{
var jsonSerializerSettings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
};
var queueMessage = new QueueMessage {
MessageBody = message.SerializeToJson(jsonSerializerSettings), MessageType = typeof(T)
};
using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(queueMessage.SerializeToJson(jsonSerializerSettings))))
{
var buffer = new byte[MaxMsmqMessageSize];
var correlationId = "";
var messageSize = memoryStream.Length;
var numberOfChunks = Convert.ToInt32(Math.Ceiling((double)messageSize / buffer.Length));
int bytes;
var chunk = 0;
Logger.Debug("Message send {QueueName} {Type} {%Message}", Name, queueMessage.MessageType.FullName, queueMessage.MessageBody);
if (!Transactional && numberOfChunks > 1)
{
throw new MessageSizeException(memoryStream.Length, buffer.Length, Transactional);
}
while ((bytes = memoryStream.Read(buffer, 0, buffer.Length)) > 0)
{
var mqMessage = new Message
{
AppSpecific = numberOfChunks,
CorrelationId = correlationId
};
mqMessage.BodyStream.Write(buffer, 0, bytes);
Logger.Debug("Sending message chunk ({Chunk}/{NumberOfChunks}) on {QueueName} {CorrelationId}", ++chunk, numberOfChunks, Name, correlationId);
MessageQueueManager.Send(MessageQueue, mqMessage, messageQueueTransaction?.Transaction);
correlationId = mqMessage.Id;
}
}
}
private ITransactionalMessage CreateTransactionalMessage(Stream stream, IMessageQueueTransaction messageQueueTransaction)
{
stream.Position = 0;
using (var streamReader = new StreamReader(stream, Encoding.UTF8))
{
var queueMessage = streamReader.ReadToEnd().DeserializeFromJson <QueueMessage>();
if (queueMessage != null)
{
Logger.Debug("Message received {QueueName} {Type} {%Message}", Name, queueMessage?.MessageType?.FullName, queueMessage?.MessageBody);
}
if (queueMessage == null)
{
messageQueueTransaction?.Commit();
messageQueueTransaction?.Dispose();
messageQueueTransaction = null;
}
return(new TransactionalMessage(queueMessage, messageQueueTransaction));
}
}
public IMessage Receive (TimeSpan timeout,
IMessageQueueTransaction transaction)
{
return Run (transaction, Receiver (timeout));
}
public IMessage RemoveCurrent (TimeSpan timeout, IMessageQueueTransaction transaction)
{
throw new NotImplementedException ();
}
private IMessage DoReceive (IMessageQueueTransaction transaction,
TimeSpan timeout, IsMatch matcher, bool ack)
{
RabbitMQMessageQueueTransaction tx = (RabbitMQMessageQueueTransaction) transaction;
return DoReceive ((IMessagingContext) tx, timeout, matcher, ack);
}
public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout,
IMessageQueueTransaction transaction)
{
return DoReceive (transaction, timeout, ByCorrelationId (id), true);
}
public IMessage ReceiveByCorrelationId (string id,
IMessageQueueTransaction transaction)
{
return DoReceive (transaction, noTime, ByCorrelationId (id), true);
}
public IMessage ReceiveByCorrelationId(string id,
IMessageQueueTransaction transaction)
{
return(DoReceive(transaction, noTime, ByCorrelationId(id), true));
}
public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout,
IMessageQueueTransaction transaction)
{
return Run (transaction, Receiver (timeout, ByCorrelationId (id)));
}
public IMessage RemoveCurrent (TimeSpan timeout, IMessageQueueTransaction transaction)
{
throw new NotSupportedException ("Unable to remove messages within a transaction");
}
internal MessageQueueTransaction(IMessageQueueTransaction delegateTx)
{
this.delegateTx = delegateTx;
}
public IMessage RemoveCurrent(IMessageQueueTransaction transaction)
{
throw new NotSupportedException("Unable to remove messages within a transaction");
}
internal MessageQueueTransaction (IMessageQueueTransaction delegateTx)
{
this.delegateTx = delegateTx;
}
public IMessage Receive(TimeSpan timeout,
IMessageQueueTransaction transaction)
{
return(DoReceive(transaction, timeout, null, true));
}
public IMessage ReceiveByCorrelationId(string id, TimeSpan timeout,
IMessageQueueTransaction transaction)
{
return(DoReceive(transaction, timeout, ByCorrelationId(id), true));
}
public IMessage Receive (IMessageQueueTransaction transaction)
{
return Run (transaction, Receiver());
}
public IMessage Receive (TimeSpan timeout,
IMessageQueueTransaction transaction)
{
return DoReceive (transaction, timeout, null, true);
}
public IMessage ReceiveByCorrelationId (string id,
IMessageQueueTransaction transaction)
{
return Run (transaction, Receiver (ByCorrelationId (id)));
}
public IMessage Receive (IMessageQueueTransaction transaction)
{
return DoReceive (transaction, TimeSpan.MaxValue, null, true);
}
/// <inheritdoc />
public TransactionalMessage()
{
_queueMessage = null;
_messageQueueTransaction = null;
}
public IMessage Receive(IMessageQueueTransaction transaction)
{
return(DoReceive(transaction, TimeSpan.MaxValue, null, true));
}
public IMessage RemoveCurrent(TimeSpan timeout, IMessageQueueTransaction transaction)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public TransactionalMessage(QueueMessage queueMessage, IMessageQueueTransaction messageQueueTransaction)
{
_queueMessage = queueMessage;
_messageQueueTransaction = messageQueueTransaction;
}
