public async Task <IActionResult> CreateSession(MessageSessionCreateViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                var fromEmail =
                    await Services.AuthorizationServices.VerifyToken(clientFactory, viewModel.FromJwt);

                if (fromEmail != null)
                {
                    var session = new MessageSession
                    {
                        Title       = viewModel.Title,
                        Description = viewModel.Description,
                        Emails      = fromEmail
                    };

                    if (viewModel.Emails != null)
                    {
                        session.Emails += ";" + string.Join(';', viewModel.Emails).ToLower();
                    }

                    await sessionRepository.CreateMessageSessionAsync(session);

                    return(Ok(JsonConvert.SerializeObject(session)));
                }

                return(BadRequest("Specified Token Not Found"));
            }
            return(BadRequest(ModelState));
        }
        protected override async Task ReceiveMessageImplAsync(
            BrokeredMessage message,
            MessageSession session,
            CancellationToken cancellationToken)
        {
            var userId         = message.GetBody <Guid>();
            var transportation = new Transportation
            {
                TransportationId = Guid.NewGuid(),
                IsActive         = true,
                CreatedAt        = DateTime.UtcNow.Subtract(DateTime.MinValue.AddYears(1969)).TotalSeconds
            };
            await _transportationRepository.SaveTransportation(transportation, userId);

            WriteLog($"Handling queue message {message.MessageId}");

            var payload = new PostTransporationResultMessage
            {
                TransportationId = transportation.TransportationId
            };
            await _serviceBusCommunicationService.SendBrokeredMessage(new BrokeredMessage(payload)
            {
                SessionId = message.SessionId
            }, "Processed-Post-Transportation-Queue");
        }
Exemplo n.º 3
0
        protected override Task ReceiveMessageImplAsync(BrokeredMessage message, MessageSession session, CancellationToken cancellationToken)
        {
            ServiceEventSource.Current.ServiceMessage(_service, $"Handling queue message {message.MessageId} in session {session?.SessionId ?? "none"}");

            RPA.RPATicket ticket;
            try
            {
                ticket = message.GetBody <RPA.RPATicket>();
                ticket = checkScope(ticket);

                if (ticket.Matches.Count > 0)
                {
                    sendToInScopeQueue(ticket);
                }
                else
                {
                    sendToOutOfScopeQueue(message);
                }
            }
            catch (Exception)
            {
                sendToErrorQueue(message);
                return(Task.FromResult(false));
            }

            return(Task.FromResult(true));
        }
Exemplo n.º 4
0
        /// <summary>
        /// Create a new session handler.
        /// </summary>
        /// <param name="session"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public IMessageSessionAsyncHandler CreateInstance(MessageSession session, BrokeredMessage message)
        {
            ServiceBusEventSource.Log.SessonAccepted(_receiverNamespace, _receiverPath, session.SessionId, message.MessageId, message.CorrelationId);

            // Use the current handler.
            return(new SessionMessageAsyncHandler(_receiverNamespace, _receiverPath, session, _messageHandler, _options));
        }
Exemplo n.º 5
0
        public Task OnCloseSessionAsync(MessageSession session)
        {
            ServiceBusEventSource.Log.SessionClosed(_receiverNamespace, _receiverPath, session.SessionId);

            // No need to do anything else.
            return(Task.FromResult(0));
        }
Exemplo n.º 6
0
        public async Task ResubmitTheEvent()
        {
            var identifiedRemovedLearningAimEvent = Context.Get <IdentifiedRemovedLearningAim>(IdentifiedRemovedLearningAim);

            identifiedRemovedLearningAimEvent.EventId = Guid.NewGuid();
            await MessageSession.Publish(identifiedRemovedLearningAimEvent);
        }
Exemplo n.º 7
0
        internal void OnInteract(Entity entity, MessageSession session, InteractMsg msg)
        {
            if (entity.Has <Fightable>())
            {
                var template = DataCenter.Instance.GetDatum <InteractTemplate>(msg.InteractId);
                if (template == null)
                {
                    Logger.Write("Request a invalid interact[{0}]", msg.InteractId);
                    return;
                }

                EffectSystem.Affect(entity, template);
            }
            else
            {
                PositionSystem.Global.Interact(entity, targets =>
                {
                    // default interaction - remove removables
                    foreach (var target in targets.Where(target => target.Has <Removable>() && target.Get <Removable>().Action))
                    {
                        // despawn target
                        PositionSystem.Global.Disappear(target);
                        EntityBinder.Instance.Remove(target);
                        EntityManager.Instance.Remove(target.Id);
                    }
                });
            }
        }
Exemplo n.º 8
0
        protected override Task ReceiveMessageImplAsync(BrokeredMessage message, MessageSession session, CancellationToken cancellationToken)
        {
            ServiceEventSource.Current.ServiceMessage(_service, $"Handling queue message {message.MessageId} in session {session?.SessionId ?? "none"}");

            RPATicket ticket;

            try
            {
                ticket          = message.GetBody <RPATicket>();
                ticket.TicketId = Guid.NewGuid().ToString();
                bool isValid = validate(ticket);
                if (isValid)
                {
                    sendToEmail(new BrokeredMessage(ticket));
                }
                else
                {
                    sendToErrorQueue(message);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                sendToErrorQueue(message);
                return(Task.FromResult(false));
            }

            return(Task.FromResult(true));
        }
Exemplo n.º 9
0
        protected async void cmdSend2_Click(object sender, EventArgs e)
        {
            byte[]          dataArr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            BrokeredMessage msg     = new BrokeredMessage(dataArr);

            msg.Properties.Add("suma", 1);
            msg.ReplyToSessionId = Guid.NewGuid().ToString("N");
            await m_tc.SendAsync(msg);

            MessageSession         session = m_qc.AcceptMessageSession(msg.ReplyToSessionId, TimeSpan.FromSeconds(60));
            List <BrokeredMessage> lst     = new List <BrokeredMessage>();

            while (lst.Count < 2)
            {
                msg = await session.ReceiveAsync();

                if (msg != null)
                {
                    lst.Add(msg);
                    await msg.CompleteAsync();
                }
            }
            lblInfo.Text = "";
            foreach (var item in lst)
            {
                lblInfo.Text += item.GetBody <string>();
            }
        }
 public async Task WhenThereIsAChangeToTheApprenticeshipDetailsForOneOfTheProviderSLearners()
 {
     await MessageSession.Publish <ApprenticeshipUpdated>(m =>
     {
         m.Ukprn = TestSession.Ukprn;
     });
 }
 /// <summary>
 /// Creates an instance of the handler factory.
 /// </summary>
 /// <returns>
 /// The created instance.
 /// </returns>
 /// <param name="session">The message session.</param>
 /// <param name="message">The message.</param>
 IMessageSessionAsyncHandler IMessageSessionAsyncHandlerFactory.CreateInstance(MessageSession session, BrokeredMessage message)
 {
     return new SessionHandler(
         msg => messageSubject.OnNext(msg),
         ex => exceptionSubject.OnNext(ex),
         scheduler);
 }
        public async Task GenerateMetricsFromLatestJob(int count)
        {
            //set these to the period you have data for
            var academicYear     = 2122;
            var collectionPeriod = 11;

            var dataContext = Container.Resolve <JobsDataContext>();
            var jobs        = await dataContext.Jobs
                              .Where(job =>
                                     job.JobType == JobType.EarningsJob &&
                                     (job.Status == JobStatus.Completed || job.Status == JobStatus.CompletedWithErrors) &&
                                     job.AcademicYear == academicYear &&
                                     job.CollectionPeriod > collectionPeriod
                                     ).OrderByDescending(job => job.LearnerCount)
                              .Take(count)
                              .ToListAsync();

            var messages = jobs.Select(job => new RecordPeriodEndRequestReportsJob
            {
                JobId            = job.DcJobId.Value,
                CollectionPeriod = job.CollectionPeriod,
                CollectionYear   = job.AcademicYear,
            })
                           .ToList();

            foreach (var periodEndRequestReportsEvent in messages)
            {
                await MessageSession.Send(periodEndRequestReportsEvent).ConfigureAwait(false);
            }
        }
Exemplo n.º 13
0
        public async Task GenerateMetricsFromLatestJob(int count)
        {
            var dataContext = Container.Resolve <JobsDataContext>();
            var jobs        = await dataContext.Jobs
                              .Where(job =>
                                     job.JobType == JobType.EarningsJob &&
                                     (job.Status == JobStatus.Completed || job.Status == JobStatus.CompletedWithErrors)
                                     ).OrderByDescending(job => job.LearnerCount)
                              .Take(count)
                              .ToListAsync();

            var messages = jobs.Select(job => new GenerateSubmissionSummary
            {
                Ukprn            = job.Ukprn.Value,
                CollectionPeriod = job.CollectionPeriod,
                AcademicYear     = job.AcademicYear,
                JobId            = job.DcJobId.Value,
            })
                           .ToList();

            foreach (var generateSubmissionSummary in messages)
            {
                await MessageSession.Send(generateSubmissionSummary).ConfigureAwait(false);
            }
        }
Exemplo n.º 14
0
        public Task OnCloseSessionAsync(MessageSession session)
        {
            ServiceBusEventSource.Log.SessionClosed(_receiverNamespace, _receiverPath, session.SessionId);

            // No need to do anything else.
            return Task.FromResult(0);
        }
Exemplo n.º 15
0
        public async Task Send()
        {
            await CreateResponseQueue();

            QueueClient sendClient     = QueueClient.CreateFromConnectionString(ConfigurationManager.AppSettings[Helpers.ConnectionStringKey], Helpers.BasicQueueName);
            QueueClient responseClient = QueueClient.CreateFromConnectionString(ConfigurationManager.AppSettings[Helpers.ConnectionStringKey], Helpers.ResponseQueue);

            byte[] messageData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(Helpers.GetModels()));
            string sessionId   = Guid.NewGuid().ToString("N");

            BrokeredMessage message = new BrokeredMessage(new MemoryStream(messageData), true)
            {
                ContentType      = "application/json",
                Label            = "dynamic data",
                TimeToLive       = TimeSpan.FromMinutes(20),
                ReplyToSessionId = sessionId,
                ReplyTo          = Helpers.ResponseQueue
            };

            await sendClient.SendAsync(message);

            MessageSession messageSession = await responseClient.AcceptMessageSessionAsync(sessionId);

            BrokeredMessage responseMessage = await messageSession.ReceiveAsync();

            string responseMessageBody = responseMessage.GetBody <string>();

            Console.WriteLine($"Message response received: \n{responseMessageBody}");
        }
 public MessageSessionAsyncHandler(ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
 {
     _supervisor = supervisor;
     _receiver   = receiver;
     _session    = session;
     _message    = message;
 }
Exemplo n.º 17
0
        protected override async Task <SessionWorkItem> OnFetchWorkItem(TimeSpan receiveTimeout)
        {
            MessageSession session = await orchestratorQueueClient.AcceptMessageSessionAsync(receiveTimeout);

            if (session == null)
            {
                return(null);
            }

            IEnumerable <BrokeredMessage> newMessages =
                await Utils.ExecuteWithRetries(() => session.ReceiveBatchAsync(PrefetchCount),
                                               session.SessionId, "Receive Session Message Batch", MaxRetries, IntervalBetweenRetriesSecs);

            TraceHelper.TraceSession(TraceEventType.Information, session.SessionId,
                                     GetFormattedLog(
                                         $@"{newMessages.Count()} new messages to process: {
                        string.Join(",", newMessages.Select(m => m.MessageId))
                        }, max latency: {
                        newMessages.Max(message => message.DeliveryLatency())}ms"
                                         ));

            return(new SessionWorkItem {
                Session = session, Messages = newMessages
            });
        }
Exemplo n.º 18
0
        protected override async Task <SessionWorkItem> OnFetchWorkItem(TimeSpan receiveTimeout)
        {
            IEnumerable <BrokeredMessage> newMessages = null;

            MessageSession session = await trackingQueueClient.AcceptMessageSessionAsync(receiveTimeout);

            if (session == null)
            {
                return(null);
            }

            newMessages = await Utils.ExecuteWithRetries(() => session.ReceiveBatchAsync(PrefetchCount),
                                                         session.SessionId, "Receive Tracking Message Batch",
                                                         MaxRetriesServiceBus,
                                                         IntervalBetweenRetriesSecs);

            TraceHelper.TraceSession(TraceEventType.Information, session.SessionId,
                                     GetFormattedLog(
                                         string.Format("{0} new messages to process: {1}",
                                                       newMessages.Count(),
                                                       string.Join(",", newMessages.Select(m => m.MessageId + " [" + m.SequenceNumber + "]")))));

            return(new SessionWorkItem {
                Session = session, Messages = newMessages
            });
        }
Exemplo n.º 19
0
        public async Task WhenTheEventIsDuplicatedButWithADifferentCommandIdOnTheProcessLearnerCommand()
        {
            var command = Context.Get <ProcessLearnerCommand>(ProcessLearnerCommand);

            command.CommandId = Guid.NewGuid();
            await MessageSession.Send(command);
        }
Exemplo n.º 20
0
        protected override async Task ReceiveMessageImplAsync(
            BrokeredMessage message,
            MessageSession session,
            CancellationToken cancellationToken)
        {
            var postUserRoleMessage = message.GetBody <PostUserRoleMessage>();

            foreach (var role in (RoleType[])Enum.GetValues(typeof(RoleType)))
            {
                await _roleRepository.DeleteUserRole(postUserRoleMessage.UserId,
                                                     role);
            }

            foreach (var role in postUserRoleMessage.Roles)
            {
                await _roleRepository.AddUserRole(postUserRoleMessage.UserId,
                                                  (RoleType)Enum.Parse(typeof(RoleType), role));
            }

            WriteLog($"Handling queue message {message.MessageId}");
            var payload = new PostUserRoleResultMessage();

            await _serviceBusCommunicationService.SendBrokeredMessage(new BrokeredMessage(payload)
            {
                SessionId = message.SessionId
            }, "Processed-Post-User-Roles-Queue");
        }
Exemplo n.º 21
0
        static void SendMessages(TopicClient topicClient, SubscriptionClient responseClient)
        {
            // Send request messages to queue:
            Console.WriteLine("Sending request messages to topic {0}", topicClient.Path);
            Console.WriteLine("Receiving response messages on subscription {0}", responseClient.Name);


            MessageSession session = responseClient.AcceptMessageSession(ClientId);

            for (int i = 0; i < SampleManager.NumMessages; ++i)
            {
                // send request message
                BrokeredMessage message = new BrokeredMessage
                {
                    ReplyToSessionId = ClientId,
                    MessageId        = i.ToString(),
                    CorrelationId    = SampleManager.RequestSubName
                };

                topicClient.Send(message);
                SampleManager.OutputMessageInfo("REQUEST: ", message);

                // start asynchronous receive operation
                //TODO: Fix
                //session.ReceiveAsync ( TimeSpan.FromSeconds(ResponseMessageTimeout), ProcessResponse, session);

                var brokeredMessage = session.Receive(TimeSpan.FromSeconds(ResponseMessageTimeout));

                ProcessResponse(brokeredMessage);
            }


            Console.WriteLine();
        }
Exemplo n.º 22
0
        public static void ReceiveQ()
        {
            Console.WriteLine("In Receive method().");

            TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(QReceiver.IssuerName, QReceiver.IssuerKey);
            Uri           serviceUri  = ServiceBusEnvironment.CreateServiceUri("sb", QReceiver.ServiceNamespace, string.Empty);

            MessagingFactory factory = null;

            factory = MessagingFactory.Create(serviceUri, credentials);

            QueueClient sessionQueueClient = factory.CreateQueueClient(QReceiver.QueueName);

            //Create sessionQueueClient and subscribe to SessionIDs that have a value of "Mike"
            MessageSession  sessionReceiver = sessionQueueClient.AcceptMessageSession("92610", TimeSpan.FromSeconds(60));
            BrokeredMessage receivedMessage;

            while ((receivedMessage = sessionReceiver.Receive(TimeSpan.FromSeconds(60))) != null)
            {
                Console.WriteLine("Received Messages.");
                var data = receivedMessage.GetBody <FireEvent>(new DataContractSerializer(typeof(FireEvent)));
                //Console.WriteLine(String.Format("Customer Name: {0}", data.CustomerName));
                Console.WriteLine("SessionID: {0}", receivedMessage.SessionId);
                //remove message from Topic
                receivedMessage.Complete();
            }

            Console.WriteLine("All received on this session...press enter to exit");
            Console.Read();
        }
        /// <summary>
        /// Create a new session handler.
        /// </summary>
        /// <param name="session"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public IMessageSessionAsyncHandler CreateInstance(MessageSession session, BrokeredMessage message)
        {
            ServiceBusEventSource.Log.SessonAccepted(_receiverNamespace, _receiverPath, session.SessionId, message.MessageId, message.CorrelationId);

            // Use the current handler.
            return new SessionMessageAsyncHandler(_receiverNamespace, _receiverPath, session, _messageHandler, _options);
        }
        /// <summary>
        /// Get all messages that has a session
        /// </summary>
        /// <param name="client">QueueClient</param>
        private void GetSessionMessages(QueueClient client)
        {
            try
            {
                MessageSession ses = client.AcceptMessageSession(properties.Session);

                BrokeredMessage item = ses.Receive(properties.ReceiveTimeout);

                while (true)
                {
                    if (item == null)
                    {
                        break;
                    }

                    if (SubmitMessage(item) == false)
                    {
                        ses.Abort();
                        break;
                    }

                    //allow setting timeout
                    item = ses.Receive(properties.ReceiveTimeout);
                }
            }
            catch (Exception)
            {
                //probably lock
            }
        }
        /// <summary>
        /// Get all messages with a specific session
        /// </summary>
        /// <param name="client">QueueClient</param>
        private void GetAllMessagesWithSession(QueueClient client)
        {
            foreach (MessageSession sessions in client.GetMessageSessions())
            {
                try
                {
                    MessageSession ses = client.AcceptMessageSession(sessions.SessionId);

                    BrokeredMessage item = ses.Receive(properties.ReceiveTimeout);

                    while (true)
                    {
                        if (item == null)
                        {
                            break;
                        }

                        if (SubmitMessage(item) == false)
                        {
                            ses.Abort();
                            break;
                        }
                        //allow setting timeout
                        item = ses.Receive(properties.ReceiveTimeout);
                    }
                }
                catch (Exception)
                {
                    break;
                }
            }
        }
        public async Task <ActionResult> Sub(int a = 5, int b = 12)
        {
            int   result = 0;
            Param p      = new Param {
                A = a, B = b
            };
            BrokeredMessage msg = new BrokeredMessage(p);

            msg.Properties.Add("operation", 2);
            msg.ReplyToSessionId = Guid.NewGuid().ToString("N");
            await m_tc.SendAsync(msg);

            string session = msg.ReplyToSessionId;

            msg = null;
            while (msg == null)
            {
                MessageSession msgsession = m_qc.AcceptMessageSession(session, TimeSpan.FromSeconds(360));
                msg = await msgsession.ReceiveAsync();

                if (msg != null)
                {
                    result = msg.GetBody <int>();
                }
            }
            return(View(result));
        }
Exemplo n.º 27
0
        public MessageSessionPage(SessionSettings settings, MessageSession session)
        {
            _settings      = settings;
            BindingContext = new MessageSessionPageContext(session);
            _context       = BindingContext as MessageSessionPageContext;

            _threadStart = new ThreadStart(() =>
            {
                while (true)
                {
                    try
                    {
                        _context.RefreshMessages(_settings.Jwt);
                        Thread.Sleep(3000);
                    }
                    catch (ThreadAbortException)
                    {
                        break;
                    }
                }
            });

            _refreshThread = new Thread(_threadStart);

            InitializeComponent();
        }
        public async Task <IActionResult> UpdateSession(MessageSessionUpdateViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                var fromEmail =
                    await Services.AuthorizationServices.VerifyToken(clientFactory, viewModel.JwtFrom);

                if (fromEmail == null)
                {
                    return(Unauthorized());
                }

                var session = new MessageSession
                {
                    Title       = viewModel.Title,
                    Description = viewModel.Description,
                    Emails      = fromEmail
                };

                if (viewModel.Emails != null)
                {
                    session.Emails += ";" + string.Join(';', viewModel.Emails).ToLower();
                }

                await sessionRepository.UpdateMessageSessionAsync(viewModel.Id, session);

                return(Ok(JsonConvert.SerializeObject(session)));
            }
            return(BadRequest());
        }
Exemplo n.º 29
0
        static void ProcessMessage(BrokeredMessage message, MessageSession session = null)
        {
            DateTime startProcessingNewMessage = DateTime.Now;
            TimeSpan elapsed = startProcessingNewMessage - lastReceive;

            lastReceive = startProcessingNewMessage;

            // Using the Session State to track how much processing time was spent on a group.
            // This value will persist even if a receiver process is killed and the remaining
            // messages are picked up by another receiver.
            string readState = null;

            if (session != null)
            {
                TimeSpan totalElapsed = elapsed;

                readState = GetState(session);
                if (readState != null)
                {
                    TimeSpan prevElapsed = TimeSpan.FromSeconds(Double.Parse(readState));
                    totalElapsed = elapsed + prevElapsed;
                }

                SetState(session, totalElapsed.TotalSeconds.ToString());
            }

            SampleManager.OutputMessageInfo("RECV: ", message, "State: " + readState);

            Thread.Sleep(receiverDelay);
        }
 public void VerifyTokensForAmendedTemplate()
 {
     VerifyCommonTokensForTemplate("review");
     MessageSession.Verify(x => x.Send(It.Is <SendEmailToEmployerCommand>(p => p.Tokens["provider_name"] == Commitment.ProviderName &&
                                                                          p.Tokens["employer_hashed_account"] == Commitment.EmployerAccountId.ToString()),
                                       It.IsAny <SendOptions>()));
 }
Exemplo n.º 31
0
        /// <summary>
        /// 转换为MessageSession用于数据库存储
        /// </summary>
        public MessageSession AsMessageSession()
        {
            MessageSession messageSession;

            if (SessionId > 0)
            {
                MessageService messageService = new MessageService();
                messageSession = messageService.GetSession(SessionId);
                messageSession.LastMessageId      = this.LastMessageId;
                messageSession.MessageCount       = this.MessageCount;
                messageSession.MessageType        = this.MessageType;
                messageSession.OtherUserId        = this.OtherUserId;
                messageSession.UnreadMessageCount = this.UnreadMessageCount;
                messageSession.UserId             = this.UserId;
            }
            else
            {
                messageSession = MessageSession.New();
                messageSession.LastMessageId      = this.LastMessageId;
                messageSession.MessageCount       = this.MessageCount;
                messageSession.MessageType        = this.MessageType;
                messageSession.OtherUserId        = this.OtherUserId;
                messageSession.UnreadMessageCount = this.UnreadMessageCount;
                messageSession.UserId             = this.UserId;
            }
            return(messageSession);
        }
        public Task OnCloseSessionAsync(MessageSession session)
        {
            if (_log.IsDebugEnabled)
                _log.DebugFormat("Session Closed: {0} ({1})", session.SessionId, _receiver.InputAddress);

            return TaskUtil.Completed;
        }
        protected override Task ReceiveMessageImplAsync(BrokeredMessage message, MessageSession session, CancellationToken cancellationToken)
        {
            ServiceEventSource.Current.ServiceMessage(_service, $"Handling queue message {message.MessageId} in session {session?.SessionId ?? "none"}");

            RPATicket ticket = null;

            try
            {
                ticket = message.GetBody <RPATicket>();
                bool isValid = validate(ticket);

                if (isValid)
                {
                    executionScript(ticket);
                }
                else
                {
                    sendToErrorQueue(ticket);
                }
            }
            catch (Exception e)
            {
                ticket.Error = e.Message;
                sendToErrorQueue(ticket);
                return(Task.FromResult(false));
            }
            storeResultToDB(ticket);

            return(Task.FromResult(true));
        }
 public MessageSessionAsyncHandler(ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
 {
     _supervisor = supervisor;
     _receiver = receiver;
     _session = session;
     _message = message;
 }
        static void SendMessages(QueueClient requestClient, QueueClient responseClient)
        {
            // Send request messages to queue:
            Console.WriteLine("Sending request messages to queue {0}", requestClient.Path);
            Console.WriteLine("Receiving response messages on queue {0}", responseClient.Path);

            MessageSession receiver = responseClient.AcceptMessageSession(ReplyToSessionId);

            for (int i = 0; i < SampleManager.NumMessages; ++i)
            {
                // send request message
                BrokeredMessage message = CreateRequestMessage(i);
                requestClient.Send(message);
                SampleManager.OutputMessageInfo("REQUEST: ", message);

                // receive response message
                BrokeredMessage receivedMessage = receiver.Receive(TimeSpan.FromSeconds(ResponseMessageTimeout));
                if (receivedMessage != null)
                {
                    SampleManager.OutputMessageInfo("RESPONSE: ", message);
                    receivedMessage.Complete();
                }
                else
                {
                    Console.WriteLine("ERROR: Response timed out.");
                }
            }
            receiver.Close();

            Console.WriteLine();
        }
 public MessageSessionAsyncHandler(ConnectionContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
 {
     _context = context;
     _supervisor = supervisor;
     _receiver = receiver;
     _session = session;
     _message = message;
 }
Exemplo n.º 37
0
 public SessionMessageAsyncHandler(string receiverNamespace, string receiverPath, MessageSession session, OnSessionMessage messageHandler, OnSessionMessageOptions options)
 {
     _receiverNamespace = receiverNamespace;
     _receiverPath = receiverPath;
     _session = session;
     _messageHandler = messageHandler;
     _options = options;
 }
 public MessageSessionAsyncHandler(NamespaceContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session,
     IDeliveryTracker tracker, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
 {
     _context = context;
     _supervisor = supervisor;
     _receiver = receiver;
     _session = session;
     _tracker = tracker;
     _sendEndpointProvider = sendEndpointProvider;
     _publishEndpointProvider = publishEndpointProvider;
 }
Exemplo n.º 39
0
        public StartableEndpoint(SettingsHolder settings, IBuilder builder, FeatureActivator featureActivator, PipelineConfiguration pipelineConfiguration, IEventAggregator eventAggregator, TransportInfrastructure transportInfrastructure, CriticalError criticalError)
        {
            this.criticalError = criticalError;
            this.settings = settings;
            this.builder = builder;
            this.featureActivator = featureActivator;
            this.pipelineConfiguration = pipelineConfiguration;
            this.eventAggregator = eventAggregator;
            this.transportInfrastructure = transportInfrastructure;

            pipelineCache = new PipelineCache(builder, settings);

            messageSession = new MessageSession(new RootContext(builder, pipelineCache, eventAggregator));
        }
        async Task IMessageSessionAsyncHandler.OnMessageAsync(MessageSession session, BrokeredMessage message)
        {
            if (_receiver.IsShuttingDown)
            {
                await WaitAndAbandonMessage(message).ConfigureAwait(false);
                return;
            }

            using (var delivery = _tracker.BeginDelivery())
            {
                if (_log.IsDebugEnabled)
                    _log.DebugFormat("Receiving {0}:{1}({3}) - {2}", delivery.Id, message.MessageId, _receiver.QueuePath, session.SessionId);

                var context = new ServiceBusReceiveContext(_receiver.InputAddress, message, _context, _sendEndpointProvider, _publishEndpointProvider);

                context.GetOrAddPayload<MessageSessionContext>(() => new BrokeredMessageSessionContext(session));
                context.GetOrAddPayload(() => _context);

                try
                {
                    await _context.PreReceive(context).ConfigureAwait(false);

                    await _receiver.ReceivePipe.Send(context).ConfigureAwait(false);

                    await context.CompleteTask.ConfigureAwait(false);

                    await message.CompleteAsync().ConfigureAwait(false);

                    await _context.PostReceive(context).ConfigureAwait(false);

                    if (_log.IsDebugEnabled)
                        _log.DebugFormat("Receive completed: {0}", message.MessageId);
                }
                catch (Exception ex)
                {
                    if (_log.IsErrorEnabled)
                        _log.Error($"Received faulted: {message.MessageId}", ex);

                    await message.AbandonAsync().ConfigureAwait(false);
                    await _context.ReceiveFault(context, ex).ConfigureAwait(false);
                }
                finally
                {
                    context.Dispose();
                }
            }
        }
        async Task IMessageSessionAsyncHandler.OnMessageAsync(MessageSession session, BrokeredMessage message)
        {
            if (_receiver.IsShuttingDown)
            {
                await WaitAndAbandonMessage(message).ConfigureAwait(false);
                return;
            }

            var deliveryCount = _receiver.IncrementDeliveryCount();

            if (_log.IsDebugEnabled)
                _log.DebugFormat("Receiving {0}:{1}({3}) - {2}", deliveryCount, message.MessageId, _receiver.QueuePath, session.SessionId);

            var context = new ServiceBusReceiveContext(_receiver.InputAddress, message, _receiver.ReceiveObserver);
            context.GetOrAddPayload<MessageSessionContext>(() => new BrokeredMessageSessionContext(session));

            try
            {
                await _receiver.ReceiveObserver.PreReceive(context).ConfigureAwait(false);

                await _receiver.ReceivePipe.Send(context).ConfigureAwait(false);

                await context.CompleteTask.ConfigureAwait(false);

                await message.CompleteAsync().ConfigureAwait(false);

                await _receiver.ReceiveObserver.PostReceive(context).ConfigureAwait(false);

                if (_log.IsDebugEnabled)
                    _log.DebugFormat("Receive completed: {0}", message.MessageId);
            }
            catch (Exception ex)
            {
                if (_log.IsErrorEnabled)
                    _log.Error($"Received faulted: {message.MessageId}", ex);

                await message.AbandonAsync().ConfigureAwait(false);
                await _receiver.ReceiveObserver.ReceiveFault(context, ex).ConfigureAwait(false);
            }
            finally
            {
                _receiver.DeliveryComplete();
            }
        }
        public async Task OnMessageAsync(MessageSession session, BrokeredMessage message)
        {
            try
            {
                ServiceBusEventSource.Log.SessionMessageReceived(_receiverNamespace, _receiverPath, session.SessionId, message.MessageId, message.CorrelationId);

                // Handle the message.
                await _messageHandler(session, message);
            }
            catch (Exception exception)
            {
                ServiceBusEventSource.Log.SessionMessageReceiverException(_receiverNamespace, _receiverPath, session.SessionId, message.MessageId, message.CorrelationId, "OnMessage", exception.Message, exception.StackTrace);

                // Don't allow other messages to be processed.
                if (_options.RequireSequentialProcessing)
                {
                    message.Abandon();
                    session.Abort();
                }

                throw;
            }
        }
Exemplo n.º 43
0
        public async Task OnMessageAsync(MessageSession session, BrokeredMessage message)
        {
            try
            {
                ServiceBusEventSource.Log.SessionMessageReceived(_receiverNamespace, _receiverPath, message.MessageId, message.CorrelationId, message.SessionId, message.DeliveryCount, message.Size);

                // Handle the message.
                await _messageHandler(session, message)
                    .ConfigureAwait(false);
            }
            catch (Exception exception)
            {
                ServiceBusEventSource.Log.MessagePumpExceptionReceived(_receiverNamespace, _receiverPath, "OnSessionMessage", exception);

                // Don't allow other messages to be processed.
                if (_options.RequireSequentialProcessing)
                {
                    message.Abandon();
                    session.Abort();
                }

                throw;
            }
        }
 public async Task OnCloseSessionAsync(MessageSession session)
 {
     // nothing to do
 }
Exemplo n.º 45
0
 public async Task OnMessageAsync(MessageSession session, BrokeredMessage message)
 {
     try
     {
         if (message == null)
         {
             return;
         }
         if (session == null)
         {
             return;
         }
         if (configuration == null)
         {
             return;
         }
         if (configuration.MessageInspector != null)
         {
             message = configuration.MessageInspector.AfterReceiveMessage(message);
         }
         if (configuration.Logging)
         {
             var builder = new StringBuilder(string.Format(MessageSuccessfullyReceived,
                                             string.IsNullOrWhiteSpace(message.MessageId)
                                                 ? NullValue
                                                 : message.MessageId,
                                             string.IsNullOrWhiteSpace(message.SessionId)
                                                 ? NullValue
                                                 : message.SessionId,
                                             string.IsNullOrWhiteSpace(message.Label)
                                                 ? NullValue
                                                 : message.Label,
                                             message.Size));
             if (configuration.Verbose)
             {
                 configuration.ServiceBusHelper.GetMessageAndProperties(builder, message, configuration.MessageEncoder);
             }
             configuration.WriteToLog(builder.ToString(), false);
         }
         if (configuration.Tracking)
         {
             configuration.TrackMessage(message.Clone());
         }
         if (configuration.Graph)
         {
             configuration.UpdateStatistics(1, configuration.GetElapsedTime(), message.Size);
         }
         if (configuration.ReceiveMode == ReceiveMode.PeekLock && !configuration.AutoComplete)
         {
             await message.CompleteAsync();
         }
         if (!SessionDictionary.ContainsKey(message.SessionId))
         {
             SessionDictionary.Add(message.SessionId, 1);
         }
         else
         {
             SessionDictionary[message.SessionId]++;
         }
     }
     catch (Exception ex)
     {
         HandleException(ex);
     }
 }
Exemplo n.º 46
0
        /// <summary>
        /// Handle the message.
        /// </summary>
        /// <param name="session"></param>
        /// <param name="brokeredMessage"></param>
        /// <param name="receiver"></param>
        /// <param name="handlerMap"></param>
        /// <returns></returns>
        private async Task OnHandleMessage(IMessageReceiver receiver, MessageSession session, BrokeredMessage brokeredMessage, MessageHandlerMap handlerMap)
        {
            MessagingEventSource.Log.MessageReceived(brokeredMessage.ContentType, receiver, brokeredMessage.MessageId, brokeredMessage.CorrelationId, brokeredMessage.SessionId);

            // Create new isolated scope.
            using (var scope = Configuration.Container.BeginScope())
            {
                var envelope = await BuildMessage(brokeredMessage);

                // Dispatch the message.
                var dispatcher = new MessageDispatcher(scope, handlerMap);
                await dispatcher.Dispatch(brokeredMessage.ContentType, envelope, session != null ? new Session(session, Configuration.Serializer) : null);

                // Cleanup the message.
                var messageReceiver = receiver as IMessagePump;
                if (messageReceiver != null && messageReceiver.Mode == ReceiveMode.PeekLock)
                {
                    // Log.
                    MessagingEventSource.Log.MessageCompleting(brokeredMessage.ContentType, brokeredMessage.MessageId, brokeredMessage.CorrelationId, brokeredMessage.SessionId);

                    // Complete the message.
                    brokeredMessage.TryComplete();
                    return;
                }

                // Cleanup the message.
                var sessionMessageReceiver = receiver as ISessionMessagePump;
                if (sessionMessageReceiver != null && sessionMessageReceiver.Mode == ReceiveMode.PeekLock)
                {
                    // Log.
                    MessagingEventSource.Log.MessageCompleting(brokeredMessage.ContentType, brokeredMessage.MessageId, brokeredMessage.CorrelationId, brokeredMessage.SessionId);

                    // Complete the message.
                    brokeredMessage.TryComplete();
                }
            }
        }
Exemplo n.º 47
0
 public Task OnCloseSessionAsync(MessageSession session)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 48
0
 public Task OnMessageAsync(MessageSession session, BrokeredMessage message)
 {
     throw new NotImplementedException();
 }
 public IMessageSessionAsyncHandler CreateInstance(MessageSession session, BrokeredMessage message)
 {
     return new CustomMessageSessionAsyncHandler(Configuration);
 }
 /// <summary>
 /// Raises an event that occurs when the session has been asynchronously closed.
 /// </summary>
 /// <returns>
 /// The task object representing the asynchronous operation.
 /// </returns>
 /// <param name="session">The closed session.</param>
 public async Task OnCloseSessionAsync(MessageSession session)
 {
 }
        /// <summary>
        /// Receives the messages in an asynchronous loop and closes the session once there are no more messages.
        /// </summary>
        private void ReceiveMessagesAndCloseSession(MessageSession session, CancellationToken cancellationToken)
        {
            CountdownEvent unreleasedMessages = new CountdownEvent(1);

            Action<bool> closeSession = (bool success) =>
            {
                Action doClose = () =>
                    {
                        try
                        {
                            unreleasedMessages.Signal();
                            if (!unreleasedMessages.Wait(15000, cancellationToken))
                            {
                                Trace.TraceWarning("Waited for pending unreleased messages before closing session in subscription {0} but they did not complete in time", this.subscription);
                            }
                        }
                        catch (OperationCanceledException)
                        {
                        }
                        finally
                        {
                            unreleasedMessages.Dispose();
                        }

                        this.receiveRetryPolicy.ExecuteAction(
                            cb => session.BeginClose(cb, null),
                            session.EndClose,
                            () =>
                            {
                                this.instrumentation.SessionEnded();
                                if (success)
                                {
                                    this.dynamicThrottling.NotifyWorkCompleted();
                                }
                                else
                                {
                                    this.dynamicThrottling.NotifyWorkCompletedWithError();
                                }
                            },
                            ex =>
                            {
                                this.instrumentation.SessionEnded();
                                Trace.TraceError("An unrecoverable error occurred while trying to close a session in subscription {1}:\r\n{0}", ex, this.subscription);
                                this.dynamicThrottling.NotifyWorkCompletedWithError();
                            });
                    };

                if (this.requiresSequentialProcessing)
                {
                    doClose.Invoke();
                }
                else
                {
                    // Allow some time for releasing the messages before closing. Also, continue in a non I/O completion thread in order to block.
                    TaskEx.Delay(200).ContinueWith(t => doClose());
                }
            };

            // Declare an action to receive the next message in the queue or closes the session if cancelled.
            Action receiveNext = null;

            // Declare an action acting as a callback whenever a non-transient exception occurs while receiving or processing messages.
            Action<Exception> recoverReceive = null;

            // Declare an action responsible for the core operations in the message receive loop.
            Action receiveMessage = (() =>
            {
                // Use a retry policy to execute the Receive action in an asynchronous and reliable fashion.
                this.receiveRetryPolicy.ExecuteAction
                (
                    cb =>
                    {
                        // Start receiving a new message asynchronously.
                        // Does not wait for new messages to arrive in a session. If no further messages we will just close the session.
                        session.BeginReceive(TimeSpan.Zero, cb, null);
                    },
                    // Complete the asynchronous operation. This may throw an exception that will be handled internally by retry policy.
                    session.EndReceive,
                    msg =>
                    {
                        // Process the message once it was successfully received
                        // Check if we actually received any messages.
                        if (msg != null)
                        {
                            var roundtripStopwatch = Stopwatch.StartNew();
                            long schedulingElapsedMilliseconds = 0;
                            long processingElapsedMilliseconds = 0;

                            unreleasedMessages.AddCount();

                            Task.Factory.StartNew(() =>
                                {
                                    var releaseAction = MessageReleaseAction.AbandonMessage;

                                    try
                                    {
                                        this.instrumentation.MessageReceived();

                                        schedulingElapsedMilliseconds = roundtripStopwatch.ElapsedMilliseconds;

                                        // Make sure the process was told to stop receiving while it was waiting for a new message.
                                        if (!cancellationToken.IsCancellationRequested)
                                        {
                                            try
                                            {
                                                try
                                                {
                                                    // Process the received message.
                                                    releaseAction = this.InvokeMessageHandler(msg);

                                                    processingElapsedMilliseconds = roundtripStopwatch.ElapsedMilliseconds - schedulingElapsedMilliseconds;
                                                    this.instrumentation.MessageProcessed(releaseAction.Kind == MessageReleaseActionKind.Complete, processingElapsedMilliseconds);
                                                }
                                                catch
                                                {
                                                    processingElapsedMilliseconds = roundtripStopwatch.ElapsedMilliseconds - schedulingElapsedMilliseconds;
                                                    this.instrumentation.MessageProcessed(false, processingElapsedMilliseconds);

                                                    throw;
                                                }
                                            }
                                            finally
                                            {
                                                if (roundtripStopwatch.Elapsed > TimeSpan.FromSeconds(45))
                                                {
                                                    this.dynamicThrottling.Penalize();
                                                }
                                            }
                                        }
                                    }
                                    finally
                                    {
                                        // Ensure that any resources allocated by a BrokeredMessage instance are released.
                                        if (this.requiresSequentialProcessing)
                                        {
                                            this.ReleaseMessage(msg, releaseAction, () => { receiveNext(); }, () => { closeSession(false); }, unreleasedMessages, processingElapsedMilliseconds, schedulingElapsedMilliseconds, roundtripStopwatch);
                                        }
                                        else
                                        {
                                            // Receives next without waiting for the message to be released.
                                            this.ReleaseMessage(msg, releaseAction, () => { }, () => { this.dynamicThrottling.Penalize(); }, unreleasedMessages, processingElapsedMilliseconds, schedulingElapsedMilliseconds, roundtripStopwatch);
                                            receiveNext.Invoke();
                                        }
                                    }
                                });
                        }
                        else
                        {
                            // no more messages in the session, close it and do not continue receiving
                            closeSession(true);
                        }
                    },
                    ex =>
                    {
                        // Invoke a custom action to indicate that we have encountered an exception and
                        // need further decision as to whether to continue receiving messages.
                        recoverReceive.Invoke(ex);
                    });
            });

            // Initialize an action to receive the next message in the queue or closes the session if cancelled.
            receiveNext = () =>
            {
                if (!cancellationToken.IsCancellationRequested)
                {
                    // Continue receiving and processing new messages until told to stop.
                    receiveMessage.Invoke();
                }
                else
                {
                    closeSession(true);
                }
            };

            // Initialize a custom action acting as a callback whenever a non-transient exception occurs while receiving or processing messages.
            recoverReceive = ex =>
            {
                // Just log an exception. Do not allow an unhandled exception to terminate the message receive loop abnormally.
                Trace.TraceError("An unrecoverable error occurred while trying to receive a new message from subscription {1}:\r\n{0}", ex, this.subscription);

                // Cannot continue to receive messages from this session.
                closeSession(false);
            };

            // Start receiving messages asynchronously for the session.
            receiveNext.Invoke();
        }
Exemplo n.º 52
0
        /// <summary>
        /// Handle the message.
        /// </summary>
        /// <param name="session"></param>
        /// <param name="brokeredMessage"></param>
        /// <param name="receiver"></param>
        /// <param name="handlerMap"></param>
        /// <returns></returns>
        private async Task OnHandleMessage(IMessageReceiver receiver, MessageSession session, BrokeredMessage brokeredMessage, MessageHandlerMap handlerMap)
        {
            MessengerEventSource.Log.MessageReceived(brokeredMessage.ContentType, receiver, brokeredMessage.MessageId, brokeredMessage.CorrelationId, brokeredMessage.SessionId);

            // Create new isolated scope.
            using (var scope = Configuration.Container.BeginScope())
            {
                var envelope = await BuildMessage(brokeredMessage)
                    .ConfigureAwait(false);

                // Dispatch the message.
                var dispatcher = new MessageDispatcher(scope, handlerMap);
                await dispatcher.Dispatch(brokeredMessage.ContentType, envelope, session != null ? new Session(session, Configuration.Serializer) : null)
                    .ConfigureAwait(false);
            }
        }
 public IMessageSessionAsyncHandler CreateInstance(MessageSession session, BrokeredMessage message)
 {
     return new MessageSessionAsyncHandler(_context, _supervisor, _receiver, session, message);
 }
            public async Task OnMessageAsync(MessageSession session, BrokeredMessage message)
            {
                if (message.Label != null &&
                  message.ContentType != null &&
                  message.Label.Equals("RecipeStep", StringComparison.InvariantCultureIgnoreCase) &&
                  message.ContentType.Equals("application/json", StringComparison.InvariantCultureIgnoreCase))
                {
                    var body = message.GetBody<Stream>();

                    dynamic recipeStep = JsonConvert.DeserializeObject(new StreamReader(body, true).ReadToEnd());
                    lock (Console.Out)
                    {
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.WriteLine(
                            "\t\t\t\tMessage received:  \n\t\t\t\t\t\tSessionId = {0}, \n\t\t\t\t\t\tMessageId = {1}, \n\t\t\t\t\t\tSequenceNumber = {2}," +
                            "\n\t\t\t\t\t\tContent: [ step = {3}, title = {4} ]",
                            message.SessionId,
                            message.MessageId,
                            message.SequenceNumber,
                            recipeStep.step,
                            recipeStep.title);
                        Console.ResetColor();
                    }
                    await message.CompleteAsync();

                    if (recipeStep.step == 5)
                    {
                        // end of the session!
                        await session.CloseAsync();
                    }
                }
                else
                {
                    await message.DeadLetterAsync("BadMessage", "Unexpected message");
                }
            }
Exemplo n.º 55
0
 public Task OnCloseSessionAsync(MessageSession session)
 {
     if (session == null)
     {
         return Task.FromResult(0);
     }
     if (configuration == null)
     {
         return Task.FromResult(0);
     }
     configuration.WriteToLog(string.Format(SessionClosed, session.SessionId, SessionDictionary[session.SessionId]));
     return Task.FromResult(0);
 }
            /// <summary>
            /// Raises an event that occurs when a message has been brokered.
            /// </summary>
            /// <returns>
            /// The task object representing the asynchronous operation.
            /// </returns>
            /// <param name="session">The message session.</param>
            /// <param name="message">The brokered message.</param>
            public async Task OnMessageAsync(MessageSession session, BrokeredMessage message)
            {
                var json = message.GetBody<string>();

                var @event = json.FromJsonTo<ServiceBusScheduledCommand>();
                @event.BrokeredMessage = message;

                onMessage(@event);

                var result = await clockTrigger.Trigger(commands => commands.Due(@event.DueTime)
                                                                         .Where(c => c.AggregateId == @event.AggregateId));

                if (!result.FailedCommands.Any())
                {
                    if (result.SuccessfulCommands.Any())
                    {
                        Debug.WriteLine("ServiceBusCommandQueueReceiver: completing on success: " + @event.AggregateId);
                        await message.CompleteAsync();
                        return;
                    }

                    using (var db = createCommandSchedulerDbContext())
                    {
                        // if the command was already applied, we can complete the message. its job is done.
                        if (db.ScheduledCommands
                              .Where(cmd => cmd.AppliedTime != null || cmd.FinalAttemptTime != null)
                              .Where(cmd => cmd.SequenceNumber == @event.SequenceNumber)
                              .Any(cmd => cmd.AggregateId == @event.AggregateId))
                        {
                            Debug.WriteLine("ServiceBusCommandQueueReceiver: completing because command was previously applied: " + @event.AggregateId);

                            await message.CompleteAsync();
                        }
                    }
                }
            }
 public BrokeredMessageSessionContext(MessageSession session)
 {
     _session = session;
 }
 /// <summary>
 /// Creates an instance of the handler factory.
 /// </summary>
 /// <returns>
 /// The created instance.
 /// </returns>
 /// <param name="session">The message session.</param>
 /// <param name="message">The message.</param>
 IMessageSessionAsyncHandler IMessageSessionAsyncHandlerFactory.CreateInstance(MessageSession session, BrokeredMessage message)
 {
     return new SessionHandler(
         msg => messageSubject.OnNext(msg),
         ex => exceptionSubject.OnNext(ex),
         clockTrigger,
         createCommandSchedulerDbContext);
 }
 public IMessageSessionAsyncHandler CreateInstance(MessageSession session, BrokeredMessage message)
 {
     return new MessageSessionAsyncHandler(_context, _supervisor, _receiver, session, _tracker, _sendEndpointProvider, _publishEndpointProvider);
 }