public QueueMessageVisualization get_message_Port_QueueName_SourceInstanceId_MessageId(
MessageInputModel input)
{
var messageId = new MessageId
{
MessageIdentifier = input.MessageId,
SourceInstanceId = input.SourceInstanceId
};
var message = retrieveMessage(messageId, input.Port, input.QueueName);
if (message == null)
{
return new QueueMessageVisualization {NotFound = true};
}
var envelope = message.ToEnvelope();
envelope.UseSerializer(_serializer);
// TODO -- show errors if in error queue
var model = new QueueMessageVisualization
{
MessageId = messageId,
QueueName = message.Queue,
SubQueueName = message.SubQueue,
Status = message.Status,
SentAt = message.SentAt,
Headers = message.Headers.ToDictionary(),
Port = input.Port
};
try
{
// TODO -- gotta watch how big this monster would be
model.Payload = JsonSerialization.ToJson(envelope.Message, true);
}
catch (Exception)
{
model.Payload = "Could not render as JSON";
}
return model;
}
public void Setup()
{
_queue = ObjectMother.QueueManager();
_queue.Start();
_receiver = ObjectMother.QueueManager("test2", 23457);
using (var tx = new TransactionScope())
{
_messageId = _queue.Send(
new Uri("lq.tcp://localhost:23457/h"),
new MessagePayload
{
Data = new byte[] {1, 2, 4, 5}
});
tx.Complete();
}
}
public PersistentMessageToSend GetMessageCurrentlySendingById(MessageId id)
{
AssertNotDisposedOrDisposing();
return _queueStorage.Send(actions => actions.GetMessageToSendById(id.MessageIdentifier));
}
public PersistentMessageToSend GetSentMessageById(MessageId id)
{
AssertNotDisposedOrDisposing();
return _queueStorage.Global(actions => actions.GetSentMessageById(id.MessageIdentifier));
}
public HistoryMessage GetProcessedMessageById(string queueName, MessageId id)
{
AssertNotDisposedOrDisposing();
return _queueStorage.Global(actions => actions.GetQueue(queueName).GetProcessedMessageById(id.MessageIdentifier));
}
public PersistentMessage PeekById(MessageId id)
{
var enumerator = _messages.GetEnumerator(new MessageIdIndex(id));
while(enumerator.MoveNext())
{
var bookmark = enumerator.Current;
bookmark.QueueName = _queueName;
var status = (MessageStatus) _messages.ForColumnType<IntColumn>().Get("status");
if (status != MessageStatus.ReadyToDeliver)
continue;
return _messages.ReadMessageWithId<PersistentMessage>(bookmark, _queueName);
}
return null;
}
public static void EnqueueDirectlyTo(this ITransactionalScope scope, string queue, MessagePayload payload, MessageId id = null)
{
scope.QueueManager.EnqueueDirectlyTo(scope.Transaction, queue, null, payload, id);
}
public PersistentMessage PeekById(string queueName, MessageId id)
{
PersistentMessage message = null;
_queueStorage.Global(actions =>
{
var queue = actions.GetQueue(queueName);
message = queue.PeekById(id);
});
return message;
}
public void EnqueueDirectlyTo(string queue, string subqueue, MessagePayload payload, MessageId id = null)
{
EnsureEnlistment();
EnqueueDirectlyTo(_enlistment, queue, subqueue, payload);
}
public void MarkReceived(MessageId id)
{
recveivedMsgs.Insert(() =>
{
recveivedMsgs.ForColumnType<GuidColumn>().Set("instance_id", id.SourceInstanceId);
recveivedMsgs.ForColumnType<GuidColumn>().Set("msg_id", id.MessageIdentifier);
});
}
public bool Equals(MessageId other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other.SourceInstanceId.Equals(SourceInstanceId) && other.MessageIdentifier.Equals(MessageIdentifier);
}
public PersistentMessage PeekById(MessageId id)
{
var enumerator = _messages.GetEnumerator(new MessageIdIndex(id));
while(enumerator.MoveNext())
{
var bookmark = enumerator.Current;
bookmark.QueueName = _queueName;
return _messages.ReadMessageWithId<PersistentMessage>(bookmark, _queueName);
}
return null;
}
public MessageIdIndex(MessageId id)
: base("by_id")
{
_id = id;
}
public static Message ReceiveById(this ITransactionalScope scope, string queue, MessageId id)
{
return scope.QueueManager.ReceiveById(scope.Transaction, queue, id);
}
public Message ReceiveById(string queueName, MessageId id)
{
EnsureEnlistment();
return ReceiveById(_enlistment, queueName, id);
}
public QueueMessageVisualization get_message_details_Port_QueueName_SourceInstanceId_MessageId(
MessageInputModel input)
{
var messageId = new MessageId
{
MessageIdentifier = input.MessageId,
SourceInstanceId = input.SourceInstanceId
};
var message = RetrieveMessage(messageId, input.Port, input.QueueName);
if (message == null)
{
_fubuRequest.Set(new QueueMessageNotFound
{
Id = messageId,
QueueName = input.QueueName
});
return null;
}
var envelope = message.ToEnvelope();
envelope.UseSerializer(_serializer);
return new QueueMessageVisualization
{
MessageId = messageId,
QueueName = message.Queue,
SubQueueName = message.SubQueue,
Status = message.Status,
SentAt = message.SentAt,
Headers = message.Headers,
Payload = envelope.Message
};
}
public Message ReceiveById(ITransaction transaction, string queueName, MessageId id)
{
var message = _queueStorage.Global(actions =>
{
var queue = actions.GetQueue(queueName);
var msg = queue.PeekById(id);
if (msg == null)
return null;
queue.SetMessageStatus(msg.Bookmark, MessageStatus.Processing);
actions.RegisterUpdateToReverse(transaction.Id, msg.Bookmark, MessageStatus.ReadyToDeliver, null);
return msg;
});
return message;
}
private PersistentMessage RetrieveMessage(MessageId messageId, int port, string queueName)
{
var request = new QueueMessageRetrievalRequest
{
Port = port,
QueueName = queueName,
MessageId = new MessageId
{
MessageIdentifier = messageId.MessageIdentifier,
SourceInstanceId = messageId.SourceInstanceId
}
};
return _queueMessageRetrieval.GetSingleMessageInQueue(request);
}
public void EnqueueDirectlyTo(ITransaction transaction, string queue, string subqueue, MessagePayload payload, MessageId id = null)
{
var message = new PersistentMessage
{
Data = payload.Data,
Headers = payload.Headers,
Id = id ?? new MessageId
{
SourceInstanceId = _queueStorage.Id,
MessageIdentifier = GuidCombGenerator.Generate()
},
Queue = queue,
SentAt = DateTime.Now,
SubQueue = subqueue,
Status = MessageStatus.EnqueueWait
};
_queueStorage.Global(actions =>
{
var queueActions = actions.GetQueue(queue);
var bookmark = queueActions.Enqueue(message);
actions.RegisterUpdateToReverse(transaction.Id, bookmark, MessageStatus.EnqueueWait, subqueue);
});
_logger.QueuedForReceive(message);
lock (_newMessageArrivedLock)
{
Monitor.PulseAll(_newMessageArrivedLock);
}
}
public ErrorQueueMessageVisualization get_error_message_details_Port_QueueName_SourceInstanceId_MessageId(
ErrorMessageInputModel input)
{
var messageId = new MessageId
{
MessageIdentifier = input.MessageId,
SourceInstanceId = input.SourceInstanceId
};
var message = RetrieveMessage(messageId, input.Port, input.QueueName);
if (message == null)
{
_fubuRequest.Set(new QueueMessageNotFound
{
Id = messageId,
QueueName = input.QueueName
});
return null;
}
var errorReport = ErrorReport.Deserialize(message.Data);
var exceptionDetails = new ExceptionDetails
{
Explanation = errorReport.Explanation,
ExceptionType = errorReport.ExceptionType,
ExceptionMessage = errorReport.ExceptionMessage,
ExceptionText = errorReport.ExceptionText
};
var envelope = new Envelope(new NameValueHeaders(message.Headers)) {Data = errorReport.RawData};
envelope.UseSerializer(_serializer);
return new ErrorQueueMessageVisualization
{
MessageId = messageId,
QueueName = message.Queue,
SubQueueName = message.SubQueue,
Status = message.Status,
SentAt = message.SentAt,
Headers = message.Headers,
Payload = envelope.Message,
ExceptionDetails = exceptionDetails
};
}
public MessageId Send(ITransaction transaction, Uri uri, MessagePayload payload)
{
if (_waitingForAllMessagesToBeSent)
throw new CannotSendWhileWaitingForAllMessagesToBeSentException("Currently waiting for all messages to be sent, so we cannot send. You probably have a race condition in your application.");
var parts = uri.AbsolutePath.Substring(1).Split('/');
var queue = parts[0];
string subqueue = null;
if (parts.Length > 1)
{
subqueue = string.Join("/", parts.Skip(1).ToArray());
}
Guid msgId = Guid.Empty;
var port = uri.Port;
if (port == -1)
port = 2200;
var destination = new Endpoint(uri.Host, port);
_queueStorage.Global(actions =>
{
msgId = actions.RegisterToSend(destination, queue,
subqueue, payload, transaction.Id);
});
var messageId = new MessageId
{
SourceInstanceId = _queueStorage.Id,
MessageIdentifier = msgId
};
var message = new Message
{
Id = messageId,
Data = payload.Data,
Headers = payload.Headers,
Queue = queue,
SubQueue = subqueue
};
_logger.QueuedForSend(message, destination);
return messageId;
}
public Message PeekById(MessageId id)
{
return queueManager.PeekById(queueName, id);
}
