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>())); }