/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="timeOut">The time out.</param>
/// <param name="queueWait">The queue wait.</param>
/// <returns></returns>
/// <exception cref="System.TimeoutException"></exception>
public IReceivedMessage <TReceivedMessage> Handle(IMessageId messageId, TimeSpan timeOut, IQueueWait queueWait)
{
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => queueWait, queueWait);
//use a message context, and talk to the transport directly
//we are not going to use the consumer queue, because we are going to re-use the calling thread for all of the work below
using (var context = _messageContextFactory.Create())
{
var recMessage = _receiveMessagesFactory.Create();
//set message Id on the context, so that the transport knows we want a particular message
context.Set(_configurationReceive.HeaderNames.StandardHeaders.RpcContext, _rpcContextFactory.Create(messageId, timeOut));
//use a stop watch to determine when we have timed out
var sw = new Stopwatch();
sw.Start();
while (true)
{
var messageRec = recMessage.ReceiveMessage(context);
if (messageRec != null)
{
_commitMessage.Commit(context);
return((IReceivedMessage <TReceivedMessage>)_messageHandler.GenerateMessage(messageRec));
}
if (sw.ElapsedMilliseconds >= timeOut.TotalMilliseconds)
{
throw new TimeoutException();
}
queueWait.Wait();
}
}
}
private async ValueTask FlushAndClean()
{
await Flush();
_lastCumulativeAck = (MessageId)IMessageId.Earliest;
_pendingIndividualAcks.Clear();
}
public int CompareTo(IMessageId o)
{
if (o is BatchMessageId bm)
{
var ord = 0;
var ledgercompare = _ledgerId.CompareTo(bm.LedgerId);
if (ledgercompare != 0)
{
ord = ledgercompare;
}
var entryCompare = EntryId.CompareTo(bm.EntryId);
if (entryCompare != 0 && ord == 0)
{
ord = entryCompare;
}
var partitionCompare = PartitionIndex.CompareTo(bm.PartitionIndex);
if (partitionCompare != 0 && ord == 0)
{
ord = partitionCompare;
}
var result = ledgercompare == 0 && entryCompare == 0 && partitionCompare == 0;
if (result && bm.BatchIndex > -1)
{
return(-1);
}
return(ord);
}
if (o is MessageId other)
{
var ledgerCompare = _ledgerId.CompareTo(other.LedgerId);
if (ledgerCompare != 0)
{
return(ledgerCompare);
}
var entryCompare = _entryId.CompareTo(other.EntryId);
if (entryCompare != 0)
{
return(entryCompare);
}
var partitionedCompare = _partitionIndex.CompareTo(other.PartitionIndex);
if (partitionedCompare != 0)
{
return(partitionedCompare);
}
return(0);
}
if (o is TopicMessageId impl)
{
return(CompareTo(impl.InnerMessageId));
}
throw new ArgumentException("expected MessageId object. Got instance of " + o.GetType().FullName);
}
private void BuildCommandInternal(SqlCommand selectCommand,
SqlTransaction transaction, IMessageId messageId, List <string> routes)
{
selectCommand.Transaction = transaction;
if (messageId != null && messageId.HasValue)
{
selectCommand.CommandText =
_createDequeueStatement.GetDeQueueCommand(true, routes);
selectCommand.Parameters.Add("@QueueID", SqlDbType.BigInt);
selectCommand.Parameters["@QueueID"].Value = messageId.Id.Value;
}
else
{
selectCommand.CommandText =
_createDequeueStatement.GetDeQueueCommand(false, routes);
}
if (_options.Value.EnableRoute && routes != null && routes.Count > 0)
{
var routeCounter = 1;
foreach (var route in routes)
{
selectCommand.Parameters.Add("@Route" + routeCounter, SqlDbType.VarChar);
selectCommand.Parameters["@Route" + routeCounter].Value = route;
routeCounter++;
}
}
}
protected internal virtual void OnAcknowledgeCumulative(IMessageId messageId, Exception exception)
{
if (Interceptors != null)
{
Interceptors.OnAcknowledgeCumulative(Self, messageId, exception);
}
}
/// <summary>
/// Returns the next message, if any.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// A message if one is found; null otherwise
/// </returns>
public async Task <IReceivedMessageInternal> GetMessageAsync(IMessageContext context)
{
//if stopping, exit now
if (_cancelToken.Tokens.Any(t => t.IsCancellationRequested))
{
return(null);
}
//check for a specific MessageID to pull
IMessageId messageId = null;
var rpc = context.Get(_configuration.HeaderNames.StandardHeaders.RpcContext);
if (rpc?.MessageId != null && rpc.MessageId.HasValue)
{
messageId = rpc.MessageId;
}
//ask for the next message, or a specific message if we have a messageID
var receivedTransportMessage = await
_receiveMessageAsync.Handle(new ReceiveMessageQueryAsync <IDbConnection, IDbTransaction>(null, null, messageId, _configuration.Routes)).ConfigureAwait(false);
//if no message (null) run the no message action and return
if (receivedTransportMessage == null)
{
return(null);
}
//set the message ID on the context for later usage
context.MessageId = receivedTransportMessage.MessageId;
return(receivedTransportMessage);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReceiveMessageQuery"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="id">The identifier.</param>
public ReceiveMessageQuery(IMessageContext context, IMessageId id)
{
Guard.NotNull(() => context, context);
MessageContext = context;
MessageId = id;
}
protected internal virtual void OnSendAcknowledgement(IMessage <T> message, IMessageId msgId, Exception exception)
{
if (Interceptors != null && message != null)
{
Interceptors.OnSendAcknowledgement(Self, message, msgId, exception);
}
}
private int RemoveMessagesTill(IMessageId msgId)
{
try
{
var removed = 0;
var iterator = MessageIdPartitionMap.Keys;
foreach (var i in iterator)
{
var messageId = i;
if (messageId.CompareTo(msgId) <= 0)
{
var exist = MessageIdPartitionMap[messageId];
exist?.Remove(messageId);
MessageIdPartitionMap.Remove(i, out var remove);
removed++;
}
}
return(removed);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
return(-1);
}
}
internal void BuildCommand(SQLiteCommand selectCommand, IMessageId messageId, CommandString commandString,
SqLiteMessageQueueTransportOptions options, List<string> routes )
{
if (messageId != null && messageId.HasValue)
{
selectCommand.CommandText = commandString.CommandText;
selectCommand.Parameters.Add("@QueueID", DbType.Int64);
selectCommand.Parameters.Add("@CurrentDateTime", DbType.Int64);
selectCommand.Parameters["@QueueID"].Value = messageId.Id.Value;
selectCommand.Parameters["@CurrentDateTime"].Value =
_getTime.GetCurrentUtcDate().Ticks;
}
else
{
selectCommand.CommandText = commandString.CommandText;
selectCommand.Parameters.Add("@CurrentDateTime", DbType.Int64);
selectCommand.Parameters["@CurrentDateTime"].Value =
_getTime.GetCurrentUtcDate().Ticks;
}
if (options.EnableRoute && routes != null && routes.Count > 0)
{
var routeCounter = 1;
foreach (var route in routes)
{
selectCommand.Parameters.Add("@Route" + routeCounter.ToString(), DbType.AnsiString);
selectCommand.Parameters["@Route" + routeCounter.ToString()].Value = route;
routeCounter++;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResponseId"/> class.
/// </summary>
/// <param name="messageId">The identifier.</param>
/// <param name="timeOut">The time out.</param>
public ResponseId(IMessageId messageId, TimeSpan timeOut)
{
Guard.NotNull(() => messageId, messageId);
MessageId = messageId;
TimeOut = timeOut;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReceiveMessageQuery{TConnection, TTransaction}" /> class.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="transaction">The transaction.</param>
/// <param name="messageId">A specific message identifier to de-queue. If null, the first message found will be de-queued.</param>
/// <param name="routes">The routes.</param>
public ReceiveMessageQueryAsync(TConnection connection, TTransaction transaction, IMessageId messageId, List <string> routes)
{
Connection = connection;
Transaction = transaction;
MessageId = messageId;
Routes = routes;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReceiveMessageQuery{TConnection, TTransaction}" /> class.
/// </summary>
/// <param name="messageId">A specific message identifier to de-queue. If null, the first message found will be de-queued.</param>
/// <param name="routes">The routes.</param>
public ReceiveMessageQueryAsync(IMessageId messageId, List <string> routes)
{
Connection = default(TConnection);
Transaction = default(TTransaction);
MessageId = messageId;
Routes = routes;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResponseId"/> class.
/// </summary>
/// <param name="messageId">The identifier.</param>
/// <param name="timeOut">The time out.</param>
public ResponseId(IMessageId messageId, TimeSpan timeOut)
{
Guard.NotNull(() => messageId, messageId);
MessageId = messageId;
TimeOut = timeOut;
}
public AcknowledgeWithTxn(IMessageId messageId, IDictionary <string, long> properties, IActorRef txn)
{
MessageId = messageId;
AckType = AckType.Individual;
Properties = properties;
Txn = txn;
}
/// <summary>
/// Adds the message identifier tag.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="id">The identifier.</param>
public static void AddMessageIdTag(this ISpan span, IMessageId id)
{
if (id != null && id.HasValue)
{
span.SetTag("MessageId", id.Id.Value.ToString());
}
}
/// <summary>
/// Creates a new instance of <see cref="IReceivedMessageInternal"/>
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <returns></returns>
public IReceivedMessageInternal Create(IMessage message, IMessageId messageId, ICorrelationId correlationId)
{
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => message, message);
Guard.NotNull(() => correlationId, correlationId);
return(new ReceivedMessageInternal(message, messageId, correlationId));
}
private void DoCumulativeAckAsync(MessageId msgId)
{
if (msgId.CompareTo(_lastCumulativeAck) > 0)
{
_lastCumulativeAck = msgId;
_cumulativeAckFlushRequired = true;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SentMessage"/> class.
/// </summary>
/// <param name="messageId">The identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public SentMessage(IMessageId messageId, ICorrelationId correlationId)
{
//NOTE - null messageID's are allowed, as this indicates a failure by the transport to send
Guard.NotNull(() => correlationId, correlationId);
MessageId = messageId;
CorrelationId = correlationId;
}
public IEnumerable<IMessageId> GetChanges(IMessageId startId, long sinceSeq, out long lastSeq)
{
// Get changes after sinceSeq, and drop messages at or before _startId
Replicate();
lastSeq = GetLastSeq();
return Enumerable.Range((int) sinceSeq + 1, (int) (lastSeq - sinceSeq)).Select(seqId => MessageIdManager.Create(_docInfos[seqId].DocId)).
OrderBy(mId => mId).SkipWhile(mId => mId.CompareTo(startId) <= 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="SentMessage"/> class.
/// </summary>
/// <param name="messageId">The identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public SentMessage(IMessageId messageId, ICorrelationId correlationId)
{
//NOTE - null messageID's are allowed, as this indicates a failure by the transport to send
Guard.NotNull(() => correlationId, correlationId);
MessageId = messageId;
CorrelationId = correlationId;
}
/// <inheritdoc />
public IDictionary <string, object> GetHeaders(IMessageId id)
{
if (id != null && id.HasValue)
{
return(_commandHandler.Handle(new GetHeaderQuery((long)id.Id.Value)));
}
return(null);
}
/// <summary>
/// Creates a new instance of <see cref="IReceivedMessageInternal"/>
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <returns></returns>
public IReceivedMessageInternal Create(IMessage message, IMessageId messageId, ICorrelationId correlationId)
{
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => message, message);
Guard.NotNull(() => correlationId, correlationId);
return new ReceivedMessageInternal(message, messageId, correlationId);
}
/// <summary>
/// Gets the headers for the specified message if possible
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns>
/// null if the headers could not be obtained; otherwise a collection with 0 or more records
/// </returns>
public IDictionary <string, object> GetHeaders(IMessageId id)
{
if (id != null && id.HasValue)
{
return(_dataStorage.GetHeaders((Guid)id.Id.Value));
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResetHeartBeatOutput"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="headers">The headers.</param>
/// <param name="approximateResetTimeStart">The approximate reset time start.</param>
/// <param name="approximateResetTimeEnd">The approximate reset time end.</param>
public ResetHeartBeatOutput(IMessageId messageId, IReadOnlyDictionary <string, object> headers,
DateTime approximateResetTimeStart, DateTime approximateResetTimeEnd)
{
MessageId = messageId;
Headers = headers;
ApproximateResetTimeStart = approximateResetTimeStart;
ApproximateResetTimeEnd = approximateResetTimeEnd;
}
public async ValueTask AcknowledgeAsync(IMessageId messageId)
{
var ask = await _consumerActor.Ask <AskResponse>(new AcknowledgeMessageId(messageId)).ConfigureAwait(false);
if (ask.Failed)
{
throw ask.Exception;
}
}
public void Send(IMessageId msg, string name, params object[] args)
{
Node.Send(new RpcMail{
To = Remote,
From = Id,
MessageId = msg.As<MessageId>(),
Message = new FunctionCall(name, args),
});
}
/// <summary>
/// Creates new instance of <see cref="IRedisQueueWorkSub" /> that will only respond if the specified ID is sent
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
public IRedisQueueWorkSub Create(IMessageId id)
{
if (id == null || !id.HasValue)
{
return Create();
}
//return a new instance
return new RedisQueueWorkSubRpc(_connection, _redisNames, _cancelWork, id);
}
/// <inheritdoc />
public IRedisQueueWorkSub Create(IMessageId id)
{
if (id == null || !id.HasValue)
{
return(Create());
}
//return a new instance
return(new RedisQueueWorkSubRpc(_connection, _redisNames, _cancelWork, id));
}
public int CompareTo(IMessageId o)
{
var m = InnerMessageId as BatchMessageId;
if (m != null)
{
return(m.CompareTo(o));
}
return(((MessageId)InnerMessageId).CompareTo(o));
}
/// <inheritdoc />
public RemoveMessageStatus Remove(IMessageId id, RemoveMessageReason reason)
{
if (id == null || !id.HasValue)
{
return(RemoveMessageStatus.NotFound);
}
var result = _deleteMessage.Handle(new DeleteMessageCommand <string>(id.Id.Value.ToString()));
return(result ? RemoveMessageStatus.Removed : RemoveMessageStatus.NotFound);
}
/// <inheritdoc />
public RemoveMessageStatus Remove(IMessageId id, RemoveMessageReason reason)
{
if (id == null || !id.HasValue)
{
return(RemoveMessageStatus.NotFound);
}
var result = _deleteMessage.Handle(new DeleteMessageCommand((RedisQueueId)id));
return(result ? RemoveMessageStatus.Removed : RemoveMessageStatus.NotFound);
}
/// <summary>
/// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public ReceivedMessageInternal(IMessage message, IMessageId messageId, ICorrelationId correlationId)
{
Guard.NotNull(() => message, message);
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => correlationId, correlationId);
Body = message.Body;
MessageId = messageId;
CorrelationId = correlationId;
Headers = new ReadOnlyDictionary <string, object>(message.Headers.ToDictionary(entry => entry.Key,
entry => entry.Value));
}
/// <summary>
/// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public ReceivedMessageInternal(IMessage message, IMessageId messageId, ICorrelationId correlationId)
{
Guard.NotNull(() => message, message);
Guard.NotNull(() => messageId, messageId);
Guard.NotNull(() => correlationId, correlationId);
Body = message.Body;
MesssageId = messageId;
CorrelationId = correlationId;
Headers = new ReadOnlyDictionary<string, object>(message.Headers.ToDictionary(entry => entry.Key,
entry => entry.Value));
}
/// <inheritdoc />
public RemoveMessageStatus Remove(IMessageId id, RemoveMessageReason reason)
{
if (id != null && id.HasValue)
{
var result = _deleteMessageCommandHandler.Handle(new DeleteMessageCommand((long)id.Id.Value));
if (result > 0)
{
return(RemoveMessageStatus.Removed);
}
}
return(RemoveMessageStatus.NotFound);
}
public static long GetOffset(IMessageId messageId)
{
var msgId = (MessageId)messageId;
var ledgerId = msgId.LedgerId;
var entryId = msgId.EntryId;
// Combine ledger id and entry id to form offset
// Use less than 32 bits to represent entry id since it will get
// rolled over way before overflowing the max int range
var offset = (ledgerId << 28) | entryId;
return(offset);
}
// If all messageId in map are same Size, and all bigger/smaller than the other, return valid value.
public int CompareTo(IMessageId o)
{
if (!(o is MultiMessageId))
{
throw new ArgumentException("expected MultiMessageId object. Got instance of " + o.GetType().FullName);
}
var other = (MultiMessageId)o;
var otherMap = other.Map;
if ((Map == null || Map.Count == 0) && (otherMap == null || otherMap.Count == 0))
{
return(0);
}
if (otherMap == null || Map == null || otherMap.Count != Map.Count)
{
throw new ArgumentException("Current Size and other Size not equals");
}
var result = 0;
foreach (var entry in HashMapHelper.SetOfKeyValuePairs(Map))
{
if (!otherMap.TryGetValue(entry.Key, out var otherMessage))
{
throw new ArgumentException("Other MessageId not have topic " + entry.Key);
}
var currentResult = entry.Value.CompareTo(otherMessage);
if (result == 0)
{
result = currentResult;
}
else if (currentResult == 0)
{
continue;
}
else if (result != currentResult)
{
throw new ArgumentException("Different MessageId in Map get different compare result");
}
else
{
continue;
}
}
return(result);
}
public IEnumerable<IMessageId> GetChanges(IMessageId startId, long sinceSeq, out long lastSeq)
{
// Get changes after sinceSeq, throw out non-messages e.g. design doc updates, and drop messages at or before _startId
// Loveseat doesn't have a _changes call, so it has to be done like this.
var changes = _db.GetDocument(string.Format("_changes?since={0}&filter=filters/nodeletions", sinceSeq));
// Changes are returned as
// {"results":[{"seq":28312,"id":"04b8dbf49b5d2603","changes":[{"rev":"1-ea426b58321d93c39a3486cc4d55abe2"}]},
// ...
// {"seq":28313,"id":"_design/mce","changes":[{"rev":"9-4d4ec5b438064ab0d602f2ed2ea9ac34"}]}
// ],
// "last_seq":28313}
lastSeq = (long) changes["last_seq"];
return changes["results"].Select(jObj => (string) jObj["id"]).Where(MessageIdManager.IsMessageId).Select(MessageIdManager.Create)
.OrderBy(mId => mId).SkipWhile(mId => mId.CompareTo(startId) <= 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="RedisQueueWorkSubRpc"/> class.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="redisNames">The redis names.</param>
/// <param name="cancelWork">The cancel work.</param>
/// <param name="messageId">The message identifier.</param>
public RedisQueueWorkSubRpc(IRedisConnection connection,
RedisNames redisNames,
IQueueCancelWork cancelWork,
IMessageId messageId)
{
Guard.NotNull(() => connection, connection);
Guard.NotNull(() => redisNames, redisNames);
Guard.NotNull(() => cancelWork, cancelWork);
_connection = connection;
_redisNames = redisNames;
_cancelWork = cancelWork;
_messageId = messageId;
_waitHandle = new ManualResetEventSlim(false);
_waitHandle.Set();
}
private object GetReturnValue(MethodInfo method, IMessageId msg)
{
if (method.ReturnType == typeof(void)) return null;
if (method.IsGenericMethod && typeof(Task).IsAssignableFrom(method.ReturnType))
{
return TaskEx.New(() =>
{
var mail = Remote.Receive(msg);
var returnType = method.ReturnType.GetGenericArguments()[0];
return mail.As<RpcMail>().Message.Args[0].Convert(returnType);
}, method.ReturnType);
}
else
{
var mail = Remote.Receive(msg).Result;
if (!mail.HasValue || mail.Value.As<RpcMail>().Message.Args.Length == 0)
{
if (method.ReturnType.IsClass) return null;
return method.ReturnType.CreateInstance();
}
return mail.Value.As<RpcMail>().Message.Args[0].Convert(method.ReturnType);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="inner">The inner.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
public MessageException(string message, Exception inner, IMessageId messageId, ICorrelationId correlationId)
: base(message, inner)
{
MessageId = messageId;
CorrelationId = correlationId;
}
/// <summary>
/// Creates a new instance of <see cref="IResponseId" />
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="timeOut">The time out.</param>
/// <returns></returns>
public IResponseId Create(IMessageId messageId, TimeSpan timeOut)
{
Guard.NotNull(() => messageId, messageId);
return new ResponseId(messageId, timeOut);
}
/// <summary>
/// Creates new instance of <see cref="IRpcContext" />
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="timeout">The timeout.</param>
/// <returns></returns>
public IRpcContext Create(IMessageId messageId, TimeSpan? timeout)
{
Guard.NotNull(() => messageId, messageId);
return new RpcContext(messageId, timeout);
}
/// <summary>
/// Initializes a new instance of the <see cref="RpcContext"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="timeOut">The time out.</param>
public RpcContext(IMessageId messageId, TimeSpan? timeOut)
{
Guard.NotNull(() => messageId, messageId);
MessageId = messageId;
Timeout = timeOut;
}
/// <summary>
/// Initializes a new instance of the <see cref="HeartBeatStatus"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="lastHeartBeatTime">The last heart beat time.</param>
public HeartBeatStatus(IMessageId messageId, DateTime? lastHeartBeatTime)
{
Guard.NotNull(() => messageId, messageId);
MessageId = messageId;
LastHeartBeatTime = lastHeartBeatTime;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="inner">The inner.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <param name="messagePayload">The raw message payload.</param>
/// <param name="headerPayload">The raw header payload.</param>
public PoisonMessageException(string message, Exception inner, IMessageId messageId, ICorrelationId correlationId, byte[] messagePayload, byte[] headerPayload)
: base(message, inner, messageId, correlationId)
{
MessagePayload = messagePayload;
HeaderPayload = headerPayload;
}
public bool Equals(IMessageId other)
{
var utcOther = (UtcIdMessageId) other;
return _timeBits == utcOther._timeBits && _suffix == utcOther._suffix;
}
public void Reply(IActorId to, IMessageId msg, string name, params object[] args)
{
node.Reply(to, id, msg, name, args);
}
/// <summary>
/// Gets the next message from the queue
/// </summary>
/// <param name="context">The context.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns></returns>
private RedisMessage GetMessage(IMessageContext context, IMessageId messageId)
{
var message = _receiveMessage.Handle(new ReceiveMessageQuery(context, messageId));
if (message == null) return null;
if (!message.Expired)
{
context.MessageId = message.Message.MesssageId;
}
return message;
}
/// <summary>
/// Gets the next message from the queue
/// </summary>
/// <param name="context">The context.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns></returns>
private async Task<RedisMessage> GetMessageAsync(IMessageContext context, IMessageId messageId)
{
var message = await _receiveMessageAsync.Handle(new ReceiveMessageQueryAsync(context, messageId)).ConfigureAwait(false);
if (message == null) return null;
if (!message.Expired)
{
context.MessageId = message.Message.MesssageId;
}
return message;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
public MessageException(IMessageId messageId, ICorrelationId correlationId, string format, params object[] args)
: base(string.Format(format, args))
{
MessageId = messageId;
CorrelationId = correlationId;
}
public bool Equals(IMessageId other)
{
if(other == null || other.GetType() != GetType())
return false;
return ((MessageId)other).id == id;
}
public int CompareTo(IMessageId other)
{
var utcOther = (UtcIdMessageId) other;
var highCompare = _timeBits.CompareTo(utcOther._timeBits);
return highCompare == 0 ? String.Compare(_suffix, utcOther._suffix, StringComparison.Ordinal) : highCompare;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageException"/> class.
/// </summary>
/// <param name="messageId">The message identifier.</param>
/// <param name="correlationId">The correlation identifier.</param>
/// <param name="messagePayload">The raw message payload.</param>
/// <param name="headerPayload">The raw header payload.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
public PoisonMessageException(IMessageId messageId, ICorrelationId correlationId, byte[] messagePayload, byte[] headerPayload, string format, params object[] args)
: base(string.Format(format, args), messageId, correlationId)
{
MessagePayload = messagePayload;
HeaderPayload = headerPayload;
}
