public void Stop()
{
var start = Listener.Start;
var end = DateTime.UtcNow;
var seconds = (end - start).Seconds;
var count = MyMessageListener.Counter;
var rate = 1.0 * count / seconds;
Console.WriteLine("Received {0} messages in {1} seconds. Rate is {2} msgs/sec.", count, seconds, rate);
_consumer.Close();
_session.Close();
_connection.Stop();
}
public IEnumerable <IMessageSelector> SelectiveReceive(TimeSpan timeout)
{
Session session = _connection.CreateSession(true, SessionMode.SessionTransacted);
if (session == null)
{
throw new EndpointException(Uri, "Unable to open session to endpoint");
}
Destination destination = session.CreateQueue(_queueName);
MessageConsumer consumer = session.CreateConsumer(destination);
if (consumer != null)
{
Message message;
do
{
message = consumer.Receive((long)timeout.TotalMilliseconds);
if (message != null)
{
using (var selector = new TibcoMessageSelector(this, session, message, _serializer))
{
yield return(selector);
}
}
} while (message != null);
consumer.Close();
}
else
{
throw new EndpointException(Uri, "Unable to create message consumer");
}
session.Close();
}
async Task ActiveAndActualAgentsCompleted(StopContext context)
{
if (_dispatcher.ActiveDispatchCount > 0)
{
try
{
await _deliveryComplete.Task.OrCanceled(context.CancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
LogContext.Warning?.Log("Stop canceled waiting for message consumers to complete: {InputAddress}", _context.InputAddress);
}
}
try
{
_messageConsumer.Close();
_messageConsumer.Dispose();
}
catch (OperationCanceledException)
{
LogContext.Warning?.Log("Stop canceled waiting for consumer shutdown: {InputAddress}", _context.InputAddress);
}
}
private void Run()
{
int i = 0;
bool first = true;
Message msg;
String uniqueName = null;
int numMsgsToReceive;
MessageConsumer msgConsumer = null;
Session session = null;
try
{
Thread.Sleep(new TimeSpan(10000 * 250));
}
catch (ThreadInterruptedException)
{
}
try
{
// create the session
Connection connection = this.MyConnection;
session = connection.CreateSession(useTxn, ackMode);
// create the destination
Destination destination = CreateDestination(session);
// create the consumer
if (durableName == null)
{
msgConsumer = session.CreateConsumer(destination);
}
else
{
uniqueName = this.MyUniqueName;
msgConsumer = session.CreateDurableSubscriber((Topic)destination, uniqueName);
}
if (Tibems.IsConsumerMulticast(msgConsumer))
{
Tibems.MulticastExceptionHandler += new EMSMulticastExceptionHandler(HandleMulticastException);
}
if (uniqueDests || useTopic)
{
numMsgsToReceive = count;
}
else
{
numMsgsToReceive = (count / threads);
}
// read messages
for (i = 0; i < numMsgsToReceive; i++)
{
// receive the message
msg = msgConsumer.Receive();
if (first)
{
startTime.Add((DateTime.Now.Ticks - 621355968000000000) / 10000);
first = false;
}
if (msg == null)
{
break;
}
if (ackMode == Session.CLIENT_ACKNOWLEDGE ||
ackMode == Session.EXPLICIT_CLIENT_ACKNOWLEDGE ||
ackMode == Session.EXPLICIT_CLIENT_DUPS_OK_ACKNOWLEDGE)
{
msg.Acknowledge();
}
if (useTxn && (i % txnSize) == (txnSize - 1))
{
session.Commit();
}
}
if (useTxn)
{
session.Commit();
}
}
catch (EMSException e)
{
if (!stopNow)
{
Console.Error.WriteLine("Exception in csMsgConsumerPerf: " +
e.Message);
Console.Error.WriteLine(e.StackTrace);
if (e.LinkedException != null)
{
Console.Error.WriteLine("Linked Exception: " +
e.LinkedException.Message);
Console.Error.WriteLine(e.LinkedException.StackTrace);
}
Environment.Exit(-1);
}
}
if (!first)
{
endTime.Add((DateTime.Now.Ticks - 621355968000000000) / 10000);
CountReceives(i);
}
try
{
msgConsumer.Close();
if (durableName != null)
{
session.Unsubscribe(uniqueName);
}
session.Close();
}
catch (EMSException)
{
}
}
public csBrowser(string[] args)
{
ParseArgs(args);
try {
tibemsUtilities.initSSLParams(serverUrl, args);
}
catch (Exception e)
{
System.Console.WriteLine("Exception: " + e.Message);
System.Console.WriteLine(e.StackTrace);
System.Environment.Exit(-1);
}
Console.WriteLine("\n------------------------------------------------------------------------");
Console.WriteLine("csBrowser SAMPLE");
Console.WriteLine("------------------------------------------------------------------------");
Console.WriteLine("Server....................... " + ((serverUrl != null)?serverUrl:"localhost"));
Console.WriteLine("User......................... " + ((userName != null)?userName:"******"));
Console.WriteLine("Queue........................ " + queueName);
Console.WriteLine("------------------------------------------------------------------------\n");
try {
ConnectionFactory factory = new TIBCO.EMS.ConnectionFactory(serverUrl);
Connection connection = factory.CreateConnection(userName, password);
Session session = connection.CreateSession(false, Session.AUTO_ACKNOWLEDGE);
TIBCO.EMS.Queue queue = session.CreateQueue(queueName);
MessageProducer producer = session.CreateProducer(queue);
Message message = null;
connection.Start();
// drain the queue
MessageConsumer consumer = session.CreateConsumer(queue);
int drain_count = 0;
Console.WriteLine("Draining the queue " + queueName);
// read queue until empty
while (consumer.Receive(1000) != null)
{
drain_count++;
}
Console.WriteLine("Drained " + drain_count + " messages from the queue");
// close consumer to prevent any queue messages from being delivered
consumer.Close();
int message_number = 0;
// send 5 messages into queue
Console.WriteLine("Sending 5 messages into queue.");
for (int i = 0; i < 5; i++)
{
message_number++;
message = session.CreateMessage();
message.SetIntProperty("msg_num", message_number);
producer.Send(message);
}
// create browser and browse what is there in the queue
Console.WriteLine("--- Browsing the queue.");
QueueBrowser browser = session.CreateBrowser(queue);
IEnumerator msgs = browser.GetEnumerator();
int browseCount = 0;
while (msgs.MoveNext())
{
message = (Message)msgs.Current;
Console.WriteLine("Browsed message: number=" + message.GetIntProperty("msg_num"));
browseCount++;
}
Console.WriteLine("--- No more messages in the queue.");
// send 5 more messages into queue
Console.WriteLine("Sending 5 more messages into queue.");
for (int i = 0; i < 5; i++)
{
message_number++;
message = session.CreateMessage();
message.SetIntProperty("msg_num", message_number);
producer.Send(message);
}
// try to browse again, if no success for some time then quit
// notice that we will NOT receive new messages instantly. It
// happens because QueueBrowser limits the frequency of query
// requests sent into the queue after the queue was
// empty. Internal engine only queries the queue every so many
// seconds, so we'll likely have to wait here for some time.
int attemptCount = 0;
while (!msgs.MoveNext())
{
attemptCount++;
Console.WriteLine("Waiting for messages to arrive, count=" + attemptCount);
Thread.Sleep(1000);
if (attemptCount > 30)
{
Console.WriteLine("Still no messages in the queue after " + attemptCount + " seconds");
Environment.Exit(0);
}
}
// got more messages, continue browsing
Console.WriteLine("Found more messages. Continue browsing.");
do
{
message = (Message)msgs.Current;
Console.WriteLine("Browsed message: number=" + message.GetIntProperty("msg_num"));
} while (msgs.MoveNext());
// close all and quit
browser.Close();
connection.Close();
} catch (EMSException e) {
Console.Error.WriteLine("Exception in csBrowser: " + e.Message);
Console.Error.WriteLine(e.StackTrace);
Environment.Exit(0);
} catch (ThreadInterruptedException e) {
Console.Error.WriteLine("Exception in csBrowser: " + e.Message);
Console.Error.WriteLine(e.StackTrace);
Environment.Exit(0);
}
}
public void Close()
{
nativeMessageConsumer.Close();
}
public csSelector(String[] args)
{
ParseArgs(args);
try {
tibemsUtilities.initSSLParams(serverUrl, args);
}
catch (Exception e)
{
System.Console.WriteLine("Exception: " + e.Message);
System.Console.WriteLine(e.StackTrace);
System.Environment.Exit(-1);
}
Console.WriteLine("\n------------------------------------------------------------------------");
Console.WriteLine("csSelector SAMPLE");
Console.WriteLine("------------------------------------------------------------------------");
Console.WriteLine("Server....................... " + ((serverUrl != null)?serverUrl:"localhost"));
Console.WriteLine("User......................... " + ((userName != null)?userName:"******"));
Console.WriteLine("Queue........................ " + queueName);
Console.WriteLine("------------------------------------------------------------------------\n");
if (!noselector)
{
Console.WriteLine("\n*** Also try to run this sample with the -noselector");
Console.WriteLine("*** option to see the difference it makes.");
}
try {
ConnectionFactory factory = new TIBCO.EMS.ConnectionFactory(serverUrl);
Connection connection = factory.CreateConnection(userName, password);
Session receive_session = connection.CreateSession(false, Session.AUTO_ACKNOWLEDGE);
Session send_session = connection.CreateSession(false, Session.AUTO_ACKNOWLEDGE);
Queue queue = send_session.CreateQueue(queueName);
// Start the connection so we can drain the queue and then proceed.
connection.Start();
// drain the queue
MessageConsumer receiver = receive_session.CreateConsumer(queue);
int drain_count = 0;
Console.WriteLine("\nDraining the queue " + queueName);
// read queue until empty
while (receiver.Receive(1000) != null)
{
drain_count++;
}
Console.WriteLine("Drained " + drain_count + " messages from the queue");
// close receiver to prevent any queue messages to be delivered
receiver.Close();
// create receivers with selectors
Console.WriteLine("");
if (!noselector)
{
Console.WriteLine("Creating receivers with selectors:\n");
}
else
{
Console.WriteLine("Creating receivers without selectors:\n");
}
Thread.Sleep(500);
int receiver_count = 3;
for (int i = 0; i < receiver_count; i++)
{
String selector = null;
if (!noselector)
{
selector = "count >= " + (i * 4) + " AND count < " + (i * 4 + 4);
}
receiver = receive_session.CreateConsumer(queue, selector);
if (!noselector)
{
Console.WriteLine("Created receiver " + i + " with selector: \"" + selector + "\"");
}
else
{
Console.WriteLine("Created receiver " + i);
}
receiver.MessageListener = new MyMessageListener(i);
Thread.Sleep(500);
}
// create sender
MessageProducer sender = send_session.CreateProducer(queue);
Message message = null;
int message_number = 0;
// send 12 messages into queue
Console.WriteLine("");
Console.WriteLine("Sending 12 messages into the queue:\n");
Thread.Sleep(200);
for (int i = 0; i < 12; i++)
{
message = send_session.CreateMessage();
message.SetIntProperty("count", message_number);
sender.Send(message);
Thread.Sleep(500);
message_number++;
}
// wait for some time while all messages received
Thread.Sleep(1000);
connection.Close();
} catch (EMSException e) {
Console.Error.WriteLine("Exception in csSelector: " + e.Message);
Console.Error.WriteLine(e.StackTrace);
Environment.Exit(0);
} catch (ThreadInterruptedException e) {
Console.Error.WriteLine("Exception in csSelector: " + e.Message);
Console.Error.WriteLine(e.StackTrace);
Environment.Exit(0);
}
}
