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 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 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;
}
/* CONSTRUCTOR */
public MainMenuController(IClientConnectionManager _manager, IMainMenuView mainMenuView,
IConnectToServerView connectToServerView)
{
initGame();
myView = new MainMenuForm(this);
//Create main view components and link them
this.MyView = mainMenuView;
this.MyView.Controller = this;
//Create connect to server components and link them
myConnectToServerController = new ConnectToServerController(_manager);
myConnectToServerController.setView(connectToServerView);
connectToServerView.setController(myConnectToServerController);
mainMenuType = typeof(IConnectToServerView);
((IDisputeObservable)myConnectToServerController).registerObserver(this);
//mySoMSelectorController=new GraphicSoMSelectorController();
//myMatchController = new GraphicMatchController(myGame);
myCreateCharacterFormController = new GraphicCreateCharacterController();
connectionManager = _manager;
//Register as observer of other controllers
((IDisputeObservable)myCreateCharacterFormController).registerObserver(this);
((IConnectionObservable)connectionManager).registerObserver(this);
}
public ServiceConnectionFactory(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
ILoggerFactory logger)
{
_serviceProtocol = serviceProtocol;
_clientConnectionManager = clientConnectionManager;
_logger = logger;
}
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));
_clientConnectionManager = resolver.Resolve <IClientConnectionManager>() ?? throw new ArgumentNullException(nameof(IClientConnectionManager));
_parser = resolver.Resolve <IMessageParser>() ?? throw new ArgumentNullException(nameof(IMessageParser));
_ackHandler = resolver.Resolve <IAckHandler>() ?? throw new ArgumentNullException(nameof(IAckHandler));
}
private void Init()
{
_connectionManager = _client.GetConnectionManager();
_clientMembershipListener = new ClientMembershipListener(_client);
_connectionManager.AddConnectionHeartBeatListener(this);
_connectionManager.AddConnectionListener(this);
_credentials = _client.GetClientConfig().GetCredentials();
}
public ServiceConnectionProxy(IClientConnectionManager clientConnectionManager, ILoggerFactory loggerFactory, ConnectionDelegate callback = null, PipeOptions clientPipeOptions = null, SignalR.IServiceMessageHandler serviceMessageHandler = null) :
base(
Guid.NewGuid().ToString("N"),
SharedServiceProtocol,
new TestConnectionFactory(),
clientConnectionManager,
loggerFactory,
serviceMessageHandler ?? new TestServiceMessageHandler())
{
}
public ServiceConnectionProxy(IClientConnectionManager clientConnectionManager, ILoggerFactory loggerFactory, ConnectionDelegate callback = null, PipeOptions clientPipeOptions = null) :
base(
Guid.NewGuid().ToString("N"),
Guid.NewGuid().ToString("N"),
SharedServiceProtocol,
new TestConnectionFactory(),
clientConnectionManager,
loggerFactory.CreateLogger <ServiceConnectionProxy>())
{
}
public QueryWindowPresenter(IClientConnectionManager clientConnectionManager,
IQueryStatementParser queryStatementParser,
IQueryWindowPresenterLogger logger,
IEnumerable <IQueryRunner> queryRunners)
{
_logger = logger;
_logger.SetPresenter(this);
_queryParser = queryStatementParser;
_queryRunners = queryRunners;
_clientConnectionManager = clientConnectionManager;
}
public AzureTransport(HostContext context, IDependencyResolver resolver)
{
_context = context;
context.Environment[AspNetConstants.Context.AzureSignalRTransportKey] = this;
_pool = resolver.Resolve <IMemoryPool>();
_serializer = resolver.Resolve <JsonSerializer>();
_serviceProtocol = resolver.Resolve <IServiceProtocol>();
_logger = resolver.Resolve <ILoggerFactory>()?.CreateLogger <AzureTransport>() ??
NullLogger <AzureTransport> .Instance;
_clientConnectionManager = resolver.Resolve <IClientConnectionManager>();
}
public ServiceConnectionFactory(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory)
{
_serviceProtocol = serviceProtocol;
_clientConnectionManager = clientConnectionManager;
_loggerFactory = loggerFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
}
public ServiceConnection(
string hubName,
string connectionId,
IServiceProtocol serviceProtocol,
IConnectionFactory connectionFactory,
IClientConnectionManager clientConnectionManager,
ILogger logger)
: base(serviceProtocol, logger, connectionId)
{
_hubName = hubName;
_connectionFactory = connectionFactory;
_clientConnectionManager = clientConnectionManager;
}
public static ConnectToServerController getInstance(IClientConnectionManager cm = null)
{
if (instance == null)
{
instance = new ConnectToServerController(cm);
}
else
{
instance.cm = cm;
}
return(instance);
}
public ServiceConnection(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string connectionId) :
base(serviceProtocol, loggerFactory.CreateLogger <ServiceConnection>(), connectionId)
{
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
}
private HazelcastClient(ClientConfig config)
{
this.config = config;
var groupConfig = config.GetGroupConfig();
instanceName = "hz.client_" + id + (groupConfig != null ? "_" + groupConfig.GetName() : string.Empty);
//threadGroup = new ThreadGroup(instanceName);
lifecycleService = new LifecycleService(this);
try
{
string partitioningStrategyClassName = null;
//TODO make partition strategy parametric
//Runtime.GetProperty(PropPartitioningStrategyClass);
IPartitioningStrategy partitioningStrategy;
if (partitioningStrategyClassName != null && partitioningStrategyClassName.Length > 0)
{
partitioningStrategy = null;
}
else
{
//new Instance for partitioningStrategyClassName;
partitioningStrategy = new DefaultPartitioningStrategy();
}
serializationService =
new SerializationServiceBuilder().SetManagedContext(new HazelcastClientManagedContext(this,
config.GetManagedContext()))
.SetConfig(config.GetSerializationConfig())
.SetPartitioningStrategy(partitioningStrategy)
.SetVersion(SerializationService.SerializerVersion)
.Build();
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
proxyManager = new ProxyManager(this);
//TODO EXECUTION SERVICE
executionService = new ClientExecutionService(instanceName, config.GetExecutorPoolSize());
clusterService = new ClientClusterService(this);
loadBalancer = config.GetLoadBalancer() ?? new RoundRobinLB();
connectionManager = new ClientConnectionManager(this, loadBalancer);
invocationService = GetInvocationService(config);
listenerService = new ClientListenerService(this);
userContext = new ConcurrentDictionary <string, object>();
loadBalancer.Init(GetCluster(), config);
proxyManager.Init(config);
partitionService = new ClientPartitionService(this);
}
public QueryWindowPresenter(IClientConnectionManager clientConnectionManager,
IQueryStatementParser queryStatementParser,
IQueryPresenterLogger logger,
IEnumerable <IQueryRunner> queryRunners,
IQueryManager queryManager,
ITextWriterFactory textWriter) : base(queryStatementParser)
{
_logger = logger;
_logger.SetPresenter(this);
_queryRunners = queryRunners;
_clientConnectionManager = clientConnectionManager;
_queryManager = queryManager;
_textWriter = textWriter;
}
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 ServiceConnectionFactory(
IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory logger,
IServerNameProvider nameProvider
)
{
_serviceProtocol = serviceProtocol;
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_logger = logger;
_nameProvider = nameProvider;
}
public ServiceConnection(
string connectionId,
IServiceProtocol serviceProtocol,
IConnectionFactory connectionFactory,
IClientConnectionManager clientConnectionManager,
ILoggerFactory loggerFactory,
IServiceMessageHandler serviceMessageHandler,
ServerConnectionType connectionType = ServerConnectionType.Default)
: base(serviceProtocol, loggerFactory, connectionId, serviceMessageHandler, connectionType)
{
_connectionFactory = connectionFactory;
_clientConnectionManager = clientConnectionManager;
_logger = loggerFactory?.CreateLogger <ServiceConnection>() ?? NullLogger <ServiceConnection> .Instance;
}
public ServiceConnection(
string connectionId,
HubServiceEndpoint endpoint,
IServiceProtocol serviceProtocol,
IConnectionFactory connectionFactory,
IClientConnectionManager clientConnectionManager,
ILoggerFactory loggerFactory,
IServiceMessageHandler serviceMessageHandler,
ServerConnectionType connectionType = ServerConnectionType.Default)
: base(serviceProtocol, connectionId, endpoint, serviceMessageHandler, connectionType,
loggerFactory?.CreateLogger <ServiceConnection>())
{
_connectionFactory = connectionFactory;
_clientConnectionManager = clientConnectionManager;
}
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 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>();
}
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;
}
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 ServiceConnectionFactory(
IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
IServerNameProvider nameProvider,
IServiceEventHandler serviceEventHandler)
{
_serviceProtocol = serviceProtocol;
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_loggerFactory = loggerFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
_nameProvider = nameProvider;
_serviceEventHandler = serviceEventHandler;
}
public MockServiceConnectionFactory(
IMockService mockService,
IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
IServerNameProvider nameProvider)
: base(
serviceProtocol,
clientConnectionManager,
new MockServiceConnectionContextFactory(mockService), // use instead of connectionFactory
loggerFactory,
connectionDelegate,
clientConnectionFactory,
nameProvider)
{
_mockService = mockService;
}
public ServiceConnection(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string connectionId,
HubServiceEndpoint endpoint,
IServiceMessageHandler serviceMessageHandler,
ServiceConnectionType connectionType = ServiceConnectionType.Default,
int closeTimeOutMilliseconds = DefaultCloseTimeoutMilliseconds) :
base(serviceProtocol, connectionId, endpoint, serviceMessageHandler, connectionType, loggerFactory?.CreateLogger <ServiceConnection>())
{
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
_closeTimeOutMilliseconds = closeTimeOutMilliseconds;
_enableConnectionMigration = false;
}
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;
}
public ServiceConnection(IServiceProtocol serviceProtocol,
IClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string serverId,
string connectionId,
HubServiceEndpoint endpoint,
IServiceMessageHandler serviceMessageHandler,
ServiceConnectionType connectionType = ServiceConnectionType.Default,
GracefulShutdownMode mode = GracefulShutdownMode.Off,
int closeTimeOutMilliseconds = DefaultCloseTimeoutMilliseconds
) : base(serviceProtocol, serverId, connectionId, endpoint, serviceMessageHandler, connectionType, loggerFactory?.CreateLogger <ServiceConnection>(), mode)
{
_clientConnectionManager = clientConnectionManager;
_connectionFactory = connectionFactory;
_connectionDelegate = connectionDelegate;
_clientConnectionFactory = clientConnectionFactory;
_closeTimeOutMilliseconds = closeTimeOutMilliseconds;
}
private void Init()
{
_connectionManager = _client.GetConnectionManager();
_clientMembershipListener = new ClientMembershipListener(_client);
_connectionManager.AddConnectionHeartBeatListener(this);
_connectionManager.AddConnectionListener(this);
_credentials = _client.GetClientConfig().GetCredentials();
}
