public void Initialize(IServiceBus bus)
{
_serviceBusConfiguration = bus.Configuration;
using (_databaseContextFactory.Create(SqlServerConfiguration.ProviderName, _subscriptionConnectionString))
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.GetScript(
Script.SubscriptionManagerExists))) != 1)
{
try
{
_databaseGateway.ExecuteUsing(RawQuery.Create(
_scriptProvider.GetScript(
Script.SubscriptionManagerCreate)));
}
catch (Exception ex)
{
if (!ex.Message.Equals("There is already an object named 'SubscriberMessageType' in the database.", StringComparison.OrdinalIgnoreCase))
{
throw new DataException(SqlResources.SubscriptionManagerCreateException, ex);
}
}
}
}
if (HasDeferredSubscriptions)
{
Subscribe(_deferredSubscriptions);
}
}
public void Register(string endpointName, string machineName, string baseDirectory,
string entryAssemblyQualifiedName,
string inboxWorkQueueUri, string controlInboxWorkQueueUri)
{
var id = FindId(endpointName, machineName, baseDirectory);
if (id.HasValue)
{
_databaseGateway.ExecuteUsing(_queryFactory.Save(
id.Value,
entryAssemblyQualifiedName,
inboxWorkQueueUri,
controlInboxWorkQueueUri));
}
else
{
_databaseGateway.ExecuteUsing(_queryFactory.Add(
endpointName,
machineName,
baseDirectory,
entryAssemblyQualifiedName,
inboxWorkQueueUri,
controlInboxWorkQueueUri));
}
}
public void Add(Order order)
{
_databaseGateway.ExecuteUsing(_queryFactory.Add(order));
foreach (var item in order.Items)
{
_databaseGateway.ExecuteUsing(_queryFactory.AddItem(item, order.Id));
}
}
public void Save(Document document)
{
Guard.AgainstNull(document, nameof(document));
_databaseGateway.ExecuteUsing(_queryFactory.Save(document));
SaveStatusEvents(document);
SaveProperties(document);
}
public void Add(Invoice invoice)
{
_databaseGateway.ExecuteUsing(_queryFactory.Add(invoice));
foreach (var item in invoice.Items)
{
_databaseGateway.ExecuteUsing(_queryFactory.AddItem(item, invoice.Id));
}
}
public void Add(TransportMessage transportMessage)
{
using (databaseConnectionFactory.Create(IdempotenceDataSource))
{
databaseGateway.ExecuteUsing(
IdempotenceDataSource,
RawQuery.CreateFrom(
scriptProvider.GetScript(Script.IdempotenceTrackerAdd))
.AddParameterValue(IdempotenceTrackerColumns.MessageId, transportMessage.MessageId));
}
}
public void Save(Session session)
{
Guard.AgainstNull(session, nameof(session));
_databaseGateway.ExecuteUsing(_queryFactory.Remove(session.Username));
_databaseGateway.ExecuteUsing(_queryFactory.Add(session));
foreach (var permission in session.Permissions)
{
_databaseGateway.ExecuteUsing(_queryFactory.AddPermission(session.Token, permission));
}
}
public void Create()
{
using (_databaseContextFactory.Create(_connectionName))
{
_databaseGateway.ExecuteUsing(_createQuery);
}
}
public void Subscribe(IEnumerable <string> messageTypeFullNames)
{
Guard.AgainstNull(messageTypeFullNames, "messageTypeFullNames");
if (!Started)
{
deferredSubscriptions.AddRange(messageTypeFullNames);
return;
}
using (databaseConnectionFactory.Create(_subscriptionDataSource))
{
foreach (var messageType in messageTypeFullNames)
{
databaseGateway.ExecuteUsing(
_subscriptionDataSource,
RawQuery.Create(
scriptProvider.GetScript(Script.SubscriptionManagerSubscribe))
.AddParameterValue(SubscriptionManagerColumns.InboxWorkQueueUri,
serviceBusConfiguration.Inbox.WorkQueue.Uri.ToString())
.AddParameterValue(SubscriptionManagerColumns.MessageType, messageType));
}
}
}
public void SetSequenceNumber(string name, long sequenceNumber)
{
using (
_databaseContextFactory.Create(_projectionConfiguration.ProviderName, _projectionConfiguration.ConnectionString))
{
_databaseGateway.ExecuteUsing(_queryFactory.SetSequenceNumber(name, sequenceNumber));
}
}
public void Enqueue(string sourceQueueUri, TransportMessage transportMessage, Stream stream)
{
try
{
using (_databaseContextFactory.Create())
{
_databaseGateway.ExecuteUsing(_inspectionQueueQueryFactory.Enqueue(sourceQueueUri, transportMessage,
stream));
}
}
catch (Exception ex)
{
_log.Error(
string.Format(Resources.EnqueueException, transportMessage.MessageId, ex.Message));
throw;
}
}
public void Save(string machineName, string baseDirectory, string entryAssemblyQualifiedName,
string ipv4Address, string inboxWorkQueueUri, string inboxDeferredQueueUri, string inboxErrorQueueUri,
string outboxWorkQueueUri, string outboxErrorQueueUri, string controlInboxWorkQueueUri,
string controlInboxErrorQueueUri, string heartbeatIntervalDuration)
{
_databaseGateway.ExecuteUsing(_queryFactory.Save(machineName, baseDirectory, entryAssemblyQualifiedName,
ipv4Address, inboxWorkQueueUri, inboxDeferredQueueUri, inboxErrorQueueUri, controlInboxWorkQueueUri,
controlInboxErrorQueueUri, outboxWorkQueueUri, outboxErrorQueueUri, heartbeatIntervalDuration));
}
public void Initialize(IServiceBus bus)
{
using (var connection = _databaseConnectionFactory.Create(_idempotenceDataSource))
using (var transaction = connection.BeginTransaction())
{
if (_databaseGateway.GetScalarUsing <int>(
_idempotenceDataSource,
RawQuery.Create(
_scriptProvider.GetScript(
Script.IdempotenceServiceExists))) != 1)
{
throw new IdempotenceServiceException(SqlResources.IdempotenceDatabaseNotConfigured);
}
_databaseGateway.ExecuteUsing(
_idempotenceDataSource,
RawQuery.Create(
_scriptProvider.GetScript(
Script.IdempotenceInitialize))
.AddParameterValue(IdempotenceColumns.InboxWorkQueueUri, bus.Configuration.Inbox.WorkQueue.Uri.ToString()));
transaction.CommitTransaction();
}
}
public void Add(OrderProcess orderProcess)
{
Guard.AgainstNull(orderProcess, "orderProcess");
_databaseGateway.ExecuteUsing(_queryFactory.Add(orderProcess));
foreach (var orderProcessItem in orderProcess.OrderProcessItems)
{
_databaseGateway.ExecuteUsing(_queryFactory.AddItem(orderProcessItem, orderProcess.Id));
}
foreach (var status in orderProcess.Statuses)
{
_databaseGateway.ExecuteUsing(_queryFactory.AddStatus(status, orderProcess.Id));
}
}
public void Create()
{
if (Exists())
{
return;
}
try
{
using (_databaseContextFactory.Create(_connectionName))
{
_databaseGateway.ExecuteUsing(_createQuery);
}
}
catch (Exception ex)
{
_log.Error(string.Format(SqlResources.CreateError, Uri, ex.Message, _createQuery));
throw;
}
}
public void Create()
{
if (Exists() != QueueAvailability.Missing)
{
return;
}
try
{
using (databaseConnectionFactory.Create(dataSource))
{
databaseGateway.ExecuteUsing(dataSource, createQuery);
}
}
catch (Exception ex)
{
log.Debug(string.Format("Could not create queue '{0}'. Exception: {1}. Query: {2}", Uri,
ex.Message, createQuery));
throw;
}
}
public void Registered(Guid id, string name, Guid?columnArgumentId, Guid rowArgumentId,
string dataTypeName)
{
_databaseGateway.ExecuteUsing(_queryFactory.Add(id, name, columnArgumentId, rowArgumentId,
dataTypeName));
}
public void Registered(Guid formulaId, string name)
{
_databaseGateway.ExecuteUsing(_queryFactory.Registered(formulaId, name));
}
public ProcessingStatus ProcessingStatus(TransportMessage transportMessage)
{
try
{
using (
var connection = _databaseContextFactory.Create(SqlServerConfiguration.ProviderName,
_idempotenceConnectionString))
using (var transaction = connection.BeginTransaction())
{
try
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.GetScript(
Script.IdempotenceHasCompleted))
.AddParameterValue(IdempotenceColumns.MessageId, transportMessage.MessageId)) == 1)
{
return(Esb.ProcessingStatus.Ignore);
}
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.GetScript(
Script.IdempotenceIsProcessing))
.AddParameterValue(IdempotenceColumns.MessageId, transportMessage.MessageId)) == 1)
{
return(Esb.ProcessingStatus.Ignore);
}
_databaseGateway.ExecuteUsing(
RawQuery.Create(
_scriptProvider.GetScript(
Script.IdempotenceProcessing))
.AddParameterValue(IdempotenceColumns.MessageId, transportMessage.MessageId)
.AddParameterValue(IdempotenceColumns.InboxWorkQueueUri,
transportMessage.RecipientInboxWorkQueueUri)
.AddParameterValue(IdempotenceColumns.AssignedThreadId,
Thread.CurrentThread.ManagedThreadId));
var messageHandled = _databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.GetScript(
Script.IdempotenceIsMessageHandled))
.AddParameterValue(IdempotenceColumns.MessageId, transportMessage.MessageId)) == 1;
return(messageHandled
? Esb.ProcessingStatus.MessageHandled
: Esb.ProcessingStatus.Assigned);
}
finally
{
transaction.CommitTransaction();
}
}
}
catch (SqlException ex)
{
var message = ex.Message.ToUpperInvariant();
if (message.Contains("VIOLATION OF UNIQUE KEY CONSTRAINT") ||
message.Contains("CANNOT INSERT DUPLICATE KEY") || message.Contains("IGNORE MESSAGE PROCESSING"))
{
return(Esb.ProcessingStatus.Ignore);
}
throw;
}
}
public void Register(ProjectionEvent projectionEvent, Registered domainEvent)
{
_databaseGateway.ExecuteUsing(_queryFactory.Register(projectionEvent.Id, domainEvent));
}
public void Remove(string key)
{
_databaseGateway.ExecuteUsing(_queryFactory.Remove(key));
}
public void Save(Guid id, string key, string value)
{
_databaseGateway.ExecuteUsing(_queryFactory.Save(id, key, value));
}
public void Remove(Guid id)
{
_databaseGateway.ExecuteUsing(_queryFactory.RemoveSnapshot(id));
_databaseGateway.ExecuteUsing(_queryFactory.RemoveEventStream(id));
}
public void Save(string uri, string processor, string type)
{
_databaseGateway.ExecuteUsing(_queryFactory.Save(uri, processor, type));
}
public void Added(PrimitiveEvent primitiveEvent, Added domainEvent)
{
_databaseGateway.ExecuteUsing(_queryFactory.Added(primitiveEvent.Id, domainEvent));
}
public void Subscribe(IEnumerable <string> messageTypeFullNames)
{
Guard.AgainstNull(messageTypeFullNames, "messageTypeFullNames");
if (_deferSubscribtions)
{
_deferredSubscriptions.AddRange(messageTypeFullNames);
return;
}
if (_serviceBusConfiguration.IsWorker || _configuration.Subscribe == SubscribeOption.Ignore)
{
return;
}
if (!_serviceBusConfiguration.HasInbox
||
_serviceBusConfiguration.Inbox.WorkQueue == null)
{
throw new InvalidOperationException(EsbResources.SubscribeWithNoInboxException);
}
var missingMessageTypes = new List <string>();
using (_databaseContextFactory.Create(_subscriptionProviderName, _subscriptionConnectionString))
{
foreach (var messageType in messageTypeFullNames)
{
if (_configuration.Subscribe == SubscribeOption.Normal)
{
_databaseGateway.ExecuteUsing(
RawQuery.Create(
_scriptProvider.Get(Script.SubscriptionManagerSubscribe))
.AddParameterValue(SubscriptionManagerColumns.InboxWorkQueueUri,
_serviceBusConfiguration.Inbox.WorkQueue.Uri.ToString())
.AddParameterValue(SubscriptionManagerColumns.MessageType, messageType));
}
else
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.Get(Script.SubscriptionManagerContains))
.AddParameterValue(SubscriptionManagerColumns.InboxWorkQueueUri,
_serviceBusConfiguration.Inbox.WorkQueue.Uri.ToString())
.AddParameterValue(SubscriptionManagerColumns.MessageType, messageType)) == 0)
{
missingMessageTypes.Add(messageType);
}
}
}
}
if (!missingMessageTypes.Any())
{
return;
}
foreach (var messageType in missingMessageTypes)
{
_log.Error(string.Format(SubscriptionResources.MissingSubscription, messageType));
}
throw new ApplicationException(string.Format(SubscriptionResources.MissingSubscriptionException, string.Join(",", missingMessageTypes)));
}
public SubscriptionManager(IServiceBusEvents events, IServiceBusConfiguration serviceBusConfiguration,
ISubscriptionConfiguration configuration, IScriptProvider scriptProvider,
IDatabaseContextFactory databaseContextFactory, IDatabaseGateway databaseGateway)
{
Guard.AgainstNull(events, "events");
Guard.AgainstNull(serviceBusConfiguration, "serviceBusConfiguration");
Guard.AgainstNull(configuration, "configuration");
Guard.AgainstNull(scriptProvider, "scriptProvider");
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(databaseGateway, "databaseGateway");
_log = Log.For(this);
_serviceBusConfiguration = serviceBusConfiguration;
_configuration = configuration;
_scriptProvider = scriptProvider;
_databaseContextFactory = databaseContextFactory;
_databaseGateway = databaseGateway;
events.Started += ServiceBus_Started;
_subscriptionProviderName = configuration.ProviderName;
if (string.IsNullOrEmpty(_subscriptionProviderName))
{
throw new ConfigurationErrorsException(string.Format(SubscriptionResources.ProviderNameEmpty,
"SubscriptionManager"));
}
_subscriptionConnectionString = configuration.ConnectionString;
if (string.IsNullOrEmpty(_subscriptionConnectionString))
{
throw new ConfigurationErrorsException(string.Format(SubscriptionResources.ConnectionStringEmpty,
"SubscriptionManager"));
}
using (_databaseContextFactory.Create(_subscriptionProviderName, _subscriptionConnectionString))
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.Get(
Script.SubscriptionManagerExists))) != 1)
{
try
{
_databaseGateway.ExecuteUsing(RawQuery.Create(
_scriptProvider.Get(
Script.SubscriptionManagerCreate)));
}
catch (Exception ex)
{
if (
!ex.Message.Equals(
"There is already an object named 'SubscriberMessageType' in the database.",
StringComparison.OrdinalIgnoreCase))
{
throw new DataException(SubscriptionResources.SubscriptionManagerCreateException, ex);
}
}
}
}
}
public void Register(Guid id, string name, Guid formulaId, string expectedResult, string expectedResultDataTypeName,
string comparison)
{
_databaseGateway.ExecuteUsing(_queryFactory.Register(id, name, formulaId, expectedResult,
expectedResultDataTypeName, comparison));
}
public void Save(Projection projection)
{
Guard.AgainstNull(projection, nameof(projection));
_databaseGateway.ExecuteUsing(_queryFactory.Save(projection));
}
public IdempotenceService(
IServiceBusConfiguration serviceBusConfiguration,
IIdempotenceConfiguration idempotenceConfiguration,
IScriptProvider scriptProvider,
IDatabaseContextFactory databaseContextFactory,
IDatabaseGateway databaseGateway)
{
Guard.AgainstNull(serviceBusConfiguration, "serviceBusConfiguration");
Guard.AgainstNull(idempotenceConfiguration, "idempotenceConfiguration");
Guard.AgainstNull(scriptProvider, "scriptProvider");
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(databaseGateway, "databaseGateway");
if (!serviceBusConfiguration.HasInbox)
{
throw new InvalidOperationException(Resources.NoInboxException);
}
_scriptProvider = scriptProvider;
_databaseContextFactory = databaseContextFactory;
_databaseGateway = databaseGateway;
_idempotenceProviderName = idempotenceConfiguration.ProviderName;
if (string.IsNullOrEmpty(_idempotenceProviderName))
{
throw new ApplicationException(string.Format(Resources.ProviderNameEmpty,
"IdempotenceService"));
}
_idempotenceConnectionString = idempotenceConfiguration.ConnectionString;
if (string.IsNullOrEmpty(_idempotenceConnectionString))
{
throw new ApplicationException(string.Format(Resources.ConnectionStringEmpty,
"IdempotenceService"));
}
Guard.AgainstNull(idempotenceConfiguration, "configuration");
using (
var connection = _databaseContextFactory.Create(_idempotenceProviderName,
_idempotenceConnectionString))
using (var transaction = connection.BeginTransaction())
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.Get(
Script.IdempotenceServiceExists))) != 1)
{
throw new InvalidOperationException(Resources.IdempotenceDatabaseNotConfigured);
}
_databaseGateway.ExecuteUsing(
RawQuery.Create(
_scriptProvider.Get(
Script.IdempotenceInitialize))
.AddParameterValue(IdempotenceColumns.InboxWorkQueueUri,
serviceBusConfiguration.Inbox.WorkQueueUri));
transaction.CommitTransaction();
}
}
