public When_pre_inserting_the_state_machine_instance_using_ef() { ISagaDbContextFactory <Instance> sagaDbContextFactory = new DelegateSagaDbContextFactory <Instance>( () => new InstanceSagaDbContext(LocalDbConnectionStringProvider.GetLocalDbConnectionString())); _repository = EntityFrameworkSagaRepository <Instance> .CreatePessimistic(sagaDbContextFactory); }
public When_using_EntityFramework() { _sagaDbContextFactory = new DelegateSagaDbContextFactory <ShoppingChore>( () => new ShoppingChoreSagaDbContext(SagaDbContextFactoryProvider.GetLocalDbConnectionString())); _repository = new Lazy <ISagaRepository <ShoppingChore> >(() => EntityFrameworkSagaRepository <ShoppingChore> .CreatePessimistic(_sagaDbContextFactory)); }
public When_pre_inserting_in_an_invalid_state_using_ef() { var sagaDbContextFactory = new DelegateSagaDbContextFactory <Instance>(() => new InstanceSagaDbContext(SagaDbContextFactoryProvider.GetLocalDbConnectionString())); _repository = EntityFrameworkSagaRepository <Instance> .CreatePessimistic(sagaDbContextFactory); }
public Locating_an_existing_ef_saga() { var sagaDbContextFactory = new DelegateSagaDbContextFactory <SimpleSaga>(() => new SimpleSagaDbContext(LocalDbConnectionStringProvider.GetLocalDbConnectionString())); _sagaRepository = new Lazy <ISagaRepository <SimpleSaga> >(() => EntityFrameworkSagaRepository <SimpleSaga> .CreatePessimistic(sagaDbContextFactory)); }
public When_using_EntityFrameworkConcurrencyPessimistic() { _sagaDbContextFactory = new DelegateSagaDbContextFactory <ChoirStatePessimistic>(() => new ChoirStatePessimisticSagaDbContext(SagaDbContextFactoryProvider.GetLocalDbConnectionString())); _repository = new Lazy <ISagaRepository <ChoirStatePessimistic> >(() => EntityFrameworkSagaRepository <ChoirStatePessimistic> .CreatePessimistic(_sagaDbContextFactory)); }
public static void UseEntityFrameworkCoreSagaRepository(this IJobServiceConfigurator configurator, Func<JobServiceSagaDbContext> contextFactory, ILockStatementProvider lockStatementProvider = default) { configurator.Repository = EntityFrameworkSagaRepository<JobTypeSaga>.CreatePessimistic(contextFactory, lockStatementProvider); configurator.JobRepository = EntityFrameworkSagaRepository<JobSaga>.CreatePessimistic(contextFactory, lockStatementProvider); configurator.JobAttemptRepository = EntityFrameworkSagaRepository<JobAttemptSaga>.CreatePessimistic(contextFactory, lockStatementProvider); }
public Locating_an_existing_ef_saga() { // add new migration by calling // dotnet ef migrations add --context "SagaDbContext``2" Init -v _sagaRepository = new Lazy <ISagaRepository <SimpleSaga> >(() => EntityFrameworkSagaRepository <SimpleSaga> .CreatePessimistic( () => new SimpleSagaContextFactory().CreateDbContext(DbContextOptionsBuilder), RawSqlLockStatements)); }
public Using_custom_include_in_repository() { // // add new migration by calling // // dotnet ef migrations add --context "SagaDbContext``2" Init -v _sagaRepository = new Lazy <ISagaRepository <SagaWithDependency> >(() => EntityFrameworkSagaRepository <SagaWithDependency> .CreatePessimistic( () => new SagaWithDependencyContextFactory().CreateDbContext(DbContextOptionsBuilder), RawSqlLockStatements, queryable => queryable.Include(it => it.Dependency).ThenInclude(dependency => dependency.SagaInnerDependency))); }
static async Task Main(string[] args) { var isService = !(Debugger.IsAttached || args.Contains("--console")); var builder = new HostBuilder() .ConfigureAppConfiguration((hostingContext, config) => { config.AddJsonFile("appsettings.json", optional: true); config.AddEnvironmentVariables(); if (args != null) { config.AddCommandLine(args); } }) .ConfigureServices((hostContext, services) => { services.Configure <AppConfig>(options => hostContext.Configuration.GetSection("AppConfig").Bind(options)); services.AddMassTransit(cfg => { cfg.AddConsumersFromNamespaceContaining <ConsumerAnchor>(); cfg.AddSagaStateMachinesFromNamespaceContaining <StateMachineAnchor>(); cfg.AddActivitiesFromNamespaceContaining <ActivitiesAnchor>(); cfg.AddBus(ConfigureBus); }); services.AddDbContext <DbContext, SampleBatchDbContext>(x => x.UseSqlServer(hostContext.Configuration.GetConnectionString("sample-batch"))); services.AddSingleton(typeof(ISagaDbContextFactory <BatchState>), typeof(SagaScopedDbConnectionFactory <BatchState>)); services.AddSingleton(typeof(ISagaDbContextFactory <JobState>), typeof(SagaScopedDbConnectionFactory <JobState>)); // I specified the MsSqlLockStatements because in my State Entities EFCore EntityConfigurations, I changed the column name from CorrelationId, to "BatchId" and "BatchJobId" // Otherwise I could just use the default, which are "... WHERE CorrelationId = @p0" services.AddSingleton <ISagaRepository <BatchState> >(x => EntityFrameworkSagaRepository <BatchState> .CreatePessimistic(x.GetRequiredService <ISagaDbContextFactory <BatchState> >(), new MsSqlLockStatements(rowLockStatement: "select * from {0}.{1} WITH (UPDLOCK, ROWLOCK) WHERE BatchId = @p0"))); services.AddSingleton <ISagaRepository <JobState> >(x => EntityFrameworkSagaRepository <JobState> .CreatePessimistic(x.GetRequiredService <ISagaDbContextFactory <JobState> >(), new MsSqlLockStatements(rowLockStatement: "select * from {0}.{1} WITH (UPDLOCK, ROWLOCK) WHERE BatchJobId = @p0"))); services.AddSingleton <IHostedService, MassTransitConsoleHostedService>(); services.AddSingleton <IHostedService, EfDbCreatedHostedService>(); // So we don't need to use ef migrations for this sample. Likely if you are going to deploy to a production environment, you want a better DB deploy strategy. }) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); }); if (isService) { await builder.RunAsServiceAsync(); } else { await builder.RunConsoleAsync(); } }
public SlowConcurrentSaga_Specs() { // rowlock statements that don't work to cause a deadlock. var notWorkingRowLockStatements = new SqlLockStatementProvider("dbo", "SELECT * FROM \"{1}\" WHERE \"CorrelationId\" = @p0"); // add new migration by calling // dotnet ef migrations add --context "SagaDbContext``2" Init -v _sagaRepository = new Lazy <ISagaRepository <SlowConcurrentSaga> >(() => EntityFrameworkSagaRepository <SlowConcurrentSaga> .CreatePessimistic( () => new SlowConcurrentSagaContextFactory().CreateDbContext(DbContextOptionsBuilder), notWorkingRowLockStatements)); _sagaTestHarness = BusTestHarness.StateMachineSaga(new SlowConcurrentSagaStateMachine(), _sagaRepository.Value); }
public Locating_an_existing_ef_saga() { // add new migration by calling // dotnet ef migrations add --context "SagaDbContext``2" Init -v var contextFactory = new ContextFactory(); using (SagaDbContext <SimpleSaga, SimpleSagaMap> context = contextFactory.CreateDbContext(Array.Empty <string>())) { context.Database.Migrate(); } _sagaDbContextFactory = () => contextFactory.CreateDbContext(Array.Empty <string>()); _sagaRepository = new Lazy <ISagaRepository <SimpleSaga> >(() => EntityFrameworkSagaRepository <SimpleSaga> .CreatePessimistic(_sagaDbContextFactory)); }
public Using_ef_connection_resiliency() { // add new migration by calling // dotnet ef migrations add --context "SagaDbContext``2" Init -v var contextFactory = new ContextFactoryWithResilienceStrategy(); using (var context = contextFactory.CreateDbContext(Array.Empty <string>())) { context.Database.Migrate(); } _sagaDbContextFactory = () => contextFactory.CreateDbContext(Array.Empty <string>()); _sagaRepository = new Lazy <ISagaRepository <SimpleSaga> >(() => EntityFrameworkSagaRepository <SimpleSaga> .CreatePessimistic(_sagaDbContextFactory)); }
public Using_custom_include_in_repository() { // add new migration by calling // dotnet ef migrations add --context "SagaWithDependencyContext" Init -v var contextFactory = new SagaWithDependencyContextFactory(); using (var context = contextFactory.CreateDbContext(Array.Empty <string>())) { context.Database.Migrate(); } _sagaDbContextFactory = () => contextFactory.CreateDbContext(Array.Empty <string>()); _sagaRepository = new Lazy <ISagaRepository <SagaWithDependency> >(() => EntityFrameworkSagaRepository <SagaWithDependency> .CreatePessimistic(_sagaDbContextFactory, queryCustomization: queryable => queryable.Include(it => it.Dependency).ThenInclude(dependency => dependency.SagaInnerDependency) )); }
protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator) { _discarded = GetTask <bool>(); _simpleStateMachine = new SimpleStateMachine(x => { _discarded.TrySetResult(true); }); _sagaDbContextFactory = new DelegateSagaDbContextFactory <SimpleState>(() => new SimpleStateSagaDbContext(SagaDbContextFactoryProvider.GetLocalDbConnectionString())); _simpleStateRepository = new Lazy <ISagaRepository <SimpleState> >(() => EntityFrameworkSagaRepository <SimpleState> .CreatePessimistic(_sagaDbContextFactory)); configurator.StateMachineSaga(_simpleStateMachine, _simpleStateRepository.Value); base.ConfigureInMemoryReceiveEndpoint(configurator); }
public BatchStateMachineTests() { var dbOptionsBuilder = new DbContextOptionsBuilder() .UseSqlServer(TestConstants.ConnectionString) .EnableSensitiveDataLogging(); _dbContextFactory = () => new SampleBatchDbContext(dbOptionsBuilder.Options); // Makes sure the DB is created for tests using (var db = _dbContextFactory()) { db.Database.EnsureCreated(); } _sagaRepository = EntityFrameworkSagaRepository <BatchState> .CreatePessimistic(_dbContextFactory, new CustomSqlLockStatementProvider("select * from {0}.{1} WITH (UPDLOCK, ROWLOCK) WHERE BatchId = @p0")); _stateMachine = new BatchStateMachine(); _inMemoryTestHarness = new InMemoryTestHarness(); _inMemoryConsumerHarness = _inMemoryTestHarness.Consumer <FakeBatchJobSagaConsumer>(Guid.NewGuid().ToString()); _inMemoryTestHarness.OnConfigureInMemoryReceiveEndpoint += ConfigureInMemoryReceiveEndpoint; _inMemoryTestHarness.OnConfigureInMemoryBus += ConfigureInMemoryBus; }
static async Task Main(string[] args) { var bus = Bus.Factory.CreateUsingRabbitMq(cfg => { cfg.Host(new Uri(BASE_URI), c => { c.Username("guest"); c.Password("guest"); }); cfg.ReceiveEndpoint("mysaga", ec => { ec.UseInMemoryOutbox(); var _mySagaInstance = new MySaga(); //ISagaRepository<MySaga> repoCreateQuoteSaga = new InMemorySagaRepository<MySaga>(); ISagaRepository <MySaga> repoCreateQuoteSaga = EntityFrameworkSagaRepository <MySaga> .CreatePessimistic(() => { var options = new DbContextOptionsBuilder() .UseSqlServer(DB_CS, m => { object p = m.MigrationsAssembly(Assembly.GetExecutingAssembly().GetName().Name); m.MigrationsHistoryTable($"__MySaga"); }) .Options; var dbContext = new MySagaDbContext(options); return(dbContext); }); ec.Saga(repoCreateQuoteSaga); }); }); using var cancelation = new CancellationTokenSource(TimeSpan.FromSeconds(30)); await bus.StartAsync(cancelation.Token); try { await Console.Out.WriteLineAsync("Press any key to exit..."); await Task.Run(Console.ReadKey); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); } finally { try { bus.Stop(); } catch (Exception e) { Console.WriteLine(e.Message); } } }
ISagaRepository<ReadOnlyInstance> CreateSagaRepository() { return EntityFrameworkSagaRepository<ReadOnlyInstance>.CreatePessimistic( () => new ReadOnlySagaDbContextFactory().CreateDbContext(DbContextOptionsBuilder), RawSqlLockStatements); }