protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
ValidateSagaOutboxCombo(settings);
var sqlDialect = settings.GetSqlDialect();
var container = context.Container;
var connectionManager = settings.GetConnectionBuilder <StorageType.Sagas>();
var sqlSagaPersistenceActivated = settings.IsFeatureActive(typeof(SqlSagaFeature));
SagaInfoCache infoCache = null;
if (sqlSagaPersistenceActivated)
{
infoCache = BuildSagaInfoCache(sqlDialect, settings);
}
var sessionHolder = new CurrentSessionHolder();
//Info cache can be null if Outbox is enabled but Sagas are disabled.
container.ConfigureComponent(() => new SynchronizedStorage(connectionManager, infoCache, sessionHolder), DependencyLifecycle.SingleInstance);
container.ConfigureComponent(() => new StorageAdapter(connectionManager, infoCache, sqlDialect, sessionHolder), DependencyLifecycle.SingleInstance);
container.ConfigureComponent(() => sessionHolder.Current, DependencyLifecycle.InstancePerCall);
context.Pipeline.Register(new CurrentSessionBehavior(sessionHolder), "Manages the lifecycle of the current session holder.");
if (sqlSagaPersistenceActivated)
{
var sagaPersister = new SagaPersister(infoCache, sqlDialect);
container.ConfigureComponent <ISagaPersister>(() => sagaPersister, DependencyLifecycle.SingleInstance);
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
ValidateSagaOutboxCombo(settings);
var sqlDialect = settings.GetSqlDialect();
var services = context.Services;
var connectionManager = settings.GetConnectionBuilder <StorageType.Sagas>();
var sqlSagaPersistenceActivated = settings.IsFeatureActive(typeof(SqlSagaFeature));
SagaInfoCache infoCache = null;
if (sqlSagaPersistenceActivated)
{
infoCache = BuildSagaInfoCache(sqlDialect, settings);
}
var sessionHolder = new CurrentSessionHolder();
//Info cache can be null if Outbox is enabled but Sagas are disabled.
services.AddSingleton <ISynchronizedStorage>(new SynchronizedStorage(connectionManager, infoCache, sessionHolder));
services.AddSingleton <ISynchronizedStorageAdapter>(new StorageAdapter(connectionManager, infoCache, sqlDialect, sessionHolder));
services.AddTransient(_ => sessionHolder.Current);
context.Pipeline.Register(new CurrentSessionBehavior(sessionHolder), "Manages the lifecycle of the current session holder.");
if (sqlSagaPersistenceActivated)
{
var sagaPersister = new SagaPersister(infoCache, sqlDialect);
services.AddSingleton <ISagaPersister>(sagaPersister);
}
}
public StorageAdapter(IConnectionManager connectionBuilder, SagaInfoCache infoCache, SqlDialect dialect, CurrentSessionHolder currentSessionHolder)
{
this.connectionBuilder = connectionBuilder;
this.infoCache = infoCache;
this.dialect = dialect;
this.currentSessionHolder = currentSessionHolder;
}
public MyLoadHandlersConnector(
CurrentSessionHolder sessionHolder,
MessageHandlerRegistry messageHandlerRegistry,
ISynchronizedStorage synchronizedStorage,
ISynchronizedStorageAdapter adapter)
{
this.sessionHolder = sessionHolder;
this.messageHandlerRegistry = messageHandlerRegistry;
this.synchronizedStorage = synchronizedStorage;
this.adapter = adapter;
}
public MessageSession(IMessageSession messageSession, CurrentSessionHolder sessionHolder)
{
this.sessionHolder = sessionHolder;
this.messageSession = messageSession;
}
public CurrentSessionBehavior(CurrentSessionHolder currentSessionHolder)
{
this.currentSessionHolder = currentSessionHolder;
}
public RegisterCurrentSessionBehavior(CurrentSessionHolder sessionHolder)
{
this.sessionHolder = sessionHolder;
}
public Scope(CurrentSessionHolder sessionHolder)
{
this.sessionHolder = sessionHolder;
}
public RegisterSessionStartupTask(CurrentSessionHolder sessionHolder)
{
this.sessionHolder = sessionHolder;
}
public SynchronizedStorage(IConnectionManager connectionManager, SagaInfoCache infoCache, CurrentSessionHolder currentSessionHolder)
{
this.connectionManager = connectionManager;
this.infoCache = infoCache;
this.currentSessionHolder = currentSessionHolder;
}
static async Task Start()
{
var config = new EndpointConfiguration("NHibernateOutboxEntityFrameworkIntegration");
config.EnableOutbox();
config.SendFailedMessagesTo("error");
config.EnableInstallers();
var currentSessionHolder = new CurrentSessionHolder();
//we replace the regular LoadHandlersConnector with one that stores the NH session in the async local
config.Pipeline.Replace("LoadHandlersConnector", b =>
{
var adapter = b.Build <ISynchronizedStorageAdapter>();
var syncStorage = b.Build <ISynchronizedStorage>();
return(new MyLoadHandlersConnector(currentSessionHolder, b.Build <MessageHandlerRegistry>(), syncStorage, adapter));
});
config.RegisterComponents(c =>
{
c.ConfigureComponent <MyDataContext>(b =>
{
var session = currentSessionHolder.Current;
var connection = session.Session().Connection;
var dataContext = new MyDataContext(connection);
DbTransaction transaction;
using (var dummyCommand = connection.CreateCommand())
{
session.Session().Transaction.Enlist(dummyCommand);
transaction = dummyCommand.Transaction;
}
dataContext.Database.UseTransaction(transaction);
return(dataContext);
}, DependencyLifecycle.InstancePerCall);
});
//connection.isolation instructs NHibernate to use Snapshot isolation level when opening transactions
var persistence = config.UsePersistence <NHibernatePersistence>();
var connectionString = "data source=(local); initial catalog=testnh; integrated security=true";
var nhConfig = new Configuration
{
Properties =
{
["dialect"] = "NHibernate.Dialect.MsSql2012Dialect",
["connection.driver_class"] = "NHibernate.Driver.Sql2008ClientDriver",
["connection.connection_string"] = connectionString,
["connection.isolation"] = IsolationLevel.Snapshot.ToString()
}
};
persistence.UseConfiguration(nhConfig);
config.UseTransport <LearningTransport>();
var endpoint = await Endpoint.Start(config);
var ctx = new MyDataContext(new SqlConnection(connectionString));
ctx.Database.Initialize(true);
Console.WriteLine("Type ID and press <enter> to create a new entity");
while (true)
{
var id = Console.ReadLine();
var message = new MyMessage
{
Id = id
};
await endpoint.SendLocal(message).ConfigureAwait(false);
}
}
public ContextSCope(CurrentSessionHolder sessionHolder)
{
this.sessionHolder = sessionHolder;
}
