public void RawApiConsumer()
{
string host = "localhost";
int port = 5672;
org.apache.qpid.client.Client client = new org.apache.qpid.client.Client();
try
{
client.Connect(host, port, "dev-only", "guest", "guest");
IClientSession session = client.CreateSession(50000);
//
session.QueueDeclare("message_queue");
session.ExchangeBind("message_queue", "amq.direct", "routing_key");
IClientSession session2 = session;
lock (session2)
{
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, "message_queue");
session.MessageSubscribe("message_queue");
Monitor.Wait(session);
}
//
client.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
protected void TryToConnect()
{
reqsOutstanding = 1;
Agent newAgent = new Agent(this, 0, "BrokerAgent");
Agents.Add(newAgent.AgentKey(), newAgent);
client = new Client();
client.Connect(url.Hostname, url.Port, null, url.AuthName, url.AuthPassword);
clientSession = client.CreateSession(timeout);
//clientSession.SetAutoSync(false) ;
string name = System.Text.Encoding.UTF8.GetString(clientSession.GetName());
replyName = "reply-" + name;
topicName = "topic-" + name;
clientSession.SetAutoSync(true);
Option[] options = new Option[] { Option.EXCLUSIVE, Option.AUTO_DELETE };
// This queue is used for responses to messages which are sent.
clientSession.QueueDeclare(replyName, options);
clientSession.ExchangeBind(replyName, "amq.direct", replyName);
clientSession.AttachMessageListener(this, "rdest");
clientSession.MessageSubscribe(replyName, "rdest", MessageAcceptMode.NONE, MessageAcquireMode.PRE_ACQUIRED, null, 0, null);
clientSession.MessageSetFlowMode("rdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("rdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("rdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
// This queue is used for unsolicited messages sent to this class.
clientSession.QueueDeclare(topicName, options);
clientSession.AttachMessageListener(this, "tdest");
clientSession.MessageSubscribe(topicName, "tdest", MessageAcceptMode.NONE, MessageAcquireMode.PRE_ACQUIRED, null, 0, null);
clientSession.MessageSetFlowMode("tdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("tdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("tdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
outSession = client.CreateSession(timeout);
outSession.ExchangeBind(replyName, "amq.direct", replyName);
connected = true;
consoleSession.HandleBrokerConnect(this);
IEncoder encoder = CreateEncoder();
this.SetHeader(encoder, 'B', 0);
this.Send(encoder);
}
private void sendAndReceive(byte[] messageBody, int count)
{
IClientSession ssn = Client.CreateSession(0);
ssn.Sync();
ssn.QueueDeclare("queue1", null, null);
ssn.QueueDelete("queue1");
QueueQueryResult result = (QueueQueryResult)ssn.QueueQuery("queue1").Result;
Assert.IsNull(result.GetQueue());
ssn.QueueDeclare("queue1", null, null);
ssn.ExchangeBind("queue1", "amq.direct", "queue1", null);
Object myLock = new Object();
MyListener myListener = new MyListener(myLock, count);
ssn.AttachMessageListener(myListener, "myDest");
ssn.MessageSubscribe("queue1", "myDest", MessageAcceptMode.EXPLICIT, MessageAcquireMode.PRE_ACQUIRED, null,
0, null);
// issue credits
ssn.MessageSetFlowMode("myDest", MessageFlowMode.WINDOW);
ssn.MessageFlow("myDest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
ssn.MessageFlow("myDest", MessageCreditUnit.MESSAGE, 10000);
ssn.Sync();
for (int i = 0; i < count; i++)
{
ssn.MessageTransfer("amq.direct", MessageAcceptMode.NONE, MessageAcquireMode.PRE_ACQUIRED,
new Header(new DeliveryProperties().SetRoutingKey("queue1"),
new MessageProperties().SetMessageId(UUID.RandomUuid())),
messageBody);
}
ssn.Sync();
lock (myLock)
{
if (myListener.Count != 0)
{
Monitor.Wait(myLock, 10000000);
}
}
Assert.IsTrue(myListener.Count == 0);
ssn.MessageAccept(myListener.UnAck);
ssn.Sync();
// the queue should be empty
result = (QueueQueryResult)ssn.QueueQuery("queue1").Result;
Assert.IsTrue(result.GetMessageCount() == 0);
ssn.Close();
}
private static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
// Each client creates its own private queue, using the
// session id to guarantee a unique name. It then routes
// all messages from the fanout exchange to its own queue
// by binding to the queue.
//
// The binding specifies a binding key, but for a fanout
// exchange, the binding key is optional and is not used
// for routing decisions. It can be useful for tracking
// messages and routing in logs.
string myQueue = session.Name;
session.QueueDeclare(myQueue, Option.EXCLUSIVE, Option.AUTO_DELETE);
session.ExchangeBind(myQueue, "amq.fanout", "my-key");
lock (session)
{
Console.WriteLine("Listening");
// Create a listener and subscribe it to my queue.
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, myQueue);
session.MessageSubscribe(myQueue);
// Receive messages until all messages are received
Monitor.Wait(session);
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
/// <summary>
/// Called whenever Excel requests a new RTD topic from the RealTimeData server.
/// </summary>
/// <param name="TopicID"></param>
/// <param name="Strings"></param>
/// <param name="GetNewValues"></param>
/// <returns></returns>
public object ConnectData(int TopicID, ref Array Strings, ref bool GetNewValues)
{
try
{
string queuename = "defaultExcelAddInQueue";
string destinationName = "ExcelAddIn-" + queuename;
if (Strings.Length > 0)
{
queuename = (string)Strings.GetValue(0);
}
// Error message if the queue does not exist
QueueQueryResult result = (QueueQueryResult)_session.QueueQuery(queuename).Result;
if (result.GetQueue() == null)
{
System.Windows.Forms.MessageBox.Show("Error: \n queue " + queuename + " does not exist");
return("error");
}
QpidListener listener;
_topicMessages.Add(TopicID, null);
_topicQueueName.Add(TopicID, queuename);
if (_queueListener.ContainsKey(queuename))
{
listener = _queueListener[queuename];
listener.addTopic(TopicID);
}
else
{
listener = new QpidListener(this);
listener.addTopic(TopicID);
_queueListener.Add(queuename, listener);
_session.AttachMessageListener(listener, destinationName);
_session.MessageSubscribe(queuename, destinationName, MessageAcceptMode.EXPLICIT,
MessageAcquireMode.PRE_ACQUIRED, null, 0, null);
// issue credits
_session.MessageSetFlowMode(destinationName, MessageFlowMode.WINDOW);
_session.MessageFlow(destinationName, MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
_session.MessageFlow(destinationName, MessageCreditUnit.MESSAGE, 1000);
_session.Sync();
}
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show("Error: \n" + e.StackTrace);
return("error");
}
return("waiting");
}
static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
// Create a request queue for clients to use when making
// requests.
const string request_queue = "request";
// Use the name of the request queue as the routing key
session.QueueDeclare(request_queue);
session.ExchangeBind(request_queue, "amq.direct", request_queue);
lock (session)
{
// Create a listener and subscribe it to the request_queue
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, request_queue);
session.MessageSubscribe(request_queue);
// Receive messages until all messages are received
Console.WriteLine("Waiting for requests");
Monitor.Wait(session);
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
private static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
// Create a queue named "message_queue", and route all messages whose
// routing key is "routing_key" to this newly created queue.
session.QueueDeclare("message_queue");
session.ExchangeBind("message_queue", "amq.direct", "routing_key");
lock (session)
{
// Create a listener and subscribe it to the queue named "message_queue"
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, "message_queue");
session.MessageSubscribe("message_queue");
// Receive messages until all messages are received
Monitor.Wait(session);
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
private static void prepareQueue(string queue, string routing_key, IClientSession session)
{
// Create a unique queue name for this consumer by concatenating
// the queue name parameter with the Session ID.
Console.WriteLine("Declaring queue: " + queue);
session.QueueDeclare(queue, Option.EXCLUSIVE, Option.AUTO_DELETE);
// Route messages to the new queue if they match the routing key.
// Also route any messages to with the "control" routing key to
// this queue so we know when it's time to stop. A publisher sends
// a message with the content "That's all, Folks!", using the
// "control" routing key, when it is finished.
session.ExchangeBind(queue, "amq.topic", routing_key);
session.ExchangeBind(queue, "amq.topic", "control");
// subscribe the listener to the queue
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, queue);
session.MessageSubscribe(queue);
}
private static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
IMessage request = new Message();
//--------- Main body of program --------------------------------------------
// Create a response queue so the server can send us responses
// to our requests. Use the client's session ID as the name
// of the response queue.
string response_queue = "client" + session.GetName();
// Use the name of the response queue as the routing key
session.QueueDeclare(response_queue);
session.ExchangeBind(response_queue, "amq.direct", response_queue);
// Each client sends the name of their own response queue so
// the service knows where to route messages.
request.DeliveryProperties.SetRoutingKey("request");
request.MessageProperties.SetReplyTo(new ReplyTo("amq.direct", response_queue));
lock (session)
{
// Create a listener for the response queue and listen for response messages.
Console.WriteLine("Activating response queue listener for: " + response_queue);
IMessageListener listener = new ClientMessageListener(session);
session.AttachMessageListener(listener, response_queue);
session.MessageSubscribe(response_queue);
// Now send some requests ...
string[] strs =
{
"Twas brillig, and the slithy toves",
"Did gire and gymble in the wabe.",
"All mimsy were the borogroves,",
"And the mome raths outgrabe.",
"That's all, folks!"
};
foreach (string s in strs)
{
request.ClearData();
request.AppendData(Encoding.UTF8.GetBytes(s));
session.MessageTransfer("amq.direct", request);
}
Console.WriteLine("Waiting for all responses to arrive ...");
Monitor.Wait(session);
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
public void setHeaders()
{
_log.Debug("Running: setHeaders");
IClientSession ssn = Client.CreateSession(0);
ssn.QueueDeclare("queue1");
ssn.ExchangeBind("queue1", "amq.direct", "queue1");
ssn.Sync();
CircularBuffer <IMessage> buff = new CircularBuffer <IMessage>(10);
SyncListener listener = new SyncListener(ssn, buff);
ssn.AttachMessageListener(listener, "queue1");
ssn.MessageSubscribe("queue1");
IMessage message = new org.apache.qpid.client.Message();
message.DeliveryProperties.SetRoutingKey("queue1");
const long someLong = 14444444;
message.ApplicationHeaders.Add("someLong", someLong);
const int someInt = 14;
message.ApplicationHeaders.Add("soneInt", someInt);
const float someFloat = 14.001F;
message.ApplicationHeaders.Add("soneFloat", someFloat);
const double someDouble = 14.5555555;
message.ApplicationHeaders.Add("someDouble", someDouble);
const byte someByte = 2;
message.ApplicationHeaders.Add("someByte", someByte);
const string someString = "someString";
message.ApplicationHeaders.Add("someString", someString);
const char someChar = 'a';
message.ApplicationHeaders.Add("someChar", someChar);
const Boolean someBoolean = true;
message.ApplicationHeaders.Add("someBoolean", someBoolean);
// transfer the message
ssn.MessageTransfer("amq.direct", message);
// get the message and check the headers
IMessage messageBack = buff.Dequeue();
Assert.IsTrue(((string)messageBack.ApplicationHeaders["someString"]).Equals(someString));
Assert.IsTrue(((char)messageBack.ApplicationHeaders["someChar"]).Equals(someChar));
Assert.IsTrue((long)messageBack.ApplicationHeaders["someLong"] == someLong);
Assert.IsTrue((int)messageBack.ApplicationHeaders["soneInt"] == someInt);
Assert.IsTrue((double)messageBack.ApplicationHeaders["someDouble"] == someDouble);
Assert.IsTrue((byte)messageBack.ApplicationHeaders["someByte"] == someByte);
Assert.IsTrue((Boolean)messageBack.ApplicationHeaders["someBoolean"]);
// c# has an conversion precision issue with decimal
Assert.IsTrue((float)messageBack.ApplicationHeaders["soneFloat"] <= someFloat);
float b = (float)messageBack.ApplicationHeaders["soneFloat"];
Assert.IsTrue(Convert.ToInt32(b) == Convert.ToInt32(someFloat));
}
static void Main(string[] args)
{
XmlConfigurator.Configure(new FileInfo("..\\..\\log.xml"));
// DOMConfigurator.Configure()
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
IConnectionInfo connectionInfo = new QpidConnectionInfo();
connectionInfo.VirtualHost = virtualhost;
//connectionInfo.host = host;
//connectionInfo.port = port;
connectionInfo.Username = username;
connectionInfo.Password = password;
//Client client = new Client();
Console.WriteLine("Client created");
//client.Connect(host, port, virtualhost, username, password);
IConnection clientConnection = new AMQConnection(connectionInfo);
Console.WriteLine("Connection established");
IClientSession ssn = client.CreateSession(50000);
Console.WriteLine("Session created");
ssn.QueueDeclare("queue1", null, null);
ssn.ExchangeBind("queue1", "amq.direct", "queue1", null);
Object wl = new Object();
ssn.AttachMessageListener(new MyListener(ssn, wl), "myDest");
ssn.MessageSubscribe("queue1", "myDest", MessageAcceptMode.EXPLICIT, MessageAcquireMode.PRE_ACQUIRED, null,
0, null);
DateTime start = DateTime.Now;
// issue credits
ssn.MessageSetFlowMode("myDest", MessageFlowMode.WINDOW);
ssn.MessageFlow("myDest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
ssn.MessageFlow("myDest", MessageCreditUnit.MESSAGE, 10000);
ssn.Sync();
for (int i = 0; i < 10000; i++)
{
ssn.MessageTransfer("amq.direct", MessageAcceptMode.NONE, MessageAcquireMode.PRE_ACQUIRED,
new Header(new DeliveryProperties().SetRoutingKey("queue1"),
new MessageProperties().SetMessageId(UUID.RandomUuid())),
Encoding.UTF8.GetBytes("test: " + i));
}
lock (wl)
{
Monitor.Wait(wl);
}
DateTime now = DateTime.Now;
Console.WriteLine("Start time " + start + " now: " + now);
Console.WriteLine("Done time: " + (now - start));
lock (wl)
{
Monitor.Wait(wl, 30000);
}
client.Close();
}
protected void TryToConnect() {
reqsOutstanding = 1 ;
Agent newAgent = new Agent(this,0,"BrokerAgent") ;
Agents.Add(newAgent.AgentKey(), newAgent) ;
client = new Client() ;
client.Connect(url.Hostname, url.Port, null, url.AuthName, url.AuthPassword) ;
clientSession = client.CreateSession(timeout) ;
//clientSession.SetAutoSync(false) ;
string name = System.Text.Encoding.UTF8.GetString(clientSession.GetName()) ;
replyName = "reply-" + name ;
topicName = "topic-" + name ;
clientSession.SetAutoSync(true) ;
Option[] options = new Option[] {Option.EXCLUSIVE, Option.AUTO_DELETE} ;
// This queue is used for responses to messages which are sent.
clientSession.QueueDeclare(replyName,options) ;
clientSession.ExchangeBind(replyName,"amq.direct",replyName) ;
clientSession.AttachMessageListener(this, "rdest") ;
clientSession.MessageSubscribe(replyName,"rdest",MessageAcceptMode.NONE,MessageAcquireMode.PRE_ACQUIRED,null,0,null) ;
clientSession.MessageSetFlowMode("rdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("rdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("rdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
// This queue is used for unsolicited messages sent to this class.
clientSession.QueueDeclare(topicName, options) ;
clientSession.AttachMessageListener(this, "tdest") ;
clientSession.MessageSubscribe(topicName,"tdest",MessageAcceptMode.NONE,MessageAcquireMode.PRE_ACQUIRED,null,0,null) ;
clientSession.MessageSetFlowMode("tdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("tdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("tdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
outSession = client.CreateSession(timeout) ;
outSession.ExchangeBind(replyName,"amq.direct",replyName) ;
connected = true ;
consoleSession.HandleBrokerConnect(this) ;
IEncoder encoder = CreateEncoder() ;
this.SetHeader(encoder, 'B', 0) ;
this.Send(encoder) ;
}
private static void prepareQueue(string queue, string routing_key, IClientSession session)
{
// Create a unique queue name for this consumer by concatenating
// the queue name parameter with the Session ID.
Console.WriteLine("Declaring queue: " + queue);
session.QueueDeclare(queue, Option.EXCLUSIVE, Option.AUTO_DELETE);
// Route messages to the new queue if they match the routing key.
// Also route any messages to with the "control" routing key to
// this queue so we know when it's time to stop. A publisher sends
// a message with the content "That's all, Folks!", using the
// "control" routing key, when it is finished.
session.ExchangeBind(queue, "amq.topic", routing_key);
session.ExchangeBind(queue, "amq.topic", "control");
// subscribe the listener to the queue
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, queue);
session.MessageSubscribe(queue);
}
