protected override void EstablishContext() { base.EstablishContext(); _repository = SetupSagaRepository<CombineSaga>(); _transactionId = NewId.NextGuid(); }
protected override void EstablishContext() { base.EstablishContext(); _sagaRepository = new NHibernateSagaRepositoryForContainers<ConcurrentLegacySaga>(SessionFactory); ObjectBuilder.Stub(x => x.GetInstance<ISagaRepository<ConcurrentLegacySaga>>()).Return(_sagaRepository); }
public bool Start(HostControl hostControl) { _log.Info("Creating bus..."); _sagaRepository = GetSagaRepository(); ITrackingEventWriter writer = GetTrackingEventWriter(); _busControl = Bus.Factory.CreateUsingRabbitMq(x => { var host = x.Host(GetHostAddress(), h => { h.Username(ConfigurationManager.AppSettings["RabbitMQUsername"]); h.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]); }); x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["BookingStateQueueName"], e => { e.StateMachineSaga(_stateMachine, _sagaRepository); }); x.ReceiveEndpoint(host, ConfigurationManager.AppSettings["EventTrackingQueueName"], e => { e.Consumer(() => new EventTrackingConsumer(writer)); }); }); _log.Info("Starting bus..."); _busHandle = _busControl.Start(); TaskUtil.Await(() => _busHandle.Ready); return true; }
protected override void EstablishContext() { base.EstablishContext(); _repository = SetupSagaRepository<CombineSaga>(); _transactionId = CombGuid.Generate(); }
protected override void ConfigureLocalBus(ServiceBusConfigurator configurator) { base.ConfigureLocalBus(configurator); _sagaRepository = new NHibernateSagaRepository<ConcurrentSaga>(SessionFactory); configurator.Subscribe(x => x.Saga(_sagaRepository)); }
public void EstablishContext() { MockBus = MockRepository.GenerateStub<IServiceBus>(); MockEndpointFactory = MockRepository.GenerateStub<IEndpointFactory>(); MockRepo = MockRepository.GenerateStub<ISagaRepository<LegacySubscriptionClientSaga>>(); Service = new LegacySubscriptionProxyService(MockRepo, MockEndpointFactory, MockBus); }
protected override void EstablishContext() { base.EstablishContext(); _correlationId = NewId.NextGuid(); _timeoutSagaRepository = SetupSagaRepository<TimeoutSaga>(); _timeoutService = new TimeoutService(LocalBus, _timeoutSagaRepository); _timeoutService.Start(); }
protected override void EstablishContext() { base.EstablishContext(); _correlationId = CombGuid.Generate(); _timeoutSagaRepository = SetupSagaRepository<TimeoutSaga>(ObjectBuilder); _timeoutService = new TimeoutService(LocalBus, _timeoutSagaRepository); _timeoutService.Start(); }
public bool Start(HostControl hostControl) { _log.Info("Creating bus..."); _metrics = new RoutingSlipMetrics("Routing Slip"); _activityMetrics = new RoutingSlipMetrics("Validate Activity"); _machine = new RoutingSlipStateMachine(); _provider = new SQLiteSessionFactoryProvider(false, typeof(RoutingSlipStateSagaMap)); _sessionFactory = _provider.GetSessionFactory(); _repository = new NHibernateSagaRepository<RoutingSlipState>(_sessionFactory); _busControl = Bus.Factory.CreateUsingRabbitMq(x => { IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h => { h.Username("guest"); h.Password("guest"); }); x.ReceiveEndpoint(host, "routing_slip_metrics", e => { e.PrefetchCount = 100; e.UseRetry(Retry.None); e.Consumer(() => new RoutingSlipMetricsConsumer(_metrics)); }); x.ReceiveEndpoint(host, "routing_slip_activity_metrics", e => { e.PrefetchCount = 100; e.UseRetry(Retry.None); e.Consumer(() => new RoutingSlipActivityConsumer(_activityMetrics, "Validate")); }); x.ReceiveEndpoint(host, "routing_slip_state", e => { e.PrefetchCount = 8; e.UseConcurrencyLimit(1); e.StateMachineSaga(_machine, _repository); }); }); _log.Info("Starting bus..."); _busHandle = _busControl.Start(); return true; }
protected override void EstablishContext() { base.EstablishContext(); _repository = SetupSagaRepository<AutoStateMachineSaga>(); // this just shows that you can easily respond to the message LocalBus.SubscribeHandler<SendUserVerificationEmail>( x => LocalBus.Publish(new UserVerificationEmailSent(x.CorrelationId, x.Email))); _transactionId = NewId.NextGuid(); _username = "******"; _password = "******"; _email = "*****@*****.**"; _displayName = "Joe Blow"; }
protected override void EstablishContext() { base.EstablishContext(); _correlationId = CombGuid.Generate(); _timeoutSagaRepository = SetupSagaRepository<TimeoutSaga>(ObjectBuilder); _timeoutService = new TimeoutService(RemoteBus, _timeoutSagaRepository); _timeoutService.Start(); _repository = new InMemoryDeferredMessageRepository(); ObjectBuilder.Stub(x => x.GetInstance<IDeferredMessageRepository>()).Return(_repository); ObjectBuilder.Stub(x => x.GetInstance<DeferMessageConsumer>()).Return(new DeferMessageConsumer(RemoteBus, _repository)); ObjectBuilder.Stub(x => x.GetInstance<TimeoutExpiredConsumer>()).Return(new TimeoutExpiredConsumer(RemoteBus, _repository)); _deferService = new MessageDeferralService(RemoteBus); _deferService.Start(); }
public WindsorSagaRepository(ISagaRepository <T> repository, IWindsorContainer container) { _repository = repository; _container = container; }
public GridServiceLoadBalancer(ISagaRepository<Acceptor<AvailableGridServiceNode>> acceptors, ISagaRepository<Learner<AvailableGridServiceNode>> listeners) { _acceptors = acceptors; _listeners = listeners; }
public static IEnumerable <TSaga> Where <TSaga>(this ISagaRepository <TSaga> source, Expression <Func <TSaga, bool> > filter) where TSaga : class, ISaga { return(source.Where(new SagaFilter <TSaga>(filter))); }
public ProcessCoordinatorService(IServiceBus bus, ISagaRepository<ProcessOrchestrationSaga> sagaRepository) { _bus = bus; _sagaRepository = sagaRepository; }
public ISagaRepository <TSaga> DecorateSagaRepository(ISagaRepository <TSaga> repository) { return(new TestSagaRepositoryDecorator <TSaga>(repository, Consumed, Created, Sagas)); }
public static StateMachineSagaTestHarness <TInstance, TStateMachine> StateMachineSaga <TInstance, TStateMachine>(this BusTestHarness harness, TStateMachine stateMachine, ISagaRepository <TInstance> repository) where TInstance : class, SagaStateMachineInstance where TStateMachine : SagaStateMachine <TInstance> { if (stateMachine == null) { throw new ArgumentNullException(nameof(stateMachine)); } if (repository == null) { throw new ArgumentNullException(nameof(repository)); } return(new StateMachineSagaTestHarness <TInstance, TStateMachine>(harness, repository, stateMachine)); }
public SagaConfigurator(ISagaRepository <TSaga> sagaRepository) { _sagaRepository = sagaRepository; _pipeSpecifications = new List <IPipeSpecification <SagaConsumeContext <TSaga> > >(); }
public CorrelatedSagaMessageSink(ISagaRepository <TSaga> repository, ISagaPolicy <TSaga, TMessage> policy) : base(repository, policy, new CorrelatedSagaLocator <TMessage>(), GetHandlers) { }
public RegistrationStateMachineSagaTestHarness(SagaTestHarnessRegistration <TInstance> registration, ISagaRepository <TInstance> repository, TStateMachine stateMachine) : base(repository, registration.TestTimeout) { _stateMachine = stateMachine; Consumed = registration.Consumed; Created = registration.Created; Sagas = registration.Sagas; }
protected override void ConfigureMessagePipe(IPipeConfigurator <ConsumeContext <TMessage> > configurator, ISagaRepository <TSaga> repository, IPipe <SagaConsumeContext <TSaga, TMessage> > sagaPipe) { configurator.UseFilter(new CorrelationIdMessageFilter <TMessage>(_correlationIdSelector)); configurator.UseFilter(new CorrelatedSagaFilter <TSaga, TMessage>(repository, _policy, sagaPipe)); }
/// <summary> /// Configure the message pipe that is prior to the saga repository /// </summary> /// <param name="configurator">The pipe configurator</param> /// <param name="repository"></param> /// <param name="sagaPipe"></param> protected abstract void ConfigureMessagePipe(IPipeConfigurator <ConsumeContext <TMessage> > configurator, ISagaRepository <TSaga> repository, IPipe <SagaConsumeContext <TSaga, TMessage> > sagaPipe);
public ObservesSagaWorkerConnector(ISagaRepository <TSaga> sagaRepository) : base(sagaRepository) { }
public static void ImplementSagaDistributorWorker <T>(this ServiceBusConfigurator configurator, ISagaRepository <T> repository) where T : SagaStateMachine <T>, ISaga { configurator.AddService(BusServiceLayer.Presentation, bus => new SagaWorker <T>(repository)); }
public ImageRetrievalStateBusInstance(IConfigurationProvider configuration, ImageRetrievalStateMachine machine, ISagaRepository<ImageRetrievalState> sagaRepository) : base(configuration, "ImageRetrievalTrackingQueueName", "ImageRetrievalTrackingConsumerLimit", 1) { this.StateMachineSaga(machine, sagaRepository, machine.ConfigureStateMachineCorrelations); }
public static TSaga GetById <TSaga>(this ISagaRepository sagaRepository, Guid sagaId) where TSaga : class, ISaga { return(sagaRepository.GetById <TSaga>(Bucket.Default, sagaId.ToString())); }
public MemberService() { _stateMachine = new NewAddressStateMachine(); _stateMachineRepository = new InMemorySagaRepository<NewAddressState>(); }
/// <summary> /// Инициализирует новый экземпляр класса <see cref="DefaultSagaLifecycle{TS,TM,TK}"/>. /// </summary> /// <param name="repository">Хранилище временного состояния саги.</param> /// <param name="separator">Вычислитель идентификатора саги из сообщения.</param> /// <param name="factory">Фабрика создающая сагу.</param> public DefaultSagaLifecycle(ISagaRepository <TS, TK> repository, ISagaIdSeparator <TM, TK> separator, ISagaFactory <TS, TK> factory) { this.SagaRepository = repository; this.SagaIdSeparator = separator; this.SagaFactory = factory; }
public NinjectSagaRepository(ISagaRepository <TSaga> repository) { _repository = repository; }
public SagaTestInstance(TScenario scenario, IList <TestAction <TScenario> > actions, ISagaRepository <TSaga> sagaRepository) : base(scenario, actions) { _subject = new SagaTestSubject <TScenario, TSaga>(sagaRepository); }
public OrchestratesSagaSubscriptionConnector(ISagaRepository <TSaga> sagaRepository) : base(sagaRepository, new ExistingOrIgnoreSagaPolicy <TSaga, TMessage>(x => false)) { }
public static void LogFault <TSaga, TMessage>(this ConsumeContext <TMessage> context, ISagaRepository <TSaga> repository, Exception exception, Guid?correlationId = default) where TSaga : class, ISaga where TMessage : class { LogContext.Error?.Log(exception, "SAGA:{SagaType}:{CorrelationId} Fault {MessageType}", TypeMetadataCache <TSaga> .ShortName, correlationId, TypeMetadataCache <TMessage> .ShortName); }
public CorrelatedSagaStateMachineMessageSink(ISagaRepository <TSaga> repository, ISagaPolicy <TSaga, TMessage> policy, DataEvent <TSaga, TMessage> dataEvent) : base(repository, policy, new CorrelatedSagaLocator <TMessage>(), (s, c) => GetHandlers(s, c, dataEvent)) { }
public SagaManager(TSagaMachine sagaMachine, ISagaRepository <TSagaData> sagaRepository) { _sagaRepository = sagaRepository; SagaMachine = sagaMachine; }
protected EventHandlerBase(ISagaRepository sagas) { this.sagas = sagas; }
protected override void Context() { this._storeEvents = Wireup.Init().UsingInMemoryPersistence().Build(); this._repository = new SagaEventStoreRepository(this._storeEvents, new SagaFactory()); }
public SagaToTest(IServiceBus serviceBus, ISagaRepository repository) : base(serviceBus, repository) { }
public StructureMapSagaRepository(ISagaRepository <TSaga> repository, IContainer container) { _repository = repository; _container = container; }
public NodeInstaller(IServiceBus bus, ISagaRepository<NodeSetupSaga> installerSagaRepo) { this.bus = bus; this.installerSagaRepo = installerSagaRepo ?? new InMemorySagaRepository<NodeSetupSaga>(); }
public CashierService(IServiceBus bus, ISagaRepository<CashierSaga> sagaRepository) { _bus = bus; _sagaRepository = sagaRepository; }
public UnitySagaRepository(ISagaRepository <TSaga> repository, IUnityContainer container) { _repository = repository; _container = container; }
public ConfirmUserHandler(ICommandBus commandBus, ISagaRepository sagaRepository, IPasswordHasher passwordHasher) { _commandBus = commandBus; _sagaRepository = sagaRepository; _passwordHasher = passwordHasher; }
public NinjectSagaRepository(ISagaRepository <TSaga> repository, IKernel kernel) { _repository = repository; _kernel = kernel; }
public ExtensionsDependencyInjectionSagaRepository(ISagaRepository <TSaga> repository, IServiceProvider services) { this._services = services; this._repository = repository; }
protected override void EstablishContext() { base.EstablishContext(); _sagaRepository = new NHibernateSagaRepository<ConcurrentSaga>(SessionFactory); }
public TimeoutService(IServiceBus bus, ISagaRepository <TimeoutSaga> repository) { _bus = bus; _repository = repository; }
public InitiatedBySagaWorkerConnector(ISagaRepository <TSaga> sagaRepository) : base(sagaRepository) { }
protected override void EstablishContext() { FirstSagaRepository = SetupSagaRepository <FirstSaga>(); base.EstablishContext(); }
protected override ISagaMessageSink <TSaga, TMessage> GetSagaMessageSink(ISagaRepository <TSaga> sagaRepository, ISagaPolicy <TSaga, TMessage> policy) { return(new CorrelatedSagaMessageSink <TSaga, TMessage>(sagaRepository, policy)); }