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; }