Пример #1
0
 public EmsWorkItem
     (
     decimal id,
     int externalEntityId,
     WorkItemState workItemState,
     SubmissionPriority submissionPriority,
     byte[] messageBody,
     bool assigned,
     bool isRetry,
     string ownerName,
     ContextIdentifier contextIdentifier,
     EmsReaderQueue queue,
     Message message
     )
     : base
         (
         id,
         externalEntityId,
         workItemState,
         submissionPriority,
         messageBody,
         assigned,
         isRetry,
         ownerName,
         contextIdentifier
         )
 {
     this.queue = queue;
     this.message = message;
 }
Пример #2
0
        /// <summary>
        /// Convert from a EMS Message to a .NET object.
        /// </summary>
        /// <param name="messageToConvert">the message to convert</param>
        /// <returns>the converted .NET object</returns>
        /// <throws>MessageConversionException in case of conversion failure </throws>
        public object FromMessage(Message messageToConvert)
        {
            if (messageToConvert == null)
            {
                throw new MessageConversionException("Can't convert null message");
            }
            try
            {
                string converterId = messageToConvert.GetStringProperty(typeMapper.TypeIdFieldName);
                if (converterId == null)
                {
                    return defaultMessageConverter.FromMessage(messageToConvert);
                }
                TextMessage textMessage = messageToConvert as TextMessage;
                if (textMessage == null)
                {
                    throw new MessageConversionException("Can't convert message of type " +
                                                         messageToConvert.GetType());
                }

                using (MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(textMessage.Text)))
                {

                    XmlSerializer xs = new XmlSerializer(GetTargetType(textMessage));
                    XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
                    return xs.Deserialize(memoryStream);
                }
            }
            catch (Exception e)
            {
                throw new MessageConversionException("Can't convert message of type " + messageToConvert.GetType(), e);
            }
        }
Пример #3
0
		public TibcoMessageSelector(TibcoEndpoint endpoint, Session session, Message transportMessage, IMessageSerializer serializer)
		{
			_endpoint = endpoint;
			_session = session;
			_transportMessage = transportMessage;
			_serializer = serializer;
		}
Пример #4
0
 public static void SendReplyMessage(TIBCO.EMS.Message ReplyMessage, TIBCO.EMS.Queue ReplyQueue)
 {
     try {
         Session session = Messaging.EMS.Connection.EMSQueueConnection.connection.CreateSession(false, Session.AUTO_ACKNOWLEDGE);
         Messaging.EMS.Producers.Messageproducer.SendReplyMessage(ReplyMessage, ReplyQueue, ref session);
     }
     catch (EMSException e) { throw e; }
 }
Пример #5
0
        public static void SendReplyMessage(TIBCO.EMS.Message msg, TIBCO.EMS.Queue ReplyQueue, ref Session session)
        {
            try
            {
                TIBCO.EMS.MessageProducer producer = session.CreateProducer(ReplyQueue);

                producer.Send(msg);
            }
            catch (EMSException e) { throw e; }
        }
Пример #6
0
 public void Commit(Message msg)
 {
     if (session.IsTransacted)
     {
         Commit();
     }
     else
     {
         msg.Acknowledge();
     }
 }
Пример #7
0
 public static Message SendRequestAndReceiveReply(TIBCO.EMS.Message msg, TIBCO.EMS.Queue queue)
 {
     try
     {
         QueueSession             session = Messaging.EMS.Connection.EMSQueueConnection.connection.CreateQueueSession(false, Session.AUTO_ACKNOWLEDGE);
         TIBCO.EMS.QueueRequestor qr      = new TIBCO.EMS.QueueRequestor(session, queue);
         Message ReplyMessage             = qr.Request(msg);
         qr.Close();
         return(ReplyMessage);
     }
     catch (EMSException e) { throw e; }
 }
Пример #8
0
 public void OnMessage(Message message)
 {           
     messageCount++;
     LOG.Debug("Message listener count = " + messageCount);
     TextMessage textMessage = message as TextMessage;
     if (textMessage != null)
     {
         LOG.Info("Message Text = " + textMessage.Text);
     } else
     {
         LOG.Warn("Can not process message of type " + message.GetType());
     }
 }
Пример #9
0
        public static void  SendMessage(TIBCO.EMS.Message msg, TIBCO.EMS.Queue queue)

        {
            try
            {
                Session session = Messaging.EMS.Connection.EMSQueueConnection.connection.CreateSession(false, Session.CLIENT_ACKNOWLEDGE);

                TIBCO.EMS.MessageProducer producer = session.CreateProducer(queue);

                producer.Send(msg);
            }
            catch (EMSException e)


            { throw e; }
        }
        public void OnException(Message msg, Exception ex)
        {
            try
            {
                Utilities.WriteLog(String.Format(@"Error sending message {0}.",
                        ((TextMessage)msg).Text));
            }
            catch (EMSException e)
            {
                Utilities.WriteLog(String.Format(@"Error retrieving message text."));
                Utilities.WriteLog(String.Format(@"Message: " + e.Message));
                Utilities.WriteLog(String.Format(e.StackTrace));
            }

            Utilities.WriteLog(String.Format(@"Message: " + ex.Message));
            Utilities.WriteLog(String.Format(ex.StackTrace));
        }
        public void OnCompletion(Message msg)
        {
            string msgText = ((TextMessage)msg).Text;
            BaseRequest baseRequest = xmlHelper.OutputXMLParse2BaseResponse(msgText);
            try
            {
                Utilities.WriteLog(String.Format(@"Successfully sent message {0} {1}.", msg.MessageID, msgText.Substring(0,100)));

                _model.fsp_MessageLog_OutputEMSUpdate(baseRequest.MessageLogId, msg.MessageID, 0,"OK", Utilities.ConvertFromUnixToDateTime(msg.DeliveryTime), 0);
            }
            catch (EMSException e)
            {
                Utilities.WriteLog(String.Format(@"Error retrieving message text."));
                Utilities.WriteLog(String.Format(@"Message: " + e.Message));
                Utilities.WriteLog(String.Format(e.StackTrace));
                _model.fsp_MessageLog_OutputEMSUpdate(baseRequest.MessageLogId, msg.MessageID, -1, e.Message, Utilities.ConvertFromUnixToDateTime(msg.DeliveryTime), 0);
            }
        }
Пример #12
0
 public void OnCompletion(TIBCO.EMS.Message msg)
 {
     try
     {
         rtb.Invoke((MethodInvoker) delegate() { rtb.Text = rtb.Text + "\nSuccessfully sent message " + ((TextMessage)msg).Text; });
         log.Info("nSuccessfully sent message " + ((TextMessage)msg).Text);
     }
     catch (EMSException e)
     {
         rtb.Invoke((MethodInvoker) delegate()
         {
             rtb.Text = rtb.Text + "\nError retrieving message text.";
             rtb.Text = rtb.Text + "\nMessage: " + e.Message;
             rtb.Text = rtb.Text + "\n" + e.StackTrace;
             log.Error(e, "Error retrieving message text.");
         });
     }
 }
Пример #13
0
 /// <summary> Convert from a EMS Message to a .NET object.</summary>
 /// <param name="messageToConvert">the message to convert
 /// </param>
 /// <returns> the converted .NET object
 /// </returns>
 /// <throws>MessageConversionException in case of conversion failure </throws>
 public object FromMessage(Message messageToConvert)
 {
     if (messageToConvert is TextMessage)
     {
         return ExtractStringFromMessage((TextMessage) messageToConvert);
     }
     if (messageToConvert is BytesMessage)
     {
         return ExtractByteArrayFromMessage((BytesMessage) messageToConvert);
     }
     if (messageToConvert is MapMessage)
     {
         return ExtractMapFromMessage((MapMessage) messageToConvert);
     }
     if (messageToConvert is ObjectMessage)
     {
         return ExtractSerializableFromMessage((ObjectMessage) messageToConvert);
     }
     return messageToConvert;
 }
Пример #14
0
        public override void OnMessage(TIBCO.EMS.Message msg)
        {
            /*
             * Herein will lie the call to AMT report , to pass on  the msg consumed from EMS Queue .
             * Also, any response returned from AMT report call can be sent back to requestor
             * as the reply-queue and correlation-id are avaible as part of JMS Header of msg .
             * Not to be confused with void return .Also bear in mind , as many max. concurrent
             * invocations of Onmessage will be allowed ,as specfied in NoOfSessions parameter passed to
             * constructor as shown above.In other words ,If NoOfSessions=5 , 5  threads will be
             * created to excute as many instances of OnMessage, at a time.
             */


            try {
                Messaging.EMS.CommonUtils.ProcessEMSMessage(msg);
            }

            catch (EMSException e)
            {
                Console.Write("\n\n(******** Exception :\n" + e.StackTrace);
                msg.Acknowledge();
            }
        }
Пример #15
0
        public void OnException(TIBCO.EMS.Message msg, Exception ex)
        {
            try
            {
                rtb.Invoke((MethodInvoker) delegate() { rtb.Text = rtb.Text + "\nError sending message " + ((TextMessage)msg).Text; });
                log.Error("Error sending message " + ((TextMessage)msg).Text);
            }
            catch (EMSException e)
            {
                rtb.Invoke((MethodInvoker) delegate()
                {
                    rtb.Text = rtb.Text + "\nError retrieving message text.";
                    rtb.Text = rtb.Text + "\nMessage: " + e.Message;
                    rtb.Text = rtb.Text + "\n" + e.StackTrace;
                    log.Error(e, "Error retrieving message text.");
                });
            }

            rtb.Invoke((MethodInvoker) delegate()
            {
                rtb.Text = rtb.Text + "\nMessage: " + ex.Message;
                rtb.Text = rtb.Text + "\n" + ex.StackTrace;
            });
        }
Пример #16
0
 /// <summary>
 /// Sends a message to the specified destination.
 /// </summary>
 /// <param name="destination">The destination.</param>
 /// <param name="message">The message.</param>
 public void Send(Destination destination, Message message)
 {
     target.Send(destination, message, this.deliveryMode, this.priority, this.timeToLive);
 }
Пример #17
0
 public void Send(Message message, MessageDeliveryMode deliveryMode, int priority, long timeToLive)
 {
     target.Send(message, deliveryMode, priority, timeToLive);
 }
Пример #18
0
 public void Send(Destination dest, Message message, MessageDeliveryMode deliveryMode, int priority, long timeToLive)
 {
     target.Send(dest, message, deliveryMode, priority, timeToLive);
 }
 /// <summary>
 /// Executes the specified listener, 
 /// committing or rolling back the transaction afterwards (if necessary).
 /// </summary>
 /// <param name="session">The session to operate on.</param>
 /// <param name="message">The received message.</param>
 /// <see cref="InvokeListener"/>
 /// <see cref="CommitIfNecessary"/>
 /// <see cref="RollbackOnExceptionIfNecessary"/>
 /// <see cref="HandleListenerException"/>
 public virtual void ExecuteListener(ISession session, Message message)
 {
     try
     {
         DoExecuteListener(session, message);
     }
     catch (Exception ex)
     {
         HandleListenerException(ex);
     }
 }
 public void SendMessage(Message message)
 {
     messageListener.OnMessage(message);
 }
Пример #21
0
 public void OnMessage(Message message)
 {
     lastReceivedMessage = message;
     messageCount++;
     LOG.Debug("Message listener count = " + messageCount);
 }
Пример #22
0
        /*        
        /// <summary>
        /// Gets or sets a value indicating whether the EmsTemplate should itself
        /// be responsible for caching EMS Connection/Session/MessageProducer as compared to
        /// creating new instances per operation (unless such resources are already
        /// present in Thread-Local storage either due to the use of EmsTransactionMananger or
        /// SimpleMessageListenerContainer at an outer calling layer.
        /// </summary>
        /// <remarks>Connection/Session/MessageProducer are thread-safe classes in TIBCO EMS.</remarks>
        /// <value><c>true</c> to locally cache ems resources; otherwise, <c>false</c>.</value>
        virtual public bool CacheEmsResources
        {
            get { return cacheEmsResources; }
            set { cacheEmsResources = value; }
        }*/


        #endregion

        /// <summary>
        /// Extract the content from the given JMS message.
        /// </summary>
        /// <param name="message">The Message to convert (can be <code>null</code>).</param>
        /// <returns>The content of the message, or <code>null</code> if none</returns>
        protected virtual object DoConvertFromMessage(Message message)
        {
            if (message != null)
            {
                return MessageConverter.FromMessage(message);
            }
            return null;
        }
Пример #23
0
 public void Send(Message message)
 {
     throw new NotImplementedException();
 }
Пример #24
0
        public void Consumer()
        {
            int ackMode = Session.AUTO_ACKNOWLEDGE;

            TIBCO.EMS.Message msg = null;

            while (true)
            {
                try
                {
                    // receive the message
                    msg = msgConsumer.Receive();
                }
                catch (EMSException EMSex)
                {
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + EMSex.Message; });
                    logger.Error(EMSex.Message);
                }
                if (msg == null)
                {
                    break;
                }

                if (ackMode == Session.CLIENT_ACKNOWLEDGE ||
                    ackMode == Session.EXPLICIT_CLIENT_ACKNOWLEDGE ||
                    ackMode == Session.EXPLICIT_CLIENT_DUPS_OK_ACKNOWLEDGE)
                {
                    msg.Acknowledge();
                }

                LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\nReceived message: " + msg; });
                logger.Info("Received message: " + msg);

                if (msg is TextMessage)
                {
                    TextMessage tm = (TextMessage)msg;
                    //ReceveMsgTextBox.Text = tm.Text;
                    ReceveMsgTextBox.Invoke((MethodInvoker) delegate() { ReceveMsgTextBox.Text = tm.Text; });
                    logger.Info(tm.Text);
                }
                if (msg is BytesMessage)
                {
                    BytesMessage bm = (BytesMessage)msg;
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadBoolean(); });
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadChar(); });
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadShort(); });
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadInt(); });
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadLong(); });
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadFloat(); });
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + bm.ReadDouble(); });
                }

                if (msg is MapMessage)
                {
                    MapMessage mm       = (MapMessage)msg;
                    var        mapNames = mm.GetMapNames();
                    LogTextBox.Invoke((MethodInvoker) delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.ToString(); });

                    /*   foreach (String name in mapNames)
                     * {
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetBoolean(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetByte(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetBytes(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetChar(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetShort(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetInt(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetLong(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetFloat(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetDouble(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetString(name); });
                     *     LogTextBox.Invoke((MethodInvoker)delegate() { LogTextBox.Text = LogTextBox.Text + "\n" + mm.GetObject(name); });
                     * }*/
                }
            }
        }
 /// <summary>
 /// Perform a commit or message acknowledgement, as appropriate
 /// </summary>
 /// <param name="session">The session to commit.</param>
 /// <param name="message">The message to acknowledge.</param>
 /// <exception cref="EMSException">In case of commit failure</exception>
 protected virtual void CommitIfNecessary(ISession session, Message message)
 {
     // Commit session or acknowledge message
     if (session.Transacted)
     {
         // Commit necessary - but avoid commit call is Session transaction is externally coordinated.
         if (IsSessionLocallyTransacted(session))
         {
             EmsUtils.CommitIfNecessary(session);
         }
     }
     else if (IsClientAcknowledge(session))
     {
         message.Acknowledge();
     }
 }
 /// <summary>
 /// Invoke the specified listener as Spring ISessionAwareMessageListener,
 /// exposing a new EMS Session (potentially with its own transaction)
 /// to the listener if demanded.
 /// </summary>
 /// <param name="listener">The Spring ISessionAwareMessageListener to invoke.</param>
 /// <param name="session">The session to operate on.</param>
 /// <param name="message">The received message.</param>
 /// <exception cref="EMSException">If thrown by EMS API methods.</exception>
 /// <see cref="ISessionAwareMessageListener"/>
 /// <see cref="ExposeListenerSession"/>
 protected virtual void DoInvokeListener(ISessionAwareMessageListener listener, ISession session, Message message)
 {
     IConnection conToClose = null;
     ISession sessionToClose = null;
     try
     {
         ISession sessionToUse = session;
         if (!ExposeListenerSession)
         {
             //We need to expose a separate Session.
             conToClose = CreateConnection();
             sessionToClose = CreateSession(conToClose);
             sessionToUse = sessionToClose;
         }
         // Actually invoke the message listener
         if (logger.IsDebugEnabled)
         {
             logger.Debug("Invoking listener with message of type [" + message.GetType() + 
                          "] and session [" + sessionToUse + "]");
         }
         listener.OnMessage(message, sessionToUse);
         // Clean up specially exposed Session, if any
         if (sessionToUse != session)
         {
             if (sessionToUse.Transacted && SessionTransacted)
             {
                 // Transacted session created by this container -> commit.
                 EmsUtils.CommitIfNecessary(sessionToUse);
             }                        
         }
     } finally
     {
         EmsUtils.CloseSession(sessionToClose);
         EmsUtils.CloseConnection(conToClose);
     }
 }
        /// <summary>
        /// Invokes the specified listener: either as standard EMS MessageListener
        /// or (preferably) as Spring ISessionAwareMessageListener.
        /// </summary>
        /// <param name="session">The session to operate on.</param>
        /// <param name="message">The received message.</param>
        /// <exception cref="EMSException">If thrown by EMS API methods.</exception>
        /// <see cref="MessageListener"/>
        protected virtual void InvokeListener(ISession session, Message message)
        {
            object listener = MessageListener;
            if (listener is ISessionAwareMessageListener)
            {
                DoInvokeListener((ISessionAwareMessageListener) listener, session, message);
            }

            else if (listener is IMessageListener)
            {
                DoInvokeListener((IMessageListener)listener, message);
            }
            else if (listener != null)
            {
                throw new ArgumentException("Only MessageListener and ISessionAwareMessageListener supported");
            }
            else
            {
                throw new InvalidOperationException("No message listener specified - see property MessageListener");
            }
        }
        /// <summary>
        /// Executes the specified listener, 
        /// committing or rolling back the transaction afterwards (if necessary).
        /// </summary>
        /// <param name="session">The session to operate on.</param>
        /// <param name="message">The received message.</param>
        /// <exception cref="EMSException">If thrown by EMS API methods.</exception>
        /// <see cref="InvokeListener"/>
        /// <see cref="CommitIfNecessary"/>
        /// <see cref="RollbackOnExceptionIfNecessary"/>
        protected virtual void DoExecuteListener(ISession session, Message message)
        {
            if (!AcceptMessagesWhileStopping && !IsRunning)
            {
                #region Logging
                if (logger.IsWarnEnabled)
                {
                    logger.Warn("Rejecting received message because of the listener container " +
                        "having been stopped in the meantime: " + message);
                }
                #endregion
                RollbackIfNecessary(session);
                throw new MessageRejectedWhileStoppingException();
            }

            try
            {
                InvokeListener(session, message);
            }
            catch (Exception ex)
            {
                RollbackOnExceptionIfNecessary(session, ex);
                throw;
            }
            CommitIfNecessary(session, message);
        }
Пример #29
0
 /// <summary>
 /// Sends the specified message.
 /// </summary>
 /// <param name="message">The message.</param>
 public void Send(Message message)
 {
     target.Send(message, this.deliveryMode, this.priority, this.timeToLive);
 }
Пример #30
0
 public void Send(Destination destination, Message message)
 {
     throw new NotImplementedException();
 }
 /// <summary>
 /// Post-process the given message producer before using it to send the response.
 /// The default implementation is empty.
 /// </summary>
 /// <param name="producer">The producer that will be used to send the message.</param>
 /// <param name="response">The outgoing message about to be sent.</param>
 protected virtual void PostProcessProducer(IMessageProducer producer, Message response)
 {
     
 }
Пример #32
0
 public void Send(Message message, int deliveryMode, int priority, long timeToLive)
 {
     throw new NotImplementedException();
 }
 public void OnMessage(Message message)
 {
     bool exposeResource = container.ExposeListenerSession;
     if (exposeResource)
     {
         TransactionSynchronizationManager.BindResource(
             container.ConnectionFactory, new LocallyExposedEmsResourceHolder(session));
     }
     try
     {
         container.ExecuteListener(session, message);
     } finally
     {
         if (exposeResource)
         {
             TransactionSynchronizationManager.UnbindResource(container.ConnectionFactory);
         }
     }
 }
Пример #34
0
 public void Send(Destination dest, Message message, MessageDeliveryMode deliveryMode, int priority, long timeToLive)
 {
     throw new NotImplementedException();
 }
 public void OnMessage(Message message, ISession session)
 {
     throw exception;
 }
Пример #36
0
 public void OnMessage(Message message)
 {
     this.message = "Test1";
 }
 /// <summary>
 /// Invoke the specified listener as standard JMS MessageListener.
 /// </summary>
 /// <remarks>Default implementation performs a plain invocation of the
 /// <code>OnMessage</code> methods</remarks>
 /// <param name="listener">The listener to invoke.</param>
 /// <param name="message">The received message.</param>
 /// <exception cref="EMSException">if thrown by the EMS API methods</exception>
 protected virtual void DoInvokeListener(IMessageListener listener, Message message)
 {
     listener.OnMessage(message);
 }
Пример #38
0
 /// <summary> Actually send the given EMS message.</summary>
 /// <param name="producer">the EMS MessageProducer to send with
 /// </param>
 /// <param name="message">the EMS Message to send
 /// </param>
 /// <exception cref="EMSException">If there is any problem accessing the EMS API</exception>
 protected virtual void DoSend(IMessageProducer producer, Message message)
 {
     if (ExplicitQosEnabled)
     {
         producer.Send(message, DeliveryMode, Priority, TimeToLive);
     }
     else
     {
         producer.Send(message);
     }
 }