public IClusterClientPersistentStreamConfigurator Configure <TOptions>(Action <OptionsBuilder <TOptions> > configureOptions) where TOptions : class, new()
{
clientBuilder.ConfigureServices(services =>
{
configureOptions?.Invoke(services.AddOptions <TOptions>(this.name));
services.ConfigureNamedOptionForLogging <TOptions>(this.name);
});
return(this);
}
public static IClientBuilder UseUnixSocketConnection(this IClientBuilder clientBuilder)
{
clientBuilder.ConfigureServices(services =>
{
services.AddSingletonKeyedService <object, IConnectionFactory>(ClientOutboundConnectionFactory.ServicesKey, CreateUnixSocketConnectionFactory());
});
return(clientBuilder);
}
/// <summary>
/// Configures the cluster general options.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="configureOptions">The delegate that configures the options.</param>
/// <returns>The same instance of the <see cref="IClientBuilder"/> for chaining.</returns>
public static IClientBuilder ConfigureCluster(this IClientBuilder builder, Action <ClusterOptions> configureOptions)
{
if (configureOptions != null)
{
builder.ConfigureServices(services => services.Configure <ClusterOptions>(configureOptions));
}
return(builder);
}
public static IClientBuilder UseRedisGatewayListProvider(this IClientBuilder builder, ILogger <RedisGatewayListProvider> logger)
{
return(builder.ConfigureServices(services =>
{
services.AddOptions <RedisClusteringOptions>();
services.AddSingleton <IGatewayListProvider, RedisGatewayListProvider>();
services.TryAddSingleton <ILogger <RedisGatewayListProvider> >(logger);
}));
}
/// <summary>
/// Configures the cluster client general options.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="configureOptions">The delegate that configures the options using the options builder.</param>
/// <returns>The same instance of the <see cref="IClientBuilder"/> for chaining.</returns>
public static IClientBuilder ConfigureClusterClient(this IClientBuilder builder, Action <OptionsBuilder <ClusterClientOptions> > configureOptions)
{
if (configureOptions != null)
{
builder.ConfigureServices(services => configureOptions.Invoke(services.AddOptions <ClusterClientOptions>()));
}
return(builder);
}
/// <summary>
/// Use Windows performance counters as source for host environment statistics
/// </summary>
public static IClientBuilder UsePerfCounterEnvironmentStatistics(this IClientBuilder builder)
{
return(builder.ConfigureServices(services =>
{
services.AddSingleton <PerfCounterEnvironmentStatistics>();
services.AddFromExisting <IHostEnvironmentStatistics, PerfCounterEnvironmentStatistics>();
services.AddFromExisting <ILifecycleParticipant <IClusterClientLifecycle>, PerfCounterEnvironmentStatistics>();
}));
}
public ClusterClientSqsStreamConfigurator(string name, IClientBuilder builder)
: base(name, builder, SQSAdapterFactory.Create)
{
builder
.ConfigureServices(services =>
{
services.ConfigureNamedOptionForLogging <SqsOptions>(name)
.ConfigureNamedOptionForLogging <HashRingStreamQueueMapperOptions>(name);
});
}
/// <summary>
/// Use Linux host environment statistics
/// </summary>
public static IClientBuilder UseLinuxEnvironmentStatistics(this IClientBuilder builder)
{
return(builder.ConfigureServices(services =>
{
services.AddTransient <IConfigurationValidator, LinuxEnvironmentStatisticsValidator>();
services.AddSingleton <LinuxEnvironmentStatistics>();
services.AddFromExisting <IHostEnvironmentStatistics, LinuxEnvironmentStatistics>();
services.AddFromExisting <ILifecycleParticipant <IClusterClientLifecycle>, LinuxEnvironmentStatistics>();
}));
}
/// <summary>
/// Configures the client to use dns name lookup clustering.
/// </summary>
public static IClientBuilder UseDnsNameLookupClustering(this IClientBuilder builder, Action <OptionsBuilder <DnsNameGatewayListProviderOptions> > configureOptions)
{
return(builder.ConfigureServices(
collection =>
{
configureOptions?.Invoke(collection.AddOptions <DnsNameGatewayListProviderOptions>());
collection.AddSingleton <IGatewayListProvider, DnsNameGatewayListProvider>()
.ConfigureFormatter <DnsNameGatewayListProviderOptions>();
}));
}
public void Configure(IConfiguration configuration, IClientBuilder hostBuilder)
{
hostBuilder
.AddSimpleMessageStreamProvider(InterfaceConst.SMSProvider);
hostBuilder.ConfigureServices(services =>
{
services.AddEventStoreService();
services.AddAggregateServices();
});
}
/// <summary>
/// Configures the client to use Azure Storage for clustering.
/// </summary>
/// <param name="builder">
/// The client builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
public static IClientBuilder UseAzureStorageClustering(
this IClientBuilder builder,
Action <OptionsBuilder <AzureStorageGatewayOptions> > configureOptions)
{
return(builder.ConfigureServices(
services =>
{
configureOptions?.Invoke(services.AddOptions <AzureStorageGatewayOptions>());
services.AddSingleton <IGatewayListProvider, AzureGatewayListProvider>();
}));
}
public static IClientBuilder UseRedisClustering(this IClientBuilder builder, string redisConnectionString, int db = 0)
{
return(builder.ConfigureServices(services => services
.Configure <RedisOptions>(opt =>
{
opt.ConnectionString = redisConnectionString;
opt.Database = db;
})
.AddRedis()
.AddSingleton <IGatewayListProvider, RedisGatewayListProvider>()));
}
/// <summary>
/// Specified the configuration to use for this client.
/// </summary>
/// <param name="builder">The client builder.</param>
/// <param name="configuration">The configuration.</param>
/// <remarks>This method may only be called once per builder instance.</remarks>
/// <returns>The builder.</returns>
public static IClientBuilder UseConfiguration(this IClientBuilder builder, ClientConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
return(builder.ConfigureServices(services =>
{
services.AddLegacyClientConfigurationSupport(configuration);
}));
}
/// <summary>
/// Configures the client to use DynamoDB for clustering.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
public static IClientBuilder UseDynamoDBClustering(
this IClientBuilder builder,
Action <OptionsBuilder <DynamoDBClusteringClientOptions> > configureOptions)
{
return(builder.ConfigureServices(
services =>
{
configureOptions?.Invoke(services.AddOptions <DynamoDBClusteringClientOptions>());
services.AddSingleton <IGatewayListProvider, DynamoDBGatewayListProvider>();
}));
}
/// <summary>
/// Uses the entity framework clustering.
/// </summary>
/// <param name="builder">The builder.</param>
/// <returns></returns>
public static IClientBuilder UseEntityFrameworkClustering(this IClientBuilder builder)
{
ConfigureParts(builder);
builder.ConfigureServices(services =>
{
services.AddSingleton <IGatewayListProvider, OrleansEFGatewayListProvider>();
});
return(builder);
}
/// <summary>
/// Configure the client to use ZooKeeper for clustering.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
public static IClientBuilder UseZooKeeperClustering(
this IClientBuilder builder,
Action <OptionsBuilder <ZooKeeperGatewayListProviderOptions> > configureOptions)
{
return(builder.ConfigureServices(
services =>
{
configureOptions?.Invoke(services.AddOptions <ZooKeeperGatewayListProviderOptions>());
services.AddSingleton <IGatewayListProvider, ZooKeeperGatewayListProvider>();
}));
}
/// <summary>
/// Configures this client to use ADO.NET for clustering. Instructions on configuring your database are available at <see href="http://aka.ms/orleans-sql-scripts"/>.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
/// <remarks>
/// Instructions on configuring your database are available at <see href="http://aka.ms/orleans-sql-scripts"/>.
/// </remarks>
public static IClientBuilder UseAdoNetClustering(
this IClientBuilder builder,
Action <OptionsBuilder <AdoNetClusteringClientOptions> > configureOptions)
{
return(builder.ConfigureServices(
services =>
{
configureOptions?.Invoke(services.AddOptions <AdoNetClusteringClientOptions>());
services.AddSingleton <IGatewayListProvider, AdoNetGatewayListProvider>();
services.AddSingleton <IConfigurationValidator, AdoNetClusteringClientOptionsValidator>();
}));
}
public static IClientBuilder UseCassandraClustering(this IClientBuilder builder, Action <CassandraClusteringOptions> configureOptions)
{
return(builder.ConfigureServices(
services =>
{
if (configureOptions != null)
{
services.Configure(configureOptions);
}
services.AddSingleton <IGatewayListProvider, CassandraGatewayListProvider>();
}));
}
/// <summary>
/// Configures default client services.
/// </summary>
/// <param name="builder">The host builder.</param>
/// <returns>The client builder.</returns>
public static IClientBuilder ConfigureDefaults(this IClientBuilder builder)
{
// Configure the container to use an Orleans client.
builder.ConfigureServices(services =>
{
const string key = "OrleansClientServicesAdded";
if (!builder.Properties.ContainsKey(key))
{
DefaultClientServices.AddDefaultServices(services);
builder.Properties.Add(key, true);
}
});
return(builder);
}
public static IClientBuilder UseRedisClustering(this IClientBuilder builder, Action <RedisOptions> configuration)
{
return(builder.ConfigureServices(services =>
{
if (configuration != null)
{
services.Configure(configuration);
}
services
.AddRedis()
.AddSingleton <IGatewayListProvider, RedisGatewayListProvider>();
}));
}
/// <summary>
/// Configures the client to use static clustering.
/// </summary>
public static IClientBuilder UseStaticClustering(this IClientBuilder builder, Action <StaticGatewayListProviderOptions> configureOptions)
{
return(builder.ConfigureServices(
collection =>
{
if (configureOptions != null)
{
collection.Configure(configureOptions);
}
collection.AddSingleton <IGatewayListProvider, StaticGatewayListProvider>()
.TryConfigureFormatter <StaticGatewayListProviderOptions, StaticGatewayListProviderOptionsFormatter>();
}));
}
public override void Configure(IConfiguration configuration, IClientBuilder clientBuilder)
{
var primaryGw = this.ClusterConfiguration.Overrides["Primary"].ProxyGatewayEndpoint.ToGatewayUri();
clientBuilder.ConfigureServices(services =>
{
services.AddSingleton(sp =>
{
var gateway = new TestGatewayManager();
gateway.Gateways.Add(primaryGw);
return(gateway);
});
services.AddFromExisting <IGatewayListProvider, TestGatewayManager>();
});
}
/// <summary>
/// Adds Request Context Grain call filter.
/// </summary>
/// <param name="builder">The <see cref="IClientBuilder"/>.</param>
/// <param name="serviceProvider">The <see cref="IServiceProvider"/>.</param>
/// <returns>The <see cref="IClientBuilder"/>.</returns>
public static IClientBuilder AddRequestContextOutgoingFilter([NotNull] this IClientBuilder builder, [NotNull] IServiceProvider serviceProvider)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
builder.ConfigureServices(services => services.TryAddSingleton(serviceProvider.GetRequiredService <IRequestContextAccessor>()));
return(builder.AddOutgoingGrainCallFilter <RequestContextGrainCallFilter>());
}
/// <summary>
/// Configure the client to use ZooKeeper for clustering.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
public static IClientBuilder UseZooKeeperClustering(
this IClientBuilder builder,
Action <ZooKeeperGatewayListProviderOptions> configureOptions)
{
return(builder.ConfigureServices(
services =>
{
if (configureOptions != null)
{
services.Configure(configureOptions);
}
services.AddSingleton <IGatewayListProvider, ZooKeeperClusteringClientOptions>();
}));
}
public static IClientBuilder AddSignalR(this IClientBuilder builder, Action <SimpleMessageStreamProviderOptions> configureOptions)
{
builder.AddSimpleMessageStreamProvider(Constants.STREAM_PROVIDER, configureOptions)
.ConfigureApplicationParts(manager =>
{
manager.AddApplicationPart(typeof(IClientGrain).Assembly).WithReferences();
});
builder.ConfigureServices(services =>
{
services.TryAddSingleton(typeof(IClientSetPartitioner <>), typeof(DefaultClientSetPartitioner <>));
});
return(builder);
}
/// <summary>
/// Configures the client to use Azure Storage for clustering.
/// </summary>
/// <param name="builder">
/// The client builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
public static IClientBuilder UseAzureStorageClustering(
this IClientBuilder builder,
Action <AzureStorageGatewayOptions> configureOptions)
{
return(builder.ConfigureServices(
services =>
{
if (configureOptions != null)
{
services.Configure(configureOptions);
}
services.AddSingleton <IGatewayListProvider, AzureGatewayListProvider>()
.ConfigureFormatter <AzureStorageGatewayOptions>();
}));
}
/// <summary>
/// Configures this client to use ADO.NET for clustering. Instructions on configuring your database are available at <see href="http://aka.ms/orleans-sql-scripts"/>.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="configureOptions">
/// The configuration delegate.
/// </param>
/// <returns>
/// The provided <see cref="IClientBuilder"/>.
/// </returns>
/// <remarks>
/// Instructions on configuring your database are available at <see href="http://aka.ms/orleans-sql-scripts"/>.
/// </remarks>
public static IClientBuilder UseAdoNetClustering(
this IClientBuilder builder,
Action <AdoNetClusteringClientOptions> configureOptions)
{
return(builder.ConfigureServices(
services =>
{
if (configureOptions != null)
{
services.Configure(configureOptions);
}
services.AddSingleton <IGatewayListProvider, AdoNetGatewayListProvider>();
services.AddSingleton <IConfigurationValidator, AdoNetClusteringClientOptionsValidator>();
}));
}
public static IClientBuilder UseRedisMembership(this IClientBuilder builder, string redisConnectionString, int db = 0)
{
builder.Configure <ClusterMembershipOptions>(x => x.ValidateInitialConnectivity = true);
return(builder.ConfigureServices(services => services
.Configure <RedisOptions>(opt =>
{
opt.ConnectionString = redisConnectionString;
opt.Database = db;
})
.AddSingleton(new GatewayOptions()
{
GatewayListRefreshPeriod = GatewayOptions.DEFAULT_GATEWAY_LIST_REFRESH_PERIOD
})
.AddRedis()
.AddSingleton <IGatewayListProvider, RedisGatewayListProvider>()));
}
/// <summary>
/// Adds support for connecting to a cluster hosted in Service Fabric.
/// </summary>
/// <param name="clientBuilder">The client builder.</param>
/// <param name="serviceName">The Service Fabric service name.</param>
/// <returns>The provided client builder.</returns>
public static IClientBuilder UseServiceFabricClustering(
this IClientBuilder clientBuilder,
Uri serviceName)
{
clientBuilder.ConfigureServices(
serviceCollection =>
{
AddStandardServices(serviceCollection);
// Use Service Fabric for cluster membership.
serviceCollection.TryAddSingleton <IFabricServiceSiloResolver>(sp => ActivatorUtilities.CreateInstance <FabricServiceSiloResolver>(sp, serviceName));
serviceCollection.TryAddSingleton <IGatewayListProvider, FabricGatewayProvider>();
});
return(clientBuilder);
}
public ClusterClientRabbitMQStreamConfigurator(string name, IClientBuilder builder)
: base(name, builder, RabbitMQAdapterFactory.Create)
{
builder.ConfigureApplicationParts(parts =>
{
parts.AddFrameworkPart(typeof(RabbitMQAdapterFactory).Assembly);
parts.AddFrameworkPart(typeof(EventSequenceTokenV2).Assembly);
parts.AddFrameworkPart(typeof(EventSequenceToken).Assembly);
});
builder.ConfigureServices(services =>
{
services.ConfigureNamedOptionForLogging<HashRingStreamQueueMapperOptions>(name);
services.ConfigureNamedOptionForLogging<RabbitMQOptions>(name);
services.AddTransient<IConfigurationValidator>(sp => new RabbitMQOptionsValidator(sp.GetOptionsByName<RabbitMQOptions>(name), name));
});
}