public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null || ServiceBusConfiguration.ServiceBusSection.Modules == null)
{
return;
}
var types = new List<Type>();
foreach (ModuleElement moduleElement in ServiceBusConfiguration.ServiceBusSection.Modules)
{
var type = Type.GetType(moduleElement.Type);
Guard.Against<ESBConfigurationException>(type == null,
string.Format(ESBResources.UnknownTypeException, moduleElement.Type));
types.Add(type);
}
foreach (var type in types)
{
try
{
type.AssertDefaultConstructor(string.Format(ESBResources.DefaultConstructorRequired, "Module", type.FullName));
configuration.Modules.Add((IModule)Activator.CreateInstance(type));
}
catch (Exception ex)
{
throw new ESBConfigurationException(string.Format(ESBResources.ModuleInstantiationException, ex.Message));
}
}
}
public DistributorPipeline(IServiceBusConfiguration configuration, GetWorkMessageObserver getWorkMessageObserver, DeserializeTransportMessageObserver deserializeTransportMessageObserver,
DistributorMessageObserver distributorMessageObserver, SerializeTransportMessageObserver serializeTransportMessageObserver,
DispatchTransportMessageObserver dispatchTransportMessageObserver, AcknowledgeMessageObserver acknowledgeMessageObserver,
DistributorExceptionObserver distributorExceptionObserver)
{
Guard.AgainstNull(configuration, "configuration");
State.SetWorkQueue(configuration.Inbox.WorkQueue);
State.SetErrorQueue(configuration.Inbox.ErrorQueue);
RegisterStage("Distribute")
.WithEvent <OnGetMessage>()
.WithEvent <OnDeserializeTransportMessage>()
.WithEvent <OnAfterDeserializeTransportMessage>()
.WithEvent <OnHandleDistributeMessage>()
.WithEvent <OnAfterHandleDistributeMessage>()
.WithEvent <OnSerializeTransportMessage>()
.WithEvent <OnAfterSerializeTransportMessage>()
.WithEvent <OnDispatchTransportMessage>()
.WithEvent <OnAfterDispatchTransportMessage>()
.WithEvent <OnAcknowledgeMessage>()
.WithEvent <OnAfterAcknowledgeMessage>();
RegisterObserver(getWorkMessageObserver);
RegisterObserver(deserializeTransportMessageObserver);
RegisterObserver(distributorMessageObserver);
RegisterObserver(serializeTransportMessageObserver);
RegisterObserver(dispatchTransportMessageObserver);
RegisterObserver(acknowledgeMessageObserver);
RegisterObserver(distributorExceptionObserver); // must be last
}
public void Apply(IServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null ||
ServiceBusConfiguration.ServiceBusSection.MessageRoutes == null)
{
return;
}
var specificationFactory = new MessageRouteSpecificationFactory();
var provider = configuration.MessageRouteProvider;
foreach (MessageRouteElement mapElement in ServiceBusConfiguration.ServiceBusSection.MessageRoutes)
{
var messageRoute = provider.Find(mapElement.Uri);
if (messageRoute == null)
{
messageRoute = new MessageRoute(configuration.QueueManager.GetQueue(mapElement.Uri));
provider.Add(messageRoute);
}
foreach (SpecificationElement specificationElement in mapElement)
{
messageRoute.AddSpecification(specificationFactory.Create(specificationElement.Name, specificationElement.Value));
}
}
}
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 Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
var section = ServiceBusConfiguration.ServiceBusSection;
if (section == null)
{
configuration.RemoveMessagesNotHandled = false;
return;
}
configuration.CreateQueues = section.CreateQueues;
configuration.CacheIdentity = section.CacheIdentity;
configuration.RegisterHandlers = section.RegisterHandlers;
configuration.RemoveMessagesNotHandled = section.RemoveMessagesNotHandled;
configuration.CompressionAlgorithm = section.CompressionAlgorithm;
configuration.EncryptionAlgorithm = section.EncryptionAlgorithm;
var transactionScopeElement = section.TransactionScope;
configuration.TransactionScope = transactionScopeElement != null
? new TransactionScopeConfiguration
{
Enabled = transactionScopeElement.Enabled,
IsolationLevel = transactionScopeElement.IsolationLevel,
TimeoutSeconds = transactionScopeElement.TimeoutSeconds
}
: new TransactionScopeConfiguration();
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusSection.Get() == null ||
ServiceBusSection.Get().MessageRoutes == null)
{
return;
}
foreach (MessageRouteElement mapElement in ServiceBusSection.Get().MessageRoutes)
{
var messageRoute = new MessageRouteConfiguration(mapElement.Uri);
foreach (SpecificationElement specificationElement in mapElement)
{
messageRoute.AddSpecification(specificationElement.Name, specificationElement.Value);
}
if (messageRoute.Specifications.Any())
{
configuration.AddMessageRoute(messageRoute);
}
}
}
public void CreatePhysicalQueues(IServiceBusConfiguration serviceBusConfiguration, QueueCreationType queueCreationType)
{
if (queueCreationType == QueueCreationType.None)
{
return;
}
if (serviceBusConfiguration.HasInbox)
{
CreateQueues(queueCreationType, serviceBusConfiguration.Inbox);
}
if (serviceBusConfiguration.HasOutbox)
{
CreateQueues(queueCreationType, serviceBusConfiguration.Outbox);
}
if (serviceBusConfiguration.HasControlInbox)
{
CreateQueues(queueCreationType, serviceBusConfiguration.ControlInbox);
}
if (serviceBusConfiguration.IsWorker)
{
if (ShouldCreate(queueCreationType, serviceBusConfiguration.Worker.DistributorControlInboxWorkQueue))
{
CreatePhysicalQueue(serviceBusConfiguration.Worker.DistributorControlInboxWorkQueue);
}
}
}
public DeferredMessagePipeline(IServiceBusConfiguration configuration,
IGetDeferredMessageObserver getDeferredMessageObserver,
IDeserializeTransportMessageObserver deserializeTransportMessageObserver,
IProcessDeferredMessageObserver processDeferredMessageObserver)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(getDeferredMessageObserver, nameof(getDeferredMessageObserver));
Guard.AgainstNull(deserializeTransportMessageObserver, nameof(deserializeTransportMessageObserver));
Guard.AgainstNull(processDeferredMessageObserver, nameof(processDeferredMessageObserver));
State.SetWorkQueue(configuration.Inbox.WorkQueue);
State.SetErrorQueue(configuration.Inbox.ErrorQueue);
State.SetDeferredQueue(configuration.Inbox.DeferredQueue);
RegisterStage("Process")
.WithEvent <OnGetMessage>()
.WithEvent <OnDeserializeTransportMessage>()
.WithEvent <OnAfterDeserializeTransportMessage>()
.WithEvent <OnProcessDeferredMessage>()
.WithEvent <OnAfterProcessDeferredMessage>();
RegisterObserver(getDeferredMessageObserver);
RegisterObserver(deserializeTransportMessageObserver);
RegisterObserver(processDeferredMessageObserver);
}
public DistributorPipeline(IServiceBusConfiguration configuration,
IEnumerable <IPipelineObserver> observers)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(observers, nameof(observers));
var list = observers.ToList();
State.SetWorkQueue(configuration.Inbox.WorkQueue);
State.SetErrorQueue(configuration.Inbox.ErrorQueue);
RegisterStage("Distribute")
.WithEvent <OnGetMessage>()
.WithEvent <OnDeserializeTransportMessage>()
.WithEvent <OnAfterDeserializeTransportMessage>()
.WithEvent <OnHandleDistributeMessage>()
.WithEvent <OnAfterHandleDistributeMessage>()
.WithEvent <OnSerializeTransportMessage>()
.WithEvent <OnAfterSerializeTransportMessage>()
.WithEvent <OnDispatchTransportMessage>()
.WithEvent <OnAfterDispatchTransportMessage>()
.WithEvent <OnAcknowledgeMessage>()
.WithEvent <OnAfterAcknowledgeMessage>();
RegisterObserver(list.Get <IGetWorkMessageObserver>());
RegisterObserver(list.Get <IDeserializeTransportMessageObserver>());
RegisterObserver(list.Get <IDistributorMessageObserver>());
RegisterObserver(list.Get <ISerializeTransportMessageObserver>());
RegisterObserver(list.Get <IDispatchTransportMessageObserver>());
RegisterObserver(list.Get <IAcknowledgeMessageObserver>());
RegisterObserver(list.Get <IDistributorExceptionObserver>()); // must be last
}
public OutboxPipeline(IServiceBusConfiguration configuration, GetWorkMessageObserver getWorkMessageObserver,
DeserializeTransportMessageObserver deserializeTransportMessageObserver,
SendOutboxMessageObserver sendOutboxMessageObserver, AcknowledgeMessageObserver acknowledgeMessageObserver,
OutboxExceptionObserver outboxExceptionObserver)
{
Guard.AgainstNull(configuration, nameof(configuration));
State.SetWorkQueue(configuration.Outbox.WorkQueue);
State.SetErrorQueue(configuration.Outbox.ErrorQueue);
State.SetDurationToIgnoreOnFailure(configuration.Outbox.DurationToIgnoreOnFailure);
State.SetMaximumFailureCount(configuration.Outbox.MaximumFailureCount);
RegisterStage("Read")
.WithEvent <OnGetMessage>()
.WithEvent <OnAfterGetMessage>()
.WithEvent <OnDeserializeTransportMessage>()
.WithEvent <OnAfterDeserializeTransportMessage>();
RegisterStage("Send")
.WithEvent <OnDispatchTransportMessage>()
.WithEvent <OnAfterDispatchTransportMessage>()
.WithEvent <OnAcknowledgeMessage>()
.WithEvent <OnAfterAcknowledgeMessage>();
RegisterObserver(getWorkMessageObserver);
RegisterObserver(deserializeTransportMessageObserver);
RegisterObserver(sendOutboxMessageObserver);
RegisterObserver(acknowledgeMessageObserver);
RegisterObserver(outboxExceptionObserver); // must be last
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null
||
ServiceBusConfiguration.ServiceBusSection.Outbox == null
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Outbox.WorkQueueUri))
{
return;
}
configuration.Outbox =
new OutboxQueueConfiguration
{
WorkQueue = configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Outbox.WorkQueueUri),
ErrorQueue = configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Outbox.ErrorQueueUri),
MaximumFailureCount = ServiceBusConfiguration.ServiceBusSection.Outbox.MaximumFailureCount,
DurationToIgnoreOnFailure =
ServiceBusConfiguration.ServiceBusSection.Outbox.DurationToIgnoreOnFailure ?? ServiceBusConfiguration.DefaultDurationToIgnoreOnFailure,
DurationToSleepWhenIdle =
ServiceBusConfiguration.ServiceBusSection.Outbox.DurationToSleepWhenIdle ?? ServiceBusConfiguration.DefaultDurationToSleepWhenIdle,
ThreadCount = ServiceBusConfiguration.ServiceBusSection.Inbox.ThreadCount
};
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
var section = ServiceBusConfiguration.ServiceBusSection;
if (section == null)
{
configuration.RemoveMessagesNotHandled = false;
return;
}
configuration.CreateQueues = section.CreateQueues;
configuration.RemoveMessagesNotHandled = section.RemoveMessagesNotHandled;
configuration.CompressionAlgorithm = section.CompressionAlgorithm;
configuration.EncryptionAlgorithm = section.EncryptionAlgorithm;
var transactionScopeElement = section.TransactionScope;
configuration.TransactionScope = transactionScopeElement != null
? new TransactionScopeConfiguration
{
Enabled = transactionScopeElement.Enabled,
IsolationLevel = transactionScopeElement.IsolationLevel,
TimeoutSeconds = transactionScopeElement.TimeoutSeconds
}
: new TransactionScopeConfiguration();
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusSection.Get() == null
||
ServiceBusSection.Get().Outbox == null
||
string.IsNullOrEmpty(ServiceBusSection.Get().Outbox.WorkQueueUri))
{
return;
}
configuration.Outbox =
new OutboxQueueConfiguration
{
WorkQueueUri = ServiceBusSection.Get().Outbox.WorkQueueUri,
ErrorQueueUri = ServiceBusSection.Get().Outbox.ErrorQueueUri,
MaximumFailureCount = ServiceBusSection.Get().Outbox.MaximumFailureCount,
DurationToIgnoreOnFailure =
ServiceBusSection.Get().Outbox.DurationToIgnoreOnFailure ??
ServiceBusConfiguration.DefaultDurationToIgnoreOnFailure,
DurationToSleepWhenIdle =
ServiceBusSection.Get().Outbox.DurationToSleepWhenIdle ??
ServiceBusConfiguration.DefaultDurationToSleepWhenIdle,
ThreadCount = ServiceBusSection.Get().Inbox.ThreadCount
};
}
public InboxMessagePipeline(IServiceBusConfiguration configuration,
GetWorkMessageObserver getWorkMessageObserver,
DeserializeTransportMessageObserver deserializeTransportMessageObserver,
DeferTransportMessageObserver deferTransportMessageObserver,
DeserializeMessageObserver deserializeMessageObserver, DecryptMessageObserver decryptMessageObserver,
DecompressMessageObserver decompressMessageObserver,
AssessMessageHandlingObserver assessMessageHandlingObserver, IdempotenceObserver idempotenceObserver,
HandleMessageObserver handleMessageObserver, TransactionScopeObserver transactionScopeObserver,
AcknowledgeMessageObserver acknowledgeMessageObserver,
SendDeferredObserver sendDeferredObserver, ReceiveExceptionObserver receiveExceptionObserver)
: base(
getWorkMessageObserver, deserializeTransportMessageObserver, deferTransportMessageObserver,
deserializeMessageObserver, decryptMessageObserver, decompressMessageObserver,
assessMessageHandlingObserver, idempotenceObserver, handleMessageObserver, transactionScopeObserver,
acknowledgeMessageObserver, sendDeferredObserver, receiveExceptionObserver)
{
Guard.AgainstNull(configuration, nameof(configuration));
State.SetWorkQueue(configuration.Inbox.WorkQueue);
State.SetDeferredQueue(configuration.Inbox.DeferredQueue);
State.SetErrorQueue(configuration.Inbox.ErrorQueue);
State.SetDurationToIgnoreOnFailure(configuration.Inbox.DurationToIgnoreOnFailure);
State.SetMaximumFailureCount(configuration.Inbox.MaximumFailureCount);
}
public TransportMessage TransportMessage(IServiceBusConfiguration configuration)
{
if (_local && !configuration.HasInbox)
{
throw new InvalidOperationException(EsbResources.SendToSelfException);
}
var identity = WindowsIdentity.GetCurrent();
var result = new TransportMessage
{
RecipientInboxWorkQueueUri = _local ? configuration.Inbox.WorkQueue.Uri.ToString() : _recipientInboxWorkQueueUri,
SenderInboxWorkQueueUri = string.IsNullOrEmpty(_sendInboxWorkQueueUri)
? configuration.HasInbox
? configuration.Inbox.WorkQueue.Uri.ToString()
: string.Empty
: _sendInboxWorkQueueUri,
PrincipalIdentityName = identity != null
? identity.Name
: WindowsIdentity.GetAnonymous().Name,
IgnoreTillDate = _ignoreTillDate,
ExpiryDate = _expiryDate,
MessageType = Message.GetType().FullName,
AssemblyQualifiedName = Message.GetType().AssemblyQualifiedName,
EncryptionAlgorithm = configuration.EncryptionAlgorithm,
CompressionAlgorithm = configuration.CompressionAlgorithm,
MessageReceivedId = HasTransportMessageReceived ? _transportMessageReceived.MessageId : Guid.Empty,
CorrelationId = _correlationId,
SendDate = DateTime.Now
};
result.Headers.Merge(Headers);
return(result);
}
public void CreatePhysicalQueues(IServiceBusConfiguration serviceBusConfiguration, QueueCreationType queueCreationType)
{
if (queueCreationType == QueueCreationType.None)
{
return;
}
if (serviceBusConfiguration.HasInbox)
{
CreateQueues(queueCreationType, serviceBusConfiguration.Inbox);
}
if (serviceBusConfiguration.HasOutbox)
{
CreateQueues(queueCreationType, serviceBusConfiguration.Outbox);
}
if (serviceBusConfiguration.HasControlInbox)
{
CreateQueues(queueCreationType, serviceBusConfiguration.ControlInbox);
}
if (serviceBusConfiguration.IsWorker)
{
if (ShouldCreate(queueCreationType, serviceBusConfiguration.Worker.DistributorControlInboxWorkQueue))
{
CreatePhysicalQueue(serviceBusConfiguration.Worker.DistributorControlInboxWorkQueue);
}
}
}
public void CreatePhysicalQueues(IServiceBusConfiguration serviceBusConfiguration)
{
if (serviceBusConfiguration.HasInbox)
{
CreateQueues(serviceBusConfiguration.Inbox);
if (serviceBusConfiguration.HasDeferredQueue)
{
serviceBusConfiguration.Inbox.DeferredQueue.AttemptCreate();
}
}
if (serviceBusConfiguration.HasOutbox)
{
CreateQueues(serviceBusConfiguration.Outbox);
}
if (serviceBusConfiguration.HasControlInbox)
{
CreateQueues(serviceBusConfiguration.ControlInbox);
}
if (serviceBusConfiguration.IsWorker)
{
serviceBusConfiguration.Worker.DistributorControlInboxWorkQueue.AttemptCreate();
}
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null
||
ServiceBusConfiguration.ServiceBusSection.Inbox == null
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Inbox.WorkQueueUri))
{
return;
}
configuration.Inbox =
new InboxQueueConfiguration
{
WorkQueue = configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Inbox.WorkQueueUri),
ErrorQueue = configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Inbox.ErrorQueueUri),
ThreadCount = ServiceBusConfiguration.ServiceBusSection.Inbox.ThreadCount,
MaximumFailureCount = ServiceBusConfiguration.ServiceBusSection.Inbox.MaximumFailureCount,
DurationToIgnoreOnFailure =
ServiceBusConfiguration.ServiceBusSection.Inbox.DurationToIgnoreOnFailure ??
ServiceBusConfiguration.DefaultDurationToIgnoreOnFailure,
DurationToSleepWhenIdle =
ServiceBusConfiguration.ServiceBusSection.Inbox.DurationToSleepWhenIdle ??
ServiceBusConfiguration.DefaultDurationToSleepWhenIdle,
Distribute = ServiceBusConfiguration.ServiceBusSection.Inbox.Distribute,
DistributeSendCount = ServiceBusConfiguration.ServiceBusSection.Inbox.DistributeSendCount,
DeferredQueue =
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Inbox.DeferredQueueUri)
? null
: configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Inbox.DeferredQueueUri)
};
}
public void Apply(IServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null ||
ServiceBusConfiguration.ServiceBusSection.MessageRoutes == null)
{
return;
}
var specificationFactory = new MessageRouteSpecificationFactory();
var provider = configuration.MessageRouteProvider;
foreach (MessageRouteElement mapElement in ServiceBusConfiguration.ServiceBusSection.MessageRoutes)
{
var messageRoute = provider.Find(mapElement.Uri);
if (messageRoute == null)
{
messageRoute = new MessageRoute(configuration.QueueManager.GetQueue(mapElement.Uri));
provider.Add(messageRoute);
}
foreach (SpecificationElement specificationElement in mapElement)
{
messageRoute.AddSpecification(specificationFactory.Create(specificationElement.Name, specificationElement.Value));
}
}
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null)
{
return;
}
var controlInboxElement = ServiceBusConfiguration.ServiceBusSection.ControlInbox;
if (controlInboxElement == null
||
string.IsNullOrEmpty(controlInboxElement.WorkQueueUri)
||
string.IsNullOrEmpty(controlInboxElement.ErrorQueueUri))
{
return;
}
configuration.ControlInbox =
new ControlInboxQueueConfiguration
{
WorkQueue = configuration.QueueManager.GetQueue(controlInboxElement.WorkQueueUri),
ErrorQueue = configuration.QueueManager.GetQueue(controlInboxElement.ErrorQueueUri),
ThreadCount = controlInboxElement.ThreadCount,
MaximumFailureCount = controlInboxElement.MaximumFailureCount,
DurationToIgnoreOnFailure =
controlInboxElement.DurationToIgnoreOnFailure ?? ServiceBusConfiguration.DefaultDurationToIgnoreOnFailure,
DurationToSleepWhenIdle =
controlInboxElement.DurationToSleepWhenIdle ?? ServiceBusConfiguration.DefaultDurationToSleepWhenIdle
};
}
public OutboxPipeline(IServiceBusConfiguration configuration, IEnumerable <IPipelineObserver> observers)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(observers, nameof(observers));
var list = observers.ToList();
State.SetWorkQueue(configuration.Outbox.WorkQueue);
State.SetErrorQueue(configuration.Outbox.ErrorQueue);
State.SetDurationToIgnoreOnFailure(configuration.Outbox.DurationToIgnoreOnFailure);
State.SetMaximumFailureCount(configuration.Outbox.MaximumFailureCount);
RegisterStage("Read")
.WithEvent <OnGetMessage>()
.WithEvent <OnAfterGetMessage>()
.WithEvent <OnDeserializeTransportMessage>()
.WithEvent <OnAfterDeserializeTransportMessage>();
RegisterStage("Send")
.WithEvent <OnDispatchTransportMessage>()
.WithEvent <OnAfterDispatchTransportMessage>()
.WithEvent <OnAcknowledgeMessage>()
.WithEvent <OnAfterAcknowledgeMessage>();
RegisterObserver(list.Get <IGetWorkMessageObserver>());
RegisterObserver(list.Get <IDeserializeTransportMessageObserver>());
RegisterObserver(list.Get <ISendOutboxMessageObserver>());
RegisterObserver(list.Get <IAcknowledgeMessageObserver>());
RegisterObserver(list.Get <IOutboxExceptionObserver>()); // must be last
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null)
{
return;
}
var controlInboxElement = ServiceBusConfiguration.ServiceBusSection.ControlInbox;
if (controlInboxElement == null
||
string.IsNullOrEmpty(controlInboxElement.WorkQueueUri)
||
string.IsNullOrEmpty(controlInboxElement.ErrorQueueUri))
{
return;
}
configuration.ControlInbox =
new ControlInboxQueueConfiguration
{
WorkQueue = configuration.QueueManager.GetQueue(controlInboxElement.WorkQueueUri),
ErrorQueue = configuration.QueueManager.GetQueue(controlInboxElement.ErrorQueueUri),
ThreadCount = controlInboxElement.ThreadCount,
MaximumFailureCount = controlInboxElement.MaximumFailureCount,
DurationToIgnoreOnFailure =
controlInboxElement.DurationToIgnoreOnFailure ?? ServiceBusConfiguration.DefaultDurationToIgnoreOnFailure,
DurationToSleepWhenIdle =
controlInboxElement.DurationToSleepWhenIdle ?? ServiceBusConfiguration.DefaultDurationToSleepWhenIdle
};
}
public PurgeInboxObserver(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, nameof(configuration));
_configuration = configuration;
_log = Log.For(this);
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null || ServiceBusConfiguration.ServiceBusSection.Modules == null)
{
return;
}
var types = new List <Type>();
foreach (ModuleElement moduleElement in ServiceBusConfiguration.ServiceBusSection.Modules)
{
var type = Type.GetType(moduleElement.Type);
Guard.Against <EsbConfigurationException>(type == null,
string.Format(EsbResources.UnknownTypeException, moduleElement.Type));
types.Add(type);
}
foreach (var type in types)
{
try
{
type.AssertDefaultConstructor(string.Format(EsbResources.DefaultConstructorRequired, "Module", type.FullName));
configuration.Modules.Add((IModule)Activator.CreateInstance(type));
}
catch (Exception ex)
{
throw new EsbConfigurationException(string.Format(EsbResources.ModuleInstantiationException, ex.Message));
}
}
}
public DeferTransportMessageObserver(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
_configuration = configuration;
_log = Log.For(this);
}
public ServiceBusContext(IServiceBusConfiguration configuration, ILogger logger)
{
_configuration = configuration;
_logger = logger;
//Initialize the queue with custom settings
_namespaceManager = NamespaceManager.CreateFromConnectionString(configuration.ConnectionString);
}
public AzureServiceBusEndpointFactory(IServiceBusConfiguration configuration, IEnumerable <IMessageEnricher> enrichers)
{
Guard.Against.Null(configuration, nameof(configuration));
Guard.Against.Null(enrichers, nameof(enrichers));
_configuration = configuration;
_enrichers = enrichers;
}
public AzureServiceBusEndpointFactory(IServiceBusConfiguration configuration, IServiceProvider serviceProvider)
{
Guard.Against.Null(configuration, nameof(configuration));
Guard.Against.Null(serviceProvider, nameof(serviceProvider));
_configuration = configuration;
_serviceProvider = serviceProvider;
}
public AssembleMessageObserver(IServiceBusConfiguration configuration, IIdentityProvider identityProvider)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(identityProvider, nameof(identityProvider));
_configuration = configuration;
_identityProvider = identityProvider;
}
public WorkerAvailableHandler(IServiceBusConfiguration configuration, IWorkerAvailabilityManager workerAvailabilityManager)
{
Guard.AgainstNull(workerAvailabilityManager, nameof(workerAvailabilityManager));
Guard.AgainstNull(configuration, nameof(configuration));
_configuration = configuration;
_workerAvailabilityManager = workerAvailabilityManager;
}
public ServiceBusTransport(IServiceBusConfiguration configuration)
{
TransportChannelFactories = new ITransportChannelFactory[]
{
new ServiceBusQueueChannelFactory(configuration),
new ServiceBusTopicChannelFactory(configuration)
};
}
public ServiceBusStartupObserver(IServiceBus bus)
{
Guard.AgainstNull(bus, "bus");
_bus = bus;
_configuration = _bus.Configuration;
_log = Log.For(this);
}
public MessagePublisher(IServiceBusConfiguration serviceBusConfiguration)
{
_serviceBusConfiguration = serviceBusConfiguration;
_jsonSerializerSettings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
_topicClients = new Dictionary <string, ITopicClient>();
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
foreach (var configurator in _configurators)
{
configurator.Apply(configuration);
}
}
public QueueClientFactory(IServiceBusConfiguration serviceBusConfiguration)
{
_serviceBusConnectionString = new ServiceBusConnectionStringBuilder
{
Endpoint = serviceBusConfiguration.Endpoint,
SasKeyName = serviceBusConfiguration.SharedAccessKeyName,
SasKey = serviceBusConfiguration.SharedAccessKeyToken
}.GetNamespaceConnectionString();
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
foreach (var configurator in _configurators)
{
configurator.Apply(configuration);
}
}
internal ServiceBus(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
log = Log.For(this);
Configuration = configuration;
Events = new ServiceBusEvents();
}
public ServiceBus(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
Configuration = configuration;
Events = new ServiceBusEvents();
_messageSender = new MessageSender(this);
}
public ServiceBus(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
Configuration = configuration;
Events = new ServiceBusEvents();
_messageSender = new MessageSender(this);
}
public DefaultMessageHandlerInvoker(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, nameof(configuration));
_configuration = configuration;
_pipelineFactory = configuration.Resolver.Resolve <IPipelineFactory>();
_subscriptionManager = configuration.Resolver.Resolve <ISubscriptionManager>();
_transportMessageFactory = configuration.Resolver.Resolve <ITransportMessageFactory>();
}
public void Apply(IServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null ||
ServiceBusConfiguration.ServiceBusSection.UriResolver == null)
{
return;
}
foreach (UriResolverItemElement uriRepositoryItemElement in ServiceBusConfiguration.ServiceBusSection.UriResolver)
{
configuration.UriResolver.Add(uriRepositoryItemElement.Name.ToLower(), new Uri(uriRepositoryItemElement.Uri));
}
}
public void Apply(IServiceBusConfiguration configuration)
{
Guard.AgainstNull(configuration, "configuration");
if (ServiceBusConfiguration.ServiceBusSection == null
||
ServiceBusConfiguration.ServiceBusSection.Worker == null
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Worker.DistributorControlWorkQueueUri))
{
return;
}
configuration.Worker =
new WorkerConfiguration(configuration.QueueManager.CreateQueue(
ServiceBusConfiguration.ServiceBusSection.Worker.DistributorControlWorkQueueUri),
ServiceBusConfiguration.ServiceBusSection.Worker.ThreadAvailableNotificationIntervalSeconds);
}
public void CreatePhysicalQueues(IServiceBusConfiguration configuration)
{
if (configuration.HasInbox)
{
CreateQueues(configuration.Inbox);
if (configuration.Inbox.HasDeferredQueue)
{
configuration.Inbox.DeferredQueue.AttemptCreate();
}
}
if (configuration.HasOutbox)
{
CreateQueues(configuration.Outbox);
}
if (configuration.HasControlInbox)
{
CreateQueues(configuration.ControlInbox);
}
}
public void Apply(IServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null ||
ServiceBusConfiguration.ServiceBusSection.QueueFactories == null)
{
return;
}
foreach (QueueFactoryElement queueFactoryElement in ServiceBusConfiguration.ServiceBusSection.QueueFactories)
{
var type = Type.GetType(queueFactoryElement.Type);
Guard.Against<ESBConfigurationException>(type == null,
string.Format(ESBResources.UnknownTypeException, queueFactoryElement.Type));
configuration.QueueManager.RegisterQueueFactory(type);
}
if (ServiceBusConfiguration.ServiceBusSection.QueueFactories.Scan)
{
configuration.QueueManager.ScanForQueueFactories();
}
}
public void Initialize(IServiceBus bus)
{
serviceBusConfiguration = bus.Configuration;
using (databaseConnectionFactory.Create(SubscriptionDataSource))
{
if (databaseGateway.GetScalarUsing<int>(
SubscriptionDataSource,
RawQuery.CreateFrom(
scriptProvider.GetScript(
Script.SubscriptionManagerExists))) != 1)
{
throw new SubscriptionManagerException(SqlResources.SubscriptionManagerDatabaseNotConfigured);
}
}
if (HasDeferredSubscriptions)
{
Subscribe(deferredSubscriptions);
}
}
public ServiceBusBuilder WithConfiguration(IServiceBusConfiguration serviceBusConfiguration)
{
serviceBusConfiguration.Configure(this.serviceBusResolver);
return this;
}
public TransportMessage TransportMessage(IServiceBusConfiguration configuration)
{
if (_local && !configuration.HasInbox)
{
throw new InvalidOperationException(ESBResources.SendToSelfException);
}
var identity = WindowsIdentity.GetCurrent();
var result = new TransportMessage
{
RecipientInboxWorkQueueUri = _local ? configuration.Inbox.WorkQueue.Uri.ToString() : _recipientInboxWorkQueueUri,
SenderInboxWorkQueueUri = configuration.HasInbox
? configuration.Inbox.WorkQueue.Uri.ToString()
: string.Empty,
PrincipalIdentityName = identity != null
? identity.Name
: WindowsIdentity.GetAnonymous().Name,
IgnoreTillDate = _ignoreTillDate,
MessageType = Message.GetType().FullName,
AssemblyQualifiedName = Message.GetType().AssemblyQualifiedName,
EncryptionAlgorithm = configuration.EncryptionAlgorithm,
CompressionAlgorithm = configuration.CompressionAlgorithm,
MessageReceivedId = HasTransportMessageReceived ? _transportMessageReceived.MessageId : Guid.Empty,
CorrelationId = _correlationId,
SendDate = DateTime.Now
};
result.Headers.Merge(Headers);
return result;
}
public ConfigurationAvailableEventArgs(IServiceBusConfiguration configuration)
{
Configuration = configuration;
}
