/// <summary>
///
/// </summary>
/// <param name="message"></param>
public void AddMessage(Message message)
{
lock (_messages)
{
_messages.Add(message);
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
public bool Post(Message message)
{
string msgType = null;
_storage.AddMessage(message);
if (message.Headers.TryGetValue(MessageHeaders.MessageType, out msgType))
{
var queueNames = _queueMap[msgType];
if (queueNames == null)
return false;
foreach (var item in queueNames)
{
Queue queue;
if (_queues.TryGetValue(item, out queue))
{
queue.Enqueue(message.Clone());
return true;
}
}
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
public void UpdateMessage(Message message)
{
if (_messages != null)
{
Message existing = null;
lock (_messages)
{
existing = _messages.Single(x => x.MessageId == message.MessageId);
}
if (existing != null)
{
existing.Headers = message.Headers;
existing.Body = message.Body;
existing.CorrelationId = message.CorrelationId;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
public void Add(Message message)
{
_lock.EnterWriteLock();
try
{
if (!_outgoing.ContainsKey(message.MessageId.Value))
{
var timeStamp = DateTime.Now;
_outgoing.Add(message.MessageId.Value, timeStamp);
_storage.AddToOutbox(message.MessageId.Value, timeStamp);
}
}
finally
{
_lock.ExitWriteLock();
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Message Clone()
{
var message = new Message()
{
MessageId = this.MessageId,
Version = this.Version,
CorrelationId = this.CorrelationId
};
if (this.Body != null)
{
message.Body = new byte[this.Body.Length];
this.Body.CopyTo(message.Body, 0);
}
foreach (var item in this.Headers.Keys)
{
message.Headers.Add(item, this.Headers[item]);
}
return message;
}
public void MessageBinarySerialization()
{
var messageBody = "Test message";
var msg = new Message() {
Body = Encoding.Unicode.GetBytes(messageBody),
};
msg.Headers.Add("Token1", "3000");
msg.Headers.Add("Token2", "2000");
msg.Headers.Add("Token3", "1000");
var serialized = msg.ToByteArray();
var msg2 = serialized.FromByteArray();
var b1 = Encoding.Unicode.GetString(msg.Body);
var b2 = Encoding.Unicode.GetString(msg2.Body);
Assert.AreEqual(msg.MessageId, msg2.MessageId);
Assert.AreEqual(msg.CorrelationId, msg2.CorrelationId);
Assert.AreEqual(msg.CorrelationId, msg2.CorrelationId);
Assert.AreEqual(b1, b2);
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
/// <param name="msg"></param>
/// <param name="onMessageSent"></param>
public void SendAsync(IConnection connection, Message msg, Action<IConnection,Message> onMessageSent)
{
var conn = connection as TcpConnection<MessageBuilder>;
conn.State.OnMessageSent = onMessageSent;
var data = msg.ToByteArray();
conn.Handler.BeginSend(data, 0
, data.Length
, SocketFlags.None
, new AsyncCallback(SendCallback), Tuple.Create(conn, msg) );
}
/// <summary>
///
/// </summary>
/// <param name="incomingMsg"></param>
public void OnIncomingMessageReceived(IConnection connection, Message incomingMsg)
{
_logger.Debug(String.Format("Handling incoming message with id:[{0}]", incomingMsg.MessageId));
var clientAck = incomingMsg.FromMessage<Ack>(_serializer);
if (clientAck != null)
{
//Message processed. Update queue status
_queueManager.Outbox.Ack(clientAck.ForMessageId);
return;
}
var disconnect = incomingMsg.FromMessage<Disconnect>(_serializer);
if (disconnect != null)
{
_logger.Info(String.Format("Session Id {0} received Disconnect command", connection.Id));
connection.CancelSession.Cancel();
return;
}
var register = incomingMsg.FromMessage<Subscribe>(_serializer);
if (register!=null)
{
connection.Subscribers = register.SubscriberMap;
foreach (var item in register.SubscriberMap)
{
_queueManager.Subscribe(item.Key, item.Value);
}
//prepare and send back session info
var sessionInfo = new SessionInfo(incomingMsg.MessageId.Value, connection.Id)
.ToMessage(_serializer, incomingMsg.CorrelationId.Value);
_transport.SendAsync(connection, sessionInfo, null);
return;
}
if (_queueManager.Post(incomingMsg))
{
var ack = new Ack(incomingMsg.MessageId.Value)
.ToMessage(_serializer, incomingMsg.CorrelationId.Value);
_transport.SendAsync(connection, ack, null);
}
else
{
var errNoQueue = new Error(incomingMsg.MessageId.Value, "Post: No queue for message")
.ToMessage(_serializer, incomingMsg.CorrelationId.Value);
_transport.SendAsync(connection, errNoQueue, null);
}
}
