public RaftService(
ILoggerFactory logger,
IOptions <ClusterOptions> clusterOptions,
IOptions <NodeOptions> nodeOptions,
IClusterConnectionPool clusterConnectionPool,
INodeStorage <State> nodeStorage,
IStateMachine <State> stateMachine,
NodeStateService nodeStateService,
ClusterClient clusterClient
) : base(logger.CreateLogger <RaftService <State> >(), clusterOptions.Value, nodeOptions.Value, stateMachine, nodeStateService)
{
_nodeStorage = nodeStorage;
_loggerFactory = logger;
//Bootstrap the node
_snapshotService = new Snapshotter <State>(logger.CreateLogger <Snapshotter <State> >(), nodeStorage, stateMachine, nodeStateService);
_bootstrapService = new Bootstrapper <State>(logger.CreateLogger <Bootstrapper <State> >(), clusterOptions.Value, nodeOptions.Value, nodeStorage, StateMachine, NodeStateService);
_commitService = new CommitService <State>(logger.CreateLogger <CommitService <State> >(), clusterOptions.Value, nodeOptions.Value, nodeStorage, StateMachine, NodeStateService);
_discovery = new Discovery(logger.CreateLogger <Discovery>());
_clusterClient = clusterClient;
_clusterConnectionPool = clusterConnectionPool;
NodeStateService.Id = _nodeStorage.Id;
_electionTimeoutTimer = new Timer(ElectionTimeoutEventHandler);
_heartbeatTimer = new Timer(HeartbeatTimeoutEventHandler);
if (!ClusterOptions.TestMode)
{
_bootstrapTask = Task.Run(async() =>
{
//Wait for the rest of the node to bootup
Logger.LogInformation("Starting bootstrap...");
Thread.Sleep(3000);
nodeStateService.Url = await _bootstrapService.GetMyUrl(ClusterOptions.GetClusterUrls(), TimeSpan.FromMilliseconds(ClusterOptions.LatencyToleranceMs));
NodeStateService.IsBootstrapped = true;
SetNodeRole(NodeState.Follower);
});
}
else
{
Logger.LogInformation("Running in test mode...");
SetNodeRole(NodeState.Leader);
NodeStateService.IsBootstrapped = true;
Handle(new ExecuteCommands()
{
Commands = new List <BaseCommand>()
{
{
new UpsertNodeInformation()
{
Id = NodeStateService.Id,
Name = "",
TransportAddress = "https://localhost:5021",
IsContactable = true
}
}
}
}).GetAwaiter().GetResult();
}
}
// for test only
internal RoundRobinLoadBalancer(
IClusterConnectionPool clusterConnPool,
RoundRobinClusterView clusterView)
{
_clusterConnectionPool = clusterConnPool;
_clusterView = clusterView;
_logger = null;
}
public ClusterClient(IClusterConnectionPool connectionPool,
IServiceProvider serviceProvider,
NodeStateService nodeStateService)
{
_clusterConnectionPool = connectionPool;
_nodeStateService = nodeStateService;
_serviceProvider = serviceProvider;
}
// for test only
internal LoadBalancer(
IClusterConnectionPool clusterConnPool,
IRoutingTable routingTable,
Uri seed = null)
{
_clusterConnectionPool = clusterConnPool;
_routingTable = routingTable;
_seed = seed;
}
// for test only
internal LoadBalancer(
IClusterConnectionPool clusterConnPool,
IRoutingTableManager routingTableManager)
{
_clusterConnectionPool = clusterConnPool;
_routingTableManager = routingTableManager;
var config = Config.DefaultConfig;
_loadBalancingStrategy = CreateLoadBalancingStrategy(config.LoadBalancingStrategy, clusterConnPool, config.Logger);
}
public LoadBalancer(
IPooledConnectionFactory connectionFactory,
RoutingSettings routingSettings,
ConnectionPoolSettings poolSettings,
IDriverLogger logger)
{
_logger = logger;
_clusterConnectionPool = new ClusterConnectionPool(Enumerable.Empty <Uri>(), connectionFactory, poolSettings, logger);
_routingTableManager = new RoutingTableManager(routingSettings, this, logger);
_loadBalancingStrategy = CreateLoadBalancingStrategy(routingSettings.Strategy, _clusterConnectionPool, _logger);
}
public LoadBalancer(
IPooledConnectionFactory connectionFactory,
RoutingSettings routingSettings,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_logger = logger;
var uris = routingSettings.InitialServers;
_clusterConnectionPool = new ClusterConnectionPool(uris, connectionFactory, poolSettings, logger);
_routingTableManager = new RoutingTableManager(routingSettings, this, logger);
_loadBalancingStrategy = CreateLoadBalancingStrategy(routingSettings.Strategy, _clusterConnectionPool, logger);
}
public LoadBalancer(
IPooledConnectionFactory connectionFactory,
RoutingSettings routingSettings,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_logger = logger;
_clusterConnectionPool =
new ClusterConnectionPool(Enumerable.Empty <Uri>(), connectionFactory, poolSettings, logger);
_routingTableManager = new RoutingTableManager(routingSettings, this, logger);
_loadBalancingStrategy = CreateLoadBalancingStrategy(_clusterConnectionPool, _logger);
_initialServerAddressProvider = routingSettings.InitialServerAddressProvider;
}
public NodeController(IClusterRequestHandler handler,
ILogger <NodeController <State> > logger,
NodeStateService nodeStateService,
IStateMachine <State> stateMachine,
INodeStorage <State> nodeStorage,
IClusterConnectionPool clusterConnectionPool,
IShardRepository shardRepository)
{
_handler = handler;
Logger = logger;
_nodeStateService = nodeStateService;
_stateMachine = stateMachine;
_nodeStorage = nodeStorage;
_clusterConnectionPool = clusterConnectionPool;
_shardRepository = shardRepository;
}
public RoundRobinLoadBalancer(
Uri seedServer,
IAuthToken authToken,
EncryptionManager encryptionManager,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_clusterConnectionPool = new ClusterConnectionPool(
seedServer, authToken, encryptionManager,
poolSettings, logger, CreateClusterPooledConnectionErrorHandler);
_stopwatch = new Stopwatch();
_clusterView = new RoundRobinClusterView(seedServer, _stopwatch);
_logger = logger;
}
protected virtual void Dispose(bool isDisposing)
{
if (!isDisposing)
{
return;
}
_clusterView = null;
if (_clusterConnectionPool != null)
{
_clusterConnectionPool.Dispose();
_clusterConnectionPool = null;
}
_logger = null;
}
private static ILoadBalancingStrategy CreateLoadBalancingStrategy(LoadBalancingStrategy strategy,
IClusterConnectionPool pool,
IDriverLogger logger)
{
if (strategy == LoadBalancingStrategy.LeastConnected)
{
return(new LeastConnectedLoadBalancingStrategy(pool, logger));
}
else if (strategy == LoadBalancingStrategy.RoundRobin)
{
return(new RoundRobinLoadBalancingStrategy(logger));
}
else
{
throw new ArgumentException($"Unknown load balancing strategy: {strategy}");
}
}
public LoadBalancer(
RoutingSettings routingSettings,
ConnectionSettings connectionSettings,
ConnectionPoolSettings poolSettings,
ILogger logger)
{
_clusterConnectionPool = new ClusterConnectionPool(
connectionSettings, poolSettings, logger);
_stopwatch = new Stopwatch();
_routingTable = new RoundRobinRoutingTable(_stopwatch);
_seed = connectionSettings.InitialServerUri;
_routingContext = routingSettings.RoutingContext;
_logger = logger;
var uris = _seed.Resolve();
PrependRouters(uris);
}
private static LeastConnectedLoadBalancingStrategy NewLeastConnectedStrategy(
IClusterConnectionPool connectionPool)
{
return(new LeastConnectedLoadBalancingStrategy(connectionPool, new Mock <ILogger>().Object));
}
private static ILoadBalancingStrategy CreateLoadBalancingStrategy(IClusterConnectionPool pool,
ILogger logger)
{
return(new LeastConnectedLoadBalancingStrategy(pool, logger));
}
public LeastConnectedLoadBalancingStrategy(IClusterConnectionPool connectionPool, ILogger logger)
{
_connectionPool = connectionPool;
_logger = logger;
}
private static LeastConnectedLoadBalancingStrategy NewLeastConnectedStrategy(
IClusterConnectionPool connectionPool, ILogger logger = null)
{
return(new LeastConnectedLoadBalancingStrategy(connectionPool, logger ?? Mock.Of <ILogger>()));
}
