/// <summary>
/// Adds the minimum essential Azure SignalR services to the specified <see cref="ISignalRServerBuilder" />.
/// </summary>
/// <param name="builder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="configure">A callback to configure the <see cref="ServiceOptions"/>.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddAzureSignalR(this ISignalRServerBuilder builder, Action <ServiceOptions> configure)
{
builder.AddAzureSignalR()
.Services.Configure(configure);
return(builder);
}
public static ISignalRServerBuilder AddRedis(this ISignalRServerBuilder builder, string redisConnectionString)
{
return(AddRedis(builder, o =>
{
o.Configuration = ConfigurationOptions.Parse(redisConnectionString);
}));
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using an Azure Service Bus topic.
/// </summary>
/// <param name="builder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="configureOptions">A callback to configure the service bus options.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddAzureServiceBus(this ISignalRServerBuilder builder, Action <SignalRAzureServiceBusOptions> configureOptions)
{
builder.Services.Configure(configureOptions);
builder.Services.PostConfigure <SignalRAzureServiceBusOptions>(options =>
{
if (string.IsNullOrEmpty(options.ConnectionString))
{
throw new ArgumentException("ConnectionString must be specified");
}
if (string.IsNullOrEmpty(options.TopicName))
{
throw new ArgumentException("TopicName must be specified");
}
if (options.AutoDeleteSubscriptionOnIdle.TotalMinutes < 5)
{
throw new ArgumentException("AutoDeleteSubscriptionOnIdle must be at least 5 minutes");
}
if (options.MessageTimeToLive.Ticks <= 0)
{
throw new ArgumentException("MessageTimeToLive must be strictly positive");
}
});
builder.Services.AddSingleton <INodeIdProvider, NodeIdProvider>();
builder.Services.AddSingleton <IMessageSenderProvider, MessageSenderProvider>();
builder.Services.AddSingleton <IServiceBusPublisher, ServiceBusPublisher>();
builder.Services.AddSingleton <IServiceBusListener, ServiceBusListener>();
builder.Services.AddSingleton(typeof(MessageSenderHubLifetimeManager <>));
builder.Services.AddSingleton(typeof(HubLifetimeManager <>), typeof(AzureServiceBusHubLifetimeManager <>));
builder.Services.AddHostedService <MessageDispatcher>();
return(builder);
}
private static ISignalRServerBuilder AddAzureSignalRCore(this ISignalRServerBuilder builder)
{
builder.Services
.AddSingleton(typeof(HubLifetimeManager <>), typeof(ServiceLifetimeManager <>))
.AddSingleton(typeof(IServiceProtocol), typeof(ServiceProtocol))
.AddSingleton(typeof(IClientConnectionManager), typeof(ClientConnectionManager))
.AddSingleton(typeof(IServiceConnectionManager <>), typeof(ServiceConnectionManager <>))
.AddSingleton(typeof(IServiceEndpointManager), typeof(ServiceEndpointManager))
.AddSingleton(typeof(IServerNameProvider), typeof(DefaultServerNameProvider))
.AddSingleton(typeof(IBlazorDetector), typeof(DefaultBlazorDetector))
.AddSingleton(typeof(ServiceHubDispatcher <>))
.AddSingleton(typeof(ServerLifetimeManager))
.AddSingleton(typeof(AzureSignalRMarkerService))
.AddSingleton <IClientConnectionFactory, ClientConnectionFactory>()
.AddSingleton <IHostedService, HeartBeat>()
.AddSingleton <NegotiateHandler>();
// If a custom router is added, do not add the default router
builder.Services.TryAddSingleton(typeof(IEndpointRouter), typeof(DefaultEndpointRouter));
builder.Services.TryAddSingleton(typeof(IConnectionRequestIdProvider), typeof(DefaultConnectionRequestIdProvider));
#if !NETSTANDARD2_0
builder.Services.TryAddSingleton <AzureSignalRHostedService>();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IStartupFilter, AzureSignalRStartupFilter>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <MatcherPolicy, NegotiateMatcherPolicy>());
#endif
return(builder);
}
/// <summary>
/// Adds the minimum essential Azure SignalR services to the specified <see cref="ISignalRServerBuilder" />.
/// </summary>
/// <param name="builder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="connectionString">The connection string of an Azure SignalR Service instance.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddAzureSignalR(this ISignalRServerBuilder builder, string connectionString)
{
return(builder.AddAzureSignalR(options =>
{
options.ConnectionString = connectionString;
}));
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using a shared Orleans cluster.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="clusterClient">The <see cref="IClusterClient"/>.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddOrleans <THub>(this ISignalRServerBuilder signalrBuilder, Action <OrleansOptions <THub> > configure) where THub : Hub
{
signalrBuilder.Services.Configure(configure);
signalrBuilder.Services.AddSingleton(typeof(HubLifetimeManager <THub>), typeof(OrleansHubLifetimeManager <THub>));
signalrBuilder.Services.AddSingleton(typeof(IHubProxy <THub>), provider => new HubProxy <THub>(provider.GetRequiredService <IOptions <OrleansOptions <THub> > >().Value.ClusterClient));
return(signalrBuilder);
}
public static void AddSignalR(this IServiceCollection services, ApplicationConfiguration applicationConfiguration)
{
// register SignalR
ISignalRServerBuilder signalRBuilder = services.AddSignalR(configure: options => { options.EnableDetailedErrors = applicationConfiguration.Environment.IsLocalDevelopmentOrTest(); })
.AddJsonProtocol(configure: options =>
{
JsonSerializerOptions serializerSettings = options.PayloadSerializerOptions;
serializerSettings.IgnoreNullValues = true;
serializerSettings.PropertyNameCaseInsensitive = false;
serializerSettings.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
serializerSettings.WriteIndented = false;
JsonConverterSetup.Configure(serializerSettings.Converters);
// Note Additional converters that require DI are enabled elsewhere
});
// if we're running anywhere but LOCAL or TEST then configure the redis backplane for SignalR
// DON'T ATTEMPT TO ENABLE THIS LOCALLY, IT WILL NOT WORK. AWS redis does not allow connections
// from outside AWS (regardless of security group configuration)
if (!applicationConfiguration.Environment.IsLocalOrTest())
{
_signalRConnectionFactory = new SignalRConnectionFactory();
signalRBuilder.AddStackExchangeRedis(configure: options =>
{
options.Configuration.ChannelPrefix = $"Labs-NFT-Server-{applicationConfiguration.Environment.GetName()}";
options.ConnectionFactory =
writer => _signalRConnectionFactory.ConnectionFactoryAsync(writer: writer, applicationConfiguration: applicationConfiguration);
});
}
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder" />, using a shared Orleans cluster.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder" /> to which Orleans integration should be added.</param>
/// <param name="configure">Action to configure the SignalR Orleans Integration.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder" /> for chaining.</returns>
public static ISignalRServerBuilder AddOrleans <THub>(this ISignalRServerBuilder signalrBuilder,
Action <OrleansSignalROptions <THub> > configure = null)
where THub : Hub
{
if (configure != null)
{
signalrBuilder.Services.Configure(configure);
}
signalrBuilder.Services.AddSingleton(typeof(HubLifetimeManager <THub>), c =>
{
var options = c.GetRequiredService <IOptions <OrleansSignalROptions <THub> > >();
var clusterClient = options.Value.ClusterClient ?? c.GetRequiredService <IClusterClient>();
var hubProxy = c.GetRequiredService <IHubProxy <THub> >();
var logger = c.GetRequiredService <ILogger <OrleansHubLifetimeManager <THub> > >();
return(new OrleansHubLifetimeManager <THub>(options, clusterClient, hubProxy, logger));
});
signalrBuilder.Services.AddSingleton(typeof(IHubProxy <THub>), c =>
{
var options = c.GetRequiredService <IOptions <OrleansSignalROptions <THub> > >().Value;
var clusterClient = options.ClusterClient ?? c.GetRequiredService <IClusterClient>();
return(new HubProxy <THub>(clusterClient));
});
return(signalrBuilder);
}
public static ISignalRServerBuilder AddAzureSignalRSyncDemo(this ISignalRServerBuilder builder)
{
//builder.Services.
builder.Services.AddSingleton(typeof(ClientStatTracker <>)) // counter for demo purpose
.AddSingleton(typeof(SyncServer)); // generate the access token and redirect URL
return(builder);
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using a shared Msmq server.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="msmqConnectionString">The connection string used to connect to the Msmq server.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddSignalRMsmq(this ISignalRServerBuilder signalrBuilder, string msmqConnectionString)
{
return(AddSignalRMsmq(signalrBuilder, o =>
{
o.ConnectionString = msmqConnectionString;
}));
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using a shared Orleans cluster.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="clusterClient">The <see cref="IClusterClient"/>.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddOrleans <THub>(this ISignalRServerBuilder signalrBuilder, Action <OrleansOptions <THub> > configure) where THub : Hub
{
signalrBuilder.Services.Configure(configure);
signalrBuilder.Services.AddSingleton(typeof(HubLifetimeManager <THub>), typeof(OrleansHubLifetimeManager <THub>));
signalrBuilder.Services.TryAddSingleton(typeof(IClientSetPartitioner <>), typeof(DefaultClientSetPartitioner <>));
return(signalrBuilder);
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using an Azure Service Bus topic.
/// </summary>
/// <param name="builder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="configureOptions">A callback to configure the service bus options.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddHttpForwarder(this ISignalRServerBuilder builder, Action <SignalRHttpForwarderOptions> configureOptions = null)
{
if (configureOptions == null)
{
builder.Services.AddSingleton(new SignalRHttpForwarderOptions());
}
else
{
builder.Services.Configure(configureOptions);
}
builder.Services.AddSingleton <Subject <MessageHook> >();
builder.Services.AddTransient <IObserver <MessageHook> >(s => s.GetRequiredService <Subject <MessageHook> >());
builder.Services.AddTransient <IObservable <MessageHook> >(s => s.GetRequiredService <Subject <MessageHook> >());
builder.Services.AddSingleton <IMessageSenderProvider, MessageSenderProvider>();
builder.Services.AddSingleton(typeof(MessageSenderHubLifetimeManager <>));
builder.Services.AddSingleton(typeof(HubLifetimeManager <>), typeof(HttpForwarderHubLifetimeManager <>));
builder.Services.AddSingleton <MessageDispatcher>();
builder.Services.AddSingleton <MessageForwarder>();
builder.Services.AddHostedService <MessageForwarderBootstrapper>();
builder.Services.AddSingleton <IForwarder>(s => s.GetRequiredService <MessageForwarder>());
return(builder);
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using a shared Redis server.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="redisConnectionString">The connection string used to connect to the Redis server.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddStackExchangeRedis(this ISignalRServerBuilder signalrBuilder, string redisConnectionString)
{
return(AddStackExchangeRedis(signalrBuilder, o =>
{
o.Configuration = ConfigurationOptions.Parse(redisConnectionString);
}));
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using a shared Msmq server.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="msmqConnectionString">The connection string used to connect to the Msmq server.</param>
/// <param name="configure">A callback to configure the Msmq options.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddSignalRMsmq(this ISignalRServerBuilder signalrBuilder, string msmqConnectionString, Action <MsmqOptions> configure)
{
return(AddSignalRMsmq(signalrBuilder, o =>
{
o.ConnectionString = msmqConnectionString;
configure(o);
}));
}
public static ISignalRServerBuilder AddRedisBackplaneForPopForums(this ISignalRServerBuilder signalRServerBuilder)
{
var serviceProvider = signalRServerBuilder.Services.BuildServiceProvider();
var config = serviceProvider.GetService <IConfig>();
signalRServerBuilder.AddStackExchangeRedis(config.CacheConnectionString);
return(signalRServerBuilder);
}
/// <summary>
/// Adds the minimum essential Azure SignalR services to the specified <see cref="ISignalRServerBuilder" />.
/// </summary>
/// <param name="builder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="configure">A callback to configure the <see cref="ServiceOptions"/>.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddAzureSignalR(this ISignalRServerBuilder builder, Action <ServiceOptions> configure)
{
builder.AddAzureSignalR()
.Services.Configure(configure)
.PostConfigure <ServiceOptions>(o => o.Validate());
return(builder);
}
public static ISignalRServerBuilder AddQueryNotifications(this ISignalRServerBuilder signalR)
{
signalR.Services.AddScoped <QueryHub>();
signalR.Services.AddSingleton <IQueryNotifier, QueryNotifier>();
return(signalR);
}
public static ISignalRServerBuilder AddAzureSignalR2(this ISignalRServerBuilder builder)
{
builder.AddAzureSignalR();
builder.Services.TryAddSingleton <AzureSignalRHostedService>();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IStartupFilter, AzureSignalRStartupFilter>());
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <MatcherPolicy, NegotiateMatcherPolicy>());
return(builder);
}
/// <summary>
/// Add GraphQL query streaming hub with default options.
/// Defaults:
/// - ISchema is resolved from <see cref="IServiceCollection" />
/// - IExtension's are resolved from <see cref="IServiceCollection" />
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static ISignalRServerBuilder AddQueryStreamHub(this ISignalRServerBuilder builder)
{
return(AddQueryStreamHub(
builder,
optionsBuilder => optionsBuilder
.Configure <ISchema>((options, schema) => options.Schema = schema)
));
}
/// <summary>
/// Adds the minimum essential Azure SignalR services to the specified <see cref="ISignalRServerBuilder" />.
/// </summary>
/// <param name="builder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
/// <remarks>
/// It reads connection string from a configuration entry Azure:SignalR:ConnectionString.
/// In development environment, try `dotnet user-secrets set Azure:SignalR:ConnectionString {YourConnectionString}`.
/// </remarks>
public static ISignalRServerBuilder AddAzureSignalR(this ISignalRServerBuilder builder)
{
builder.Services.AddSingleton <ServiceOptionsSetup>();
builder.Services.AddSingleton <IConfigureOptions <ServiceOptions> >(s => s.GetService <ServiceOptionsSetup>());
builder.Services.AddSingleton <IOptionsChangeTokenSource <ServiceOptions> >(s => s.GetService <ServiceOptionsSetup>());
return(builder.AddAzureSignalRCore());
}
public static ISignalRServerBuilder AddRedis(this ISignalRServerBuilder builder, string redisConnectionString, Action <RedisOptions> configure)
{
return(AddRedis(builder, o =>
{
o.Options = ConfigurationOptions.Parse(redisConnectionString);
configure(o);
}));
}
/// <summary>
/// Adds scale-out to a <see cref="ISignalRServerBuilder"/>, using a shared Nats server.
/// </summary>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="connection">The nats <see cref="IConnection"/>.</param>
/// <returns>The same instance of the <see cref="IServiceCollection"/> for chaining.</returns>
public static IServiceCollection AddNeonNats(
this ISignalRServerBuilder signalrBuilder,
IConnection connection)
{
signalrBuilder.Services.AddSingleton(connection);
return(AddNeonNats(signalrBuilder));
}
public static void AddRedisBackplane(this ISignalRServerBuilder builder, IConfiguration configuration)
{
var redisConnectionString = configuration.GetConnectionString("RedisConnectionString");
if (!string.IsNullOrEmpty(redisConnectionString))
{
builder.AddStackExchangeRedis(redisConnectionString, options => options.Configuration.ChannelPrefix = configuration["SignalR:RedisBackplane:ChannelName"] ?? "VirtoCommerceChannel");
}
}
/// <summary>
/// Add GraphQL query streaming hub with configured options
/// </summary>
/// <param name="builder"></param>
/// <param name="configureOptions"></param>
/// <returns></returns>
public static ISignalRServerBuilder AddTankaServerHub(
this ISignalRServerBuilder builder)
{
var services = builder.Services;
services.AddSignalR();
services.TryAddScoped <IQueryStreamService, QueryStreamService>();
return(builder);
}
/// <summary>
/// Registers the Hub Lifetime Manager based on the configuration options provided
/// </summary>
/// <param name="signalRServerBuilder">The SignalR builder abstraction for configuring SignalR servers.</param>
/// <param name="configureOptions">The MassTransit SignalR configuration options</param>
public static ISignalRServerBuilder AddMassTransitBackplane(this ISignalRServerBuilder signalRServerBuilder,
Action <MassTransitSignalROptions> configureOptions = null)
{
var options = new MassTransitSignalROptions();
configureOptions?.Invoke(options);
signalRServerBuilder.Services.AddSingleton(options);
return(signalRServerBuilder);
}
/// <summary>
/// 将模块服务添加到依赖注入服务容器中
/// </summary>
/// <param name="services">依赖注入服务容器</param>
/// <returns></returns>
public override IServiceCollection AddServices(IServiceCollection services)
{
services.TryAddSingleton <IUserIdProvider, UserNameUserIdProvider>();
ISignalRServerBuilder builder = services.AddSignalR();
Action <ISignalRServerBuilder> buildAction = GetSignalRServerBuildAction(services);
buildAction?.Invoke(builder);
return(services);
}
/// <summary>
/// Adds hub specific options to an <see cref="ISignalRServerBuilder"/>.
/// </summary>
/// <typeparam name="THub">The hub type to configure.</typeparam>
/// <param name="signalrBuilder">The <see cref="ISignalRServerBuilder"/>.</param>
/// <param name="configure">A callback to configure the hub options.</param>
/// <returns>The same instance of the <see cref="ISignalRServerBuilder"/> for chaining.</returns>
public static ISignalRServerBuilder AddHubOptions <THub>(this ISignalRServerBuilder signalrBuilder, Action <HubOptions <THub> > configure) where THub : Hub
{
if (signalrBuilder == null)
{
throw new ArgumentNullException(nameof(signalrBuilder));
}
signalrBuilder.Services.AddSingleton <IConfigureOptions <HubOptions <THub> >, HubOptionsSetup <THub> >();
signalrBuilder.Services.Configure(configure);
return(signalrBuilder);
}
public static ISignalRServerBuilder AddAzureSignalR(this ISignalRServerBuilder signalR, IConfiguration configuration)
{
var connectionString = configuration["Azure:SignalR:ConnectionString"];
if (connectionString != null)
{
return(signalR.AddAzureSignalR(connectionString));
}
return(signalR);
}
public static ISignalRServerBuilder AddRabbitMQ(this ISignalRServerBuilder signalrBuilder, string rabbitMQConnectionString, string exchangeName)
{
return(AddRabbitMQ(signalrBuilder, o =>
{
o.ConnectionFactory = new ConnectionFactory()
{
Uri = new Uri(rabbitMQConnectionString)
};
o.ExchangeName = exchangeName;
}));
}
public static ISignalRServerBuilder AddTankaServerHubWithTracing(
this ISignalRServerBuilder builder)
{
var services = builder.Services;
// add tracing extension
services.AddTankaServerExecutionExtension <TraceExtension>();
// default configuration
return(AddTankaServerHub(
builder));
}
