private void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e) { MessageQueue queue = (MessageQueue)sender; queue.EndPeek(e.AsyncResult); using (MessageQueueTransaction tx = new MessageQueueTransaction()) { tx.Begin(); var message = queue.Receive(tx); message.Formatter = new XmlMessageFormatter(_incomingHandlers.SelectMany(h => h.Value).Distinct().ToArray()); var messageType = message.Body.GetType(); var handlers = GetHandlersInstanceFor(messageType); foreach (var handler in handlers) { HandleMessage(message.Body, handler); } tx.Commit(); } queue.BeginPeek(); }
//************************************************** // Provides an event handler for the PeekCompleted // event. //************************************************** private static void MyPeekCompleted(Object source, PeekCompletedEventArgs asyncResult) { try { // Connect to the queue. MessageQueue mq = (MessageQueue)source; // End the asynchronous peek operation. Message m = mq.EndPeek(asyncResult.AsyncResult); // Display message information on the screen. Console.WriteLine("Message: " + (string)m.Body); // Restart the asynchronous peek operation, with the // same time-out. mq.BeginPeek(new TimeSpan(0, 1, 0)); } catch (MessageQueueException e) { if (e.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { Console.WriteLine(e.ToString()); } // Handle other sources of MessageQueueException. } // Handle other exceptions. return; }
/// <summary> /// Receive request from the worker on either :Peek event or Receive event /// </summary> /// <param name="request"></param> /// <returns></returns> private Response HandleIncomingRequest(RequestReceive request) { ResultModel resultModel = Converter.FromByteArray(request.Body) as ResultModel; switch (request.Metadata) { case "PeekOK": PeekCompletedEventArgs PeekArgs = new PeekCompletedEventArgs(); PeekArgs.Message = resultModel.message; peekCompleted?.Invoke(this, PeekArgs); break; case "RecieveOK": ReceiveCompletedEventArgs receiveCompletedEventArgs = new ReceiveCompletedEventArgs(); receiveCompletedEventArgs.Message= resultModel.message; receiveCompleted?.Invoke(this, receiveCompletedEventArgs); break; default: break; } return new Response(request) { Metadata = "OK", Body = Converter.ToByteArray("OK"), CacheHit = false, ClientID = $"MSMQWorker{Path}", Timestamp=DateTime.UtcNow, Executed=true, Error="" }; }
/// <summary> /// Peek Event Handler /// </summary> private async Task MyPeekCompleted(object source, PeekCompletedEventArgs asyncResult, string ChannelToReturnTo, string channelPeeked) { ResultModel resultModel = new ResultModel(); try { // Connect to the queue. System.Messaging.MessageQueue mq = (System.Messaging.MessageQueue)source; // End the asynchronous peek operation. System.Messaging.Message myMessage = mq.EndPeek(asyncResult.AsyncResult); resultModel.message = MessageConvert.ConvertFromSystemMessage(myMessage); resultModel.Result = (int)ResultsEnum.Done; // Restart the asynchronous peek operation. Response response = await initiator.SendRequestAsync(new KubeMQ.SDK.csharp.CommandQuery.LowLevel.Request() { Metadata = "PeekOK", Body = Converter.ToByteArray(resultModel), CacheKey = "", CacheTTL = 0, Channel = ChannelToReturnTo, ClientID = clientID, RequestType = RequestType.Query }); } catch (Exception ex) { _logger.LogCritical(string.Format("Failed to peek path {0} on ex {1}", channelPeeked, ex.Message)); } }
void mq_PeekCompleted(object sender, PeekCompletedEventArgs e) { var queue = (MessageQueue)sender; var type = this.SupportDataTypes.FirstOrDefault(t => t.FullName.To16bitMD5().Equals(e.Message.Label)); if (type != null) { queue.Formatter = new JsonMessageFormater(type); //queue.Formatter = new ProtoBufFormatter(typeof(T)); using (var transaction = new TransactionScope()) { var msg = queue.EndPeek(e.AsyncResult); if (this.OnDataReceived != null) { this.OnDataReceived(null, new DataReceivedArgs(msg.Body)); } //在远程队列上 (WIN7),用 Automatic 会抛出异常。 //try { // queue.ReceiveById(e.Message.Id, MessageQueueTransactionType.Single); //} catch { // queue.ReceiveById(e.Message.Id, MessageQueueTransactionType.Automatic); //} queue.Receive(); transaction.Complete(); } } queue.BeginPeek(); }
protected void PeekCompleted(object sender, PeekCompletedEventArgs e) { System.Messaging.Message msg = null; MessageQueue mq = null; try { mq = (MessageQueue)sender; mq.Formatter = new BinaryMessageFormatter(); System.Messaging.Message m = mq.EndPeek(e.AsyncResult); mq.ReceiveById(m.Id); if (OnMessageArrivedHandle != null) { OnMessageArrivedHandle(m.Label, m.Body.ToString()); } } catch (Exception ex) { string err = ex.Message; } finally { if (msg != null) { try { msg.Dispose(); } catch { } finally { msg = null; } } //接收下一次事件 if (mq != null) { mq.BeginPeek(); } } }
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e) { if (OnMessage == null) { return; } var transaction = new MessageQueueTransaction(); transaction.Begin(); try { var queueMessage = inputQueue.Receive(transaction); var headers = GetMessageHeaders(queueMessage); var message = new ChannelMessage(queueMessage.BodyStream); message.AddHeader(headers); OnMessage(message); transaction.Commit(); } catch (Exception) { transaction.Abort(); throw; } finally { inputQueue.BeginPeek(); } }
private void queue_NoTransaction(object sender, PeekCompletedEventArgs e) { var queue = (MessageQueue)sender; try { // if the queue closes after the transaction begins, // but before the call to Receive, then an exception // will be thrown and the transaction will be aborted // leaving the message to be processed next time var msg = queue.Receive(MessageQueueTransactionType.Automatic); Handle(msg); } catch (Exception ex) { Trace.WriteLine(ex.Message); } finally { if (!this.IsClosing) { queue.BeginPeek(); } } }
private static void OnPeekCompleted(Object source, PeekCompletedEventArgs asyncResult) { // Connect to the queue. MessageQueue mq = (MessageQueue)source; // create transaction using (var txn = new MessageQueueTransaction()) { try { // retrieve message and process txn.Begin(); // End the asynchronous peek operation. var message = mq.Receive(txn); // Display message information on the screen. if (message != null) { Console.WriteLine("{0}: {1}", message.Label, (string)message.Body); } // message will be removed on txn.Commit. txn.Commit(); } catch (Exception ex) { // on error don't remove message from queue Console.WriteLine(ex.ToString()); txn.Abort(); } } // Restart the asynchronous peek operation. mq.BeginPeek(); }
private void SourceQueuePeekCompleted(object sender, PeekCompletedEventArgs e) { lock (_lockObject) { MessageQueueTransaction trans = new MessageQueueTransaction(); trans.Begin(); Message message = _queue.Receive(trans); _traceSource.TraceInformation("Message Received: " + message.Label); try { ProcessMessage(message); } catch { if (_errorQueue != null) { _errorQueue.Send(message, trans); } } trans.Commit(); } _queue.BeginPeek(); }
void OnPeekCompleted(object sender, PeekCompletedEventArgs peekCompletedEventArgs) { stopResetEvent.Reset(); CallPeekWithExceptionHandling(() => queue.EndPeek(peekCompletedEventArgs.AsyncResult)); throttlingSemaphore.Wait(); Task.Factory .StartNew(Action, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default) .ContinueWith(task => { task.Exception.Handle(ex => { Logger.Error("Error processing message.", ex); return(true); }); }, TaskContinuationOptions.OnlyOnFaulted); //We using an AutoResetEvent here to make sure we do not call another BeginPeek before the Receive has been called peekResetEvent.WaitOne(); CallPeekWithExceptionHandling(() => queue.BeginPeek()); stopResetEvent.Set(); }
/// <summary> /// /// </summary> /// <param name="source"></param> /// <param name="asyncResult"></param> protected virtual void MessagePeekCompleted(object source, PeekCompletedEventArgs asyncResult) { var messageQueue = (MessageQueue)source; var message = messageQueue.EndPeek(asyncResult.AsyncResult); if (!(message.Body is IServiceMessage)) { return; } var messageContent = (IServiceMessage)message.Body; if (messageContent.SourceServiceGuid != ServiceId) { return; } Task.Run(() => ProcessMessage(messageContent)); if (IsRuning) { messageQueue.BeginPeek(); } }
private void QueuePeekCompleted(object sender, PeekCompletedEventArgs e) { var messageQueue = (MessageQueue)sender; messageQueue.EndPeek(e.AsyncResult); Message message = null; try { message = messageQueue.Receive(); if (message == null) { throw new InvalidOperationException("Null message"); } message.Formatter = (IMessageFormatter)MessageFormatter.Clone(); Trace.WriteLine(string.Format("Received message {0}", message.Id)); var command = (Int32)message.AppSpecific; var handlers = _messageHandlers .Where(x => x.Key == command) .Select(x => x.Value) .Where(x => x != null) .ToArray(); var handlerCount = handlers.Count(); Trace.WriteLine(string.Format("Executing {0} handlers", handlerCount)); if (!handlers.Any()) { handlers = new Action <object>[] { msg => Trace.TraceWarning("Message {0} has no registered handlers", message.Id) } } ; foreach (var handler in handlers) { if (command == MessageCommand) { handler(message.Body); } else { handler(message); } } } catch (Exception ex) { LogError(message, ex); } messageQueue.Refresh(); messageQueue.BeginPeek(); }
public static void QueuePeeker(object src, PeekCompletedEventArgs rcea) { MessageQueue q = (MessageQueue)src; Message m = q.EndReceive(rcea.AsyncResult); receiveMessageDepartment(); q.BeginPeek(); }
private void QueuePeekCompleted(object sender, PeekCompletedEventArgs e) { var message = _queue.EndPeek(e.AsyncResult); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("\nA message was read from the Customers queue."); Console.WriteLine(string.Format("The message was: {0}", message.Body)); _queue.Receive(); _queue.BeginPeek(); }
private void PeekCompleted(object source, PeekCompletedEventArgs eventArgs) { var abortQueue = false; try { using (var peek = _localQueue.EndPeek(eventArgs.AsyncResult)) { if (peek.AppSpecific != APP_SPECIFIC_STOP) { foreach (var conversation in LargeMessage.GetAvailableConversations(_localQueue)) { OnProcessMessage(_mode, _localQueue, conversation); } } else { _localQueue.ReceiveById(peek.Id, MessageQueueTransactionType.Single).Dispose(); DisposeLocalQueue(); } } } catch (MessageQueueException me) { if (me.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout && me.MessageQueueErrorCode != MessageQueueErrorCode.TransactionEnlist) { abortQueue = true; } } catch (SqlException) { abortQueue = true; } catch (TransactionAbortedException) { abortQueue = true; } catch { abortQueue = true; } if (abortQueue) { DisposeLocalQueue(); } else if (_started) { Thread.Sleep(SLEEP_PEEK_NEXT_MESSAGE); _localQueue.BeginPeek(); } }
private void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e) { // end peek operation var queue = (MessageQueue)sender; queue.EndPeek(e.AsyncResult); // read message transactionally MessageQueueTransaction transaction = null; try { transaction = new MessageQueueTransaction(); transaction.Begin(); // if the queue closes after the transaction begins, // but before the call to Receive, then an exception // will be thrown and the transaction will be aborted // leaving the message to be processed next time Message message = queue.Receive(TimeSpan.Zero, transaction); ProcessMessage(message, queue, transaction); transaction.Commit(); } catch (MessageQueueException ex) { transaction?.Abort(); // timeout is expected here, sometimes if (ex.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout) { Log.Error(ex.GetType().ToString(), ex); } } catch (Exception ex) { // something unexpected happened transaction?.Abort(); Log.Error(ex.GetType().ToString(), ex); } finally { transaction?.Dispose(); // start new peek operation if (_isClosing == false) { queue.BeginPeek(); } } }
private void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e) { MessageQueue queue = (MessageQueue)sender; queue.EndPeek(e.AsyncResult); using (MessageQueueTransaction tx = new MessageQueueTransaction()) { tx.Begin(); var message = queue.Receive(tx); message.Formatter = new XmlMessageFormatter(_incomingHandlers.SelectMany(h => h.Value).Distinct().ToArray()); var messageType = message.Body.GetType(); var handlers = GetHandlersInstanceFor(messageType); foreach (var handler in handlers) { // if handler is saga and message.Body contains SagaId, populate data if (IsImplementationOf(typeof(Saga <>), handler)) { var bodyType = message.Body.GetType(); var sagaIdProperty = bodyType.GetProperties().FirstOrDefault(pi => pi.Name == "SagaId"); if (sagaIdProperty != null) { var sagaId = (Guid)sagaIdProperty.GetValue(message.Body); if (sagaId != Guid.Empty) { if (!_sagaData.ContainsKey(sagaId)) { var sagaDataType = GetSagaDataTypeFor((Type)handler.RealObject.GetType()); var instance = Activator.CreateInstance(sagaDataType); instance.AsDynamic().SagaId = sagaId; _sagaData.Add(sagaId, (SagaData)instance); } handler.Data = _sagaData[sagaId]; } } } handler.Handle(message.Body); } tx.Commit(); } queue.BeginPeek(); }
private void MessageAvailable(object source, PeekCompletedEventArgs args) { var messageQueue = (MessageQueue)source; try { ReadMessage(messageQueue); } finally { messageQueue.Close(); } // Continue reading from the queue messageQueue.BeginPeek(); }
private void OnPeekCompleted(object source, PeekCompletedEventArgs asyncResult) { // Connect to the queue. MessageQueue mq = (MessageQueue)source; // create transaction using (var txn = new MessageQueueTransaction()) { try { // retrieve message and process txn.Begin(); // End the asynchronous peek operation. var message = mq.Receive(txn); // Display message information on the screen. if (message != null) { // determine the topic var topic = (TopicType)Enum.Parse(typeof(TopicType), message.Label); Console.WriteLine("{0} message received", topic); if (ProcessCommand(message, topic)) { // message will be removed on txn.Commit. txn.Commit(); } else { // Problem sending message on so put back in the queue txn.Abort(); } } } catch (Exception ex) { // on error don't remove message from queue Console.WriteLine(ex.ToString()); txn.Abort(); } } // Restart the asynchronous peek operation. mq.BeginPeek(); }
private void MessageHasBeenReceived(object sender, PeekCompletedEventArgs e) { var filas = MessageQueue.GetPrivateQueuesByMachine(Environment.MachineName); var filaTeste = filas[0]; // Get message var msg = filaTeste.EndPeek(e.AsyncResult); // Do message processing here // Remove message from queue filaTeste.ReceiveById(msg.Id); // Listen for more messages filaTeste.BeginPeek(); filaTeste.PeekCompleted += new PeekCompletedEventHandler(MessageHasBeenReceived); }
private void QueueOnPeekCompleted(object sender, PeekCompletedEventArgs peekCompletedEventArgs) { var asyncQueue = (MessageQueue)sender; using (var transaction = new MessageQueueTransaction()) { transaction.Begin(); try { using (var message = asyncQueue.ReceiveById(peekCompletedEventArgs.Message.Id, TimeSpan.FromSeconds(30), transaction)) { if (message != null) { ProcessOrderQueue((OrderQueueDataContract)message.Body); } } } catch (InvalidOperationException ex) { transaction.Abort(); } catch (Exception ex) { transaction.Abort(); } if (transaction.Status != MessageQueueTransactionStatus.Aborted) { transaction.Commit(); } else { using (var message = asyncQueue.ReceiveById(peekCompletedEventArgs.Message.Id, TimeSpan.FromSeconds(30), transaction)) { if (message != null) { MoveMessageToDeadLetter(message); message.Dispose(); } } EventLog.WriteEntry("OrderQueueProcessingService", "Could not process message: " + peekCompletedEventArgs.Message.Id); } transaction.Dispose(); } asyncQueue.EndPeek(peekCompletedEventArgs.AsyncResult); asyncQueue.BeginPeek(); }
//************************************************** // Provides an event handler for the PeekCompleted // event. //************************************************** private static void MyPeekCompleted(Object source, PeekCompletedEventArgs asyncResult) { // Connect to the queue. MessageQueue mq = (MessageQueue)source; // End the asynchronous peek operation. Message m = mq.EndPeek(asyncResult.AsyncResult); // Display message information on the screen. Console.WriteLine("Message: " + (string)m.Body); // Restart the asynchronous peek operation. mq.BeginPeek(); return; }
private static void QueuePeekCompleted(object sender, PeekCompletedEventArgs e) { var cmq = (MessageQueue)sender; cmq.EndPeek(e.AsyncResult); Message msg = null; //keep outside scope to move this to the error log try { msg = cmq.Receive(); if (msg == null) { throw new InvalidOperationException("Null message should not be possible"); } if (msg.AppSpecific == 0) { HandleMessage(msg); } else { HandleSubscribeAndUnsubscribeMessage(msg); } } catch (Exception ex) { ConsoleError("Exception in Peek: " + ex.Message); if (msg != null) { using (var scope = new TransactionScope()) { using (var myQueue = new MessageQueue(cmq.MachineName + "\\" + cmq.QueueName + "_errors")) { myQueue.Send(msg, MessageQueueTransactionType.Automatic); } scope.Complete(); } } } cmq.Refresh(); cmq.BeginPeek(); }
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e) { _queue.EndPeek(e.AsyncResult); MessageQueueTransaction trans = new MessageQueueTransaction(); Message msg = null; try { trans.Begin(); msg = _queue.Receive(trans); trans.Commit(); StartListening(); FireRecieveEvent(msg.Body); } catch { trans.Abort(); } }
private static void Queue_PeekCompleted(object sender, PeekCompletedEventArgs e) { MessageQueue queue = (MessageQueue)sender; using (MessageQueueTransaction tx = new MessageQueueTransaction()) { tx.Begin(); var message = queue.Receive(tx); message.Formatter = new XmlMessageFormatter(new Type[] { typeof(HaveBreakfastCommand) }); var recievedMessage = (HaveBreakfastCommand)message.Body; processMessage(recievedMessage); tx.Commit(); } queue.BeginPeek(); }
/// <summary> /// Called when [peek completed]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The <see cref="PeekCompletedEventArgs"/> instance containing the event data.</param> private void OnPeekCompleted(object sender, PeekCompletedEventArgs args) { messageQueue.EndPeek(args.AsyncResult); MessageQueueTransaction transaction = new MessageQueueTransaction(); Message message = null; try { transaction.Begin(); message = messageQueue.Receive(transaction); transaction.Commit(); StartListening(); FireReceiveEvent(message.Body); } catch { transaction.Abort(); } }
private void QueueOnPeekCompleted(object sender, PeekCompletedEventArgs peekCompletedEventArgs) { var asyncQueue = (MessageQueue)sender; logger.DebugFormat("Peeked message with id {0}", peekCompletedEventArgs.Message.Id); _receiveProvider.GetMessageFromQueue( peekCompletedEventArgs.Message.Id, asyncQueue, delegate(Message message) { IConsumer consumer = null; try { consumer = _registeredConsumers.FirstOrDefault(c => c.MessageType == message.Body.GetType()); } catch (InvalidOperationException ex) { logger.Error("Failed to ready message body", ex); } catch (Exception ex) { logger.Error("Failed to get consumer, might be related to message body", ex); } if (consumer != null) { try { consumer.ProcessMessage(message); } catch (Exception ex) { logger.Warn("Failed to process message", ex); } } }); logger.Debug("Peeking for next message."); //peek next. asyncQueue.BeginPeek(); }
private void PeekCompletedHandler(object sender, PeekCompletedEventArgs e) { var queue = (MessageQueue)sender; Message queueMessage = null; try { queue.EndPeek(e.AsyncResult); queueMessage = queue.Receive(); ProcessMessage(queueMessage); } catch (Exception) { if (queueMessage != null) { SendToErrorQueue(queueMessage); } } queue.BeginPeek(); }
private void OnPeekCompleted(object sender, PeekCompletedEventArgs e) { try { Process(e.Message.Body); inQueue.EndPeek(beginPeekAsyncResult); // only receive once peek is processed successfully otherwise the message is lost. inQueue.Receive(); beginPeekAsyncResult = inQueue.BeginPeek(); } catch (Exception ex) { // Ideally you'd be placing these in a Dead Letter Queue (DLQ) or Poison Queue... if (processFailed != null) { processFailed(ex); } } }