public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type)
{
var conn = _generator?.Invoke(endpoint) ?? new TestServiceConnection(serviceMessageHandler: serviceMessageHandler);
CreatedConnections.Enqueue(conn);
return(conn);
}
public TestServiceConnection(TestConnectionContainer container,
IServiceProtocol serviceProtocol,
TestClientConnectionManager clientConnectionManager,
IConnectionFactory connectionFactory,
ILoggerFactory loggerFactory,
ConnectionDelegate connectionDelegate,
IClientConnectionFactory clientConnectionFactory,
string serverId,
string connectionId,
HubServiceEndpoint endpoint,
IServiceMessageHandler serviceMessageHandler,
IServiceEventHandler serviceEventHandler,
ServiceConnectionType connectionType = ServiceConnectionType.Default,
GracefulShutdownMode mode = GracefulShutdownMode.Off,
int closeTimeOutMilliseconds = 10000) : base(
serviceProtocol,
clientConnectionManager,
connectionFactory,
loggerFactory,
connectionDelegate,
clientConnectionFactory,
serverId,
connectionId,
endpoint,
serviceMessageHandler,
serviceEventHandler,
connectionType: connectionType,
mode: mode,
closeTimeOutMilliseconds: closeTimeOutMilliseconds)
{
_container = container;
ClientConnectionManager = clientConnectionManager;
}
public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type)
{
var serviceConnection = new ServiceConnection(_serviceProtocol, _clientConnectionManager, _connectionFactory,
_loggerFactory, _connectionDelegate, _clientConnectionFactory,
Guid.NewGuid().ToString(), endpoint, serviceMessageHandler, type);
serviceConnection.ConfigureContext = ConfigureContext;
return(serviceConnection);
}
public ServiceConnectionBase(IServiceProtocol serviceProtocol, ILoggerFactory loggerFactory, string connectionId, IServiceMessageHandler serviceMessageHandler, 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;
_serviceMessageHandler = serviceMessageHandler;
}
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 IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type)
{
return(new ServiceConnection(
_nameProvider.GetName(),
Guid.NewGuid().ToString(),
endpoint,
_serviceProtocol,
_connectionFactory,
_clientConnectionManager,
_logger,
serviceMessageHandler,
_serviceEventHandler,
type));
}
private static TestServiceConnection CreateServiceConnection(Action <ConnectionBuilder> use = null,
TestClientConnectionManager clientConnectionManager = null,
string serverId = null,
string connectionId = null,
GracefulShutdownMode?mode = null,
IServiceMessageHandler messageHandler = null,
IServiceEventHandler eventHandler = null,
IClientConnectionFactory clientConnectionFactory = null,
ILoggerFactory loggerFactory = null)
{
clientConnectionManager ??= new TestClientConnectionManager();
clientConnectionFactory ??= new ClientConnectionFactory();
var container = new TestConnectionContainer();
var connectionFactory = new TestConnectionFactory(conn =>
{
container.Instance = conn;
return(Task.CompletedTask);
});
var services = new ServiceCollection();
var builder = new ConnectionBuilder(services.BuildServiceProvider());
if (use == null)
{
use = (builder) => builder.UseConnectionHandler <TestConnectionHandler>();
}
use(builder);
builder.UseConnectionHandler <TestConnectionHandler>();
ConnectionDelegate handler = builder.Build();
return(new TestServiceConnection(
container,
new ServiceProtocol(),
clientConnectionManager,
connectionFactory,
loggerFactory ?? NullLoggerFactory.Instance,
handler,
clientConnectionFactory,
serverId ?? "serverId",
connectionId ?? Guid.NewGuid().ToString("N"),
null,
messageHandler ?? new TestServiceMessageHandler(),
eventHandler ?? new TestServiceEventHandler(),
mode: mode ?? GracefulShutdownMode.Off
));
}
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 TestServiceConnection(ServiceConnectionStatus status = ServiceConnectionStatus.Connected, bool throws = false,
ILogger logger = null,
IServiceMessageHandler serviceMessageHandler = null
) : base(
new ServiceProtocol(),
"serverId",
Guid.NewGuid().ToString(),
new HubServiceEndpoint(),
serviceMessageHandler,
ServiceConnectionType.Default,
logger ?? NullLogger.Instance
)
{
_expectedStatus = status;
_throws = throws;
}
private static TestServiceConnection CreateServiceConnection(ConnectionHandler handler = null,
TestClientConnectionManager clientConnectionManager = null,
string serverId = null,
string connectionId = null,
GracefulShutdownMode?mode = null,
IServiceMessageHandler messageHandler = null,
IServiceEventHandler eventHandler = null,
IClientConnectionFactory clientConnectionFactory = null,
HubServiceEndpoint hubServiceEndpoint = null,
ILoggerFactory loggerFactory = null)
{
clientConnectionManager ??= new TestClientConnectionManager();
clientConnectionFactory ??= new TestClientConnectionFactory();
var container = new TestConnectionContainer();
var connectionFactory = new TestConnectionFactory(conn =>
{
container.Instance = conn;
return(Task.CompletedTask);
});
var services = new ServiceCollection();
var builder = new ConnectionBuilder(services.BuildServiceProvider());
if (handler == null)
{
handler = new TestConnectionHandler();
}
return(new TestServiceConnection(
container,
new ServiceProtocol(),
clientConnectionManager,
connectionFactory,
loggerFactory ?? NullLoggerFactory.Instance,
handler.OnConnectedAsync,
clientConnectionFactory,
serverId ?? "serverId",
connectionId ?? Guid.NewGuid().ToString("N"),
hubServiceEndpoint ?? new TestHubServiceEndpoint(),
messageHandler ?? new TestServiceMessageHandler(),
eventHandler ?? new TestServiceEventHandler(),
mode: mode ?? GracefulShutdownMode.Off
));
}
public IServiceConnection Create(IConnectionFactory connectionFactory, IServiceMessageHandler serviceMessageHandler,
ServerConnectionType type)
{
var connectionId = Guid.NewGuid().ToString("N");
var connection = new ServiceConnection(
SharedServiceProtocol,
this,
connectionFactory,
NullLoggerFactory.Instance,
ConnectionDelegateCallback,
this,
connectionId,
serviceMessageHandler,
type);
ServiceConnections.TryAdd(connectionId, connection);
return(connection);
}
public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler,
ServiceConnectionType type)
{
var connectionId = Guid.NewGuid().ToString("N");
var connection = new ServiceConnection(
SharedServiceProtocol,
this,
ConnectionFactory,
NullLoggerFactory.Instance,
ConnectionDelegateCallback,
this,
ServerNameProvider.GetName(),
connectionId,
endpoint,
serviceMessageHandler,
type);
ServiceConnections.TryAdd(connectionId, connection);
return(connection);
}
public virtual IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type)
{
return(new ServiceConnection(
_serviceProtocol,
_clientConnectionManager,
_connectionFactory,
_loggerFactory,
_connectionDelegate,
_clientConnectionFactory,
_nameProvider.GetName(),
Guid.NewGuid().ToString(),
endpoint,
serviceMessageHandler,
type,
ShutdownMode
)
{
ConfigureContext = ConfigureContext
});
}
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 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;
}
public TestServiceConnectionProxy(IClientConnectionManager clientConnectionManager, ILoggerFactory loggerFactory, ConnectionDelegate callback = null, PipeOptions clientPipeOptions = null, IServiceMessageHandler serviceMessageHandler = null) :
base(
Guid.NewGuid().ToString("N"),
null,
SharedServiceProtocol,
new TestConnectionFactory(),
clientConnectionManager,
loggerFactory,
serviceMessageHandler ?? new TestServiceMessageHandler())
{
}
public void Build()
{
AssertDependencyResolverSet();
var configurationProvider = new ConfigurationProvider(resolver.Resolve <KinoConfiguration>());
var scaleOutSocketConfiguration = configurationProvider.GetScaleOutConfiguration();
var clusterMembershipConfiguration = configurationProvider.GetClusterMembershipConfiguration();
var clusterHealthMonitorConfiguration = configurationProvider.GetClusterHealthMonitorConfiguration();
var heartBeatSenderConfiguration = configurationProvider.GetHeartBeatSenderConfiguration();
var socketConfiguration = configurationProvider.GetSocketConfiguration();
var rendezvousEndpoints = configurationProvider.GetRendezvousEndpointsConfiguration();
var socketFactory = new SocketFactory(socketConfiguration);
var logger = resolver.Resolve <ILogger>();
var roundRobinDestinationList = new RoundRobinDestinationList(logger);
var internalRoutingTable = new InternalRoutingTable(roundRobinDestinationList);
var externalRoutingTable = new ExternalRoutingTable(roundRobinDestinationList, logger);
var localSocketFactory = new LocalSocketFactory();
var routerLocalSocket = new LocalSocket <IMessage>();
var internalRegistrationSocket = new LocalSocket <InternalRouteRegistration>();
#if NET47
var instanceNameResolver = resolver.Resolve <IInstanceNameResolver>() ?? new InstanceNameResolver();
var performanceCounterManager = new PerformanceCounterManager <KinoPerformanceCounters>(instanceNameResolver,
logger);
#else
var performanceCounterManager = default(IPerformanceCounterManager <KinoPerformanceCounters>);
#endif
var hashCodeProvider = resolver.Resolve <Func <HMAC> >() ?? (() => HMAC.Create("HMACMD5"));
var securityProvider = resolver.Resolve <ISecurityProvider>()
?? new SecurityProvider(hashCodeProvider,
resolver.Resolve <IDomainScopeResolver>(),
resolver.Resolve <IDomainPrivateKeyProvider>());
var heartBeatSenderConfigurationManager = new HeartBeatSenderConfigurationManager(heartBeatSenderConfiguration);
var configurationStorage = resolver.Resolve <IConfigurationStorage <RendezvousClusterConfiguration> >()
?? new RendezvousClusterConfigurationReadonlyStorage(rendezvousEndpoints);
var rendezvousCluster = new RendezvousCluster(configurationStorage);
var scaleoutConfigurationProvider = new ServiceLocator <ScaleOutConfigurationManager,
NullScaleOutConfigurationManager,
IScaleOutConfigurationManager>(clusterMembershipConfiguration,
new ScaleOutConfigurationManager(scaleOutSocketConfiguration),
new NullScaleOutConfigurationManager())
.GetService();
var connectedPeerRegistry = new ConnectedPeerRegistry(clusterHealthMonitorConfiguration);
var clusterHealthMonitor = new ServiceLocator <ClusterHealthMonitor,
NullClusterHealthMonitor,
IClusterHealthMonitor>(clusterMembershipConfiguration,
new ClusterHealthMonitor(socketFactory,
localSocketFactory,
securityProvider,
routerLocalSocket,
connectedPeerRegistry,
clusterHealthMonitorConfiguration,
logger),
new NullClusterHealthMonitor())
.GetService();
var heartBeatSender = new ServiceLocator <HeartBeatSender,
NullHeartBeatSender,
IHeartBeatSender>(clusterMembershipConfiguration,
new HeartBeatSender(socketFactory,
heartBeatSenderConfigurationManager,
scaleoutConfigurationProvider,
logger),
new NullHeartBeatSender())
.GetService();
var scaleOutListener = new ServiceLocator <ScaleOutListener,
NullScaleOutListener,
IScaleOutListener>(clusterMembershipConfiguration,
new ScaleOutListener(socketFactory,
routerLocalSocket,
scaleoutConfigurationProvider,
securityProvider,
performanceCounterManager,
logger),
new NullScaleOutListener())
.GetService();
var autoDiscoverSender = new AutoDiscoverySender(rendezvousCluster,
socketFactory,
clusterMembershipConfiguration,
performanceCounterManager,
logger);
var autoDiscoveryListener = new AutoDiscoveryListener(rendezvousCluster,
socketFactory,
scaleoutConfigurationProvider,
clusterMembershipConfiguration,
performanceCounterManager,
routerLocalSocket,
logger);
var routeDiscovery = new RouteDiscovery(autoDiscoverSender,
scaleoutConfigurationProvider,
clusterMembershipConfiguration,
securityProvider,
logger);
var clusterMonitor = new ServiceLocator <ClusterMonitor,
NullClusterMonitor,
IClusterMonitor>(clusterMembershipConfiguration,
new ClusterMonitor(scaleoutConfigurationProvider,
autoDiscoverSender,
autoDiscoveryListener,
heartBeatSenderConfigurationManager,
routeDiscovery,
securityProvider,
clusterMembershipConfiguration,
logger),
new NullClusterMonitor())
.GetService();
var clusterServices = new ClusterServices(clusterMonitor,
scaleOutListener,
heartBeatSender,
clusterHealthMonitor);
var nodeRoutesRegistrar = new NodeRoutesRegistrar(clusterServices,
internalRoutingTable,
securityProvider);
var internalMessageRouteRegistrationHandler = new InternalMessageRouteRegistrationHandler(clusterMonitor,
internalRoutingTable,
securityProvider);
var serviceMessageHandlers = new IServiceMessageHandler[]
{
new ClusterMessageRoutesRequestHandler(securityProvider,
nodeRoutesRegistrar),
new PingHandler(),
new ExternalMessageRouteRegistrationHandler(externalRoutingTable,
securityProvider,
clusterHealthMonitor,
logger),
new MessageRouteDiscoveryHandler(clusterMonitor,
internalRoutingTable,
securityProvider,
logger),
new MessageRouteUnregistrationHandler(clusterHealthMonitor,
externalRoutingTable,
securityProvider,
logger),
new NodeMessageRoutesRequestHandler(securityProvider,
nodeRoutesRegistrar),
new NodeUnregistrationHandler(clusterHealthMonitor,
externalRoutingTable,
securityProvider),
new UnreachableNodeUnregistrationHandler(clusterHealthMonitor,
externalRoutingTable)
};
var serviceMessageHandlerRegistry = new ServiceMessageHandlerRegistry(serviceMessageHandlers);
messageRouter = new MessageRouter(socketFactory,
internalRoutingTable,
externalRoutingTable,
scaleoutConfigurationProvider,
clusterServices,
serviceMessageHandlerRegistry,
performanceCounterManager,
securityProvider,
routerLocalSocket,
internalRegistrationSocket,
internalMessageRouteRegistrationHandler,
roundRobinDestinationList,
logger);
var actorHostFactory = new ActorHostFactory(securityProvider,
routerLocalSocket,
internalRegistrationSocket,
localSocketFactory,
logger);
var callbackHandlerStack = new CallbackHandlerStack();
createMessageHub = (keepLocal) => new MessageHub(callbackHandlerStack,
routerLocalSocket,
internalRegistrationSocket,
localSocketFactory,
scaleoutConfigurationProvider,
securityProvider,
logger,
keepLocal);
var messageHub = createMessageHub(false);
getMessageHub = () => messageHub;
actorHostManager = new ActorHostManager(actorHostFactory, logger);
internalActorHostManager = new ActorHostManager(actorHostFactory, logger);
var internalActor = new MessageRoutesActor(externalRoutingTable, internalRoutingTable);
internalActorHostManager.AssignActor(internalActor);
//
isBuilt = true;
}
public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type) => new SimpleTestServiceConnection();
public IServiceConnection Create(IConnectionFactory connectionFactory, IServiceMessageHandler serviceMessageHandler, ServerConnectionType type)
{
return(new ServiceConnection(_serviceProtocol, _clientConnectionManager, connectionFactory,
_loggerFactory, _connectionDelegate, _clientConnectionFactory,
Guid.NewGuid().ToString(), serviceMessageHandler, type));
}
