public void Should_activate_upstream_deps_first()
{
var defaultsOrder = new List<Feature>();
var dependingFeature = new DependsOnOne_Feature
{
OnDefaults = f => defaultsOrder.Add(f)
};
var feature = new MyFeature1
{
OnDefaults = f => defaultsOrder.Add(f)
};
var settings = new SettingsHolder();
var featureSettings = new FeatureActivator(settings);
featureSettings.Add(dependingFeature);
featureSettings.Add(feature);
settings.EnableFeatureByDefault<MyFeature1>();
featureSettings.SetupFeatures(new FeatureConfigurationContext(null));
Assert.True(dependingFeature.IsActive);
Assert.IsInstanceOf<MyFeature1>(defaultsOrder.First(), "Upstream deps should be activated first");
}
public static BrokeredMessage ToBrokeredMessage(this TransportMessage message, SendOptions options, SettingsHolder settings, bool expectDelay, Configure config)
{
var brokeredMessage = BrokeredMessageBodyConversion.InjectBody(message.Body);
SetHeaders(message, options, settings, config, brokeredMessage);
var timeToSend = DelayIfNeeded(options, expectDelay);
if (timeToSend.HasValue)
brokeredMessage.ScheduledEnqueueTimeUtc = timeToSend.Value;
TimeSpan? timeToLive = null;
if (message.TimeToBeReceived < TimeSpan.MaxValue)
{
timeToLive = message.TimeToBeReceived;
}
else if (options.TimeToBeReceived.HasValue && options.TimeToBeReceived < TimeSpan.MaxValue)
{
timeToLive = options.TimeToBeReceived.Value;
}
if (timeToLive.HasValue)
{
if (timeToLive.Value <= TimeSpan.Zero) return null;
brokeredMessage.TimeToLive = timeToLive.Value;
}
GuardMessageSize(brokeredMessage);
return brokeredMessage;
}
internal void ApplyDefaults(SettingsHolder settings)
{
foreach (var @default in defaults)
{
@default(settings);
}
}
public void Should_activate_upstream_dependencies_first()
{
var order = new List<Feature>();
var dependingFeature = new NamespaceB.MyFeature
{
OnActivation = f => order.Add(f)
};
var feature = new NamespaceA.MyFeature
{
OnActivation = f => order.Add(f)
};
var settings = new SettingsHolder();
var featureSettings = new FeatureActivator(settings);
featureSettings.Add(dependingFeature);
featureSettings.Add(feature);
settings.EnableFeatureByDefault<NamespaceA.MyFeature>();
featureSettings.SetupFeatures(null, null);
Assert.True(dependingFeature.IsActive);
Assert.IsInstanceOf<NamespaceA.MyFeature>(order.First(), "Upstream dependencies should be activated first");
}
public void Should_replace_default_storages_by_overrides()
{
var settingsHolder = new SettingsHolder();
var userProvidedEnabledPersistences = new List<EnabledPersistence>
{
new EnabledPersistence
{
DefinitionType = typeof(InMemoryPersistence),
SelectedStorages = new List<Type>()
},
// user provided overrides
new EnabledPersistence
{
DefinitionType = typeof(FakePersistence),
SelectedStorages = new List<Type>{ typeof(StorageType.Sagas), typeof(StorageType.Subscriptions) }
}
};
var resultedEnabledPersistences = PersistenceStorageMerger.Merge(userProvidedEnabledPersistences, settingsHolder);
Assert.That(resultedEnabledPersistences[0].SelectedStorages, Is.EquivalentTo(
new List<Type> { typeof(StorageType.Sagas), typeof(StorageType.Subscriptions) }));
Assert.That(resultedEnabledPersistences[1].SelectedStorages, Is.EquivalentTo(
new List<Type> { typeof(StorageType.GatewayDeduplication), typeof(StorageType.Outbox), typeof(StorageType.Timeouts) }));
}
public void Clear_ShouldDisposeAllDisposables()
{
var firstOverrideDisposable = new SomeDisposable();
var secondOverrideDisposable = new SomeDisposable();
var firstDefaultDisposable = new SomeDisposable();
var secondDefaultDisposable = new SomeDisposable();
var all = new[]
{
firstDefaultDisposable,
secondDefaultDisposable,
firstOverrideDisposable,
secondOverrideDisposable
};
var settings = new SettingsHolder();
settings.Set("1.Override", firstOverrideDisposable);
settings.Set("2.Override", secondOverrideDisposable);
settings.SetDefault("1.Default", firstDefaultDisposable);
settings.SetDefault("2.Default", secondDefaultDisposable);
settings.Clear();
Assert.IsTrue(all.All(x => x.Disposed));
}
public void Should_construct_serializer_that_uses_default_encoding()
{
var settings = new SettingsHolder();
var serializer = (NServiceBus.JsonMessageSerializer)new JsonSerializer().Configure(settings)(new MessageMapper());
Assert.AreSame(Encoding.UTF8, serializer.Encoding);
}
public void Should_return_false_when_checking_if_persistence_supports_storage_type()
{
var settings = new SettingsHolder();
var supported = PersistenceStartup.HasSupportFor<StorageType.Subscriptions>(settings);
Assert.IsFalse(supported);
}
public void Should_construct_serializer_that_uses_requested_encoding()
{
var settings = new SettingsHolder();
var extensions = new SerializationExtensions<JsonSerializer>(settings);
extensions.Encoding(Encoding.UTF7);
var serializer = (NServiceBus.JsonMessageSerializer)new JsonSerializer().Configure(settings)(new MessageMapper());
Assert.AreSame(Encoding.UTF7, serializer.Encoding);
}
public void GetConnectionUsingSettingsFromConnectionString()
{
var settings = new SettingsHolder();
settings.Set(MongoPersistenceConstants.ConnectionStringKey, "mongodb://ultratinef:27017");
var readonlySettings = (ReadOnlySettings)settings;
var result = MongoHelpers.GetConnectionString(readonlySettings);
result.Should().Be("mongodb://ultratinef:27017");
}
public void Merge_ThrowsWhenChangesArePrevented()
{
var settings = new SettingsHolder();
var mergeFrom = new SettingsHolder();
settings.PreventChanges();
Assert.Throws<ConfigurationErrorsException>(() => settings.Merge(mergeFrom));
}
public void Throws_when_voron_combined_with_dtc()
{
using (var documentStore = new DocumentStore { Url = "http://localhost:8083" })
using (documentStore.SetupVoronTest())
{
var settings = new SettingsHolder();
settings.Set<TransportInfrastructure>(new FakeRavenDBTransportInfrastructure(TransportTransactionMode.TransactionScope));
Assert.Throws<InvalidOperationException>(() => StorageEngineVerifier.VerifyStorageEngineSupportsDtcIfRequired(documentStore, settings));
}
}
public TransportConfigurationResult Configure(SettingsHolder settings, TransportTransactionMode transactionMode)
{
var msmqTransportDefinition = new MsmqTransport();
settingsHolder = settings;
return new TransportConfigurationResult
{
TransportInfrastructure = msmqTransportDefinition.Initialize(settingsHolder, ""),
PurgeInputQueueOnStartup = true
};
}
public void Should_configure_default_values()
{
var feature = new InstanceMappingFileFeature();
var settings = new SettingsHolder();
feature.ConfigureDefaults(settings);
Assert.That(settings.Get<string>(InstanceMappingFileFeature.FilePathSettingsKey), Is.EqualTo("instance-mapping.xml"));
Assert.That(settings.Get<TimeSpan>(InstanceMappingFileFeature.CheckIntervalSettingsKey), Is.EqualTo(TimeSpan.FromSeconds(30)));
}
public void Should_throw_if_class_is_derived()
{
var builder = new NHibernateSagaStorage();
var properties = SQLiteConfiguration.InMemory();
var configuration = new Configuration().AddProperties(properties);
var settings = new SettingsHolder();
settings.Set("TypesToScan", new[] { typeof(MyDerivedClassWithRowVersion) });
Assert.Throws<MappingException>(() => builder.ApplyMappings(settings, configuration));
}
public void Should_be_able_to_determine_if_delivery_constraint_is_supported()
{
var settings = new SettingsHolder();
var fakeTransportDefinition = new FakeTransportDefinition();
settings.Set<TransportDefinition>(fakeTransportDefinition);
settings.Set<TransportInfrastructure>(fakeTransportDefinition.Initialize(settings, null));
var context = new FeatureConfigurationContext(settings, null, null);
var result = context.Settings.DoesTransportSupportConstraint<DeliveryConstraint>();
Assert.IsTrue(result);
}
public void Should_register_defaults_if_feature_is_activated()
{
var settings = new SettingsHolder();
var featureSettings = new FeatureActivator(settings);
featureSettings.Add(new MyFeatureWithDefaults());
featureSettings.SetupFeatures(new FeatureConfigurationContext(null));
Assert.True(settings.HasSetting("Test1"));
}
private SettingsHolder DefaultSettings()
{
var settings = new SettingsHolder();
settings.Set("NServiceBus.LocalAddress", "FakeAddress");
settings.Set("EndpointVersion", "FakeVersion");
settings.SetDefault("Transactions.SuppressDistributedTransactions", false);
settings.Set("NServiceBus.Routing.EndpointName", "FakeEndpoint");
settings.Set<SingleSharedDocumentStore>(new SingleSharedDocumentStore());
return settings;
}
static Type GetSelectedFeatureForDataBus(SettingsHolder settings)
{
DataBusDefinition dataBusDefinition;
if (!settings.TryGet("SelectedDataBus", out dataBusDefinition))
{
dataBusDefinition = new FileShareDataBus();
}
return dataBusDefinition.ProvidedByFeature();
}
public void SetUp()
{
var builder = new NHibernateSagaStorage();
var properties = SQLiteConfiguration.InMemory();
var configuration = new Configuration().AddProperties(properties);
var settings = new SettingsHolder();
settings.Set("TypesToScan", new[] { typeof(SagaWithAbstractBaseClass), typeof(ContainSagaData), typeof(MyOwnAbstractBase) });
builder.ApplyMappings(settings, configuration);
sessionFactory = configuration.BuildSessionFactory() as SessionFactoryImpl;
}
/// <summary>
/// Initializes the transport infrastructure for msmq.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="connectionString">The connection string.</param>
/// <returns>the transport infrastructure for msmq.</returns>
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString)
{
settings.EnableFeature(typeof(InstanceMappingFileFeature));
var msmqSettings = connectionString != null ? new MsmqConnectionStringBuilder(connectionString)
.RetrieveSettings() : new MsmqSettings();
settings.Set<MsmqSettings>(msmqSettings);
return new MsmqTransportInfrastructure(settings);
}
public void DoesntThrow_when_voron_without_dtc()
{
using (var documentStore = new DocumentStore { Url = "http://localhost:8083" })
using (documentStore.SetupVoronTest())
{
var settings = new SettingsHolder();
settings.Set<TransportInfrastructure>(new FakeRavenDBTransportInfrastructure(TransportTransactionMode.ReceiveOnly));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
Assert.DoesNotThrow(() => StorageEngineVerifier.VerifyStorageEngineSupportsDtcIfRequired(documentStore, settings));
}
}
public void Throws_when_voron_combined_with_dtc()
{
using (var documentStore = new DocumentStore { Url = "http://localhost:8083" })
using (documentStore.SetupVoronTest())
{
var settings = new SettingsHolder();
settings.Set("Transactions.SuppressDistributedTransactions", false);
Assert.Throws<InvalidOperationException>(() => StorageEngineVerifier.VerifyStorageEngineSupportsDtcIfRequired(documentStore, settings));
}
}
public InitializableEndpoint(SettingsHolder settings, IContainer container, List<Action<IConfigureComponents>> registrations, PipelineSettings pipelineSettings, PipelineConfiguration pipelineConfiguration)
{
this.settings = settings;
this.pipelineSettings = pipelineSettings;
this.pipelineConfiguration = pipelineConfiguration;
RegisterContainerAdapter(container);
RunUserRegistrations(registrations);
this.container.RegisterSingleton(this);
this.container.RegisterSingleton<ReadOnlySettings>(settings);
}
public void Should_generate_a_guid_only_based_name_for_machine_name_over_14_characters()
{
RuntimeEnvironment.MachineNameAction = () => "DEVMACHINENAME";
const string endpointName = "When_determining_subscription_name_for_scaled_out_endpoint";
var eventType = typeof(SomeEventWithAnInsanelyLongName);
var settings = new SettingsHolder();
settings.Set("ScaleOut.UseSingleBrokerQueue", false);
var subscriptionName = NamingConventions.SubscriptionNamingConvention(settings, eventType, endpointName);
Guid guid;
Assert.IsTrue(Guid.TryParse(subscriptionName, out guid), "expected to have a guid, but got: " + subscriptionName);
}
public void Customize_delegate_round_trip()
{
var settings = new SettingsHolder();
Action<IDocumentStore> customize = ds => ds.Identifier = "test";
DocumentStoreManager.SetCustomizeDocumentStoreDelegate(settings, customize);
var action = DocumentStoreManager.GetCustomizeDocumentStoreDelegate(settings);
Assert.AreEqual(customize, action);
}
public void RegisterBehaviorsInContainer(SettingsHolder settings, IConfigureComponents container)
{
foreach (var registeredBehavior in Modifications.Replacements)
{
container.ConfigureComponent(registeredBehavior.BehaviorType, DependencyLifecycle.InstancePerCall);
}
foreach (var step in Modifications.Additions)
{
step.ApplyContainerRegistration(settings, container);
}
}
public void DoesntThrow_when_voron_without_dtc()
{
using (var documentStore = new DocumentStore { Url = "http://localhost:8083" })
using (documentStore.SetupVoronTest())
{
var settings = new SettingsHolder();
settings.Set("Transactions.SuppressDistributedTransactions", true);
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
Assert.DoesNotThrow(() => StorageEngineVerifier.VerifyStorageEngineSupportsDtcIfRequired(documentStore, settings));
}
}
public void DoesntThrow_when_voron_combined_with_dtc_including_confirmation()
{
using (var documentStore = new DocumentStore { Url = "http://localhost:8083" })
using (documentStore.SetupVoronTest())
{
var settings = new SettingsHolder();
settings.Set<TransportInfrastructure>(new FakeRavenDBTransportInfrastructure(TransportTransactionMode.TransactionScope));
settings.Set("RavenDB.IConfirmToUseAStorageEngineWhichDoesntSupportDtcWhilstLeavingDistributedTransactionSupportEnabled", true);
Assert.DoesNotThrow(() => StorageEngineVerifier.VerifyStorageEngineSupportsDtcIfRequired(documentStore, settings));
}
}
public void Customize(IFixture fixture)
{
var settings = new SettingsHolder();
settings.SetDefault("EndpointName", "UnitTests");
var config = new PersistenceExtentions<MongoDBPersistence>(settings);
fixture.Register(() => settings);
fixture.Register(() => config);
fixture.Customize<Address>(c => c.FromFactory(new MethodInvoker(new GreedyConstructorQuery())));
fixture.Customize<TimeoutData>(
c => c.With(t => t.OwningTimeoutManager, config.GetSettings().EndpointName()));
}
internal RetryFailedSettings(SettingsHolder settings) : base(settings)
{
}
public static bool WorkerRunsOnThisEndpoint(this Configure config)
{
return(SettingsHolder.GetOrDefault <bool>("Worker.Enabled"));
}
static void SetDocumentStoreInternal(SettingsHolder settings, Type storageType, Func <ReadOnlySettings, IServiceProvider, IDocumentStore> storeCreator)
{
var initContext = new DocumentStoreInitializer(storeCreator);
settings.Set(featureSettingsKeys[storageType], initContext);
}
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString)
{
var baseTransportInfrastructure = baseTransport.Initialize(settings, connectionString);
return(new ServerlessTransportInfrastructure(baseTransportInfrastructure, settings));
}
static DistributorSatellite()
{
Address = Configure.Instance.GetMasterNodeAddress();
Disable = !ConfigureMSMQDistributor.DistributorConfiguredToRunOnThisEndpoint() || SettingsHolder.Get <int>("Distributor.Version") != 2;
}
internal SagaSettings(SettingsHolder settings)
{
this.settings = settings;
}
public UnblockServiceConnectionAttemptEvent()
{
this.UnblockedWebsite = SettingsHolder.get_Settings().get_ProfileUncensoring().get_CurrentUnblockUrl();
this.UnblockedWebsiteName = SettingsHolder.get_Settings().get_ProfileUncensoring().get_SelectedItemName();
}
public Network()
{
this.InitializeComponent();
base.DataContext = SettingsHolder.get_Settings().get_ProfileNetwork();
this.ConnectBtn.Command = new AsyncDelegateCommand(new Func <Task>(this.ConnectToServer), new Func <bool>(this.CanExecute));
}
public void Setup()
{
SettingsHolder.Reset();
}
/// <summary>
/// Creates a new instance of ConventionsBuilder class.
/// </summary>
/// <param name="settings">An instance of the current settings.</param>
public ConventionsBuilder(SettingsHolder settings) : base(settings)
{
}
public static List <EnabledPersistence> Merge(List <EnabledPersistence> definitions, SettingsHolder settings)
{
definitions.Reverse();
var availableStorages = StorageType.GetAvailableStorageTypes();
var mergedEnabledPersistences = new List <EnabledPersistence>();
foreach (var definition in definitions)
{
var persistenceDefinition = definition.DefinitionType.Construct <PersistenceDefinition>();
var supportedStorages = persistenceDefinition.GetSupportedStorages(definition.SelectedStorages);
var currentDefinition = new EnabledPersistence
{
DefinitionType = definition.DefinitionType,
SelectedStorages = new List <Type>()
};
foreach (var storageType in supportedStorages)
{
if (availableStorages.Contains(storageType))
{
currentDefinition.SelectedStorages.Add(storageType);
availableStorages.Remove(storageType);
persistenceDefinition.ApplyActionForStorage(storageType, settings);
}
}
if (currentDefinition.SelectedStorages.Any())
{
mergedEnabledPersistences.Add(currentDefinition);
}
}
return(mergedEnabledPersistences);
}
public void SetUp()
{
LicenseManager.InitializeLicense();
transportDefinition = new MsmqTransport();
settings = new SettingsHolder();
settings.SetDefault("EndpointName", "TestEndpoint");
settings.SetDefault("Endpoint.SendOnly", false);
settings.SetDefault("MasterNode.Address", MasterNodeAddress);
pipelineModifications = new PipelineModifications();
settings.Set <PipelineModifications>(pipelineModifications);
ApplyPipelineModifications();
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
FuncBuilder.Register <ReadOnlySettings>(() => settings);
router = new StaticMessageRouter(KnownMessageTypes());
var conventions = new Conventions();
handlerRegistry = new MessageHandlerRegistry(conventions);
MessageMetadataRegistry = new MessageMetadataRegistry(false, conventions);
MessageSerializer = new XmlMessageSerializer(MessageMapper, conventions);
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
configure = new Configure(settings, FuncBuilder, new List <Action <IConfigureComponents> >(), new PipelineSettings(null))
{
localAddress = Address.Parse("TestEndpoint")
};
subscriptionManager = new SubscriptionManager
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage,
Configure = configure
};
pipelineFactory = new PipelineExecutor(settings, FuncBuilder, new BusNotifications());
FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer);
FuncBuilder.Register <ISendMessages>(() => messageSender);
FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory(MessageMetadataRegistry, MessageMapper, pipelineFactory));
FuncBuilder.Register <IManageSubscriptions>(() => subscriptionManager);
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry);
FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry);
FuncBuilder.Register <IMessageMapper>(() => MessageMapper);
FuncBuilder.Register <DeserializeLogicalMessagesBehavior>(() => new DeserializeLogicalMessagesBehavior
{
MessageSerializer = MessageSerializer,
MessageMetadataRegistry = MessageMetadataRegistry,
});
FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior());
FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory);
FuncBuilder.Register <TransportDefinition>(() => transportDefinition);
var messagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var deferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts"),
Configure = configure,
};
FuncBuilder.Register <IDeferMessages>(() => deferrer);
FuncBuilder.Register <IPublishMessages>(() => messagePublisher);
bus = new UnicastBus
{
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
SubscriptionManager = subscriptionManager,
MessageRouter = router,
Settings = settings,
Configure = configure,
HostInformation = new HostInformation(Guid.NewGuid(), "HelloWorld")
};
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
FuncBuilder.Register <UnicastBus>(() => bus);
FuncBuilder.Register <Conventions>(() => conventions);
FuncBuilder.Register <Configure>(() => configure);
}
public ServerlessTransportInfrastructure(TransportInfrastructure baseTransportInfrastructure,
SettingsHolder settings)
{
this.baseTransportInfrastructure = baseTransportInfrastructure;
this.settings = settings;
}
static void Main()
{
Console.Title = "Samples.MultiTenant.Receiver";
Configuration hibernateConfig = CreateBasicNHibernateConfig();
ModelMapper mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EndpointName("Samples.MultiTenant.Receiver");
#region ReceiverConfiguration
var persistence = busConfiguration.UsePersistence <NHibernatePersistence>();
persistence.RegisterManagedSessionInTheContainer();
persistence.UseConfiguration(hibernateConfig);
persistence.UseSubscriptionStorageConfiguration(CreateBasicNHibernateConfig());
persistence.UseTimeoutStorageConfiguration(CreateBasicNHibernateConfig());
persistence.DisableSchemaUpdate();
busConfiguration.EnableOutbox();
SettingsHolder settingsHolder = busConfiguration.GetSettings();
settingsHolder.Set("NHibernate.Timeouts.AutoUpdateSchema", true);
settingsHolder.Set("NHibernate.Subscriptions.AutoUpdateSchema", true);
#endregion
#region ReplaceOpenSqlConnection
busConfiguration.Pipeline.Replace("OpenSqlConnection", typeof(MultiTenantOpenSqlConnectionBehavior));
#endregion
#region RegisterPropagateTenantIdBehavior
busConfiguration.Pipeline.Register <PropagateTenantIdBehavior.Registration>();
#endregion
busConfiguration.DisableFeature <SecondLevelRetries>();
#region CreateSchema
IStartableBus startableBus = Bus.Create(busConfiguration);
CreateSchema(hibernateConfig, "A");
CreateSchema(hibernateConfig, "B");
#endregion
#region CapturePipelineExecutor
PipelineExecutor = ((UnicastBus)startableBus).Builder.Build <PipelineExecutor>();
#endregion
using (startableBus.Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
/// <summary>
/// Initializes all the factories and supported features for the transport. This method is called right before all features
/// are activated and the settings will be locked down. This means you can use the SettingsHolder both for providing
/// default capabilities as well as for initializing the transport's configuration based on those settings (the user cannot
/// provide information anymore at this stage).
/// </summary>
/// <param name="settings">An instance of the current settings.</param>
/// <param name="connectionString">The connection string.</param>
/// <returns>The supported factories.</returns>
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString)
{
Guard.AgainstNull(nameof(settings), settings);
return(new AcceptanceTestTransportInfrastructure(settings));
}
public QueueCreator(SettingsHolder settings)
{
this.settings = settings;
}
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString)
{
return(new EmailTransportInfrastructure(settings));
}
/// <summary>
/// Default constructor.
/// </summary>
public TransportExtensions(SettingsHolder settings)
: base(settings)
{
}
public void Single_partitioning_strategy_will_throw_if_no_namespace_defined()
{
var settings = new SettingsHolder();
Assert.Throws <ConfigurationErrorsException>(() => new SingleNamespacePartitioning(settings));
}
public override void Initialize()
{
Configure.Component <MessageMapper>(DependencyLifecycle.SingleInstance);
Configure.Component <JsonMessageSerializer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(s => s.SkipArrayWrappingForSingleMessages, !SettingsHolder.GetOrDefault <bool>("SerializationSettings.WrapSingleMessages"));
}
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString)
{
throw new System.NotImplementedException();
}
public FeatureActivator(SettingsHolder settings)
{
this.settings = settings;
}
public EndpointOrientedMigrationTopologyTransportInfrastructure(SettingsHolder settings) : base(settings)
{
}
static void SetDefaultStoreInternal(SettingsHolder settings, Func <ReadOnlySettings, IServiceProvider, IDocumentStore> storeCreator)
{
var initContext = new DocumentStoreInitializer(storeCreator);
settings.Set(defaultDocStoreSettingsKey, initContext);
}
public PipelineComponent(SettingsHolder settings)
{
modifications = new PipelineModifications();
PipelineSettings = new PipelineSettings(modifications, settings);
}
public static bool DistributorConfiguredToRunOnThisEndpoint(this Configure config)
{
return(SettingsHolder.GetOrDefault <bool>("Distributor.Enabled"));
}
public override void SetUpDefaults(SettingsHolder settings)
{
settings.SetDefault(UseCallbackReceiverSettingKey, true);
settings.SetDefault(MaxConcurrencyForCallbackReceiverSettingKey, 1);
}
public void Run(SettingsHolder config)
{
}
public RouterImpl(string name, Interface[] interfaces, SendOnlyInterface[] sendOnlyInterfaces, IModule[] modules, IRoutingProtocol routingProtocol, InterfaceChains interfaceChains, SettingsHolder extensibilitySettings)
{
this.name = name;
this.sendOnlyInterfaces = sendOnlyInterfaces;
this.modules = modules;
this.routingProtocol = routingProtocol;
this.interfaceChains = interfaceChains;
this.extensibilitySettings = extensibilitySettings;
this.interfaces = interfaces;
}
internal AzureServiceBusNamespacePartitioningSettings(SettingsHolder settings) : base(settings)
{
this.settings = settings;
}
