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 void Context()
{
this._storeEvents = Wireup.Init().UsingInMemoryPersistence().Build();
this._repository = new SagaEventStoreRepository(this._storeEvents, new SagaFactory());
}
protected override ISagaMessageSink <TSaga, TMessage> GetSagaMessageSink(ISagaRepository <TSaga> sagaRepository,
ISagaPolicy <TSaga, TMessage> policy)
{
return(new CorrelatedSagaMessageSink <TSaga, TMessage>(sagaRepository, policy));
}
