static void ApplyDefaultsForExtensibility(SettingsHolder settings) { settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Composition.Strategy, typeof(FlatComposition)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Individualization.Strategy, typeof(CoreIndividualization)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Partitioning.Strategy, typeof(SingleNamespacePartitioning)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.Strategy, typeof(ThrowOnFailedValidation)); }
static void SetTransportSpecificFlags(SettingsHolder settings, string poisonQueue) { //To satisfy requirements of various transports //MSMQ settings.Set("errorQueue", poisonQueue); //Not SetDefault Because MSMQ transport verifies if that value has been explicitly set //RabbitMQ settings.SetDefault("RabbitMQ.RoutingTopologySupportsDelayedDelivery", true); //SQS settings.SetDefault("NServiceBus.AmazonSQS.DisableSubscribeBatchingOnStart", true); //ASB var builder = new ConventionsBuilder(settings); builder.DefiningEventsAs(type => true); settings.Set(builder.Conventions); //ASQ and ASB var serializer = Tuple.Create(new NewtonsoftSerializer() as SerializationDefinition, new SettingsHolder()); settings.SetDefault("MainSerializer", serializer); //SQS and ASQ bool isMessageType(Type t) => true; var ctor = typeof(MessageMetadataRegistry).GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(Func <Type, bool>) }, null); #pragma warning disable CS0618 // Type or member is obsolete settings.SetDefault <MessageMetadataRegistry>(ctor.Invoke(new object[] { (Func <Type, bool>)isMessageType })); #pragma warning restore CS0618 // Type or member is obsolete }
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 static void Apply(SettingsHolder settings) { settings.SetDefault(WellKnownConfigurationKeys.ReceiverConnectionString, DefaultConnectionString); settings.SetDefault(WellKnownConfigurationKeys.ReceiverMessageInvisibleTime, DefaultMessageInvisibleTime); settings.SetDefault(WellKnownConfigurationKeys.ReceiverPeekInterval, DefaultPeekInterval); settings.SetDefault(WellKnownConfigurationKeys.ReceiverMaximumWaitTimeWhenIdle, DefaultMaximumWaitTimeWhenIdle); settings.SetDefault(WellKnownConfigurationKeys.QueueSanitizer, (Func <string, string>)(queueName => queueName)); }
void ApplyDefaults(SettingsHolder settings) { new DefaultConfigurationValues().Apply(settings); // ensures settings are present/correct settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Composition.Strategy, typeof(FlatComposition)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Individualization.Strategy, typeof(CoreIndividualization)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Partitioning.Strategy, typeof(SingleNamespacePartitioning)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.Strategy, typeof(ThrowOnFailedValidation)); topologySectionManager = new EndpointOrientedTopologySectionManager(settings, container); }
public RecoverabilityComponent(SettingsHolder settings) { this.settings = settings; settings.SetDefault(NumberOfDelayedRetries, DefaultNumberOfRetries); settings.SetDefault(DelayedRetriesTimeIncrease, DefaultTimeIncrease); settings.SetDefault(NumberOfImmediateRetries, 5); settings.SetDefault(FaultHeaderCustomization, new Action <Dictionary <string, string> >(headers => { })); settings.AddUnrecoverableException(typeof(MessageDeserializationException)); }
/// <inheritdoc /> public override Transport.TransportInfrastructure Initialize(SettingsHolder settings, string connectionString) { if (!string.IsNullOrEmpty(connectionString)) { throw new ArgumentException($"{nameof(SqsTransport)} does not require a connection string, but a connection string was provided. Use the code based configuration methods instead."); } settings.SetDefault(SettingsKeys.S3BucketForLargeMessages, string.Empty); settings.SetDefault(SettingsKeys.S3KeyPrefix, string.Empty); settings.SetDefault(SettingsKeys.MaxTimeToLive, TimeSpan.FromDays(4)); settings.SetDefault(SettingsKeys.QueueNamePrefix, string.Empty); return(new TransportInfrastructure(settings)); }
public void SetUp() { settings = new SettingsHolder(); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); extensions.NamespacePartitioning().AddNamespace(PrimaryName, PrimaryConnectionString); extensions.NamespacePartitioning().AddNamespace(SecondaryName, SecondaryConnectionString); namespacePartitioningStrategy = new RoundRobinNamespacePartitioning(settings); // apply entity maximum lengths for addressing logic settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.QueuePathMaximumLength, 260); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.TopicPathMaximumLength, 260); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.SubscriptionNameMaximumLength, 50); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.RuleNameMaximumLength, 50); }
void ApplyDefaultValuesForSubscriptions(SettingsHolder settings) { settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.SubscriptionNameMaximumLength, 50); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.AutoDeleteOnIdle, TimeSpan.MaxValue); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.DefaultMessageTimeToLive, TimeSpan.MaxValue); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.LockDuration, TimeSpan.FromMilliseconds(30000)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.EnableBatchedOperations, true); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.EnableDeadLetteringOnFilterEvaluationExceptions, false); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.EnableDeadLetteringOnMessageExpiration, false); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.MaxDeliveryCount, GetNumberOfImmediateRetries(settings)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.ForwardDeadLetteredMessagesToCondition, new Func <string, bool>(name => true)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Resources.Subscriptions.ForwardDeadLetteredMessagesTo, null); }
public void Should_use_local_address_when_worker_is_disabled() { SettingsHolder.SetDefault("Worker.Enabled", false); RegisterMessageType <DeferredMessage>(); bus.Defer(TimeSpan.FromDays(1), new DeferredMessage()); VerifyThatMessageWasSentWithHeaders(h => h["NServiceBus.Timeout.RouteExpiredTimeoutTo"] == Address.Local.ToString()); }
public void Creates_subscription_on_each_topic_in_bundle() { var container = new TransportPartsContainer(); var settings = new SettingsHolder(); container.Register(typeof(SettingsHolder), () => settings); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); settings.SetDefault("NServiceBus.Routing.EndpointName", "sales"); extensions.UseForwardingTopology().NamespacePartitioning().AddNamespace(Name, Connectionstring); var topology = new ForwardingTopology(container); topology.Initialize(settings); var sectionManager = container.Resolve <ITopologySectionManager>(); sectionManager.DetermineResourcesToCreate(new QueueBindings()); var section = sectionManager.DetermineResourcesToSubscribeTo(typeof(SomeTestEvent)); Assert.That(section.Entities.Count(), Is.EqualTo(2)); // TODO: need to verify that subscription is done on each topic }
public void Determines_there_should_be_a_topic_bundle_created() { var container = new TransportPartsContainer(); var settings = new SettingsHolder(); container.Register(typeof(SettingsHolder), () => settings); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); settings.SetDefault("NServiceBus.Routing.EndpointName", "sales"); extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring); var topology = new ForwardingTopology(container); topology.Initialize(settings); var sectionManager = container.Resolve <ITopologySectionManager>(); var definition = sectionManager.DetermineResourcesToCreate(new QueueBindings()); var result = definition.Entities.Where(ei => ei.Type == EntityType.Topic && ei.Namespace.ConnectionString == Connectionstring && ei.Path.StartsWith("bundle-")); Assert.That(result.Count(), Is.EqualTo(2)); Assert.That(result, Has.Exactly(1).Matches <EntityInfo>(x => x.Path == "bundle-1")); Assert.That(result, Has.Exactly(1).Matches <EntityInfo>(x => x.Path == "bundle-2")); }
/// <summary> /// Marks the given feature as enabled by default. /// </summary> public static SettingsHolder EnableFeatureByDefault(this SettingsHolder settings, Type featureType) { Guard.AgainstNull(nameof(settings), settings); Guard.AgainstNull(nameof(featureType), featureType); settings.SetDefault(featureType.FullName, FeatureState.Enabled); return(settings); }
public Configuration(SettingsHolder settings) { this.settings = settings; settings.SetDefault(TransportConnectionString.Default); settings.Set(new QueueBindings()); }
public Settings(SettingsHolder settings) { this.settings = settings; fullPathToStartingExe = PathUtilities.SanitizedPath(Environment.CommandLine); settings.SetDefault(DisplayNameSettingsKey, RuntimeEnvironment.MachineName); settings.SetDefault(PropertiesSettingsKey, new Dictionary <string, string> { { "Machine", RuntimeEnvironment.MachineName }, { "ProcessID", Process.GetCurrentProcess().Id.ToString() }, { "UserName", Environment.UserName }, { "PathToExecutable", fullPathToStartingExe } }); settings.Set(new StartupDiagnosticEntries()); }
protected override void InternalConfigure(Configure config) { Enable <MsmqTransport>(); Enable <MessageDrivenSubscriptions>(); //for backwards compatibility SettingsHolder.SetDefault("SerializationSettings.WrapSingleMessages", true); }
/// <summary> /// Set the default for the infrastructure service to the action passed in. /// If the service is enabled and no explicit override is found this action will be used to configure the service. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="configAction"></param> public static void SetDefaultFor <T>(Action configAction) { var serviceType = typeof(T); SettingsHolder.SetDefault <T>(configAction); SetStatusToDisabled(serviceType); Logger.DebugFormat("Default provider for infrastructure service {0} has been set to a custom action", serviceType.FullName); }
/// <summary> /// Sets the default provider for the service to the give type. If the service is enabled the type will be registered /// in the container with the specified lifecycle /// </summary> /// <typeparam name="T"></typeparam> /// <param name="providerType"></param> /// <param name="dependencyLifecycle"></param> public static void SetDefaultFor <T>(Type providerType, DependencyLifecycle dependencyLifecycle) { var serviceType = typeof(T); SettingsHolder.SetDefault <T>(() => Configure.Component(providerType, dependencyLifecycle)); SetStatusToDisabled(serviceType); Logger.DebugFormat("Default provider for infrastructure service {0} has been set to {1}, lifecycle: {2}", serviceType.FullName, providerType.FullName, dependencyLifecycle); }
public void Run() { if (!Configure.Instance.HasMasterNode()) { return; } SettingsHolder.SetDefault("SecondLevelRetries.AddressOfRetryProcessor", Configure.Instance.GetMasterNodeAddress().SubScope("Retries")); }
/// <inheritdoc /> public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString) { if (!string.IsNullOrEmpty(connectionString)) { throw new ArgumentException($"{nameof(SqsTransport)} does not require a connection string, but a connection string was provided. Use the code based configuration methods instead."); } settings.SetDefault(SettingsKeys.S3BucketForLargeMessages, string.Empty); settings.SetDefault(SettingsKeys.S3KeyPrefix, string.Empty); settings.SetDefault(SettingsKeys.MaxTimeToLive, TimeSpan.FromDays(4)); settings.SetDefault(SettingsKeys.QueueNamePrefix, string.Empty); settings.SetDefault(SettingsKeys.TopicNamePrefix, string.Empty); // needed to only enable the feature when the transport is used settings.Set(typeof(SettlePolicy).FullName, FeatureState.Enabled); return(new SqsTransportInfrastructure(settings)); }
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; }
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())); }
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())); }
public static SettingsHolder Apply(SettingsHolder settings) { settings.SetDefault <TopologySettings>(new TopologySettings()); ApplyDefaultsForExtensibility(settings); ApplyDefaultsForConnectivity(settings); ApplyDefaultValuesForAddressing(settings); ApplyDefaultValuesForQueueDescriptions(settings); ApplyDefaultValuesForTopics(settings); ApplyDefaultValuesForSubscriptions(settings); ApplyDefaultValuesForRules(settings); ApplyDefaultValuesForSerialization(settings); return(settings); }
#pragma warning disable 618 ITopologySectionManager SetupForwardingTopology(TransportPartsContainer container, string enpointname) { var settings = new SettingsHolder(); container.Register(typeof(SettingsHolder), () => settings); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); settings.SetDefault("NServiceBus.Routing.EndpointName", enpointname); extensions.NamespacePartitioning().AddNamespace("namespace1", AzureServiceBusConnectionString.Value); var topology = new ForwardingTopology(container); topology.Initialize(settings); return(container.Resolve <ITopologySectionManager>()); }
internal AzureStorageQueueInfrastructure(SettingsHolder settings, string connectionString) { this.settings = settings; this.connectionString = connectionString; settings.SetDefault(WellKnownConfigurationKeys.DelayedDelivery.EnableTimeoutManager, true); if (!settings.IsFeatureEnabled(typeof(TimeoutManager)) || settings.GetOrDefault <bool>("Endpoint.SendOnly")) { // TimeoutManager is already not used. Indicate to Native Delayed Delivery that we're not in the hybrid mode. settings.Set(WellKnownConfigurationKeys.DelayedDelivery.EnableTimeoutManager, false); } delayedDelivery = new NativeDelayDelivery(connectionString, GetDelayedDeliveryTableName(settings), settings.GetOrDefault <bool>(WellKnownConfigurationKeys.DelayedDelivery.DisableDelayedDelivery)); addressGenerator = new QueueAddressGenerator(settings.GetOrDefault <Func <string, string> >(WellKnownConfigurationKeys.QueueSanitizer)); }
public void Determines_there_should_be_a_topic_with_same_name_as_endpointname_followed_by_dot_events() { var container = new TransportPartsContainer(); var settings = new SettingsHolder(); settings.Set <Conventions>(new Conventions()); container.Register(typeof(SettingsHolder), () => settings); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); settings.SetDefault("NServiceBus.Routing.EndpointName", "sales"); extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring); var definition = DetermineResourcesToCreate(settings, container); Assert.AreEqual(1, definition.Entities.Count(ei => ei.Path == "sales.events" && ei.Type == EntityType.Topic && ei.Namespace.ConnectionString == Connectionstring)); }
public LearningTransportInfrastructure(SettingsHolder settings) { this.settings = settings; if (!settings.TryGet(StorageLocationKey, out storagePath)) { storagePath = FindStoragePath(); } settings.SetDefault(new MessageProcessingOptimizationExtensions.ConcurrencyLimit { MaxValue = 1 }); var errorQueueAddress = settings.ErrorQueueAddress(); PathChecker.ThrowForBadPath(errorQueueAddress, "ErrorQueueAddress"); }
void ApplyDefaults(SettingsHolder settings) { new DefaultConfigurationValues().Apply(settings); // ensures settings are present/correct settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Composition.Strategy, typeof(FlatComposition)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Individualization.Strategy, typeof(CoreIndividualization)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Partitioning.Strategy, typeof(SingleNamespacePartitioning)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.Strategy, typeof(ThrowOnFailedValidation)); settings.SetDefault(WellKnownConfigurationKeys.Topology.Bundling.NumberOfEntitiesInBundle, 2); settings.SetDefault(WellKnownConfigurationKeys.Topology.Bundling.BundlePrefix, "bundle-"); topologySectionManager = new ForwardingTopologySectionManager(settings, container); }
public void Merge_ShouldMergeContentFromSource() { var settings = new SettingsHolder(); settings.SetDefault("SomeDefaultSetting", "Value1"); settings.Set("SomeSetting", "Value1"); var mergeFrom = new SettingsHolder(); mergeFrom.SetDefault("SomeDefaultSettingThatGetsMerged", "Value1"); mergeFrom.Set("SomeSettingThatGetsMerged", "Value1"); settings.Merge(mergeFrom); var result1 = settings.Get<string>("SomeDefaultSettingThatGetsMerged"); var result2 = settings.Get<string>("SomeSettingThatGetsMerged"); Assert.AreEqual("Value1", result1); Assert.AreEqual("Value1", result2); }
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString) { if (!string.IsNullOrEmpty(connectionString)) { throw new ArgumentException($"{nameof(SqsTransport)} does not require a connection string, but a connection string was provided. Use the code based configuration methods instead."); } settings.SetDefault(SqsTransportSettingsKeys.S3BucketForLargeMessages, string.Empty); settings.SetDefault(SqsTransportSettingsKeys.S3KeyPrefix, string.Empty); settings.SetDefault(SqsTransportSettingsKeys.MaxTTLDays, 4); settings.SetDefault(SqsTransportSettingsKeys.CredentialSource, SqsCredentialSource.EnvironmentVariables); settings.SetDefault(SqsTransportSettingsKeys.ProxyHost, string.Empty); settings.SetDefault(SqsTransportSettingsKeys.ProxyPort, 0); settings.SetDefault(SqsTransportSettingsKeys.QueueNamePrefix, string.Empty); return(new SqsTransportInfrastructure(settings)); }
ITopologySectionManager SetupEndpointOrientedTopologyWithFailoverNamespace(TransportPartsContainer container, string enpointname) { var settings = new SettingsHolder(); settings.Set <Conventions>(new Conventions()); container.Register(typeof(SettingsHolder), () => settings); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); settings.SetDefault("NServiceBus.Routing.EndpointName", enpointname); extensions.NamespacePartitioning().AddNamespace("namespace1", AzureServiceBusConnectionString.Value); extensions.NamespacePartitioning().AddNamespace("namespace2", AzureServiceBusConnectionString.Fallback); extensions.NamespacePartitioning().UseStrategy <FailOverNamespacePartitioning>(); var topology = new EndpointOrientedTopology(container); topology.Initialize(settings); return(container.Resolve <ITopologySectionManager>()); }
public void Should_fail_sanitization_for_invalid_endpoint_name(string reasonToFail, string endpointName) { var container = new TransportPartsContainer(); var settings = new SettingsHolder(); container.Register(typeof(SettingsHolder), () => settings); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); settings.SetDefault("NServiceBus.Routing.EndpointName", endpointName); extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring); var topology = new ForwardingTopology(container); topology.Initialize(settings); var sectionManager = container.Resolve <ITopologySectionManager>(); Assert.Throws <Exception>(() => sectionManager.DetermineResourcesToCreate(new QueueBindings()), "Was expected to fail: " + reasonToFail); }
public LearningTransportInfrastructure(SettingsHolder settings) { this.settings = settings; if (!settings.TryGet(StorageLocationKey, out storagePath)) { var solutionRoot = FindSolutionRoot(); storagePath = Path.Combine(solutionRoot, ".learningtransport"); } settings.SetDefault <MessageProcessingOptimizationExtensions.ConcurrencyLimit>(new MessageProcessingOptimizationExtensions.ConcurrencyLimit { MaxValue = 1 }); var errorQueueAddress = settings.ErrorQueueAddress(); PathChecker.ThrowForBadPath(errorQueueAddress, "ErrorQueueAddress"); settings.Set(Recoverability.DisableLegacyRetriesSatellite, true); }
public override void SetUpDefaults(SettingsHolder settings) { settings.SetDefault(CircuitBreakerTimeToWaitBeforeTriggeringSettingsKey, TimeSpan.FromMinutes(2)); settings.SetDefault(CircuitBreakerDelayAfterFailureSettingsKey, TimeSpan.FromSeconds(10)); }
public override void SetUpDefaults(SettingsHolder settings) { settings.SetDefault(UseCallbackReceiverSettingKey, true); settings.SetDefault(MaxConcurrencyForCallbackReceiverSettingKey, 1); }