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) { 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) { 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 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(); }
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 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; }