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