public static string GetConnectionString(ReadOnlySettings settings)
{
Contract.Requires(settings != null);
Contract.Ensures(!string.IsNullOrWhiteSpace(Contract.Result<string>()));
if (settings.HasSetting(MongoPersistenceConstants.ConnectionStringKey))
{
var connectionString =
settings.Get<string>(MongoPersistenceConstants.ConnectionStringKey).AssumedNotNullOrWhiteSpace();
return connectionString;
}
if (ConfigurationManager.ConnectionStrings[MongoPersistenceConstants.DefaultConnectionStringName] != null)
{
Logger.InfoFormat(
"Using connection string from {0}",
MongoPersistenceConstants.DefaultConnectionStringName);
return GetConnectionStringFromConfig(MongoPersistenceConstants.DefaultConnectionStringName);
}
Logger.InfoFormat("Using connection string from {0}", MongoPersistenceConstants.FallbackConnectionStringName);
return GetConnectionStringFromConfig(MongoPersistenceConstants.FallbackConnectionStringName);
}
/// <summary>
/// Provides a factory method for building a message serializer.
/// </summary>
public override Func<IMessageMapper, IMessageSerializer> Configure(ReadOnlySettings settings)
{
return mapper =>
{
var conventions = settings.Get<Conventions>();
var serializer = new XmlMessageSerializer(mapper, conventions);
string customNamespace;
if (settings.TryGet(CustomNamespaceConfigurationKey, out customNamespace))
{
serializer.Namespace = customNamespace;
}
bool skipWrappingRawXml;
if (settings.TryGet(SkipWrappingRawXml, out skipWrappingRawXml))
{
serializer.SkipWrappingRawXml = skipWrappingRawXml;
}
bool sanitizeInput;
if (settings.TryGet(SanitizeInput, out sanitizeInput))
{
serializer.SanitizeInput = sanitizeInput;
}
var registry = settings.Get<MessageMetadataRegistry>();
var messageTypes = registry.GetAllMessages().Select(m => m.MessageType);
serializer.Initialize(messageTypes);
return serializer;
};
}
void ApplyConventions(ReadOnlySettings settings)
{
docStore.Conventions.FindTypeTagName = BackwardsCompatibilityHelper.LegacyFindTypeTagName;
var store = docStore as DocumentStore;
if (store == null)
{
return;
}
// Source: https://github.com/ravendb/ravendb/blob/f56963f23f54b5535eba4f043fb84d5145b11b1d/Raven.Client.Lightweight/Document/DocumentStore.cs#L129
var ravenDefaultResourceManagerId = new Guid("e749baa6-6f76-4eef-a069-40a4378954f8");
if (store.ResourceManagerId != ravenDefaultResourceManagerId)
{
Logger.Warn("Overriding user-specified documentStore.ResourceManagerId. It's no longer necessary to set this value while using NServiceBus.RavenDB persistence. Consider using busConfiguration.CustomizeDocumentStore(Action<IDocumentStore customize) if this is absolutely necessary, but it is not recommended.");
}
if (!(store.TransactionRecoveryStorage is VolatileOnlyTransactionRecoveryStorage))
{
Logger.Warn("Overriding user-specified documentStore.TransactionRecoveryStorage. It's no longer necessary to set this value while using NServiceBus.RavenDB persistence. Consider using busConfiguration.CustomizeDocumentStore(Action<IDocumentStore customize) if this is absolutely necessary, but it is not recommended.");
}
var resourceManagerId = settings.Get<string>("NServiceBus.LocalAddress") + "-" + settings.Get<string>("EndpointVersion");
store.ResourceManagerId = DeterministicGuidBuilder(resourceManagerId);
string path = $@"%LOCALAPPDATA%\NServiceBus.RavenDB\{store.ResourceManagerId}";
store.TransactionRecoveryStorage = new LocalDirectoryTransactionRecoveryStorage(path);
bool suppressDistributedTransactions;
if (settings.TryGet("Transactions.SuppressDistributedTransactions", out suppressDistributedTransactions) && suppressDistributedTransactions)
{
store.EnlistInDistributedTransactions = false;
}
}
public HeartbeatStartup(IDispatchMessages messageDispatcher, ReadOnlySettings settings)
{
backend = new ServiceControlBackend(messageDispatcher, settings);
endpointName = settings.EndpointName();
HostId = settings.Get<Guid>("NServiceBus.HostInformation.HostId");
Host = settings.Get<string>("NServiceBus.HostInformation.DisplayName");
Properties = settings.Get<Dictionary<string, string>>("NServiceBus.HostInformation.Properties");
var interval = ConfigurationManager.AppSettings["Heartbeat/Interval"];
if (!string.IsNullOrEmpty(interval))
{
heartbeatInterval = TimeSpan.Parse(interval);
}
else if (settings.HasSetting("ServiceControl.Heartbeat.Interval"))
{
heartbeatInterval = settings.Get<TimeSpan>("ServiceControl.Heartbeat.Interval");
}
ttlTimeSpan = TimeSpan.FromTicks(heartbeatInterval.Ticks*4); // Default ttl
var ttl = ConfigurationManager.AppSettings["Heartbeat/TTL"];
if (!string.IsNullOrEmpty(ttl))
{
ttlTimeSpan = TimeSpan.Parse(ttl);
}
else if (settings.HasSetting("ServiceControl.Heartbeat.Ttl"))
{
ttlTimeSpan = settings.Get<TimeSpan>("ServiceControl.Heartbeat.Ttl");
}
}
public HandledMessageInfoSubscriber(IDataBackplaneClient dataBackplane, ReadOnlySettings settings, TimeSpan sweepPeriod, TimeSpan heartbeatTimeout)
{
this.dataBackplane = dataBackplane;
this.settings = settings;
this.sweepPeriod = sweepPeriod;
this.heartbeatTimeout = heartbeatTimeout;
}
public SerializationMapper(IMessageMapper mapper,Conventions conventions, ReadOnlySettings settings)
{
jsonSerializer = new JsonMessageSerializer(mapper);
xmlSerializer = new XmlMessageSerializer(mapper, conventions);
List<Type> messageTypes = settings.GetAvailableTypes().Where(conventions.IsMessageType).ToList();
xmlSerializer.Initialize(messageTypes);
}
public CustomChecksStartup(IEnumerable<ICustomCheck> customChecks, ReadOnlySettings settings, CriticalError criticalError, IDispatchMessages dispatcher)
{
dispatchMessages = dispatcher;
this.criticalError = criticalError;
this.settings = settings;
this.customChecks = customChecks.ToList();
}
internal void EnsureDocStoreCreated(ReadOnlySettings settings)
{
if (docStore == null)
{
docStore = storeCreator(settings);
}
}
static IEnumerable<Type> ISpecifyMessageHandlerOrdering(ReadOnlySettings settings)
{
var types = new List<Type>();
settings.GetAvailableTypes().Where(TypeSpecifiesMessageHandlerOrdering)
.ToList().ForEach(t =>
{
Logger.DebugFormat("Going to ask for message handler ordering from '{0}'.", t);
var order = new Order();
((ISpecifyMessageHandlerOrdering) Activator.CreateInstance(t)).SpecifyOrder(order);
order.Types.ToList().ForEach(ht =>
{
if (types.Contains(ht))
{
throw new ConfigurationErrorsException(string.Format("The order in which the type '{0}' should be invoked was already specified by a previous implementor of ISpecifyMessageHandlerOrdering. Check the debug logs to see which other specifiers have been invoked.", ht));
}
});
types.AddRange(order.Types);
});
return types;
}
private static List<Type> GetSagaTypes(ReadOnlySettings settings)
{
var sagaDataTypes =
settings.GetAvailableTypes()
.Where(t => typeof (IContainSagaData).IsAssignableFrom(t) && !t.IsInterface)
.ToList();
return sagaDataTypes;
}
void IsTransactional(ReadOnlySettings readOnlySettings)
{
#region 5to6IsTransactional
bool isTransactional = readOnlySettings.GetRequiredTransactionModeForReceives() != TransportTransactionMode.None;
#endregion
}
void SuppressDistributedTransactions(ReadOnlySettings readOnlySettings)
{
#region 5to6SuppressDistributedTransactions
bool suppressDistributedTransactions = readOnlySettings.GetRequiredTransactionModeForReceives() != TransportTransactionMode.TransactionScope;
#endregion
}
public static Func<IDbConnection> GetConnectionFactory(ReadOnlySettings settings)
{
var holder = settings.Get<ConnectionFactoryHolder>();
if (holder.ConnectionFactory != null) return holder.ConnectionFactory;
var connectionFactory = CreateConnectionFactory();
holder.ConnectionFactory = connectionFactory;
return holder.ConnectionFactory;
}
/// <summary>
/// <see cref="SerializationDefinition.Configure"/>
/// </summary>
public override Func<IMessageMapper, IMessageSerializer> Configure(ReadOnlySettings settings)
{
return mapper =>
{
var options = settings.GetOptions();
var contentTypeKey = settings.GetContentTypeKey();
return new WireMessageSerializer(contentTypeKey, options);
};
}
internal void ApplyContainerRegistration(ReadOnlySettings settings, IConfigureComponents container)
{
if (!IsEnabled(settings) || factoryMethod != null)
{
return;
}
container.ConfigureComponent(BehaviorType, DependencyLifecycle.InstancePerCall);
}
internal static bool GetDurableMessagesEnabled(ReadOnlySettings settings)
{
bool durableMessagesEnabled;
if (settings.TryGet("Endpoint.DurableMessages", out durableMessagesEnabled))
{
return durableMessagesEnabled;
}
return true;
}
internal TransactionSettings(ReadOnlySettings settings)
{
MaxRetries = 5;
IsTransactional = settings.Get<bool>("Transactions.Enabled");
TransactionTimeout = settings.Get<TimeSpan>("Transactions.DefaultTimeout");
IsolationLevel = settings.Get<IsolationLevel>("Transactions.IsolationLevel");
SuppressDistributedTransactions = settings.Get<bool>("Transactions.SuppressDistributedTransactions");
DoNotWrapHandlersExecutionInATransactionScope = settings.Get<bool>("Transactions.DoNotWrapHandlersExecutionInATransactionScope");
}
string GetInstallationUserName(ReadOnlySettings settings)
{
string username;
if (settings.TryGet(UsernameKey, out username))
{
return username;
}
return WindowsIdentity.GetCurrent().Name;
}
/// <summary>
/// Creates an instance of <see cref="TransportReceiver"/>
/// </summary>
/// <param name="transactionSettings">The transaction settings to use for this <see cref="TransportReceiver"/>.</param>
/// <param name="maximumConcurrencyLevel">The maximum number of messages to process in parallel.</param>
/// <param name="maximumThroughput">The maximum throughput per second, 0 means unlimited.</param>
/// <param name="receiver">The <see cref="IDequeueMessages"/> instance to use.</param>
/// <param name="manageMessageFailures">The <see cref="IManageMessageFailures"/> instance to use.</param>
/// <param name="settings">The current settings</param>
/// <param name="config">Configure instance</param>
public TransportReceiver(TransactionSettings transactionSettings, int maximumConcurrencyLevel, int maximumThroughput, IDequeueMessages receiver, IManageMessageFailures manageMessageFailures, ReadOnlySettings settings, Configure config)
{
this.settings = settings;
this.config = config;
TransactionSettings = transactionSettings;
MaximumConcurrencyLevel = maximumConcurrencyLevel;
MaximumMessageThroughputPerSecond = maximumThroughput;
FailureManager = manageMessageFailures;
Receiver = receiver;
}
public HostIdFixer(UnicastBus bus, ReadOnlySettings settings)
{
Guid hostId = CreateGuid(Environment.MachineName, settings.EndpointName());
string location = Assembly.GetExecutingAssembly().Location;
Dictionary<string, string> properties = new Dictionary<string, string>
{
{"Location", location}
};
bus.HostInformation = new HostInformation(hostId, Environment.MachineName, properties);
}
/// <summary>
/// Implementers need to new up a new container.
/// </summary>
/// <param name="settings">The settings to check if an existing container exists.</param>
/// <returns>The new container wrapper.</returns>
public override ObjectBuilder.Common.IContainer CreateContainer(ReadOnlySettings settings)
{
IContainer existingContainer;
if (settings.TryGet("ExistingContainer", out existingContainer))
{
return new StructureMapObjectBuilder(existingContainer);
}
return new StructureMapObjectBuilder();
}
public HandledMessageInfoPublisher(
IDataBackplaneClient dataBackplane,
IReadOnlyCollection<Type> hanledMessageTypes,
ReadOnlySettings settings,
TimeSpan heartbeatPeriod)
{
this.dataBackplane = dataBackplane;
this.hanledMessageTypes = hanledMessageTypes;
this.settings = settings;
this.heartbeatPeriod = heartbeatPeriod;
}
/// <summary>
/// Implementers need to new up a new container.
/// </summary>
/// <param name="settings">The settings to check if an existing container exists.</param>
/// <returns>The new container wrapper.</returns>
public override ObjectBuilder.Common.IContainer CreateContainer(ReadOnlySettings settings)
{
ILifetimeScope existingLifetimeScope;
if (settings.TryGet("ExistingLifetimeScope", out existingLifetimeScope))
{
return new AutofacObjectBuilder(existingLifetimeScope);
}
return new AutofacObjectBuilder();
}
/// <summary>
/// Implementers need to new up a new container.
/// </summary>
/// <param name="settings">The settings to check if an existing container exists.</param>
/// <returns>The new container wrapper.</returns>
public override ObjectBuilder.Common.IContainer CreateContainer(ReadOnlySettings settings)
{
LifetimeScopeHolder scopeHolder;
if (settings.TryGet(out scopeHolder))
{
return new AutofacObjectBuilder(scopeHolder.ExistingLifetimeScope);
}
return new AutofacObjectBuilder();
}
static IMessageSerializer CreateMessageSerializer(Tuple<SerializationDefinition, SettingsHolder> definitionAndSettings, IMessageMapper mapper, ReadOnlySettings mainSettings)
{
var definition = definitionAndSettings.Item1;
var deserializerSettings = definitionAndSettings.Item2;
deserializerSettings.Merge(mainSettings);
deserializerSettings.PreventChanges();
var serializerFactory = definition.Configure(deserializerSettings);
var serializer = serializerFactory(mapper);
return serializer;
}
public DistributorReadyMessageProcessor(IBuilder builder, ReadOnlySettings settings)
{
disable = !settings.GetOrDefault<bool>("Distributor.Enabled");
if (disable)
{
return;
}
workerAvailabilityManager = builder.Build<IWorkerAvailabilityManager>();
address = MasterNodeConfiguration.GetMasterNodeAddress(settings).SubScope("distributor.control");
}
public string Determine(ReadOnlySettings settings, Address replyToAddress)
{
if (IsPotentialServiceBusConnectionString(replyToAddress.Machine))
{
return replyToAddress.ToString();
}
else
{
var replyQueue = replyToAddress.Queue;
var @namespace = Determine(settings); //todo: inject
return replyQueue + "@" + @namespace;
}
}
public DistributorSatellite(IBuilder builder, ReadOnlySettings settings)
{
disable = !settings.GetOrDefault<bool>("Distributor.Enabled");
if (disable)
{
return;
}
messageSender = builder.Build<ISendMessages>();
workerManager = builder.Build<IWorkerAvailabilityManager>();
address = MasterNodeConfiguration.GetMasterNodeAddress(settings);
}
internal IDocumentStore Init(ReadOnlySettings settings)
{
if (!isInitialized)
{
EnsureDocStoreCreated(settings);
ApplyConventions(settings);
BackwardsCompatibilityHelper.SupportOlderClrTypes(docStore);
docStore.Initialize();
StorageEngineVerifier.VerifyStorageEngineSupportsDtcIfRequired(docStore, settings);
}
isInitialized = true;
return docStore;
}
static string GetDefaultEndpointAddress(ReadOnlySettings settings)
{
if (!settings.GetOrDefault<bool>("IndividualizeEndpointAddress"))
{
return settings.EndpointName();
}
if (!settings.HasSetting("EndpointInstanceDiscriminator"))
{
throw new Exception("No endpoint instance discriminator found. This value is usually provided by your transport so please make sure you're on the lastest version of your specific transport or set the discriminator using 'configuration.ScaleOut().UniqueQueuePerEndpointInstance(myDiscriminator)'");
}
return settings.EndpointName() + settings.Get<string>("EndpointInstanceDiscriminator");
}
internal static bool HasSupportFor(ReadOnlySettings settings, Storage storages)
{
return(settings.Get <List <Storage> >("ResultingSupportedStorages")
.Contains(storages));
}
static IMessageSerializer CreateMessageSerializer(Tuple <SerializationDefinition, SettingsHolder> definitionAndSettings, IMessageMapper mapper, ReadOnlySettings mainSettings)
{
var definition = definitionAndSettings.Item1;
var deserializerSettings = definitionAndSettings.Item2;
deserializerSettings.Merge(mainSettings);
deserializerSettings.PreventChanges();
var serializerFactory = definition.Configure(deserializerSettings);
var serializer = serializerFactory(mapper);
return(serializer);
}
public MyMessageHandler(ReadOnlySettings settings)
{
this.settings = settings;
}
internal static SerializerOptions GetOptions(this ReadOnlySettings settings)
{
return(settings.GetOrDefault <SerializerOptions>());
}
public MyNamespacePartitioningStrategy(ReadOnlySettings settings)
{
this.settings = settings;
}
public Batcher(ITopologySectionManager topologySectionManager, ReadOnlySettings settings)
{
this.topologySectionManager = topologySectionManager;
messageSizePaddingPercentage = settings.Get <int>(WellKnownConfigurationKeys.Connectivity.MessageSenders.MessageSizePaddingPercentage);
}
public MessageHandler(Context testContext, ReadOnlySettings settings)
{
this.testContext = testContext;
this.settings = settings;
}
public static bool IsMigrationModeEnabled(ReadOnlySettings settings)
{
// this key can be set by transports once they provide native support for pub/sub.
return(settings.TryGet("NServiceBus.Subscriptions.EnableMigrationMode", out bool enabled) && enabled);
}
public override EndpointInstance BindToLocalEndpoint(EndpointInstance instance, ReadOnlySettings settings)
{
throw new NotImplementedException();
}
public static string FindScriptDirectory(ReadOnlySettings settings)
{
var currentDirectory = GetCurrentDirectory(settings);
return(Path.Combine(currentDirectory, ScriptFolder, settings.GetSqlDialect().Name));
}
public MessagingFactoryCreator(IManageNamespaceManagerLifeCycleInternal namespaceManagers, ReadOnlySettings settings)
{
this.namespaceManagers = namespaceManagers;
var transportType = settings.Get <TransportType>(WellKnownConfigurationKeys.Connectivity.TransportType);
var batchFlushInterval = settings.Get <TimeSpan>(WellKnownConfigurationKeys.Connectivity.MessagingFactories.BatchFlushInterval);
if (settings.HasExplicitValue(WellKnownConfigurationKeys.Connectivity.MessagingFactories.RetryPolicy))
{
retryPolicy = settings.Get <RetryPolicy>(WellKnownConfigurationKeys.Connectivity.MessagingFactories.RetryPolicy);
}
if (settings.HasExplicitValue(WellKnownConfigurationKeys.Connectivity.MessagingFactories.MessagingFactorySettingsFactory))
{
settingsFactory = settings.Get <Func <string, MessagingFactorySettings> >(WellKnownConfigurationKeys.Connectivity.MessagingFactories.MessagingFactorySettingsFactory);
}
else
{
settingsFactory = namespaceName =>
{
var factorySettings = new MessagingFactorySettings
{
TransportType = transportType
};
switch (transportType)
{
case TransportType.NetMessaging:
factorySettings.NetMessagingTransportSettings = new NetMessagingTransportSettings
{
BatchFlushInterval = batchFlushInterval
};
break;
case TransportType.Amqp:
factorySettings.AmqpTransportSettings = new AmqpTransportSettings
{
BatchFlushInterval = batchFlushInterval
};
break;
}
return(factorySettings);
};
}
}
internal static bool DoesTransportSupportConstraint <T>(this ReadOnlySettings settings) where T : DeliveryConstraint
{
return(settings.Get <TransportInfrastructure>()
.DeliveryConstraints.Any(t => typeof(T).IsAssignableFrom(t)));
}
internal static DocumentStoreInitializer GetUninitializedDocumentStore <TStorageType>(ReadOnlySettings settings)
where TStorageType : StorageType
{
// First try to get a document store specific to a storage type (Subscriptions, Gateway, etc.)
var docStoreInitializer = settings.GetOrDefault <DocumentStoreInitializer>(featureSettingsKeys[typeof(TStorageType)]);
// Next try finding a shared DocumentStore
if (docStoreInitializer == null)
{
docStoreInitializer = settings.GetOrDefault <DocumentStoreInitializer>(defaultDocStoreSettingsKey);
}
if (docStoreInitializer == null)
{
throw new Exception($"In order to use RavenDB as persistence for {typeof(TStorageType).Name}, a DocumentStore instance or builder must be set using persistence.{nameof(RavenDbSettingsExtensions.SetDefaultDocumentStore)}(...).");
}
return(docStoreInitializer);
}
public OutboxCleaner(OutboxRecordsCleaner cleaner, ReadOnlySettings settings)
{
this.cleaner = cleaner;
this.settings = settings;
logger = LogManager.GetLogger <OutboxCleaner>();
}
public static IDocumentStore GetDocumentStore <TStorageType>(ReadOnlySettings settings, IServiceProvider builder)
where TStorageType : StorageType
{
return(GetUninitializedDocumentStore <TStorageType>(settings).Init(settings, builder));
}
public override OutboundRoutingPolicy GetOutboundRoutingPolicy(ReadOnlySettings settings)
{
throw new NotImplementedException();
}
internal static string GetContentTypeKey(this ReadOnlySettings settings)
{
return(settings.GetOrDefault <string>("NServiceBus.Wire.ContentTypeKey"));
}
public MyCompositionStrategy(ReadOnlySettings settings)
{
this.settings = settings;
}
public Installer(ReadOnlySettings settings)
{
this.settings = settings;
installerSettings = settings.GetOrDefault <InstallerSettings>();
}
public ConfigTransportConfig(ReadOnlySettings settings)
{
this.settings = settings.Get <Settings>("ServiceControl.Settings");
}
public HierarchyComposition(ReadOnlySettings settings)
{
this.settings = settings;
}
/// <summary>
/// Allows the transport to control the local address of the endpoint if needed
/// </summary>
/// <param name="settings">The current settings in read only mode</param>
// ReSharper disable once UnusedParameter.Global
protected virtual string GetLocalAddress(ReadOnlySettings settings)
{
return(null);
}
public MyNamespacePartitioningStrategyWithControlledCaching(ReadOnlySettings settings)
{
this.settings = settings;
}
public MessagePump(IOperateTopologyInternal defaultOperator, MessageReceiverCreator messageReceiverCreator, BrokeredMessagesToIncomingMessagesConverter brokeredMessageConverter, ITopologySectionManagerInternal topologySectionManager, ReadOnlySettings settings, string localAddress) : this(defaultOperator, messageReceiverCreator, brokeredMessageConverter, topologySectionManager, settings, localAddress, TimeSpan.FromSeconds(30))
{
}
public override Func <IMessageMapper, IMessageSerializer> Configure(ReadOnlySettings settings)
{
return(mapper => new MyCustomMessageSerializer(settings.GetOrDefault <string>("MyCustomSerializer.Settings"), settings.Get <Context>()));
}
public VolatileSubscriber(IBuilder builder, IEventStoreConnection client, IDispatcher dispatcher, ReadOnlySettings settings, IMessageMapper mapper)
{
_builder = builder;
_client = client;
_dispatcher = dispatcher;
_settings = settings;
_jsonSettings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
Binder = new EventSerializationBinder(mapper),
ContractResolver = new EventContractResolver(mapper)
};
}
/// <summary>
/// Gets whether or not queues should be created.
/// </summary>
public static bool CreateQueues(this ReadOnlySettings settings)
{
Guard.AgainstNull(nameof(settings), settings);
return(settings.Get <ReceiveComponent.Configuration>().CreateQueues);
}
internal static Func <IIncomingPhysicalMessageContext, bool> GetSubscriptionAuthorizer(this ReadOnlySettings settings)
{
Func <IIncomingPhysicalMessageContext, bool> authorizer;
settings.TryGet("SubscriptionAuthorizer", out authorizer);
return(authorizer);
}
internal MessagePump(IOperateTopologyInternal defaultOperator, MessageReceiverCreator messageReceiverCreator, BrokeredMessagesToIncomingMessagesConverter brokeredMessageConverter, ITopologySectionManagerInternal topologySectionManager, ReadOnlySettings settings, string localAddress, TimeSpan timeToWaitBeforeTriggeringTheCircuitBreaker)
{
this.defaultOperator = defaultOperator;
this.messageReceiverCreator = messageReceiverCreator;
this.brokeredMessageConverter = brokeredMessageConverter;
this.topologySectionManager = topologySectionManager;
this.settings = settings;
this.localAddress = localAddress;
timeToWaitBeforeTriggering = timeToWaitBeforeTriggeringTheCircuitBreaker;
}
public SendMessage(ISendMessages sendMessages, MyContext context, ReadOnlySettings settings)
{
this.sendMessages = sendMessages;
this.context = context;
this.settings = settings;
}
