/// <summary> /// Specifies the path and file name for the instance mapping XML. The default is <code>instance-mapping.xml</code>. /// </summary> /// <param name="filePath">The relative or absolute file path to the instance mapping XML file.</param> public InstanceMappingFileSettings FilePath(string filePath) { Guard.AgainstNullAndEmpty(nameof(filePath), filePath); this.GetSettings().Set(InstanceMappingFileFeature.FilePathSettingsKey, filePath); return(this); }
/// <summary> /// The site key to use, this goes hand in hand with Bus.SendToSites(key, message). /// </summary> /// <param name="siteKey"></param> /// <param name="address">The channel address.</param> /// <param name="type">The channel type. Default is `http`.</param> /// <param name="legacyMode">Pass `true` to set the forwarding mode for this site to legacy mode.</param> public void AddSite(string siteKey, string address, string type = "http", bool legacyMode = false) { Guard.AgainstNullAndEmpty(nameof(siteKey), siteKey); Guard.AgainstNullAndEmpty(nameof(address), address); Guard.AgainstNullAndEmpty(nameof(type), type); var site = new Site { Channel = new Channel { Address = address, Type = type }, Key = siteKey, LegacyMode = legacyMode }; if (settings.TryGet(out List <Site> sites)) { sites.Add(site); } settings.Set <List <Site> >(new List <Site> { site }); }
/// <summary> /// Configures the location where message files are stored. /// </summary> /// <param name="transportExtensions">The transport extensions to extend.</param> /// <param name="path">The storage path.</param> public static void StorageDirectory(this TransportExtensions <AcceptanceTestTransport> transportExtensions, string path) { Guard.AgainstNullAndEmpty(nameof(path), path); Guard.AgainstNull(nameof(transportExtensions), transportExtensions); PathChecker.ThrowForBadPath(path, "StorageDirectory"); transportExtensions.GetSettings().Set(AcceptanceTestTransportInfrastructure.StorageLocationKey, path); }
/// <summary> /// Specifies a string value that will be prepended to the name of every SQS queue /// referenced by the endpoint. This is useful when deploying many environments of the /// same application in the same AWS region (say, a development environment, a QA environment /// and a production environment), and you need to differentiate the queue names per environment. /// </summary> public static TransportExtensions <SqsTransport> QueueNamePrefix(this TransportExtensions <SqsTransport> transportExtensions, string queueNamePrefix) { Guard.AgainstNull(nameof(transportExtensions), transportExtensions); Guard.AgainstNullAndEmpty(nameof(queueNamePrefix), queueNamePrefix); transportExtensions.GetSettings().Set(SettingsKeys.QueueNamePrefix, queueNamePrefix); return(transportExtensions); }
/// <summary> /// Adds a section to the startup diagnostics. /// </summary> public static void AddStartupDiagnosticsSection(this ReadOnlySettings settings, string sectionName, object section) { Guard.AgainstNull(nameof(settings), settings); Guard.AgainstNullAndEmpty(nameof(sectionName), sectionName); Guard.AgainstNull(nameof(section), section); settings.Get <StartupDiagnosticEntries>().Add(sectionName, section); }
/// <summary> /// Override the default database used by the persistence /// </summary> public static PersistenceExtensions <MongoPersistence> DatabaseName(this PersistenceExtensions <MongoPersistence> persistenceExtensions, string databaseName) { Guard.AgainstNull(nameof(persistenceExtensions), persistenceExtensions); Guard.AgainstNullAndEmpty(nameof(databaseName), databaseName); persistenceExtensions.GetSettings().Set(SettingsKeys.DatabaseName, databaseName); return(persistenceExtensions); }
/// <summary> /// Configures the database schema to be used. /// </summary> public static void Schema(this PersistenceExtensions <SqlPersistence> configuration, string schema) { Guard.AgainstNull(nameof(configuration), configuration); Guard.AgainstNullAndEmpty(nameof(schema), schema); Guard.AgainstSqlDelimiters(nameof(schema), schema); configuration.GetSettings() .Set("SqlPersistence.Schema", schema); }
/// <summary> /// Sets the location to which to write/read serialized properties for the databus. /// </summary> /// <param name="config">The configuration object.</param> /// <param name="basePath">The location to which to write/read serialized properties for the databus.</param> /// <returns>The configuration.</returns> public static DataBusExtensions <FileShareDataBus> BasePath(this DataBusExtensions <FileShareDataBus> config, string basePath) { Guard.AgainstNull(nameof(config), config); Guard.AgainstNullAndEmpty(nameof(basePath), basePath); config.Settings.Set("FileShareDataBusPath", basePath); return(config); }
/// <summary> /// In this mode, a host id will be generated from <paramref name="instanceName" /> and <paramref name="hostName" />. /// </summary> /// <remarks> /// This mode is recommended when deploying in Azure roles or <see cref="UsingInstalledFilePath" /> is not appropriate. /// </remarks> public HostInfoSettings UsingNames(string instanceName, string hostName) { Guard.AgainstNullAndEmpty(nameof(instanceName), instanceName); Guard.AgainstNullAndEmpty(nameof(hostName), hostName); config.Settings.Set(HostInformationFeature.HostIdSettingsKey, DeterministicGuid.Create(instanceName, hostName)); return(this); }
public AuditContext(OutgoingMessage message, string auditAddress, IBehaviorContext parent) : base(parent) { Guard.AgainstNull(nameof(message), message); Guard.AgainstNullAndEmpty(nameof(auditAddress), auditAddress); Message = message; AuditAddress = auditAddress; }
/// <summary> /// In this mode, a host id will be generated from <paramref name="instanceName" /> and <paramref name="hostName" />. /// </summary> /// <remarks> /// This mode is recommended when deploying in Azure roles or <see cref="UsingInstalledFilePath" /> is not appropriate. /// </remarks> public HostInfoSettings UsingNames(string instanceName, string hostName) { Guard.AgainstNullAndEmpty(nameof(instanceName), instanceName); Guard.AgainstNullAndEmpty(nameof(hostName), hostName); config.Settings.Get <HostingComponent.Settings>().HostId = DeterministicGuid.Create(instanceName, hostName); return(this); }
/// <summary> /// Creates a <see cref="IRoutingContext" /> based on the current context. /// </summary> public static IRoutingContext CreateRoutingContext(this ForkConnector <ITransportReceiveContext, IRoutingContext> forkConnector, OutgoingMessage outgoingMessage, string localAddress, ITransportReceiveContext sourceContext) { Guard.AgainstNull(nameof(outgoingMessage), outgoingMessage); Guard.AgainstNullAndEmpty(nameof(localAddress), localAddress); Guard.AgainstNull(nameof(sourceContext), sourceContext); return(new RoutingContext(outgoingMessage, new UnicastRoutingStrategy(localAddress), sourceContext)); }
/// <summary> /// Adds a static unicast route for a given message type. /// </summary> /// <param name="messageType">The message which should be routed.</param> /// <param name="destination">The destination endpoint.</param> public void RouteToEndpoint(Type messageType, string destination) { Guard.AgainstNull(nameof(messageType), messageType); Guard.AgainstNullAndEmpty(nameof(destination), destination); ThrowOnAddress(destination); Settings.GetOrCreate <ConfiguredUnicastRoutes>().Add(new TypeRouteSource(messageType, UnicastRoute.CreateFromEndpointName(destination))); }
/// <summary> /// Overrides the default topic name used to publish events between endpoints. /// </summary> /// <param name="transportExtensions"></param> /// <param name="topicName">The name of the topic used to publish events between endpoints.</param> public static TransportExtensions <AzureServiceBusTransport> TopicName(this TransportExtensions <AzureServiceBusTransport> transportExtensions, string topicName) { Guard.AgainstNullAndEmpty(nameof(topicName), topicName); transportExtensions.GetSettings().Set(SettingsKeys.TopicName, topicName); return(transportExtensions); }
/// <summary> /// Adds a section to the startup diagnostics. /// </summary> public static void AddStartupDiagnosticsSection(this ReadOnlySettings settings, string sectionName, object section) { Guard.AgainstNull(nameof(settings), settings); Guard.AgainstNullAndEmpty(nameof(sectionName), sectionName); Guard.AgainstNull(nameof(section), section); settings.Get <HostingComponent.Configuration>().StartupDiagnostics.Add(sectionName, section); }
/// <summary> /// Creates a new fault configuration. /// </summary> /// <param name="errorQueue">The address of the error queue.</param> /// <param name="unrecoverableExceptionTypes">Exception types that will be treated as unrecoverable.</param> public FailedConfig(string errorQueue, HashSet <Type> unrecoverableExceptionTypes) { Guard.AgainstNullAndEmpty(nameof(errorQueue), errorQueue); Guard.AgainstNull(nameof(unrecoverableExceptionTypes), unrecoverableExceptionTypes); ErrorQueue = errorQueue; UnrecoverableExceptionTypes = unrecoverableExceptionTypes; }
/// <summary> /// Registers a publisher endpoint for all event types in a given assembly. /// </summary> /// <param name="routingSettings">The <see cref="RoutingSettings<T>" /> to extend.</param> /// <param name="assembly">The assembly containing the event types.</param> /// <param name="publisherEndpoint">The publisher endpoint.</param> public static void RegisterPublisher <T>(this RoutingSettings <T> routingSettings, Assembly assembly, string publisherEndpoint) where T : TransportDefinition, IMessageDrivenSubscriptionTransport { Guard.AgainstNull(nameof(assembly), assembly); Guard.AgainstNullAndEmpty(nameof(publisherEndpoint), publisherEndpoint); ThrowOnAddress(publisherEndpoint); routingSettings.Settings.GetOrCreate <ConfiguredPublishers>().Add(new AssemblyPublisherSource(assembly, PublisherAddress.CreateFromEndpointName(publisherEndpoint))); }
public void Set(string newTimeoutManagerAddress) { Guard.AgainstNullAndEmpty(newTimeoutManagerAddress, "newTimeoutManagerAddress"); if (TransportAddress != null) { throw new InvalidOperationException("Another feature or the UnicastBusConfig section has already set the timeout manager address."); } TransportAddress = newTimeoutManagerAddress; }
/// <summary> /// Creates a new instance of <see cref="AzureServiceBusTransport"/>. /// </summary> public AzureServiceBusTransport(string connectionString) : base( defaultTransactionMode: TransportTransactionMode.SendsAtomicWithReceive, supportsDelayedDelivery: true, supportsPublishSubscribe: true, supportsTTBR: true) { Guard.AgainstNullAndEmpty(nameof(connectionString), connectionString); ConnectionString = connectionString; }
/// <summary> /// Creates a new instance of an AccountInfo. /// </summary> public AccountInfo(string alias, string connectionString) { Guard.AgainstNull(nameof(alias), alias); Guard.AgainstNullAndEmpty(nameof(connectionString), connectionString); Alias = alias; Connection = new ConnectionString(connectionString); RegisteredEndpoints = new HashSet <string>(StringComparer.OrdinalIgnoreCase); }
public static TransportExtensions <RabbitMQTransport> SetClientCertificate(this TransportExtensions <RabbitMQTransport> transportExtensions, string path, string password) { Guard.AgainstNull(nameof(transportExtensions), transportExtensions); Guard.AgainstNullAndEmpty(nameof(path), path); Guard.AgainstNullAndEmpty(nameof(password), password); transportExtensions.Transport.ClientCertificate = new X509Certificate2(path, password); return(transportExtensions); }
/// <summary> /// Registers a publisher endpoint for all event types in a given assembly. /// </summary> /// <param name="assembly">The assembly containing the event types.</param> /// <param name="publisherEndpoint">The publisher endpoint.</param> public void RegisterPublisher(Assembly assembly, string publisherEndpoint) { Guard.AgainstNull(nameof(assembly), assembly); Guard.AgainstNullAndEmpty(nameof(publisherEndpoint), publisherEndpoint); ThrowOnAddress(publisherEndpoint); Settings.GetOrCreate <ConfiguredPublishers>().Add(new AssemblyPublisherSource(assembly, PublisherAddress.CreateFromEndpointName(publisherEndpoint))); }
/// <summary> /// Configures a custom path where host diagnostics is written. /// </summary> /// <param name="config">Configuration object to extend.</param> /// <param name="path">The custom path to use.</param> public static void SetDiagnosticsPath(this EndpointConfiguration config, string path) { Guard.AgainstNull(nameof(config), config); Guard.AgainstNullAndEmpty(nameof(path), path); PathChecker.ThrowForBadPath(path, "Diagnostics root path"); config.GetSettings().Get <HostingComponent.Configuration>().DiagnosticsPath = path; }
public static TransportExtensions <AzureServiceBusTransport> ConnectionString(this TransportExtensions <AzureServiceBusTransport> transportExtensions, Func <string> connectionString) { Guard.AgainstNull(nameof(connectionString), connectionString); var value = connectionString(); Guard.AgainstNullAndEmpty(nameof(connectionString), value); transportExtensions.Transport.ConnectionString = value; return(transportExtensions); }
/// <summary> /// Sets a default schema for both input and output queues /// </summary> public static TransportExtensions <SqlServerTransport> DefaultSchema(this TransportExtensions <SqlServerTransport> transportExtensions, string schemaName) { Guard.AgainstNull(nameof(transportExtensions), transportExtensions); Guard.AgainstNullAndEmpty(nameof(schemaName), schemaName); transportExtensions.GetSettings().Set(SettingsKeys.DefaultSchemaSettingsKey, schemaName); return(transportExtensions); }
/// <summary> /// Initializes a new instance of <see cref="CriticalErrorContext" />. /// </summary> /// <param name="stop">See <see cref="ICriticalErrorContext.Stop" />.</param> /// <param name="error">See <see cref="ICriticalErrorContext.Error" />.</param> /// <param name="exception">See <see cref="ICriticalErrorContext.Exception" />.</param> public CriticalErrorContext(Func <CancellationToken, Task> stop, string error, Exception exception) { Guard.AgainstNull(nameof(stop), stop); Guard.AgainstNullAndEmpty(nameof(error), error); Guard.AgainstNull(nameof(exception), exception); Stop = stop; Error = error; Exception = exception; }
/// <summary> /// Adds a static unicast route for all types contained in the specified assembly. /// </summary> /// <param name="assembly">The assembly whose messages should be routed.</param> /// <param name="destination">Destination endpoint.</param> public void RouteToEndpoint(Assembly assembly, string destination) { Guard.AgainstNull(nameof(assembly), assembly); Guard.AgainstNullAndEmpty(nameof(destination), destination); ThrowOnAddress(destination); Settings.GetOrCreate <ConfiguredUnicastRoutes>().Add(new AssemblyRouteSource(assembly, UnicastRoute.CreateFromEndpointName(destination))); }
/// <summary> /// Specifies the certificate to use for client authentication when connecting to the broker via TLS. /// </summary> /// <param name="transportExtensions">The transport configuration object</param> /// <param name="path">The path to the certificate file.</param> /// <param name="password">The password for the certificate specified in <paramref name="path"/>.</param> public static TransportExtensions <RabbitMQTransport> SetClientCertificate(this TransportExtensions <RabbitMQTransport> transportExtensions, string path, string password) { Guard.AgainstNull(nameof(transportExtensions), transportExtensions); Guard.AgainstNullAndEmpty(nameof(path), path); Guard.AgainstNullAndEmpty(nameof(password), password); transportExtensions.GetSettings().Set(SettingsKeys.ClientCertificateCollection, new X509Certificate2Collection(new X509Certificate2(path, password))); return(transportExtensions); }
/// <summary> /// Creates a <see cref="IForwardingContext" /> based on the current context. /// </summary> public static IForwardingContext CreateForwardingContext(this ForkConnector <IIncomingPhysicalMessageContext, IForwardingContext> forwardingContext, OutgoingMessage message, string forwardingAddress, IIncomingPhysicalMessageContext sourceContext) { Guard.AgainstNull(nameof(message), message); Guard.AgainstNullAndEmpty(nameof(forwardingAddress), forwardingAddress); Guard.AgainstNull(nameof(sourceContext), sourceContext); var connector = (IForkConnector <IIncomingPhysicalMessageContext, IIncomingPhysicalMessageContext, IForwardingContext>)forwardingContext; return(connector.CreateForwardingContext(message, forwardingAddress, sourceContext)); }
/// <summary>Override the default table name used for storing delayed messages.</summary> /// <param name="delayedMessagesTableName">New table name.</param> public void UseTableName(string delayedMessagesTableName) { Guard.AgainstNullAndEmpty(nameof(delayedMessagesTableName), delayedMessagesTableName); if (tableNameRegex.IsMatch(delayedMessagesTableName) == false) { throw new ArgumentException($"{nameof(delayedMessagesTableName)} must match the following regular expression '{tableNameRegex}'"); } this.GetSettings().Set(WellKnownConfigurationKeys.DelayedDelivery.TableName, delayedMessagesTableName.ToLower()); }