Ejemplo n.º 1
0
        public void Setup()
        {
            ActivityTestContext testActivity   = GetActivityContext <TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext <SecondTestActivity>();

            _completed = SubscribeHandler <RoutingSlipCompleted>();
            _firstActivityCompleted =
                SubscribeHandler <RoutingSlipActivityCompleted>(context => context.Message.ActivityName.Equals(testActivity.Name));
            _secondActivityCompleted =
                SubscribeHandler <RoutingSlipActivityCompleted>(context => context.Message.ActivityName.Equals(secondActivity.Name));

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value     = "Hello",
                NullValue = (string)null,
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            Bus.Execute(_routingSlip)
            .Wait(TestCancellationToken);
        }
Ejemplo n.º 2
0
        public async Task Consume(ConsumeContext <IFulfillOrder> context)
        {
            _logger.LogInformation($"Fulfilled order {context.Message.OrderId}");

            var builder = new RoutingSlipBuilder(NewId.NextGuid());

            var order = await _orderService.GetOrderAsync(context.Message.OrderId);

            builder.AddActivity("SubmitOrder", QueueNames.GetActivityUri(nameof(SubmitOrderActivity)));

            builder.AddActivity("ReserveProducts", QueueNames.GetActivityUri(nameof(ReserveProductsActivity)), new
            {
                order.OrderItems
            });

            builder.AddActivity("Payment", QueueNames.GetActivityUri(nameof(PaymentActivity)));

            builder.AddActivity("Delivery", QueueNames.GetActivityUri(nameof(DeliveryActivity)));

            builder.AddVariable("CorrelationId", context.Message.CorrelationId);
            builder.AddVariable("OrderId", context.Message.OrderId);

            await builder.AddSubscription(context.SourceAddress,
                                          RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
                                          RoutingSlipEventContents.None, x => x.Send <IOrderFulfillFaultedEvent>(new { context.Message.OrderId }));

            await builder.AddSubscription(context.SourceAddress,
                                          RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
                                          RoutingSlipEventContents.None, x => x.Send <IOrderFulfillCompletedEvent>(new { context.Message.OrderId }));

            var routingSlip = builder.Build();
            await context.Execute(routingSlip).ConfigureAwait(false);
        }
        public async Task Setup()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            var testActivity   = GetActivityContext <TestActivity>();
            var secondActivity = GetActivityContext <SecondTestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value     = "Hello",
                NullValue = (string)null
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            await Bus.Execute(_routingSlip);

            var completed = (await _completed).Message;

            Assert.AreEqual(_routingSlip.TrackingNumber, completed.TrackingNumber);
        }
        public async Task Execute(ConsumeContext <IOffice365VerifyDomainCommand> context)
        {
            var builder = new RoutingSlipBuilder(NewId.NextGuid());
            var command = context.Message;

            builder.AddActivity(Office365ServiceConstants.ActivityVerifyCustomerDomain,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IVerifyCustomerDomainActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapVerifyCustomerDomain(command));

            builder.AddActivity(Office365ServiceConstants.ActivityCreateTempAdminUser,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateTempPartnerPlatformAdminUserActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapCreateTempAdminUser(command));

            builder.AddActivity(Office365ServiceConstants.ActivityAssignUserRoles,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignUserRolesActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapAssignUserRoles(command));

            builder.AddActivity(Office365ServiceConstants.ActivityFederateCustomerDomain,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IFederateCustomerDomainActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapFederateCustomerDomain(command));

            builder.AddActivity(Office365ServiceConstants.ActivityVerifyCustomerDomainDatabaseStatus,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IVerifyCustomerDomainDatabaseStatusActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapVerifyCustomerDomainDatabaseStatus(command));

            builder.AddActivity(Office365ServiceConstants.ActivityFederateCustomerDomainDatabaseStatus,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IFederateCustomerDomainDatabaseStatusActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapFederateCustomerDomainDatabaseStatus(command));

            builder.AddActivity(Office365ServiceConstants.ActivityHardDeletePartnerPlatformUser,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IHardDeletePartnerPlatformUserActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapDeleteTempAdminUser(command));

            builder.AddVariable("domainName", context.Message.DomainName);
            builder.AddVariable("workflowActivityType", WorkflowActivityType.VerifyAndFederateOffice365Domain.ToString());

            builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
                                    RoutingSlipEvents.Faulted |
                                    RoutingSlipEvents.Completed |
                                    RoutingSlipEvents.ActivityCompleted |
                                    RoutingSlipEvents.ActivityFaulted |
                                    RoutingSlipEvents.ActivityCompensated |
                                    RoutingSlipEvents.ActivityCompensationFailed);

            var routingSlip = builder.Build();

            await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
            {
                builder.TrackingNumber,
                CreateTimestamp      = DateTime.UtcNow,
                Arguments            = context.Message,
                WorkflowActivityType = WorkflowActivityType.VerifyAndFederateOffice365Domain.ToString()
            });

            await context.Execute(routingSlip);
        }
Ejemplo n.º 5
0
        public async Task <IActionResult> Get(string request)
        {
            if (string.IsNullOrEmpty(request))
            {
                return(BadRequest());
            }

            var builder = new RoutingSlipBuilder(NewId.NextGuid());

            //1
            //builder.AddActivity("DownloadImage", new Uri("rabbitmq://localhost/execute_downloadimage"), new
            //{
            //    ImageUri = new Uri("http://images.google.com/someImage.jpg")
            //});
            //2
            //builder.AddActivity("DownloadImage", new Uri("rabbitmq://localhost/execute_downloadimage"));
            //builder.AddVariable("ImageUri", "http://images.google.com/someImage.jpg");
            //3: si el ProcessImage no depende del fin de DownloadImage
            builder.AddActivity("DownloadImage", new Uri("rabbitmq://localhost/execute_downloadimage"));
            builder.AddActivity("ProcessImage", new Uri("rabbitmq://localhost/execute_processimage"));
            builder.AddVariable("ImageUri", "http://images.google.com/someImage.jpg");

            builder.AddActivity("FilterImage", new Uri("rabbitmq://localhost/execute_filterimage"));
            builder.AddVariable("WorkPath", "\\dfs\\work");
            //Events
            //1
            //builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.All);
            //2 modo flags
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"),
                                    RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
            //builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"),
            //    RoutingSlipEvents.Completed, RoutingSlipEventContents.None);
            //3
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.Completed);
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.Faulted);
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.CompensationFailed);

            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.ActivityCompleted);
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.ActivityFaulted);
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.ActivityCompensated);
            builder.AddSubscription(new Uri("rabbitmq://localhost/log-events"), RoutingSlipEvents.ActivityCompensationFailed);
            // 4 custom public interface OrderProcessingCompleted
            //builder.AddSubscription(new Uri("rabbitmq://localhost/order-events"),
            //    RoutingSlipEvents.Completed,
            //    x => x.Send<OrderProcessingCompleted>(new
            //    {
            //        OrderId = "BFG-9000",
            //        OrderApproval = "ComeGetSome"
            //    }));
            var routingSlip = builder.Build();

            await _bus.Execute(routingSlip);

            return(Ok(new { routingSlip.TrackingNumber }));
        }
        public async Task Execute(ConsumeContext <IOffice365CreateCustommerCommand> context)
        {
            var builder = new RoutingSlipBuilder(NewId.NextGuid());
            var createOffice365CustommerCommand = context.Message;

            builder.AddActivity(Office365ServiceConstants.ActivityCreateOffice365PartnerPlatformCustomer,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreatePartnerPlatformCustomerActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapCreatePartnerPlatformCustomerArguments(createOffice365CustommerCommand));

            builder.AddActivity(Office365ServiceConstants.ActivityCreateOffice365DatabaseCustomer,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateDatabaseCustomerActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapCreateDatabaseCustomerArguments(createOffice365CustommerCommand));

            builder.AddActivity(Office365ServiceConstants.ActivityAddOffice365CustomerDomainToPartnerPortal,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IAddCustomerDomainPartnerPortalActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapAddCustomerDomainPartnerPortalArguments(createOffice365CustommerCommand));

            builder.AddActivity(Office365ServiceConstants.ActivityAddOffice365CustomerDomainToDatabase,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IAddCustomerDomainToDatabaseActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapAddCustomerDomainToDatabaseArguments(createOffice365CustommerCommand));

            builder.AddActivity(Office365ServiceConstants.ActivityGetOffice365CustomerTxtRecords,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IGetCustomerDomainTxtRecordsActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapGetCustomerTxtRecords(createOffice365CustommerCommand));

            builder.AddActivity(Office365ServiceConstants.ActivitySendOffice365CustomerTxtRecords,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(ISendCustomerDomainTxtRecordsActivity)),
                                _activityOffice365CustomerArgumentsMapper.MapSendCustomerTxtRecords(createOffice365CustommerCommand));

            builder.AddVariable("companyId", context.Message.CompanyId);
            builder.AddVariable("workflowActivityType", WorkflowActivityType.Office365AddAdditionalDomain.ToString());

            builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
                                    RoutingSlipEvents.Completed |
                                    RoutingSlipEvents.Faulted |
                                    RoutingSlipEvents.ActivityCompleted |
                                    RoutingSlipEvents.ActivityFaulted |
                                    RoutingSlipEvents.ActivityCompensated |
                                    RoutingSlipEvents.ActivityCompensationFailed);

            var routingSlip = builder.Build();

            await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
            {
                builder.TrackingNumber,
                CreateTimestamp      = DateTime.UtcNow,
                Arguments            = context.Message,
                WorkflowActivityType = WorkflowActivityType.CreateOffice365Customer.ToString()
            });

            await context.Execute(routingSlip);
        }
Ejemplo n.º 7
0
        public void Setup()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            var fetchAvatarActivity = GetActivityContext <FetchAvatarActivity>();

            builder.AddActivity(fetchAvatarActivity.Name, fetchAvatarActivity.ExecuteUri);

            builder.AddVariable("EmailAddress", "*****@*****.**");
            builder.AddVariable("BookingRequestId", NewId.NextGuid());

            _routingSlip = builder.Build();

            Await(() => Bus.Execute(_routingSlip));
        }
Ejemplo n.º 8
0
        public async Task Should_retry_and_eventually_compensate()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            var testActivity             = GetActivityContext <TestActivity>();
            var faultyCompensateActivity = GetActivityContext <FirstFaultyCompensateActivity>();
            var faultActivity            = GetActivityContext <FaultyActivity>();

            Task <ConsumeContext <RoutingSlipActivityCompensated> > compensated = ConnectPublishHandler <RoutingSlipActivityCompensated>(
                context => context.Message.ActivityName.Equals(faultyCompensateActivity.Name));

            Task <ConsumeContext <RoutingSlipFaulted> > routingSlipFailure =
                ConnectPublishHandler <RoutingSlipFaulted>(x => x.Message.TrackingNumber == builder.TrackingNumber);

            builder.AddVariable("Value", "Hello");
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
            builder.AddActivity(faultyCompensateActivity.Name, faultyCompensateActivity.ExecuteUri);
            builder.AddActivity(faultActivity.Name, faultActivity.ExecuteUri);

            await Bus.Execute(builder.Build());

            await routingSlipFailure;

            await compensated;
        }
Ejemplo n.º 9
0
        public void Should_handle_the_failed_to_compensate_event()
        {
            var handledCompensationFailure = new ManualResetEvent(false);
            var handledRoutingSlipFailure = new ManualResetEvent(false);

            LocalBus.SubscribeHandler<RoutingSlipActivityCompensationFailed>(message => { handledCompensationFailure.Set(); });
            LocalBus.SubscribeHandler<RoutingSlipCompensationFailed>(message => { handledRoutingSlipFailure.Set(); });

            Assert.IsTrue(WaitForSubscription<RoutingSlipCompensationFailed>());
            Assert.IsTrue(WaitForSubscription<RoutingSlipActivityCompensationFailed>());

            ActivityTestContext testActivity = GetActivityContext<TestActivity>();
            ActivityTestContext faultyCompensateActivity = GetActivityContext<FaultyCompensateActivity>();
            ActivityTestContext faultActivity = GetActivityContext<FaultyActivity>();

            var builder = new RoutingSlipBuilder(Guid.NewGuid());
            builder.AddVariable("Value", "Hello");
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
            builder.AddActivity(faultyCompensateActivity.Name, faultyCompensateActivity.ExecuteUri);
            builder.AddActivity(faultActivity.Name, faultActivity.ExecuteUri);

            LocalBus.Execute(builder.Build());

            Assert.IsTrue(handledRoutingSlipFailure.WaitOne(Debugger.IsAttached ? 5.Minutes() : 30.Seconds()));
            Assert.IsTrue(handledCompensationFailure.WaitOne(Debugger.IsAttached ? 5.Minutes() : 30.Seconds()));
        }
Ejemplo n.º 10
0
        public async Task Should_handle_the_failed_to_compensate_event_via_subscription()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            Task <ConsumeContext <RoutingSlipActivityCompensationFailed> > handledCompensationFailure =
                SubscribeHandler <RoutingSlipActivityCompensationFailed>(x => x.Message.TrackingNumber == builder.TrackingNumber);
            Task <ConsumeContext <RoutingSlipCompensationFailed> > handledRoutingSlipFailure =
                SubscribeHandler <RoutingSlipCompensationFailed>(x => x.Message.TrackingNumber == builder.TrackingNumber);

            var testActivity             = GetActivityContext <TestActivity>();
            var faultyCompensateActivity = GetActivityContext <FaultyCompensateActivity>();
            var faultActivity            = GetActivityContext <FaultyActivity>();

            builder.AddVariable("Value", "Hello");
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
            builder.AddActivity(faultyCompensateActivity.Name, faultyCompensateActivity.ExecuteUri);
            builder.AddActivity(faultActivity.Name, faultActivity.ExecuteUri);

            builder.AddSubscription(
                Bus.Address,
                RoutingSlipEvents.CompensationFailed,
                RoutingSlipEventContents.All);

            builder.AddSubscription(
                Bus.Address,
                RoutingSlipEvents.ActivityCompensationFailed,
                RoutingSlipEventContents.All);

            await Bus.Execute(builder.Build());

            await handledRoutingSlipFailure;

            await handledCompensationFailure;
        }
Ejemplo n.º 11
0
        public void Should_handle_the_failed_to_compensate_event()
        {
            var handledCompensationFailure = new ManualResetEvent(false);
            var handledRoutingSlipFailure  = new ManualResetEvent(false);

            LocalBus.SubscribeHandler <RoutingSlipActivityCompensationFailed>(message => handledCompensationFailure.Set());
            LocalBus.SubscribeHandler <RoutingSlipCompensationFailed>(message => handledRoutingSlipFailure.Set());

            Assert.IsTrue(WaitForSubscription <RoutingSlipCompensationFailed>());
            Assert.IsTrue(WaitForSubscription <RoutingSlipActivityCompensationFailed>());

            ActivityTestContext testActivity             = GetActivityContext <TestActivity>();
            ActivityTestContext faultyCompensateActivity = GetActivityContext <FaultyCompensateActivity>();
            ActivityTestContext faultActivity            = GetActivityContext <FaultyActivity>();

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            builder.AddVariable("Value", "Hello");
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
            builder.AddActivity(faultyCompensateActivity.Name, faultyCompensateActivity.ExecuteUri);
            builder.AddActivity(faultActivity.Name, faultActivity.ExecuteUri);

            LocalBus.Execute(builder.Build());

            Assert.IsTrue(handledRoutingSlipFailure.WaitOne(Debugger.IsAttached ? 5.Minutes() : 30.Seconds()));
            Assert.IsTrue(handledCompensationFailure.WaitOne(Debugger.IsAttached ? 5.Minutes() : 30.Seconds()));
        }
Ejemplo n.º 12
0
        public void Setup()
        {
            _completed         = new TaskCompletionSource <RoutingSlipCompleted>(TestCancellationToken);
            _activityCompleted = new TaskCompletionSource <RoutingSlipActivityCompleted>(TestCancellationToken);

            LocalBus.SubscribeHandler <RoutingSlipCompleted>(x => _completed.SetResult(x));
            Assert.IsTrue(WaitForSubscription <RoutingSlipCompleted>());

            LocalBus.SubscribeHandler <RoutingSlipActivityCompleted>(x => _activityCompleted.SetResult(x));
            Assert.IsTrue(WaitForSubscription <RoutingSlipActivityCompleted>());

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity = GetActivityContext <TestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value = "Hello",
            });
            builder.AddVariable("Variable", "Knife");

            _routingSlip = builder.Build();

            LocalBus.Execute(_routingSlip);
        }
Ejemplo n.º 13
0
        public async Task Execute(FutureConsumeContext <TInput> context)
        {
            var factory = context.GetStateMachineActivityFactory();

            IItineraryPlanner <TInput> itineraryPlanner = factory.GetService <IItineraryPlanner <TInput> >(context);

            var trackingNumber = NewId.NextGuid();

            var builder = new RoutingSlipBuilder(trackingNumber);

            builder.AddVariable(nameof(FutureConsumeContext.FutureId), context.FutureId);

            builder.AddSubscription(context.ReceiveContext.InputAddress, RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);

            await itineraryPlanner.PlanItinerary(context, builder).ConfigureAwait(false);

            var routingSlip = builder.Build();

            await context.Execute(routingSlip).ConfigureAwait(false);

            if (TrackRoutingSlip)
            {
                context.Instance.Pending.Add(trackingNumber);
            }
        }
        public void Setup()
        {
            _faulted                 = SubscribeHandler <RoutingSlipFaulted>();
            _activityCompleted       = SubscribeHandler <RoutingSlipActivityCompleted>(x => x.Message.ActivityName.Equals("Test"));
            _activityCompensated     = SubscribeHandler <RoutingSlipActivityCompensated>(x => x.Message.ActivityName.Equals("Test"));
            _secondActivityCompleted = SubscribeHandler <RoutingSlipActivityCompleted>(x => x.Message.ActivityName.Equals("SecondTest"));
            _activityFaulted         = SubscribeHandler <RoutingSlipActivityFaulted>(x => x.Message.ActivityName.Equals("Faulty"));

            _trackingNumber = NewId.NextGuid();
            var builder = new RoutingSlipBuilder(_trackingNumber);

            builder.AddSubscription(Bus.Address, RoutingSlipEvents.All);

            ActivityTestContext testActivity = GetActivityContext <TestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value = "Hello",
            });

            testActivity = GetActivityContext <SecondTestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
            testActivity = GetActivityContext <FaultyActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");

            Await(() => Bus.Execute(builder.Build()));
        }
Ejemplo n.º 15
0
        public async Task Should_publish_the_completed_event()
        {
            _harness = new InMemoryTestHarness();

            _activity = _harness.Activity <TestActivity, TestArguments, TestLog>();

            await _harness.Start();

            _completed         = _harness.SubscribeHandler <RoutingSlipCompleted>();
            _activityCompleted = _harness.SubscribeHandler <RoutingSlipActivityCompleted>();

            _trackingNumber = NewId.NextGuid();
            var builder = new RoutingSlipBuilder(_trackingNumber);

            builder.AddSubscription(_harness.BusAddress, RoutingSlipEvents.All);

            builder.AddActivity(_activity.Name, _activity.ExecuteAddress, new
            {
                Value = "Hello"
            });

            builder.AddVariable("Variable", "Knife");

            await _harness.Bus.Execute(builder.Build());

            await _completed;
        }
        public async Task Consume(ConsumeContext <TRequest> context)
        {
            var builder = new RoutingSlipBuilder(NewId.NextGuid());

            builder.AddSubscription(context.ReceiveContext.InputAddress, RoutingSlipEvents.ActivityCompleted | RoutingSlipEvents.ActivityFaulted);

            builder.AddVariable("RequestId", context.RequestId);
            builder.AddVariable("ResponseAddress", context.ResponseAddress);
            builder.AddVariable("FaultAddress", context.FaultAddress);
            builder.AddVariable("Request", context.Message);

            await BuildRoutingSlip(builder, context);

            var routingSlip = builder.Build();

            await context.Execute(routingSlip).ConfigureAwait(false);
        }
Ejemplo n.º 17
0
        private static RoutingSlip BuildRoutingSlip(ConsumeContext <ProcessBurgerOrder> context, Guid trackingId)
        {
            var builder = new RoutingSlipBuilder(trackingId);

            builder.AddVariable("OrderId", context.Message.OrderId);
            builder.AddVariable("CorrelationId", context.CorrelationId);

            // minor: abstract out this
            var activityName   = typeof(ProcessBurgerOrderActivity).Name;
            var queueName      = $"{activityName.Replace("Activity", string.Empty)}_execute";
            var executeAddress = new Uri($"queue:{queueName}");

            builder.AddActivity(activityName, executeAddress);

            // Completed
            builder
            .AddSubscription(
                context.SourceAddress,
                RoutingSlipEvents.Completed,
                x => x.Send <BurgerOrderProcessed>(
                    new
            {
                context.Message.CorrelationId,
                context.Message.OrderId,
                context.Message.OrderDate
            })
                );

            // Faulted
            builder
            .AddSubscription(
                context.SourceAddress,
                RoutingSlipEvents.ActivityFaulted,
                x => x.Send <BurgerOrderFaulted>(
                    new
            {
                context.Message.CorrelationId,
                context.Message.OrderId,
                context.Message.OrderDate
            })
                );

            return(builder.Build());
        }
        public void Setup()
        {
            _completed = new TaskCompletionSource <RoutingSlipCompleted>(TestCancellationToken);
            _firstActivityCompleted  = new TaskCompletionSource <RoutingSlipActivityCompleted>(TestCancellationToken);
            _secondActivityCompleted = new TaskCompletionSource <RoutingSlipActivityCompleted>(TestCancellationToken);

            LocalBus.SubscribeHandler <RoutingSlipCompleted>(x => _completed.SetResult(x));
            Assert.IsTrue(WaitForSubscription <RoutingSlipCompleted>());

            LocalBus.SubscribeHandler <RoutingSlipActivityCompleted>(x =>
            {
                if (x.ActivityName.Equals("Test"))
                {
                    _firstActivityCompleted.SetResult(x);
                }
                if (x.ActivityName.Equals("SecondTest"))
                {
                    _secondActivityCompleted.SetResult(x);
                }
            });
            Assert.IsTrue(WaitForSubscription <RoutingSlipActivityCompleted>());

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity = GetActivityContext <TestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value     = "Hello",
                NullValue = (string)null,
            });

            testActivity = GetActivityContext <SecondTestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            LocalBus.Execute(_routingSlip);
        }
Ejemplo n.º 19
0
        public async Task Execute(ConsumeContext <IOffice365UserChangeRolesCommand> context)
        {
            var builder = new RoutingSlipBuilder(NewId.NextGuid());
            var command = context.Message;

            builder.AddActivity(Office365ServiceConstants.ActivityGetUserRoles,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IGetUserRolesActivity)),
                                _mapper.MapGetUserRolesArguments(command));

            builder.AddActivity(Office365ServiceConstants.ActivityRemoveUserRoles,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IRemoveUserRolesActivity)),
                                _mapper.MapRemoveUserRolesArguments(command));

            builder.AddActivity(Office365ServiceConstants.ActivityAssignUserRoles,
                                _activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignUserRolesActivity)),
                                _mapper.MapAssignUserRolesArguments(command));

            builder.AddVariable("userPrincipalName", context.Message.UserPrincipalName);
            builder.AddVariable("workflowActivityType", WorkflowActivityType.Office365UserChangeRoles.ToString());

            builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
                                    RoutingSlipEvents.Completed |
                                    RoutingSlipEvents.Faulted |
                                    RoutingSlipEvents.ActivityCompleted |
                                    RoutingSlipEvents.ActivityFaulted |
                                    RoutingSlipEvents.ActivityCompensated |
                                    RoutingSlipEvents.ActivityCompensationFailed);

            var routingSlip = builder.Build();

            await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
            {
                builder.TrackingNumber,
                CreateTimestamp      = DateTime.UtcNow,
                Arguments            = context.Message,
                WorkflowActivityType = WorkflowActivityType.Office365UserChangeRoles.ToString()
            });

            await context.Execute(routingSlip);
        }
        public async Task A_routing_slip()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            var testActivity   = GetActivityContext <TestActivity>();
            var secondActivity = GetActivityContext <SecondTestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value     = "Hello",
                NullValue = (string)null
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            await Bus.Execute(_routingSlip);
        }
Ejemplo n.º 21
0
        public void Setup()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity   = GetActivityContext <TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext <SecondTestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value     = "Hello",
                NullValue = (string)null,
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            Await(() => Bus.Execute(_routingSlip));
        }
Ejemplo n.º 22
0
        public async Task Execute(BehaviorContext <OrderState, SubmitOrder> context, Behavior <OrderState, SubmitOrder> next)
        {
            var consumeContext = context.GetPayload <ConsumeContext <SubmitOrder> >();
            var builder        = new RoutingSlipBuilder(NewId.NextGuid());
            var orderId        = context.Data.OrderId;

            builder.AddActivity("RedisStock", new Uri("queue:redis-stock_execute"), new
            {
                ProductKey = "ITEM123",
                Quantity   = 10.0m
            });

            builder.AddActivity("SaveOrder", new Uri("queue:save-order_execute"), new
            {
                ProductKey = "ITEM123",
                Quantity   = 10.0m
            });

            //builder.AddActivity("DbStock", new Uri("queue:db-stock_execute"), new
            //{
            //    ProductKey = "ITEM123",
            //    Quantity = 10.0m
            //});

            builder.AddVariable("OrderId", orderId);

            await builder.AddSubscription(new Uri("queue:saga_order_state"),
                                          RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
                                          RoutingSlipEventContents.None, x => x.Send <SubmitOrderFaulted>(new SubmitOrderFaulted
            {
                OrderId = orderId
            }));

            await builder.AddSubscription(new Uri("queue:saga_order_state"),
                                          RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
                                          RoutingSlipEventContents.None, x => x.Send <SubmitOrderCompleted>(new SubmitOrderCompleted
            {
                OrderId = orderId
            }));

            var routingSlip = builder.Build();

            await consumeContext.Execute(routingSlip);

            await context.RespondAsync(new SubmitOrderResponse
            {
                OrderId = orderId
            });

            await next.Execute(context);
        }
        public void Setup()
        {
            _completed = new TaskCompletionSource<RoutingSlipCompleted>(TestCancellationToken);
            _firstActivityCompleted = new TaskCompletionSource<RoutingSlipActivityCompleted>(TestCancellationToken);
            _secondActivityCompleted = new TaskCompletionSource<RoutingSlipActivityCompleted>(TestCancellationToken);

            LocalBus.SubscribeHandler<RoutingSlipCompleted>(x => _completed.SetResult(x));
            Assert.IsTrue(WaitForSubscription<RoutingSlipCompleted>());

            LocalBus.SubscribeHandler<RoutingSlipActivityCompleted>(x =>
                {
                    if (x.ActivityName.Equals("Test"))
                        _firstActivityCompleted.SetResult(x);
                    if (x.ActivityName.Equals("SecondTest"))
                        _secondActivityCompleted.SetResult(x);
                });
            Assert.IsTrue(WaitForSubscription<RoutingSlipActivityCompleted>());

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity = GetActivityContext<TestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
                {
                    Value = "Hello",
                    NullValue = (string)null,
                });

            testActivity = GetActivityContext<SecondTestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            LocalBus.Execute(_routingSlip);
        }
        public async Task Consume(ConsumeContext <FulfilOrder> context)
        {
            if (context.Message.CustomerNumber.StartsWith("INVALID"))
            {
                throw new InvalidOperationException("We tried, but the customer is invalid");
            }

            // if (context.Message.CustomerNumber.StartsWith("MAYBE"))
            // {
            //     if (new Random().Next(100) > 50)
            //         throw new ApplicationException("We randomly exploded, so sad, much tear");
            // }

            var builder = new RoutingSlipBuilder(NewId.NextGuid());

            builder.AddActivity("AllocateInventory", new Uri("queue:allocate-inventory_execute"), new AllocateInventory
            {
                ItemNumber = "Item123",
                Quantity   = 10.0m
            });

            builder.AddActivity("PaymentActivity", new Uri("queue:payment_execute"), new Payment
            {
                CardNumber = context.Message.PaymentCardNumber,
                Amount     = 99.95m
            });

            builder.AddVariable("OrderId", context.Message.OrderId);

            await builder.AddSubscription(context.SourceAddress,
                                          RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
                                          RoutingSlipEventContents.None, x => x.Send <OrderFulfillmentFaulted>(new OrderFulfillmentFaulted
            {
                OrderId   = context.Message.OrderId,
                Timestamp = InVar.Timestamp
            }));

            await builder.AddSubscription(context.SourceAddress,
                                          RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
                                          RoutingSlipEventContents.None, x => x.Send <OrderFulfillmentCompleted>(new OrderFulfillmentCompleted
            {
                OrderId   = context.Message.OrderId,
                Timestamp = InVar.Timestamp
            }));

            var routingSlip = builder.Build();

            await context.Execute(routingSlip);
        }
Ejemplo n.º 25
0
        public async Task Consume(ConsumeContext <FulfillOrder> context)
        {
            var builder = new RoutingSlipBuilder(NewId.NextGuid());

            builder.AddActivity("AllocateInventory",
                                new Uri("queue:allocate-inventory_execute"),
                                new
            {
                ItemNumber = "ITEM123",
                Quantity   = 10.0m
            });
            builder.AddVariable(nameof(context.Message.OrderId), context.Message.OrderId);
            var routingSlip = builder.Build();
            await context.Execute(routingSlip);
        }
Ejemplo n.º 26
0
        public async Task Setup()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity   = GetActivityContext <TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext <SecondTestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value     = "Hello",
                NullValue = (string)null,
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            await Bus.Execute(_routingSlip);

            Console.WriteLine("Routing slip executed");
        }
Ejemplo n.º 27
0
        public async Task Should_work_for_activity_arguments()
        {
            _intValue     = 27;
            _stringValue  = "Hello, World.";
            _decimalValue = 123.45m;

            Task <ConsumeContext <RoutingSlipCompleted> > completed = SubscribeHandler <RoutingSlipCompleted>();
            Task <ConsumeContext <RoutingSlipFaulted> >   faulted   = SubscribeHandler <RoutingSlipFaulted>();

            ActivityTestContext testActivity  = GetActivityContext <ObjectGraphTestActivity>();
            ActivityTestContext testActivity2 = GetActivityContext <TestActivity>();

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            var dictionary = new Dictionary <string, object>
            {
                { "Outer", new OuterObjectImpl(_intValue, _stringValue, _decimalValue) },
                { "Names", new[] { "Albert", "Chris" } },
                { "ArgumentsDictionary", _argumentsDictionary }
            };

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, dictionary);
            builder.AddActivity(testActivity2.Name, testActivity2.ExecuteUri, new
            {
                Value = "Howdy!"
            });

            builder.AddVariable("ArgumentsDictionary", new Dictionary <string, string>
            {
                { "good_jpath_key", "val3" },
                { "bad jpath key", "val4" }
            });

            await Bus.Execute(builder.Build());

            await Task.WhenAny(completed, faulted);

            if (faulted.Status == TaskStatus.RanToCompletion)
            {
                Assert.Fail("Failed due to exception {0}", faulted.Result.Message.ActivityExceptions.Any()
                    ? faulted.Result.Message.ActivityExceptions.First()
                            .ExceptionInfo.Message
                    : "VisitUnknownFilter");
            }

            completed.Status.ShouldBe(TaskStatus.RanToCompletion);
        }
        async Task Execute(FutureConsumeContext <T> consumeContext)
        {
            // this will need to be done by a consumer at some point, to handle retry/fault handling

            var trackingNumber = NewId.NextGuid();

            var builder = new RoutingSlipBuilder(trackingNumber);

            builder.AddVariable(nameof(consumeContext.FutureId), consumeContext.FutureId);

            builder.AddSubscription(consumeContext.ReceiveContext.InputAddress, RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);

            await _planner.PlanItinerary(consumeContext.Message, builder).ConfigureAwait(false);

            var routingSlip = builder.Build();

            await consumeContext.Execute(routingSlip).ConfigureAwait(false);
        }
Ejemplo n.º 29
0
        public async Task Should_publish_the_completed_event()
        {
            _completed         = SubscribeHandler <RoutingSlipCompleted>();
            _activityCompleted = SubscribeHandler <RoutingSlipActivityCompleted>();

            _trackingNumber = NewId.NextGuid();
            var builder = new RoutingSlipBuilder(_trackingNumber);

            builder.AddSubscription(Bus.Address, RoutingSlipEvents.ActivityCompleted, RoutingSlipEventContents.None);

            var testActivity = GetActivityContext <TestActivity>();

            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new { Value = "Hello" });

            builder.AddVariable("Variable", "Knife");

            await Bus.Execute(builder.Build());
        }
Ejemplo n.º 30
0
        public async Task Execute(FutureConsumeContext <TInput> context)
        {
            var trackingNumber = NewId.NextGuid();

            var builder = new RoutingSlipBuilder(trackingNumber);

            builder.AddVariable(nameof(FutureConsumeContext.FutureId), context.FutureId);

            builder.AddSubscription(context.ReceiveContext.InputAddress, RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);

            await _buildItinerary(context, builder).ConfigureAwait(false);

            var routingSlip = builder.Build();

            await context.Execute(routingSlip).ConfigureAwait(false);

            if (TrackRoutingSlip)
            {
                context.Instance.Pending.Add(trackingNumber);
            }
        }
        public async Task Setup()
        {
            _limit = 10;

            var testActivity   = GetActivityContext <TestActivity>();
            var secondActivity = GetActivityContext <SecondTestActivity>();

            for (var i = 0; i < _limit; i++)
            {
                var builder = new RoutingSlipBuilder(Guid.NewGuid());
                builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
                builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);
                builder.AddVariable("Value", "Hello");

                var routingSlip = builder.Build();

                await Bus.Execute(routingSlip);

                _sentRoutingSlips.Add(routingSlip.TrackingNumber);
            }
        }
Ejemplo n.º 32
0
        public void Setup()
        {
            _limit = 100;

            ActivityTestContext testActivity   = GetActivityContext <TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext <SecondTestActivity>();

            for (int i = 0; i < _limit; i++)
            {
                var builder = new RoutingSlipBuilder(Guid.NewGuid());
                builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
                builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);
                builder.AddVariable("Value", "Hello");

                RoutingSlip routingSlip = builder.Build();

                TaskUtil.Await(() => Bus.Execute(routingSlip));

                _sentRoutingSlips.Add(routingSlip.TrackingNumber);
            }
        }
        public void Setup()
        {
            _completed = new TaskCompletionSource<RoutingSlipCompleted>(TestCancellationToken);
            _activityCompleted = new TaskCompletionSource<RoutingSlipActivityCompleted>(TestCancellationToken);

            LocalBus.SubscribeHandler<RoutingSlipCompleted>(x => _completed.SetResult(x));
            Assert.IsTrue(WaitForSubscription<RoutingSlipCompleted>());

            LocalBus.SubscribeHandler<RoutingSlipActivityCompleted>(x => _activityCompleted.SetResult(x));
            Assert.IsTrue(WaitForSubscription<RoutingSlipActivityCompleted>());

            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity = GetActivityContext<TestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
                {
                    Value = "Hello",
                });
            builder.AddVariable("Variable", "Knife");

            _routingSlip = builder.Build();

            LocalBus.Execute(_routingSlip);
        }
        public void Setup()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity = GetActivityContext<TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext<SecondTestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value = "Hello",
                NullValue = (string)null,
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            Await(() => Bus.Execute(_routingSlip));
        }
        public async Task Setup()
        {
            var builder = new RoutingSlipBuilder(Guid.NewGuid());

            ActivityTestContext testActivity = GetActivityContext<TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext<SecondTestActivity>();
            builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
            {
                Value = "Hello",
                NullValue = (string)null,
            });

            builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);

            builder.AddVariable("Variable", "Knife");
            builder.AddVariable("Nothing", null);

            _routingSlip = builder.Build();

            await Bus.Execute(_routingSlip);

            Console.WriteLine("Routing slip executed");
        }
        public async Task Setup()
        {
            _limit = 100;

            ActivityTestContext testActivity = GetActivityContext<TestActivity>();
            ActivityTestContext secondActivity = GetActivityContext<SecondTestActivity>();

            for (int i = 0; i < _limit; i++)
            {
                var builder = new RoutingSlipBuilder(Guid.NewGuid());
                builder.AddActivity(testActivity.Name, testActivity.ExecuteUri);
                builder.AddActivity(secondActivity.Name, secondActivity.ExecuteUri);
                builder.AddVariable("Value", "Hello");

                RoutingSlip routingSlip = builder.Build();

                await Bus.Execute(routingSlip);

                _sentRoutingSlips.Add(routingSlip.TrackingNumber);
            }
        }