Beispiel #1
0
 private ReplyTask(IReplyInfo resultStore)
     : base(
         () => {
     return((P)resultStore.Payload);
 }
         ,
         resultStore.Cancellation.Token
         )
 {
     _resultStore = resultStore;
 }
Beispiel #2
0
        private async Task ProcessDataGram(UdpReceiveResult result)
        {
            try
            {
                ServiceBusMessage message   = null;
                BinaryFormatter   formatter = new BinaryFormatter();

                using (MemoryStream ms = new MemoryStream(result.Buffer))
                {
                    message = formatter.Deserialize(ms) as ServiceBusMessage;
                }

                if (message == null)
                {
                    Interlocked.Increment(ref _rejectDataGram);
                    _serviceBusTracing.TraceEvent(TraceEventType.Verbose, TRACEEVENT_DISCARDMESSAGE, "Discarded message.");
                    return;
                }
                else
                {
                    Interlocked.Increment(ref _acceptDataGram);
                }

                _serviceBusTracing.TraceData(TraceEventType.Verbose, TRACEEVENT_RECEIVEMESSAGE, message);

                if ((ServiceBusMessage.TO_ALL_NODES.Equals(message.ToNode) || Environment.MachineName.Equals(message.ToNode)) && _messageProcessors.ContainsKey(message.Address))
                {
                    Interlocked.Increment(ref _acceptMessage);

                    var messageProcessor = _messageProcessors[message.Address];

                    Task       replyTask          = null;
                    IReplyInfo replyReferenceInfo = null;

                    if (Guid.Empty.Equals(message.InReplyTo) == false)
                    {
                        TimeSpan started = _watch.Elapsed;

                        lock (_outgoingMessages)
                        {
                            TimeSpan duration = _watch.Elapsed - started;

                            if (duration.TotalSeconds >= 3)
                            {
                                _serviceBusTracing.TraceInformation("Long lock");
                            }

                            foreach (var value in _outgoingMessages)
                            {
                                if (value.ContainsKey(message.InReplyTo))
                                {
                                    replyTask          = value[message.InReplyTo];
                                    replyReferenceInfo = (IReplyInfo)replyTask;

                                    if (replyTask != null)
                                    {
                                        Interlocked.Increment(ref _replyMessage);
                                        value.Remove(message.InReplyTo);
                                        replyReferenceInfo.ReplyMessage = message;
                                        break;
                                    }
                                }
                                else
                                {
                                    _serviceBusTracing.TraceInformation("Trying next message container.");
                                }
                            }
                        }

                        if (_replyMessage == null)
                        {
                            Interlocked.Increment(ref _replyMessageNotFound);
                        }
                    }

                    var executing = messageProcessor.ProcessMessageAsync(message).ContinueWith(
                        (task) =>
                    {
                        if (replyTask != null)
                        {
                            replyReferenceInfo.Payload = task.Result;
                            replyTask.Start();
                        }
                    }
                        );
                }
                else
                {
                    Interlocked.Increment(ref _rejectMessage);
                }
            }
            catch (Exception ex)
            {
                _serviceBusTracing.TraceData(TraceEventType.Error, TRACEEVENT_ERROR, ex);
            }
        }