public override IMessage ToMessage(object objectToConvert, ISession session)
{
TradeRequest tradeRequest = objectToConvert as TradeRequest;
if (tradeRequest == null)
{
throw new MessageConversionException("TradeRequestConverter can not convert object of type " +
objectToConvert.GetType());
}
try
{
IMapMessage mm = session.CreateMapMessage();
mm.Body.SetString("accountName", tradeRequest.AccountName);
mm.Body.SetBool("buyRequest", tradeRequest.BuyRequest);
mm.Body.SetString("orderType", tradeRequest.OrderType);
mm.Body.SetDouble("price", tradeRequest.Price);
mm.Body.SetLong("quantity", tradeRequest.Quantity);
mm.Body.SetString("requestId", tradeRequest.RequestId);
mm.Body.SetString("ticker", tradeRequest.Ticker);
mm.Body.SetString("username", tradeRequest.UserName);
return(mm);
} catch (Exception e)
{
throw new MessageConversionException("Could not convert TradeRequest to message", e);
}
}
public INMSProducer Send(IDestination destination, IPrimitiveMap body)
{
IMapMessage message = CreateMapMessage();
ActiveMQMessageTransformation.CopyMap(body, message.Body);
return(Send(destination, message));
}
static void Main(string[] args)
{
try
{
string fileContents;
using (StreamReader sr = new StreamReader(@"C:\GAProject\dgase\EclipseWS\ECJServer\test.params"))
{
fileContents = sr.ReadToEnd();
}
Messaging messaging = new Messaging();
IMapMessage response = messaging.RequestMap("JOB1", "AddJob", fileContents);
Console.WriteLine("STATUS: " + response.Body.GetString("STATUS"));
Thread.Sleep(10000);
response = messaging.RequestMap("JOB1", "GetStatistics", fileContents);
Console.WriteLine("STATUS: " + response.Body.GetString("STATUS"));
Console.WriteLine("BODY: " + response.Body.GetString("BODY"));
}
catch (Exception ex)
{
Console.Write(ex);
}
Console.ReadLine();
}
public Task <INMSProducer> SendAsync(IDestination destination, IPrimitiveMap body)
{
IMapMessage message = CreateMapMessage();
NmsMessageTransformation.CopyMap(body, message.Body);
return(SendAsync(destination, message));
}
// OnMessageReceived - beim messageConsumer registrierte Callback-Methode,
// wird bei Empfang einer neuen Nachricht vom messageConsumer aufgerufen
public void OnMessageReceived(IMessage msg)
{
if (msg is ITextMessage)
{
ITextMessage tm = msg as ITextMessage;
//Console.WriteLine("TextMessage: ID=" + tm.GetType() + "\n" + tm.Text);
String s = tm.Text;
Console.WriteLine(s);
Schnorchel schnorchel = JsonConvert.DeserializeObject <Schnorchel>(s);
Console.WriteLine(schnorchel);
}
else if (msg is IMapMessage)
{
StringBuilder msgbuffer = new StringBuilder();
IMapMessage mm = msg as IMapMessage;
msgbuffer.AppendFormat("MapMessage: ID={0}\n", msg.GetType());
foreach (string key in mm.Properties.Keys)
{
msgbuffer.AppendFormat(" - Property '{0}' = {1}\n", key, mm.Properties[key]);
}
foreach (string key in mm.Body.Keys)
{
msgbuffer.AppendFormat(" - Eintrag '{0}' = {1}\n", key, mm.Body[key]);
}
Console.WriteLine(msgbuffer.ToString());
}
else
{
Console.WriteLine("\nAnderer Message-Typ: " + msg);
}
}
private void MessageListener(IMapMessage message)
{
IObjectMessage objectMessage = message as IObjectMessage;
RequesterObject requesterObject = ((SOA_Architecture.RequesterObject)(objectMessage.Body));
MessageBox.Show(requesterObject.Requestproerty);
}
public override IMessage ToMessage(object objectToConvert, ISession session)
{
Trade trade = objectToConvert as Trade;
if (trade == null)
{
throw new MessageConversionException("TradeConverter can not convert object of type " +
objectToConvert.GetType());
}
try
{
IMapMessage mm = session.CreateMapMessage();
mm.Body.SetString("orderType", trade.OrderType);
mm.Body.SetDouble("price", trade.Price);
mm.Body.SetLong("quantity", trade.Quantity);
mm.Body.SetString("ticker", trade.Ticker);
return(mm);
}
catch (Exception e)
{
throw new MessageConversionException("Could not convert TradeRequest to message", e);
}
}
public void TestMapMessageCompression()
{
using (Connection connection = CreateConnection(TEST_CLIENT_ID) as Connection)
{
connection.UseCompression = true;
connection.Start();
Assert.IsTrue(connection.UseCompression);
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IMapMessage message = session.CreateMapMessage();
IDestination destination = session.CreateTemporaryQueue();
IMessageProducer producer = session.CreateProducer(destination);
IMessageConsumer consumer = session.CreateConsumer(destination);
message.Body["a"] = a;
message.Body["b"] = b;
message.Body["c"] = c;
message.Body["d"] = d;
message.Body["e"] = e;
message.Body["f"] = f;
message.Body["g"] = g;
message.Body["h"] = h;
message.Body["i"] = i;
message.Body["j"] = j;
message.Body["k"] = k;
message.Body["l"] = l;
message.Body["m"] = m;
message.Body["n"] = n;
producer.Send(message);
message = consumer.Receive(TimeSpan.FromMilliseconds(4000)) as IMapMessage;
Assert.IsNotNull(message);
Assert.IsTrue(((ActiveMQMessage)message).Compressed);
Assert.AreEqual(a, message.Body.GetBool("a"), "map entry: a");
Assert.AreEqual(b, message.Body.GetByte("b"), "map entry: b");
Assert.AreEqual(c, message.Body.GetChar("c"), "map entry: c");
Assert.AreEqual(d, message.Body.GetShort("d"), "map entry: d");
Assert.AreEqual(e, message.Body.GetInt("e"), "map entry: e");
Assert.AreEqual(f, message.Body.GetLong("f"), "map entry: f");
Assert.AreEqual(g, message.Body.GetString("g"), "map entry: g");
Assert.AreEqual(h, message.Body.GetBool("h"), "map entry: h");
Assert.AreEqual(i, message.Body.GetByte("i"), "map entry: i");
Assert.AreEqual(j, message.Body.GetShort("j"), "map entry: j");
Assert.AreEqual(k, message.Body.GetInt("k"), "map entry: k");
Assert.AreEqual(l, message.Body.GetLong("l"), "map entry: l");
Assert.AreEqual(m, message.Body.GetFloat("m"), "map entry: m");
Assert.AreEqual(n, message.Body.GetDouble("n"), "map entry: n");
}
}
}
public void Publish(string ticker, double price)
{
NmsTemplate.SendWithDelegate("APP.STOCK.MARKETDATA",
delegate(ISession session)
{
IMapMessage message = session.CreateMapMessage();
message.Body.SetString("TICKER", ticker);
message.Body.SetDouble("PRICE", price);
message.NMSPriority = MsgPriority.Normal;
return(message);
});
}
/// <summary> Extract a IDictionary from the given IMapMessage.</summary>
/// <param name="message">the message to convert
/// </param>
/// <returns> the resulting Map
/// </returns>
/// <throws>NMSException if thrown by NMS methods </throws>
protected virtual IDictionary ExtractMapFromMessage(IMapMessage message)
{
IDictionary dictionary = new Hashtable();
IEnumerator e = message.Body.Keys.GetEnumerator();
while (e.MoveNext())
{
String key = (String)e.Current;
dictionary.Add(key, message.Body[key]);
}
return(dictionary);
}
public void DictionaryConversionWhereMapHasNonStringTypesForKeys()
{
IMapMessage message = A.Fake <IMapMessage>();
A.CallTo(() => session.CreateMapMessage()).Returns(message);
var content = new Hashtable();
content.Add(new Cafe(), "value1");
Assert.Throws <MessageConversionException>(() => converter.ToMessage(content, session));
}
private void SendMessage()
{
//创建临时目的地，它们的存在时间只限于创建它们的连接所保持的时间
//只有创建该临时目的地的连接上的消息消费者才能够从临时目的地中提取消息
//ITemporaryQueue queue = m_session.CreateTemporaryQueue();
IQueue queue = m_session.GetQueue("test_Queue");
m_producer = m_session.CreateProducer(queue);
//TextMessage消息类型, 普通文本消息
ITextMessage textMessage = m_producer.CreateTextMessage();
textMessage.Text = this.txtBox_消息.Text;
//MapMessafe消息类型, Map集合消息
IMapMessage mapMessage = m_producer.CreateMapMessage();
m_producer.Send(mapMessage);
//ObjectMessage消息类型, 发送序列化对象
Queue <string> obj = new Queue <string>();
obj.Enqueue("one");
obj.Enqueue("two");
IObjectMessage objectMessage = m_producer.CreateObjectMessage(obj);
m_producer.Send(objectMessage);
//BytesMessage消息类型， 发送字节消息
IBytesMessage bytesMessage = m_producer.CreateBytesMessage();
bytesMessage.WriteBytes(System.Text.Encoding.Default.GetBytes("字节"));
m_producer.Send(bytesMessage);
//其它消息类型大同小异
//设置是否持久化
//m_producer.DeliveryMode= MsgDeliveryMode.Persistent;
//设置优先级 默认 MsgPriority.BelowNormal 4级
//m_producer.Priority = MsgPriority.BelowNormal;
//设置过期时间，5秒后 只有Queue点对点有效
//m_producer.TimeToLive=new TimeSpan(1000*5);
//发送超时时间，默认等于0，如果设置超时，则所有的消息都是用同步发送
//m_producer.RequestTimeout = new TimeSpan(1000*20);
}
//
// GET: /Job/
public ActionResult Index()
{
var jobs = _jobRepository.FindAllJobs();
if (Request.IsAjaxRequest())
{
var jsonJob = from job in jobs
where job.IsTemplate == true
select new JsonJob
{
JobName = job.Name,
JobDesc = "",
ProblemName = job.Problem.Name,
ProblemDesc = job.Problem.Description,
Job_Id = job.Job_Id,
Problem_Id = job.Problem_Id
};
return(Json(jsonJob.ToList()));
}
jobs = from job in _jobRepository.FindAllJobs()
where job.IsTemplate == false
select job;
Messaging messaging = new Messaging();
foreach (Job j in jobs)
{
if (String.IsNullOrEmpty(j.Status) || (!j.Status.Trim().Equals("Complete") && !j.Status.Trim().Equals("Orphan")))
{
try
{
IMapMessage mapMessage = messaging.RequestMap(j.Name, "GetStatus", "");
String status = mapMessage.Body.GetString("BODY");
j.Status = status;
if (status.Trim().Equals("Complete"))
{
j.EndTime = DateTime.Now;
}
_jobRepository.UpdateJob(j);
}
catch { }
}
}
return(View(jobs));
}
public ActionResult Create(Job job)
{
string body = "";
if (Request.Form.HasKeys())
{
foreach (string x in Request.Form)
{
body = body + x + "=" + Request.Form[x] + "\n";
}
}
string jobName = "CMAES" + DateTime.Now.Second.ToString();
Messaging messaging = new Messaging();
IMapMessage response = messaging.RequestMap(jobName, "AddJob", body);
job.IsTemplate = false;
job.Name = jobName;
job.Problem_Id = 1;
job.Status = "Submitted";
job.StartTime = DateTime.Now;
_jobRepository.AddJob(job);
Thread.Sleep(1000);
Response.Redirect("/default.aspx");
return(View(job));
// var jobs = _jobRepository.FindAllJobs();
//return View(jobs);
//if (ModelState.IsValid)
//{
// try
// {
// _jobRepository.AddJob(job);
// return RedirectToAction("Index");
// }
// catch
// {
// return View(job);
// }
//}
//else
//{
// return View(job);
//}
}
void Send(IMessageProducer producer, MapMessage message)
{
IMapMessage mapMessage = producer.CreateMapMessage();
foreach (string key in message.Properties.Keys)
{
mapMessage.Properties[key] = message.Properties[key];
}
foreach (string key in message.Body.Keys)
{
mapMessage.Body[key] = message.Body[key];
}
_logger.DebugFormat("开始向 {0} 发送消息", _nm);
try
{
if (isFirst)
{
DateTime old = DateTime.Now;
producer.Send(mapMessage);
isFast = ((DateTime.Now - old) < TimeSpan.FromSeconds(1));
if (!isFast)
{
_logger.DebugFormat("向 {0} 发送消息发现耗时太长, 决定以后跳过!", _nm);
}
isFirst = false;
}
else if (isFast)
{
producer.Send(mapMessage);
_logger.DebugFormat("向 {0} 发送消息完成", _nm);
}
else
{
throw new ApplicationException("发送消息耗时太长, 决定跳过");
}
}
catch (Exception e)
{
if (_logger.IsDebugEnabled)
{
_logger.Debug(string.Format("向 {0} 发送消息发生错误", _nm), e);
}
throw;
}
}
public void SendReceiveForeignMapMessageTest(
[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = CreateDestination(session, DestinationType.Topic);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
try
{
producer.DeliveryMode = deliveryMode;
MapMessage request = new MapMessage();
request.Properties[propertyName] = propertyValue;
request.Body[mapElementName] = mapElementValue;
producer.Send(request);
IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(request.Properties.Count, message.Properties.Count,
"Invalid number of properties.");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
// Check the body
Assert.AreEqual(request.Body.Count, message.Body.Count);
Assert.AreEqual(mapElementValue, message.Body[mapElementName],
"MapMessage body was wrong.");
// use generic API to access entries
Assert.AreEqual(propertyValue, message.Properties[propertyName],
"generic map entry: " + propertyName);
// use type safe APIs
Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName),
"map entry: " + propertyName);
}
catch (NotSupportedException)
{
}
}
}
}
}
public void MapConversion()
{
IMapMessage message = A.Fake <IMapMessage>();
IPrimitiveMap primitiveMap = new PrimitiveMap();
IDictionary content = new Hashtable();
content["key1"] = "value1";
content["key2"] = "value2";
A.CallTo(() => session.CreateMapMessage()).Returns(message).Once();
A.CallTo(() => message.Body).Returns(primitiveMap);
//can't seem to mock indexer...
IMessage msg = converter.ToMessage(content, session);
Assert.AreEqual(content, converter.FromMessage(msg));
}
/// <summary> Create a NMS IMapMessage for the given Map.</summary>
/// <param name="map">the Map to convert
/// </param>
/// <param name="session">current NMS session
/// </param>
/// <returns> the resulting message
/// </returns>
/// <throws> NMSException if thrown by NMS methods </throws>
protected virtual IMapMessage CreateMessageForMap(IDictionary map, ISession session)
{
IMapMessage mapMessage = session.CreateMapMessage();
foreach (DictionaryEntry entry in map)
{
if (!(entry.Key is string))
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Class.getName' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
throw new MessageConversionException("Cannot convert non-String key of type [" +
(entry.Key != null ? entry.Key.GetType().FullName : null) +
"] to IMapMessage entry");
}
mapMessage.Body[entry.Key.ToString()] = entry.Value;
}
return(mapMessage);
}
public void GetStats()
{
// Crear consumidor
try
{
// Creo una cola y consumidor
IDestination queueReplyTo = session.CreateTemporaryQueue();
IMessageConsumer consumer = session.CreateConsumer(queueReplyTo);
// Crear cola monitorizada
string listeningQueue = "TEST1";
ActiveMQQueue testQueue = session.GetQueue(listeningQueue);
// Crear cola y productor
ActiveMQQueue query = session.GetQueue("ActiveMQ.Statistics.Destination.TEST1");
IMessageProducer producer = session.CreateProducer(null);
// Mandar mensaje vacío y replicar
IMessage msg = session.CreateMessage();
producer.Send(testQueue, msg);
msg.NMSReplyTo = queueReplyTo;
producer.Send(query, msg);
// Recibir
IMapMessage reply = (IMapMessage)consumer.Receive();
if (reply != null)
{
IPrimitiveMap statsMap = reply.Body;
foreach (string statKey in statsMap.Keys)
{
Console.WriteLine("{0} = {1}", statKey, statsMap[statKey]);
}
}
}
catch (Exception e)
{
var t = e.Message + " " + e.StackTrace;
}
}
public override object FromMessage(IMessage messageToConvert)
{
IMapMessage mm = messageToConvert as IMapMessage;
if (mm != null)
{
Trade trade = new Trade();
trade.OrderType = mm.Body.GetString("orderType");
trade.Price = mm.Body.GetDouble("price");
trade.Quantity = mm.Body.GetLong("quantity");
trade.Ticker = mm.Body.GetString("ticker");
return(trade);
}
else
{
throw new MessageConversionException("Not of expected type MapMessage. Message = " + messageToConvert);
}
}
protected override void AssertValidMessage(IMessage message)
{
Assert.IsTrue(message is IMapMessage, "Did not receive a MapMessage!");
IMapMessage mapMessage = (IMapMessage)message;
Console.WriteLine("Received MapMessage: " + message);
Console.WriteLine("Received Count: " + mapMessage.Body.Count);
Assert.AreEqual(ToHex(f), ToHex(mapMessage.Body.GetLong("f")), "map entry: f as hex");
// use generic API to access entries
Assert.AreEqual(a, mapMessage.Body["a"], "generic map entry: a");
Assert.AreEqual(b, mapMessage.Body["b"], "generic map entry: b");
Assert.AreEqual(c, mapMessage.Body["c"], "generic map entry: c");
Assert.AreEqual(d, mapMessage.Body["d"], "generic map entry: d");
Assert.AreEqual(e, mapMessage.Body["e"], "generic map entry: e");
Assert.AreEqual(f, mapMessage.Body["f"], "generic map entry: f");
Assert.AreEqual(g, mapMessage.Body["g"], "generic map entry: g");
Assert.AreEqual(h, mapMessage.Body["h"], "generic map entry: h");
Assert.AreEqual(i, mapMessage.Body["i"], "generic map entry: i");
Assert.AreEqual(j, mapMessage.Body["j"], "generic map entry: j");
Assert.AreEqual(k, mapMessage.Body["k"], "generic map entry: k");
Assert.AreEqual(l, mapMessage.Body["l"], "generic map entry: l");
Assert.AreEqual(m, mapMessage.Body["m"], "generic map entry: m");
Assert.AreEqual(n, mapMessage.Body["n"], "generic map entry: n");
// use type safe APIs
Assert.AreEqual(a, mapMessage.Body.GetBool("a"), "map entry: a");
Assert.AreEqual(b, mapMessage.Body.GetByte("b"), "map entry: b");
Assert.AreEqual(c, mapMessage.Body.GetChar("c"), "map entry: c");
Assert.AreEqual(d, mapMessage.Body.GetShort("d"), "map entry: d");
Assert.AreEqual(e, mapMessage.Body.GetInt("e"), "map entry: e");
Assert.AreEqual(f, mapMessage.Body.GetLong("f"), "map entry: f");
Assert.AreEqual(g, mapMessage.Body.GetString("g"), "map entry: g");
Assert.AreEqual(h, mapMessage.Body.GetBool("h"), "map entry: h");
Assert.AreEqual(i, mapMessage.Body.GetByte("i"), "map entry: i");
Assert.AreEqual(j, mapMessage.Body.GetShort("j"), "map entry: j");
Assert.AreEqual(k, mapMessage.Body.GetInt("k"), "map entry: k");
Assert.AreEqual(l, mapMessage.Body.GetLong("l"), "map entry: l");
Assert.AreEqual(m, mapMessage.Body.GetFloat("m"), "map entry: m");
Assert.AreEqual(n, mapMessage.Body.GetDouble("n"), "map entry: n");
}
protected override IMessage CreateMessage()
{
IMapMessage message = Session.CreateMapMessage();
message.Body["a"] = a;
message.Body["b"] = b;
message.Body["c"] = c;
message.Body["d"] = d;
message.Body["e"] = e;
message.Body["f"] = f;
message.Body["g"] = g;
message.Body["h"] = h;
message.Body["i"] = i;
message.Body["j"] = j;
message.Body["k"] = k;
message.Body["l"] = l;
message.Body["m"] = m;
message.Body["n"] = n;
return(message);
}
public void MapConversion()
{
IMapMessage message = mocks.StrictMock <IMapMessage>();
IPrimitiveMap primitiveMap = new PrimitiveMap();
IDictionary content = new Hashtable();
content["key1"] = "value1";
content["key2"] = "value2";
Expect.Call(session.CreateMapMessage()).Return(message).Repeat.Once();
Expect.Call(message.Body).Return(primitiveMap).Repeat.Any();
//can't seem to mock indexer...
mocks.ReplayAll();
IMessage msg = converter.ToMessage(content, session);
Assert.AreEqual(content, converter.FromMessage(msg));
mocks.VerifyAll();
}
public void TestMessageQueueDequeQueueDequeue()
{
using (IConnection connection = CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue("TestMessageQueueDequeQueueDequeue");
(connection as Connection).DeleteDestination(destination);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
connection.Start();
producer.DeliveryMode = MsgDeliveryMode.Persistent;
IMapMessage request = session.CreateMapMessage();
request.Body.SetString("Unit-Test-Key", "Unit-Test-Value");
Assert.IsNotNull(request, "request is null");
Assert.IsTrue(request.Body.Contains("Unit-Test-Key"), "Unit-Test-Key does not exist");
producer.Send(request);
// Relay from Queue back again.
IMessage received = consumer.Receive(TimeSpan.FromSeconds(2));
Assert.IsNotNull(received);
IMapMessage mapMessage = received as IMapMessage;
Assert.IsNotNull(mapMessage);
producer.Send(mapMessage);
// Read it again and validate.
received = consumer.Receive(TimeSpan.FromSeconds(2));
Assert.IsNotNull(received);
mapMessage = received as IMapMessage;
Assert.IsNotNull(mapMessage, "currentMessage is null");
// This entry in the map message should not be removed
Assert.IsTrue(mapMessage.Body.Contains("Unit-Test-Key"), "Unit-Test-Key does not exist");
}
}
}
public ITextMessage RequestText(String jobName, String verb, String body)
{
ITextMessage ecjResponse;
ConnectionFactory connectionFactory = new ConnectionFactory(URI);
try
{
using (IConnection connection = connectionFactory.CreateConnection())
{
using (ISession session = connection.CreateSession())
{
ITemporaryQueue queue = session.CreateTemporaryQueue();
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
IMapMessage message = session.CreateMapMessage();
message.Body.SetString("VERB", verb);
message.Body.SetString("BODY", body);
message.Body.SetString("JOBNAME", jobName);
message.NMSReplyTo = queue;
string correlationId = Guid.NewGuid().ToString();
message.NMSCorrelationID = correlationId;
using (IMessageProducer producer = session.CreateProducer())
{
NmsDestinationAccessor destinationResolver = new NmsDestinationAccessor();
IDestination destination = destinationResolver.ResolveDestinationName(session, DESTINATION);
producer.Send(destination, message);
}
IMessage response = consumer.Receive(TimeSpan.FromSeconds(TIMEOUT_SECS));
ecjResponse = response as ITextMessage;
}
}
}
}
catch (Exception ex)
{
throw new ApplicationException("Failed to send request", ex);
}
return(ecjResponse);
}
public void DictionaryConversionWhereMapHasNonStringTypesForKeys()
{
IMapMessage message = mocks.StrictMock <IMapMessage>();
Expect.Call(session.CreateMapMessage()).Return(message);
mocks.ReplayAll();
IDictionary content = new Hashtable();
content.Add(new Cafe(), "value1");
try
{
converter.ToMessage(content, session);
Assert.Fail("Should have thrown MessageConversionException");
} catch (MessageConversionException)
{
}
mocks.VerifyAll();
}
public override object FromMessage(IMessage messageToConvert)
{
IMapMessage mm = messageToConvert as IMapMessage;
if (mm != null)
{
TradeRequest tradeRequest = new TradeRequest();
tradeRequest.AccountName = mm.Body.GetString("accountName");
tradeRequest.BuyRequest = mm.Body.GetBool("buyRequest");
tradeRequest.OrderType = mm.Body.GetString("orderType");
tradeRequest.Price = mm.Body.GetDouble("price");
tradeRequest.Quantity = mm.Body.GetLong("quantity");
tradeRequest.RequestId = mm.Body.GetString("requestId");
tradeRequest.Ticker = mm.Body.GetString("ticker");
tradeRequest.UserName = mm.Body.GetString("username");
return(tradeRequest);
}
else
{
throw new MessageConversionException("Not of expected type MapMessage. Message = " + messageToConvert);
}
}
/// <summary>
/// Unpack the message
/// </summary>
private ResponseInfo Unpack(IMapMessage m)
{
ResponseInfo ri = new ResponseInfo();
ri.CorrelationId = m.NMSCorrelationID;
ri.SessionId = m.Body.GetString(ProtocolParams.SessionId);
ri.IsBroadcast = m.Body.GetBool(ProtocolParams.IsBroadcast);
ri.ReturnValue = m.Body.GetString(ProtocolParams.ReturnValue);
ri.IsException = m.Body.GetBool(ProtocolParams.IsException);
ri.IsChunked = m.Body.GetBool(ProtocolParams.IsChunked);
ri.IsResponseComplete = m.Body.GetBool(ProtocolParams.IsResponseComplete);
if(ri.IsChunked)
{
ri.IsFirstChunk = m.Body.GetBool(ProtocolParams.IsFirstChunk);
}
if(ri.IsFirstChunk)
{
ri.TotalItemCount = m.Body.GetInt(ProtocolParams.TotalItemCount);
}
return ri;
}
public void SendReceiveMapMessage(MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
producer.RequestTimeout = receiveTimeout;
IMapMessage request = session.CreateMapMessage();
request.Body["a"] = a;
request.Body["b"] = b;
request.Body["c"] = c;
request.Body["d"] = d;
request.Body["e"] = e;
request.Body["f"] = f;
request.Body["g"] = g;
request.Body["h"] = h;
request.Body["i"] = i;
request.Body["j"] = j;
request.Body["k"] = k;
request.Body["l"] = l;
request.Body["m"] = m;
request.Body["n"] = n;
producer.Send(request);
IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(request.Body.Count, message.Body.Count, "Invalid number of message maps.");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
Assert.AreEqual(ToHex(f), ToHex(message.Body.GetLong("f")), "map entry: f as hex");
// use generic API to access entries
Assert.AreEqual(a, message.Body["a"], "generic map entry: a");
Assert.AreEqual(b, message.Body["b"], "generic map entry: b");
Assert.AreEqual(c, message.Body["c"], "generic map entry: c");
Assert.AreEqual(d, message.Body["d"], "generic map entry: d");
Assert.AreEqual(e, message.Body["e"], "generic map entry: e");
Assert.AreEqual(f, message.Body["f"], "generic map entry: f");
Assert.AreEqual(g, message.Body["g"], "generic map entry: g");
Assert.AreEqual(h, message.Body["h"], "generic map entry: h");
Assert.AreEqual(i, message.Body["i"], "generic map entry: i");
Assert.AreEqual(j, message.Body["j"], "generic map entry: j");
Assert.AreEqual(k, message.Body["k"], "generic map entry: k");
Assert.AreEqual(l, message.Body["l"], "generic map entry: l");
Assert.AreEqual(m, message.Body["m"], "generic map entry: m");
Assert.AreEqual(n, message.Body["n"], "generic map entry: n");
// use type safe APIs
Assert.AreEqual(a, message.Body.GetBool("a"), "map entry: a");
Assert.AreEqual(b, message.Body.GetByte("b"), "map entry: b");
Assert.AreEqual(c, message.Body.GetChar("c"), "map entry: c");
Assert.AreEqual(d, message.Body.GetShort("d"), "map entry: d");
Assert.AreEqual(e, message.Body.GetInt("e"), "map entry: e");
Assert.AreEqual(f, message.Body.GetLong("f"), "map entry: f");
Assert.AreEqual(g, message.Body.GetString("g"), "map entry: g");
Assert.AreEqual(h, message.Body.GetBool("h"), "map entry: h");
Assert.AreEqual(i, message.Body.GetByte("i"), "map entry: i");
Assert.AreEqual(j, message.Body.GetShort("j"), "map entry: j");
Assert.AreEqual(k, message.Body.GetInt("k"), "map entry: k");
Assert.AreEqual(l, message.Body.GetLong("l"), "map entry: l");
Assert.AreEqual(m, message.Body.GetFloat("m"), "map entry: m");
Assert.AreEqual(n, message.Body.GetDouble("n"), "map entry: n");
}
}
}
}
public void SendReceiveNestedMapMessage(MsgDeliveryMode deliveryMode)
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
producer.RequestTimeout = receiveTimeout;
IMapMessage request = session.CreateMapMessage();
const string textFieldValue = "Nested Map Messages Rule!";
request.Body.SetString("textField", textFieldValue);
IDictionary grandChildMap = new Hashtable();
grandChildMap["x"] = "abc";
grandChildMap["y"] = new ArrayList(new object[] { "a", "b", "c" });
IDictionary nestedMap = new Hashtable();
nestedMap["a"] = "foo";
nestedMap["b"] = (int)23;
nestedMap["c"] = (long)45;
nestedMap["d"] = grandChildMap;
request.Body.SetDictionary("mapField", nestedMap);
request.Body.SetList("listField", new ArrayList(new Object[] { "a", "b", "c" }));
producer.Send(request);
IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(request.Body.Count, message.Body.Count, "Invalid number of message maps.");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
string textFieldResponse = message.Body.GetString("textField");
Assert.AreEqual(textFieldValue, textFieldResponse, "textField does not match.");
IDictionary nestedMapResponse = message.Body.GetDictionary("mapField");
Assert.IsNotNull(nestedMapResponse, "Nested map not returned.");
Assert.AreEqual(nestedMap.Count, nestedMapResponse.Count, "nestedMap: Wrong number of elements");
Assert.AreEqual("foo", nestedMapResponse["a"], "nestedMap: a");
Assert.AreEqual(23, nestedMapResponse["b"], "nestedMap: b");
Assert.AreEqual(45, nestedMapResponse["c"], "nestedMap: c");
IDictionary grandChildMapResponse = nestedMapResponse["d"] as IDictionary;
Assert.IsNotNull(grandChildMapResponse, "Grand child map not returned.");
Assert.AreEqual(grandChildMap.Count, grandChildMapResponse.Count, "grandChildMap: Wrong number of elements");
Assert.AreEqual(grandChildMapResponse["x"], "abc", "grandChildMap: x");
IList grandChildList = grandChildMapResponse["y"] as IList;
Assert.IsNotNull(grandChildList, "Grand child list not returned.");
Assert.AreEqual(3, grandChildList.Count, "grandChildList: Wrong number of list elements.");
Assert.AreEqual("a", grandChildList[0], "grandChildList: a");
Assert.AreEqual("b", grandChildList[1], "grandChildList: b");
Assert.AreEqual("c", grandChildList[2], "grandChildList: c");
IList listFieldResponse = message.Body.GetList("listField");
Assert.IsNotNull(listFieldResponse, "Nested list not returned.");
Assert.AreEqual(3, listFieldResponse.Count, "listFieldResponse: Wrong number of list elements.");
Assert.AreEqual("a", listFieldResponse[0], "listFieldResponse: a");
Assert.AreEqual("b", listFieldResponse[1], "listFieldResponse: b");
Assert.AreEqual("c", listFieldResponse[2], "listFieldResponse: c");
}
}
}
}
//[Test]
public virtual void TestSendReceiveMapMessage(
//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
MsgDeliveryMode deliveryMode, string testQueueRef)
{
using (IConnection connection = CreateConnection(GetTestClientId()))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.DeliveryMode = deliveryMode;
IMapMessage request = session.CreateMapMessage();
request.Body["a"] = a;
request.Body["b"] = b;
request.Body["c"] = c;
request.Body["d"] = d;
request.Body["e"] = e;
request.Body["f"] = f;
request.Body["g"] = g;
request.Body["h"] = h;
request.Body["i"] = i;
request.Body["j"] = j;
request.Body["k"] = k;
request.Body["l"] = l;
request.Body["m"] = m;
request.Body["n"] = n;
request.Body["o"] = o;
producer.Send(request);
IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
Assert.IsNotNull(message, "No message returned!");
Assert.AreEqual(request.Body.Count, message.Body.Count, "Invalid number of message maps.");
Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
Assert.AreEqual(ToHex(f), ToHex(message.Body.GetLong("f")), "map entry: f as hex");
// use generic API to access entries
Assert.AreEqual(a, message.Body["a"], "generic map entry: a");
Assert.AreEqual(b, message.Body["b"], "generic map entry: b");
Assert.AreEqual(c, message.Body["c"], "generic map entry: c");
Assert.AreEqual(d, message.Body["d"], "generic map entry: d");
Assert.AreEqual(e, message.Body["e"], "generic map entry: e");
Assert.AreEqual(f, message.Body["f"], "generic map entry: f");
Assert.AreEqual(g, message.Body["g"], "generic map entry: g");
Assert.AreEqual(h, message.Body["h"], "generic map entry: h");
Assert.AreEqual(i, message.Body["i"], "generic map entry: i");
Assert.AreEqual(j, message.Body["j"], "generic map entry: j");
Assert.AreEqual(k, message.Body["k"], "generic map entry: k");
Assert.AreEqual(l, message.Body["l"], "generic map entry: l");
Assert.AreEqual(m, message.Body["m"], "generic map entry: m");
Assert.AreEqual(n, message.Body["n"], "generic map entry: n");
Assert.AreEqual(o, message.Body["o"], "generic map entry: o");
// use type safe APIs
Assert.AreEqual(a, message.Body.GetBool("a"), "map entry: a");
Assert.AreEqual(b, message.Body.GetByte("b"), "map entry: b");
Assert.AreEqual(c, message.Body.GetChar("c"), "map entry: c");
Assert.AreEqual(d, message.Body.GetShort("d"), "map entry: d");
Assert.AreEqual(e, message.Body.GetInt("e"), "map entry: e");
Assert.AreEqual(f, message.Body.GetLong("f"), "map entry: f");
Assert.AreEqual(g, message.Body.GetString("g"), "map entry: g");
Assert.AreEqual(h, message.Body.GetBool("h"), "map entry: h");
Assert.AreEqual(i, message.Body.GetByte("i"), "map entry: i");
Assert.AreEqual(j, message.Body.GetShort("j"), "map entry: j");
Assert.AreEqual(k, message.Body.GetInt("k"), "map entry: k");
Assert.AreEqual(l, message.Body.GetLong("l"), "map entry: l");
Assert.AreEqual(m, message.Body.GetFloat("m"), "map entry: m");
Assert.AreEqual(n, message.Body.GetDouble("n"), "map entry: n");
Assert.AreEqual(o, message.Body.GetBytes("o"), "map entry: o");
}
}
}
}
/// <summary>
/// Parse the map message. Pull out params and
/// populate InvocationInfo instance.
/// </summary>
private InvocationInfo ParseMapMessage(IMapMessage msg)
{
IPrimitiveMap map = msg.Body;
InvocationInfo info = new InvocationInfo();
info.RpcDispatchedId = map.GetString(ProtocolParams.RpcDispatchedId);
info.RpcId = map.GetString(ProtocolParams.RpcId);
info.ArgCount = map.GetInt(ProtocolParams.ArgCount);
// parse each arg string from the map
for(int i=0; i<info.ArgCount; i++)
{
info.AddArg(map.GetString(ProtocolParams.Arg + i));
}
return info;
}
/// <summay>
/// Parses the message and reconstructs objects and invokes the method
/// and sends the response.
/// </summary>
private void ProcessMessage(IMapMessage msg)
{
log.Debug("Before ParseMapMessage");
InvocationInfo info = ParseMapMessage(msg);
log.Debug("Before ParseMapMessage");
// validate we know these ids and have mappings for them
if(!rpcDict.ContainsKey(info.RpcDispatchedId))
{
log.Debug("dict does not have key for dispatchedId will return");
SendErrorResponse(msg, string.Format("DK RpcDispatchedId {0}",info.RpcDispatchedId));
return;
}
log.Debug("Look up RpcDispatchInfo in rpcDict");
RpcDispatchInfo dispatchInfo = rpcDict[info.RpcDispatchedId] as RpcDispatchInfo;
log.Debug("Look up RpcDispatchInfo in rpcDict");
RpcInfo rpcInfo = dispatchInfo.RpcInfoForId(info.RpcId);
if(null==rpcInfo)
{
log.Debug("did not find method for the requested rpc id");
SendErrorResponse(msg, string.Format("DK RpcId {0} on RpcDispatchedId {1}", info.RpcId, info.RpcDispatchedId));
return;
}
log.Debug("Get parameters from method");
// at this point we have valid object and method to dispatch on
// we now need to get args and deserialize to the expected types
ParameterInfo[] declaredParams = rpcInfo.Method.GetParameters();
if(declaredParams.Length!=info.ArgCount)
{
log.Debug("Arg count mismatch");
SendErrorResponse(msg, string.Format("Arg mismatch on RpcId {0} RpcDispatchedId {1}. Expected {3}, but got {4}"
, info.RpcId, info.RpcDispatchedId, declaredParams.Length, info.ArgCount));
return;
}
log.Debug("Get the types of the parameters");
Type[] tt = rpcInfo.Method.GetParamTypes();
log.Debug("Json reconstruct objects");
// for a no arg method you pass in a null
object[] args = 0==declaredParams.Length ? null : Json.EachFromJson(info.Args, tt);
try
{
log.Debug("right before invoking");
object returnValue = rpcInfo.Method.Invoke(dispatchInfo.RpcDispatchedObject, args);
log.Debug("right after invoking");
SendResponse(msg, returnValue, rpcInfo);
log.Debug("right after sending response");
}
catch(Exception e)
{
log.Debug(e.Message);
log.Error(e.Message, e);
SendErrorResponse(msg, e.Message);
}
log.Debug("Finished with ProcessMessage");
}
/// <summary>
/// Sends data in a series of chunked messages.
/// </summary>
private void SendChunkedResponses(IMapMessage msg, object returnValue, RpcInfo rpcInfo)
{
Preconditions.NotNull(returnValue,"Response marked as chunked but is null.");
Preconditions.IsTrue(returnValue.GetType().IsArray, "Response is to be chunked but return value is not an array.");
object[] wholeArray = (object[]) returnValue;
IList<object[]> list = wholeArray.Split<object>(rpcInfo.ChunkSize);
for(int i=0; i<list.Count; i++)
{
string json = Json.ToJson(list[i]); // convert only the part array to JSON to save memory
bool isFirstChunk = 0==i;
bool isResponseComplete = i==list.Count-1;
nmsTemplate.SendWithDelegate(msg.NMSReplyTo,
delegate(ISession session)
{
IMapMessage response = session.CreateMapMessage();
response.Body.SetString(ProtocolParams.ReturnValue,json);
response.Body.SetBool(ProtocolParams.IsException,false);
response.Body.SetBool(ProtocolParams.IsBroadcast, rpcInfo.IsBroadcast);
response.Body.SetBool(ProtocolParams.IsChunked, true);
response.Body.SetBool(ProtocolParams.IsFirstChunk, isFirstChunk);
if(isFirstChunk)
{
response.Body.SetInt(ProtocolParams.TotalItemCount, wholeArray.Length);
}
response.Body.SetBool(ProtocolParams.IsResponseComplete, isResponseComplete);
response.Body.SetString(ProtocolParams.SessionId,
msg.Body.GetString(ProtocolParams.SessionId));
response.NMSCorrelationID = msg.NMSCorrelationID;
return response;
});
}
}
/// <summary> Extract a IDictionary from the given IMapMessage.</summary>
/// <param name="message">the message to convert
/// </param>
/// <returns> the resulting Map
/// </returns>
/// <throws>NMSException if thrown by NMS methods </throws>
protected virtual IDictionary ExtractMapFromMessage(IMapMessage message)
{
IDictionary dictionary = new Hashtable();
IEnumerator e = message.Body.Keys.GetEnumerator();
while (e.MoveNext())
{
String key = (String) e.Current;
dictionary.Add(key, message.Body[key]);
}
return dictionary;
}
/// <summary>
/// Respond with an error message. Make sure this
/// does not throw any exceptions.
/// </summary>
private void SendErrorResponse(IMapMessage msg, string errorMsg)
{
log.Error(errorMsg);
nmsTemplate.SendWithDelegate(msg.NMSReplyTo,
delegate(ISession session)
{
IMapMessage response = session.CreateMapMessage();
response.Body.SetBool(ProtocolParams.IsException,true);
response.Body.SetString(ProtocolParams.ReturnValue,errorMsg);
response.Body.SetBool(ProtocolParams.IsBroadcast, false);
response.Body.SetBool(ProtocolParams.IsChunked, false);
response.Body.SetBool(ProtocolParams.IsResponseComplete, true);
response.Body.SetString(ProtocolParams.SessionId,
msg.Body.GetString(ProtocolParams.SessionId));
response.NMSCorrelationID = msg.NMSCorrelationID;
return response;
});
}
/// <summary>
/// Sends a response with the specified return value.
/// </summary>
private void SendResponse(IMapMessage msg, object returnValue, RpcInfo info)
{
log.Debug("SendResponse with return value");
string json = null;
if(info.IsResponseChunked)
{
log.Debug("response is chunked");
SendChunkedResponses(msg, returnValue, info);
return;
}
log.Debug("response is not chunked");
json = Json.ToJson(returnValue);
log.Debug("json==> " + json);
nmsTemplate.SendWithDelegate(msg.NMSReplyTo,
delegate(ISession session)
{
IMapMessage response = session.CreateMapMessage();
response.Body.SetString(ProtocolParams.ReturnValue, json);
response.Body.SetBool(ProtocolParams.IsException,false);
response.Body.SetBool(ProtocolParams.IsChunked, false);
response.Body.SetBool(ProtocolParams.IsBroadcast, info.IsBroadcast);
response.Body.SetBool(ProtocolParams.IsResponseComplete, true);
response.Body.SetString(ProtocolParams.SessionId,
msg.Body.GetString(ProtocolParams.SessionId));
response.NMSCorrelationID = msg.NMSCorrelationID;
return response;
});
log.Debug("After using nmsTemplate");
}
/// <summary>
/// Dispatch the message targeted for Type t with the specified callback.
/// Do the actual call. Save the callback.
/// </summary>
internal void Dispatch(IMapMessage msg, Type t, object cb, Type rvType, bool isBroadcast)
{
Preconditions.Assert(typeDestDict.ContainsKey(t),"No DestinationInfo for {0}", t.FullName);
DestinationInfo di = typeDestDict[t];
/*-----------------------------------
Set the correlation id
Set the session.
Set the reply to.
Add the correlationId and callback to the reply handler
Send using the producer.
-----------------------------------*/
msg.NMSCorrelationID = NextCorrelationId.ToString();
msg.NMSReplyTo = di.ReplyDestination;
msg.Body.SetString(ProtocolParams.SessionId, sessionId);
if(!isBroadcast) // broadcast messages don't have replies associated with them
{
replyHandler.Add(msg.NMSCorrelationID, cb, rvType);
}
di.Producer.Send(msg);
}
