public Task <IServiceHubContext> CreateHubContextAsync(string hubName)
{
switch (_serviceManagerOptions.ServiceTransportType)
{
case ServiceTransportType.Persistent:
{
throw new NotImplementedException();
}
case ServiceTransportType.Transient:
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddSignalRCore();
// remove default hub lifetime manager
var serviceDescriptor = serviceCollection.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(HubLifetimeManager <>));
serviceCollection.Remove(serviceDescriptor);
// add rest hub lifetime manager
var restHubLifetimeManager = new RestHubLifetimeManager(_serviceManagerOptions, hubName);
serviceCollection.AddSingleton(typeof(HubLifetimeManager <Hub>), restHubLifetimeManager);
var services = serviceCollection.BuildServiceProvider();
var hubContext = services.GetRequiredService <IHubContext <Hub> >();
var serviceHubContext = new ServiceHubContext(hubContext, restHubLifetimeManager);
return(Task.FromResult <IServiceHubContext>(serviceHubContext));
}
default:
throw new ArgumentException("Not supported service transport type.");
}
}
public async Task<IServiceHubContext> CreateHubContextAsync(string hubName, ILoggerFactory loggerFactory = null, CancellationToken cancellationToken = default)
{
loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
switch (_serviceManagerOptions.ServiceTransportType)
{
case ServiceTransportType.Persistent:
{
var connectionFactory = new ManagementConnectionFactory(_productInfo, new ConnectionFactory(_serverNameProvider, loggerFactory));
var serviceProtocol = new ServiceProtocol();
var clientConnectionManager = new ClientConnectionManager();
var clientConnectionFactory = new ClientConnectionFactory();
ConnectionDelegate connectionDelegate = connectionContext => Task.CompletedTask;
var serviceConnectionFactory = new ServiceConnectionFactory(serviceProtocol, clientConnectionManager, connectionFactory, loggerFactory, connectionDelegate, clientConnectionFactory);
var weakConnectionContainer = new WeakServiceConnectionContainer(
serviceConnectionFactory,
_serviceManagerOptions.ConnectionCount,
new HubServiceEndpoint(hubName, _endpointProvider, _endpoint),
loggerFactory?.CreateLogger(nameof(WeakServiceConnectionContainer)) ?? NullLogger.Instance);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSignalRCore();
serviceCollection.AddSingleton<IConfigureOptions<HubOptions>, ManagementHubOptionsSetup>();
if (loggerFactory != null)
{
serviceCollection.AddSingleton(typeof(ILoggerFactory), loggerFactory);
}
serviceCollection
.AddLogging()
.AddSingleton(typeof(IConnectionFactory), sp => connectionFactory)
.AddSingleton(typeof(HubLifetimeManager<>), typeof(WebSocketsHubLifetimeManager<>))
.AddSingleton(typeof(IServiceConnectionManager<>), typeof(ServiceConnectionManager<>))
.AddSingleton(typeof(IServiceConnectionContainer), sp => weakConnectionContainer);
var success = false;
ServiceProvider serviceProvider = null;
try
{
serviceProvider = serviceCollection.BuildServiceProvider();
var serviceConnectionManager = serviceProvider.GetRequiredService<IServiceConnectionManager<Hub>>();
serviceConnectionManager.SetServiceConnection(weakConnectionContainer);
_ = serviceConnectionManager.StartAsync();
// wait until service connection established
await weakConnectionContainer.ConnectionInitializedTask.OrTimeout(cancellationToken);
var webSocketsHubLifetimeManager = (WebSocketsHubLifetimeManager<Hub>)serviceProvider.GetRequiredService<HubLifetimeManager<Hub>>();
var hubContext = serviceProvider.GetRequiredService<IHubContext<Hub>>();
var serviceHubContext = new ServiceHubContext(hubContext, webSocketsHubLifetimeManager, serviceProvider);
success = true;
return serviceHubContext;
}
finally
{
if (!success)
{
serviceProvider?.Dispose();
}
}
}
case ServiceTransportType.Transient:
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddSignalRCore();
// remove default hub lifetime manager
var serviceDescriptor = serviceCollection.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(HubLifetimeManager<>));
serviceCollection.Remove(serviceDescriptor);
// add rest hub lifetime manager
var restHubLifetimeManager = new RestHubLifetimeManager(_serviceManagerOptions, hubName, _productInfo);
serviceCollection.AddSingleton(typeof(HubLifetimeManager<Hub>), sp => restHubLifetimeManager);
var serviceProvider = serviceCollection.BuildServiceProvider();
var hubContext = serviceProvider.GetRequiredService<IHubContext<Hub>>();
return new ServiceHubContext(hubContext, restHubLifetimeManager, serviceProvider);
}
default:
throw new ArgumentException("Not supported service transport type.");
}
}
public ServiceHubContextImpl(ServiceHubContext baseHubContext, IHubContext <Hub <T>, T> typedHubContext)
{
_baseHubContext = baseHubContext;
Clients = typedHubContext.Clients;
}