public Producer()
{
string serverUrl = ConfigurationManager.AppSettings["serverUrl"];
string userName = ConfigurationManager.AppSettings["userName"];
string password = ConfigurationManager.AppSettings["password"];
string topicName = ConfigurationManager.AppSettings["avnTopicName"];
string inputQueueName = ConfigurationManager.AppSettings["inputQueueName"];
try
{
ConnectionFactory factory = new TIBCO.EMS.ConnectionFactory(serverUrl);
connection = factory.CreateConnection(userName, password);
// create the session
session = connection.CreateSession(false, Session.NO_ACKNOWLEDGE);
// create the destination
destination = session.CreateQueue(inputQueueName);
//destination = session.CreateTopic(topicName);
// create the producer
msgProducer = session.CreateProducer(null);
msg = session.CreateTextMessage();
}
catch (Exception ex)
{
Console.WriteLine("EMS Error: {0} {1}", ex.Message, ex.InnerException.Message);
}
}
public void Reconnect()
{
if (Session != null && !Session.IsClosed)
Session.Close();
Provider.Connect();
Session = Provider.Connection.CreateSession(false, SessionMode.AutoAcknowledge);
Destination = Session.CreateQueue(QueueName);
AfterReconnect();
}
public AsyncMessageConsumerUsingMessageListener(String QueueName, int NoOfSessions)
{
EMSQueueConnection.connection.Stop(); /* Iffy if multiple clients are using the conn. */
this.QueueName = QueueName;
this.NoOfSessions = NoOfSessions;
TIBCO.EMS.Session session = null;
TIBCO.EMS.MessageConsumer msgConsumer = null;
TIBCO.EMS.Destination destination = null;
try
{
for (int i = 0; i < NoOfSessions; i++)
{
/*
* Create a new session which in turn creates a thread interanlly .
* Ack mode is hard coded for now , see no possibulty for it being other than CLient_ack*/
session = EMSQueueConnection.connection.CreateSession(false, Session.CLIENT_ACKNOWLEDGE);
// create the consumer
if (destination == null)
{
destination = session.CreateQueue(QueueName);
}
msgConsumer = session.CreateConsumer(destination);
// set the message listener
msgConsumer.MessageListener = this;
/*
* Console.WriteLine("\n Subscribing to destination: " + QueueName);Console.WriteLine("************************************************\n ThreadName:"
+ System.Threading.Thread.CurrentThread.Name + "\n Session:" + session.ToString()
+
+ "\n SessionID:" + session.SessID + "\n Connection:" + session.Connection.ToString() +
+ "\n MessageConsumer:" + msgConsumer.ToString() );*/
}
EMSQueueConnection.connection.Start();
// Start pub-sub messages
}
catch (Exception e)
{
Console.Error.WriteLine("Exception in AsyncMsgConsumer: " + e.Message);
Console.Error.WriteLine(e.StackTrace);
}
}
public IMessageConsumer CreateConsumer(Destination dest, string messageSelector, bool noLocal)
{
return new EmsMessageConsumer(nativeSession.CreateConsumer(dest, messageSelector, noLocal));
}
public IMessageProducer CreateProducer(Destination dest)
{
return new EmsMessageProducer(nativeSession.CreateProducer(dest));
}
public IMessageConsumer CreateConsumer(Destination destination, string selector)
{
return new TestMessageConsumer();
}
public IMessageProducer CreateProducer(Destination dest)
{
return new TestMessageProducer();
}
public void Send(Destination destination, Message message)
{
throw new NotImplementedException();
}
/// <summary> Send the given object to the specified destination, converting the object
/// to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
/// callback allows for modification of the message after conversion.
/// </summary>
/// <param name="destination">the destination to send this message to
/// </param>
/// <param name="message">the object to convert to a message
/// </param>
/// <param name="postProcessor">the callback to modify the message
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
public void ConvertAndSend(Destination destination, object message, IMessagePostProcessor postProcessor)
{
CheckMessageConverter();
Send(destination, new ConvertAndSendMessageCreator(this, message, postProcessor));
}
/// <summary> Send a message to the specified destination.
/// The MessageCreator callback creates the message given a Session.
/// </summary>
/// <param name="destination">the destination to send this message to
/// </param>
/// <param name="messageCreator">callback to create a message
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
public void Send(Destination destination, IMessageCreator messageCreator)
{
Execute(new SendDestinationCallback(this, destination, messageCreator), false);
}
public SendDestinationCallback(EmsTemplate jmsTemplate, Destination destination, IMessageCreator messageCreator)
{
this.jmsTemplate = jmsTemplate;
this.destination = destination;
this.messageCreator = messageCreator;
}
public ReceiveSelectedCallback(EmsTemplate jmsTemplate,
Destination destination,
string messageSelector)
{
this.jmsTemplate = jmsTemplate;
this.destination = destination;
this.messageSelector = messageSelector;
}
public ReceiveCallback(EmsTemplate jmsTemplate, Destination destination)
{
this.jmsTemplate = jmsTemplate;
this.destination = destination;
}
/// <summary> Receive a message synchronously from the specified destination, but only
/// wait up to a specified time for delivery. Convert the message into an
/// object with a configured IMessageConverter.
/// <p>This method should be used carefully, since it will block the thread
/// until the message becomes available or until the timeout value is exceeded.</p>
/// </summary>
/// <param name="destination">the destination to receive a message from
/// </param>
/// <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
/// See the EMS specification for a detailed definition of selector expressions.
/// </param>
/// <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
public object ReceiveSelectedAndConvert(Destination destination, string messageSelector)
{
CheckMessageConverter();
return DoConvertFromMessage(ReceiveSelected(destination, messageSelector));
}
/// <summary> Receive a message synchronously from the specified destination, but only
/// wait up to a specified time for delivery. Convert the message into an
/// object with a configured IMessageConverter.
/// <p>This method should be used carefully, since it will block the thread
/// until the message becomes available or until the timeout value is exceeded.</p>
/// </summary>
/// <param name="destination">the destination to receive a message from
/// </param>
/// <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
public object ReceiveAndConvert(Destination destination)
{
CheckMessageConverter();
return DoConvertFromMessage(Receive(destination));
}
/// <summary> Send a message to the specified destination.
/// The MessageCreator callback creates the message given a Session.
/// </summary>
/// <param name="destination">the destination to send this message to
/// </param>
/// <param name="messageCreatorDelegate">delegate callback to create a message
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
public void SendWithDelegate(Destination destination, MessageCreatorDelegate messageCreatorDelegate)
{
Execute(new SendDestinationCallback(this, destination, messageCreatorDelegate), false);
}
public SendDestinationCallback(EmsTemplate jmsTemplate, Destination destination, MessageCreatorDelegate messageCreatorDelegate)
{
this.jmsTemplate = jmsTemplate;
this.destination = destination;
this.messageCreatorDelegate = messageCreatorDelegate;
}
/// <summary> Send the given object to the specified destination, converting the object
/// to a EMS message with a configured IMessageConverter.
/// </summary>
/// <param name="destination">the destination to send this message to
/// </param>
/// <param name="message">the object to convert to a message
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
public void ConvertAndSend(Destination destination, object message)
{
CheckMessageConverter();
Send(destination, new SimpleMessageCreator(this, message));
}
public object DoInEms(ISession session)
{
if (destination == null)
{
destination = jmsTemplate.ResolveDestinationName(session, destinationName);
}
if (messageCreator != null)
{
jmsTemplate.DoSend(session, destination, messageCreator);
}
else
{
jmsTemplate.DoSend(session, destination, messageCreatorDelegate);
}
return null;
}
/// <summary>
/// Opens if is not initialized yet, otherwise just returns with no action.
/// </summary>
public void Open()
{
if (!initialized)
{
ValidateQueueConfiguration();
try
{
factory = new ConnectionFactory(ServerConfig.Url, ServerConfig.ClientId);
}
catch (EMSException e)
{
Log.TraceData(Log.Source, TraceEventType.Error, 15000, "URL/Client ID is wrong. " + e.ToString());
throw;
}
IConfigurationValueProvider configProvider = new SingleTagSectionConfigurationProvider(this.ServerConfig.AuthenticationSectionName);
try
{
connection = factory.CreateConnection(configProvider["userName"], configProvider["password"]);
}
catch (EMSException e)
{
Log.TraceData(Log.Source, TraceEventType.Error, 15001, "Connection to ems server failed! " + e.ToString());
throw;
}
try
{
session = connection.CreateSession(this.sessionConfig.IsTransactional, sessionConfig.Mode);
}
catch (EMSException e)
{
Log.TraceData(Log.Source, TraceEventType.Error, 15002, "Error during session creation. " + e.ToString());
throw;
}
try
{
destination =
CreateDestination(session, queueConfig.Name, queueConfig.Type);
consumer =
session.CreateConsumer(destination, queueConfig.MessageSelector,
queueConfig.NoLocal);
connection.Start();
}
catch (EMSException e)
{
Log.TraceData(Log.Source, TraceEventType.Error, 15003, "Queue initialization error. " + e);
throw;
}
initialized = true;
}
}
/// <summary> Create a EMS MessageProducer for the given Session and Destination,
/// configuring it to disable message ids and/or timestamps (if necessary).
/// <p>Delegates to <code>doCreateProducer</code> for creation of the raw
/// EMS MessageProducer</p>
/// </summary>
/// <param name="session">the EMS Session to create a MessageProducer for
/// </param>
/// <param name="destination">the EMS Destination to create a MessageProducer for
/// </param>
/// <returns> the new EMS MessageProducer
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
/// <seealso cref="DoCreateProducer">
/// </seealso>
/// <seealso cref="MessageIdEnabled">
/// </seealso>
/// <seealso cref="MessageTimestampEnabled">
/// </seealso>
protected virtual IMessageProducer CreateProducer(ISession session, Destination destination)
{
IMessageProducer producer = DoCreateProducer(session, destination);
if (!MessageIdEnabled)
{
producer.DisableMessageID = true;
}
if (!MessageTimestampEnabled)
{
producer.DisableMessageTimestamp = true;
}
return producer;
}
public void Send(Destination dest, Message message, MessageDeliveryMode deliveryMode, int priority, long timeToLive)
{
throw new NotImplementedException();
}
/// <summary> Create a raw EMS MessageProducer for the given Session and Destination.
/// </summary>
/// <remarks>If CacheJmsResource is true, then the producer
/// will be created upon the first invocation and will retrun the same
/// producer (per destination) on all subsequent calls.
/// </remarks>
/// <param name="session">the EMS Session to create a MessageProducer for
/// </param>
/// <param name="destination">the EMS Destination to create a MessageProducer for
/// </param>
/// <returns> the new EMS MessageProducer
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected virtual IMessageProducer DoCreateProducer(ISession session, Destination destination)
{
return session.CreateProducer(destination);
/*
if (CacheEmsResources)
{
if (destination == null)
{
if (emsResources.UnspecifiedDestinationMessageProducer == null)
{
emsResources.UnspecifiedDestinationMessageProducer = session.CreateProducer(destination);
}
return emsResources.UnspecifiedDestinationMessageProducer;
}
IMessageProducer producer = (IMessageProducer)emsResources.Producers[destination];
if (producer != null)
{
#region Logging
if (logger.IsDebugEnabled)
{
logger.Debug("Found cached MessageProducer for destination [" + destination + "]");
}
#endregion
}
else
{
producer = session.CreateProducer(destination);
emsResources.Producers.Add(destination, producer);
#region Logging
if (logger.IsDebugEnabled)
{
logger.Debug("Created cached MessageProducer for destination [" + destination + "]");
}
#endregion
}
return producer;
}
else
{
return session.CreateProducer(destination);
}*/
}
public IMessageConsumer CreateConsumer(Destination destination)
{
return new TestMessageConsumer();
}
/// <summary> Create a EMS MessageConsumer for the given Session and Destination.
/// </summary>
/// <param name="session">the EMS Session to create a MessageConsumer for
/// </param>
/// <param name="destination">the EMS Destination to create a MessageConsumer for
/// </param>
/// <param name="messageSelector">the message selector for this consumer (can be <code>null</code>)
/// </param>
/// <returns> the new EMS MessageConsumer
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected virtual IMessageConsumer CreateConsumer(ISession session, Destination destination,
string messageSelector)
{
// Only pass in the NoLocal flag in case of a Topic:
// Some EMS providers, such as WebSphere MQ 6.0, throw IllegalStateException
// in case of the NoLocal flag being specified for a Queue.
if (PubSubDomain)
{
return session.CreateConsumer(destination, messageSelector, PubSubNoLocal);
}
else
{
return session.CreateConsumer(destination, messageSelector);
}
}
public IMessageConsumer CreateConsumer(Destination dest, string messageSelector, bool noLocal)
{
return new TestMessageConsumer();
}
/*
/// <summary>Create a EMS Connection via this template's ConnectionFactory.
/// </summary>
/// <remarks>If CacheJmsResource is true, then the connection
/// will be created upon the first invocation and will retrun the same
/// connection on all subsequent calls.
/// </remarks>
/// <returns>A EMS Connection
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected override IConnection CreateConnection()
{
if (CacheEmsResources)
{
if (emsResources.Connection == null)
{
emsResources.Connection = ConnectionFactory.CreateConnection();
}
return emsResources.Connection;
}
else
{
return ConnectionFactory.CreateConnection();
}
}*/
/*
/// <summary> Create a EMS Session for the given Connection.
/// </summary>
/// <remarks>If CacheJmsResource is true, then the session
/// will be created upon the first invocation and will retrun the same
/// session on all subsequent calls.
/// </remarks>
/// <param name="con">the EMS Connection to create a Session for
/// </param>
/// <returns> the new EMS Session
/// </returns>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected override ISession CreateSession(IConnection con)
{
if (CacheEmsResources)
{
if (emsResources.Session == null)
{
emsResources.Session = emsResources.Connection.CreateSession(SessionTransacted, SessionAcknowledgeMode);
}
return emsResources.Session;
}
else
{
return con.CreateSession(SessionTransacted, SessionAcknowledgeMode);
}
}*/
/// <summary>
/// Send the given message.
/// </summary>
/// <param name="session">The session to operate on.</param>
/// <param name="destination">The destination to send to.</param>
/// <param name="messageCreatorDelegate">The message creator delegate callback to create a Message.</param>
protected internal virtual void DoSend(ISession session, Destination destination, MessageCreatorDelegate messageCreatorDelegate)
{
AssertUtils.ArgumentNotNull(messageCreatorDelegate, "IMessageCreatorDelegate must not be null");
DoSend(session, destination, null, messageCreatorDelegate);
}
public IMessageConsumer CreateConsumer(Destination dest)
{
return new EmsMessageConsumer(nativeSession.CreateConsumer(dest));
}
/// <summary>
/// Send the given message.
/// </summary>
/// <param name="session">The session to operate on.</param>
/// <param name="destination">The destination to send to.</param>
/// <param name="messageCreator">The message creator callback to create a Message.</param>
protected internal virtual void DoSend(ISession session, Destination destination, IMessageCreator messageCreator)
{
AssertUtils.ArgumentNotNull(messageCreator, "IMessageCreator must not be null");
DoSend(session, destination, messageCreator, null);
}
/// <summary>
/// Creates a MessageConsumer for the given Session and Destination.
/// </summary>
/// <param name="session">The session to create a MessageConsumer for.</param>
/// <param name="destination">The destination to create a MessageConsumer for.</param>
/// <returns>The new MessageConsumer</returns>
protected IMessageConsumer CreateConsumer(ISession session, Destination destination)
{
// Only pass in the NoLocal flag in case of a Topic:
// Some EMS providers, such as WebSphere MQ 6.0, throw IllegalStateException
// in case of the NoLocal flag being specified for a Queue.
if (PubSubDomain)
{
if (SubscriptionDurable && destination is Topic)
{
return session.CreateDurableSubscriber(
(Topic) destination, DurableSubscriptionName, MessageSelector, PubSubNoLocal);
}
else
{
return session.CreateConsumer(destination, MessageSelector, PubSubNoLocal);
}
}
else
{
return session.CreateConsumer(destination, MessageSelector);
}
}
/// <summary> Send the given EMS message.</summary>
/// <param name="session">the EMS Session to operate on
/// </param>
/// <param name="destination">the EMS Destination to send to
/// </param>
/// <param name="messageCreator">callback to create a EMS Message
/// </param>
/// <param name="messageCreatorDelegate">delegate callback to create a EMS Message
/// </param>
/// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
protected internal virtual void DoSend(ISession session, Destination destination, IMessageCreator messageCreator,
MessageCreatorDelegate messageCreatorDelegate)
{
IMessageProducer producer = CreateProducer(session, destination);
try
{
Message message;
if (messageCreator != null)
{
message = messageCreator.CreateMessage(session) ;
}
else {
message = messageCreatorDelegate(session);
}
if (logger.IsDebugEnabled)
{
logger.Debug("Sending created message [" + message + "]");
}
DoSend(producer, message);
// Check commit, avoid commit call is Session transaction is externally coordinated.
if (session.Transacted && IsSessionLocallyTransacted(session))
{
// Transacted session created by this template -> commit.
EmsUtils.CommitIfNecessary(session);
}
}
finally
{
EmsUtils.CloseMessageProducer(producer);
}
}