public ServiceLifetimeManager(
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IHubProtocolResolver protocolResolver,
ILogger <ServiceLifetimeManager <THub> > logger,
AzureSignalRMarkerService marker,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
IBlazorDetector blazorDetector)
: base(
serviceConnectionManager,
protocolResolver,
globalHubOptions,
hubOptions, logger)
{
// after core 3.0 UseAzureSignalR() is not required.
#if NETSTANDARD2_0
if (!marker.IsConfigured)
{
throw new InvalidOperationException(MarkerNotConfiguredError);
}
#endif
_clientConnectionManager = clientConnectionManager;
if (hubOptions.Value.SupportedProtocols != null && hubOptions.Value.SupportedProtocols.Any(x => x.Equals(Constants.Protocol.BlazorPack, StringComparison.OrdinalIgnoreCase)))
{
blazorDetector?.TrySetBlazor(typeof(THub).Name, true);
}
}
public ServiceHubDispatcher(
IServiceProtocol serviceProtocol,
IHubContext <THub> context,
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IServiceEndpointManager serviceEndpointManager,
IOptions <ServiceOptions> options,
ILoggerFactory loggerFactory,
IEndpointRouter router,
IServerNameProvider nameProvider,
ServerLifetimeManager serverLifetimeManager,
IClientConnectionFactory clientConnectionFactory,
IServiceEventHandler serviceEventHandler)
{
_serviceProtocol = serviceProtocol;
_serviceConnectionManager = serviceConnectionManager;
_clientConnectionManager = clientConnectionManager;
_serviceEndpointManager = serviceEndpointManager;
_options = options != null ? options.Value : throw new ArgumentNullException(nameof(options));
Context = context;
_router = router ?? throw new ArgumentNullException(nameof(router));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger <ServiceHubDispatcher <THub> >();
_clientConnectionFactory = clientConnectionFactory;
_nameProvider = nameProvider;
_hubName = typeof(THub).Name;
_serviceEventHandler = serviceEventHandler;
serverLifetimeManager?.Register(ShutdownAsync);
}
public MockServiceHubDispatcher(
IServiceProtocol serviceProtocol,
IHubContext <THub> context,
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IServiceEndpointManager serviceEndpointManager,
IOptions <ServiceOptions> options,
ILoggerFactory loggerFactory,
IEndpointRouter router,
IServerNameProvider nameProvider,
ServerLifetimeManager serverLifetimeManager,
IClientConnectionFactory clientConnectionFactory) : base(
serviceProtocol,
context,
serviceConnectionManager,
clientConnectionManager,
serviceEndpointManager,
options,
loggerFactory,
router,
nameProvider,
serverLifetimeManager,
clientConnectionFactory,
null)
{
MockService = new ConnectionTrackingMockService();
// just store copies of these locally to keep the base class' accessor modifiers intact
_loggerFactory = loggerFactory;
_clientConnectionManager = clientConnectionManager;
_serviceProtocol = serviceProtocol;
_clientConnectionFactory = clientConnectionFactory;
}
private static void PrepareConnection(IServiceConnectionManager scm, out SortedList <string, ServiceMessage> output)
{
var result = new SortedList <string, ServiceMessage>();
scm.Initialize(new TestServiceConnectionContainerFactory(result));
output = result;
}
public ServiceMessageBus(IDependencyResolver resolver) : base(resolver)
{
// TODO: find a more decent way instead of DI, it can be easily overriden
_serviceConnectionManager = resolver.Resolve <IServiceConnectionManager>() ?? throw new ArgumentNullException(nameof(IServiceConnectionManager));
_parser = resolver.Resolve <IMessageParser>() ?? throw new ArgumentNullException(nameof(IMessageParser));
_ackHandler = resolver.Resolve <IAckHandler>() ?? throw new ArgumentNullException(nameof(IAckHandler));
}
public ServiceConnectionBase(IServiceProtocol serviceProtocol, ILoggerFactory loggerFactory, string connectionId, IServiceConnectionManager serviceConnectionManager, ServerConnectionType connectionType)
{
ServiceProtocol = serviceProtocol;
ConnectionId = connectionId;
_connectionType = connectionType;
_cachedPingBytes = serviceProtocol.GetMessageBytes(PingMessage.Instance);
_handshakeRequest = new HandshakeRequestMessage(serviceProtocol.Version, (int)connectionType);
_logger = loggerFactory?.CreateLogger <ServiceConnectionBase>() ?? NullLogger <ServiceConnectionBase> .Instance;
_serviceConnectionManager = serviceConnectionManager;
}
public ServiceHubDispatcher(IReadOnlyList <string> hubNames,
IServiceConnectionManager serviceConnectionManager,
IServiceConnectionContainerFactory serviceConnectionContainerFactory,
IOptions <ServiceOptions> options,
ILoggerFactory loggerFactory)
{
_hubNames = hubNames;
_name = $"{nameof(ServiceHubDispatcher)}[{string.Join(",", hubNames)}]";
_loggerFactory = loggerFactory;
_serviceConnectionManager = serviceConnectionManager ?? throw new ArgumentNullException(nameof(serviceConnectionManager));
_serviceConnectionContainerFactory = serviceConnectionContainerFactory;
_options = options?.Value;
_logger = _loggerFactory.CreateLogger <ServiceHubDispatcher>();
}
private static void PrepareConnection(IServiceConnectionManager scm, out SortedList <string, ServiceMessage> output)
{
var result = new SortedList <string, ServiceMessage>();
scm.Initialize(hub => new TestServiceConnection(hub,
m =>
{
lock (result)
{
result.Add(hub, m.Item1);
}
}), 5);
output = result;
}
public ServiceLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager, IHubProtocolResolver protocolResolver,
ILogger <ServiceLifetimeManager <THub> > logger, AzureSignalRMarkerService marker)
{
if (!marker.IsConfigured)
{
throw new InvalidOperationException(MarkerNotConfiguredError);
}
_serviceConnectionManager = serviceConnectionManager;
_clientConnectionManager = clientConnectionManager;
_allProtocols = protocolResolver.AllProtocols;
_logger = logger;
}
public ConnectionFactory(IReadOnlyList <string> hubNames, HubConfiguration hubConfig)
{
_config = hubConfig;
_hubNames = hubNames;
_name = $"{nameof(ConnectionFactory)}[{string.Join(",", hubNames)}]";
_userId = GenerateServerName();
_loggerFactory = hubConfig.Resolver.Resolve <ILoggerFactory>() ?? NullLoggerFactory.Instance;
_protocol = hubConfig.Resolver.Resolve <IServiceProtocol>();
_serviceConnectionManager = hubConfig.Resolver.Resolve <IServiceConnectionManager>();
_clientConnectionManager = hubConfig.Resolver.Resolve <IClientConnectionManager>();
_endpoint = hubConfig.Resolver.Resolve <IServiceEndpointProvider>();
_options = hubConfig.Resolver.Resolve <IOptions <ServiceOptions> >().Value;
_logger = _loggerFactory.CreateLogger <ConnectionFactory>();
}
public ServiceConnection(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string connectionId,
IServiceConnectionManager manager,
ServerConnectionType connectionType = ServerConnectionType.Default) :
base(serviceProtocol, loggerFactory, connectionId, manager, connectionType)
{
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
_logger = loggerFactory?.CreateLogger <ServiceConnection>() ?? NullLogger <ServiceConnection> .Instance;
}
public ServiceHubDispatcher(IReadOnlyList <string> hubNames, IServiceProtocol protocol,
IServiceConnectionManager serviceConnectionManager, IClientConnectionManager clientConnectionManager,
IServiceEndpointManager serviceEndpointManager,
IEndpointRouter router,
IOptions <ServiceOptions> options, ILoggerFactory loggerFactory)
{
_hubNames = hubNames;
_name = $"{nameof(ServiceHubDispatcher)}[{string.Join(",", hubNames)}]";
_loggerFactory = loggerFactory;
_protocol = protocol ?? throw new ArgumentNullException(nameof(protocol));
_router = router ?? throw new ArgumentNullException(nameof(router));
_serviceConnectionManager = serviceConnectionManager ?? throw new ArgumentNullException(nameof(serviceConnectionManager));
_clientConnectionManager = clientConnectionManager ?? throw new ArgumentNullException(nameof(clientConnectionManager));
_options = options?.Value;
_serviceEndpointManager = serviceEndpointManager ?? throw new ArgumentNullException(nameof(serviceEndpointManager));
_logger = _loggerFactory.CreateLogger <ServiceHubDispatcher>();
}
protected override Task StartCoreAsync(string serverUrl, ITestOutputHelper output, Dictionary <string, string> configuration)
{
var userIdProvider = new UserIdProvider();
_loggerFactory = new LoggerFactory().AddXunit(output);
_webApp = WebApp.Start(new StartOptions(serverUrl), app =>
{
var hubConfiguration = Utility.GetActualHubConfig(_loggerFactory);
hubConfiguration.Resolver.Register(typeof(TestHub), () => new TestHub(HubConnectionManager));
hubConfiguration.Resolver.Register(typeof(IUserIdProvider), () => userIdProvider);
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
app.MapAzureSignalR("/signalr", GetType().FullName, hubConfiguration, options => options.ConnectionString = TestConfiguration.Instance.ConnectionString);
_scm = hubConfiguration.Resolver.Resolve <IServiceConnectionManager>();
GlobalHost.TraceManager.Switch.Level = SourceLevels.Information;
});
return(Task.CompletedTask);
}
public ServiceLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager, IHubProtocolResolver protocolResolver,
ILogger <ServiceLifetimeManager <THub> > logger, AzureSignalRMarkerService marker)
: base(serviceConnectionManager, protocolResolver)
{
// after core 3.0 UseAzureSignalR() is not required.
#if !NETCOREAPP3_0
if (!marker.IsConfigured)
{
throw new InvalidOperationException(MarkerNotConfiguredError);
}
#endif
_serviceConnectionManager = serviceConnectionManager;
_clientConnectionManager = clientConnectionManager;
_allProtocols = protocolResolver.AllProtocols;
_logger = logger;
}
protected override Task StartCoreAsync(string serverUrl, ITestOutputHelper output, Dictionary <string, string> configuration)
{
_host = new WebHostBuilder()
.ConfigureServices(services =>
{
services.AddSingleton <TestHubConnectionManager>(HubConnectionManager);
})
.ConfigureLogging(logging => logging.AddXunit(output))
.ConfigureAppConfiguration(builder => builder.AddInMemoryCollection(configuration))
.UseStartup <TestStartup>()
.UseUrls(serverUrl)
.UseKestrel()
.Build();
_scm = _host.Services.GetRequiredService <IServiceConnectionManager <TestHub> >();
return(_host.StartAsync());
}
public ServiceHubDispatcher(IServiceProtocol serviceProtocol,
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IServiceEndpointProvider serviceEndpointProvider,
IOptions <ServiceOptions> options,
ILoggerFactory loggerFactory,
IClientConnectionFactory clientConnectionFactory)
{
_serviceProtocol = serviceProtocol;
_serviceConnectionManager = serviceConnectionManager;
_clientConnectionManager = clientConnectionManager;
_serviceEndpointProvider = serviceEndpointProvider;
_options = options != null ? options.Value : throw new ArgumentNullException(nameof(options));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger <ServiceHubDispatcher <THub> >();
_clientConnectionFactory = clientConnectionFactory;
_userId = GenerateServerName();
}
public ServiceHubDispatcher(IServiceProtocol serviceProtocol,
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IServiceEndpointManager serviceEndpointManager,
IOptions <ServiceOptions> options,
ILoggerFactory loggerFactory,
IEndpointRouter router,
IClientConnectionFactory clientConnectionFactory)
{
_serviceProtocol = serviceProtocol;
_serviceConnectionManager = serviceConnectionManager;
_clientConnectionManager = clientConnectionManager;
_serviceEndpointManager = serviceEndpointManager;
_options = options != null ? options.Value : throw new ArgumentNullException(nameof(options));
_router = router ?? throw new ArgumentNullException(nameof(router));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger <ServiceHubDispatcher <THub> >();
_clientConnectionFactory = clientConnectionFactory;
_hubName = typeof(THub).Name;
}
private HubLifetimeManager <TestHub> MockLifetimeManager(IServiceConnectionManager <TestHub> serviceConnectionManager, IClientConnectionManager clientConnectionManager = null, IBlazorDetector blazorDetector = null)
{
clientConnectionManager ??= new ClientConnectionManager();
var protocolResolver = new DefaultHubProtocolResolver(new IHubProtocol[]
{
new JsonHubProtocol(),
new MessagePackHubProtocol(),
new CustomHubProtocol(),
},
NullLogger <DefaultHubProtocolResolver> .Instance
);
IOptions <HubOptions> globalHubOptions = Options.Create(new HubOptions()
{
SupportedProtocols = new List <string>()
{
MockProtocol
}
});
IOptions <HubOptions <TestHub> > localHubOptions = Options.Create(new HubOptions <TestHub>()
{
SupportedProtocols = new List <string>()
{
MockProtocol
}
});
return(new ServiceLifetimeManager <TestHub>(
serviceConnectionManager,
clientConnectionManager,
protocolResolver,
Logger,
Marker,
globalHubOptions,
localHubOptions,
blazorDetector
));
}
public ServiceLifetimeManager(
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IHubProtocolResolver protocolResolver,
ILogger <ServiceLifetimeManager <THub> > logger,
AzureSignalRMarkerService marker,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions)
: base(
serviceConnectionManager,
protocolResolver,
globalHubOptions,
hubOptions, logger)
{
// after core 3.0 UseAzureSignalR() is not required.
#if NETSTANDARD2_0
if (!marker.IsConfigured)
{
throw new InvalidOperationException(MarkerNotConfiguredError);
}
#endif
_clientConnectionManager = clientConnectionManager;
}
public WebSocketsHubLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions, ILoggerFactory loggerFactory, IOptions <ServiceManagerOptions> serviceManagerOptions) :
base(serviceConnectionManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory?.CreateLogger(nameof(WebSocketsHubLifetimeManager <Hub>)))
{
_serviceManagerOptions = serviceManagerOptions ?? throw new ArgumentNullException(nameof(serviceManagerOptions));
}
public ServiceLifetimeManagerBase(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver, IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions, ILogger logger)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
ServiceConnectionContainer = serviceConnectionManager;
_messageSerializer = new DefaultHubMessageSerializer(protocolResolver, globalHubOptions.Value.SupportedProtocols, hubOptions.Value.SupportedProtocols);
}
public IServiceConnection Create(IConnectionFactory connectionFactory, IServiceConnectionManager manager, ServerConnectionType type)
{
return(new ServiceConnection(_serviceProtocol, _clientConnectionManager, connectionFactory,
_loggerFactory, _connectionDelegate, _clientConnectionFactory,
Guid.NewGuid().ToString(), manager, type));
}
public WebSocketsHubLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver) : base(serviceConnectionManager, protocolResolver)
{
}
private static IDependencyResolver GetDefaultResolver(IReadOnlyList <string> hubs, out IServiceConnectionManager scm)
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IServiceProtocol), () => new ServiceProtocol());
var ccm = new TestClientConnectionManager();
resolver.Register(typeof(IClientConnectionManager), () => ccm);
var connectionManager = new ServiceConnectionManager(AppName, hubs);
resolver.Register(typeof(IServiceConnectionManager), () => connectionManager);
resolver.Register(typeof(IMessageParser), () => new SignalRMessageParser(hubs, resolver, NullLogger <SignalRMessageParser> .Instance));
scm = connectionManager;
return(resolver);
}
public ServiceLifetimeManagerBase(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver, IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions)
{
ServiceConnectionContainer = serviceConnectionManager;
_messageSerializer = new DefaultHubMessageSerializer(protocolResolver, globalHubOptions.Value.SupportedProtocols, hubOptions.Value.SupportedProtocols);
}
public ServiceConnectionProxy(ConnectionDelegate callback = null, PipeOptions clientPipeOptions = null,
TestConnectionFactory connectionFactory = null, IServiceConnectionManager serviceConnectionManager = null)
{
ConnectionFactory = connectionFactory ?? new TestConnectionFactory();
ClientConnectionManager = new ClientConnectionManager();
_clientPipeOptions = clientPipeOptions;
ServiceConnection = new ServiceConnection(
SharedServiceProtocol,
this,
ConnectionFactory,
NullLoggerFactory.Instance,
callback ?? OnConnectionAsync,
this,
Guid.NewGuid().ToString("N"),
serviceConnectionManager);
ServiceConnectionContainer = new StrongServiceConnectionContainer(null, connectionFactory, new List <IServiceConnection>()
{
ServiceConnection
}, new ServiceEndpoint("", ""));
}
public WebSocketsHubLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions, ILoggerFactory loggerFactory) :
base(serviceConnectionManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory?.CreateLogger(nameof(WebSocketsHubLifetimeManager <Hub>)))
{
}
public ServiceLifetimeManagerBase(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver)
{
ServiceConnectionContainer = serviceConnectionManager;
_allProtocols = protocolResolver.AllProtocols;
}
public WebSocketsHubLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager, IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions) : base(serviceConnectionManager, protocolResolver, globalHubOptions, hubOptions)
{
}