Beispiel #1
0
        public async Task PruneNodesAsync_Does_Not_Remove_Single_Service_Nodes()
        {
            //Arrange

            var config  = ResourceHelper.ReadResource <BucketConfig>(@"Documents\Configs\rev-36310-service-per-node.json");
            var context = new ClusterContext();

            var dnsResolver = new Mock <IDnsResolver>();
            var service     = new IpEndPointService(dnsResolver.Object, new ClusterOptions());

            var hosts = new List <string> {
                "10.143.194.101", "10.143.194.102", "10.143.194.103", "10.143.194.104"
            };

            hosts.ForEach(async x => context.AddNode(await CreateMockedNode(x, 11210, service).ConfigureAwait(false)));

            //Act

            await context.PruneNodesAsync(config).ConfigureAwait(false);

            //Assert

            foreach (var host in hosts)
            {
                var removed = await service.GetIpEndPointAsync(host, 11210).ConfigureAwait(false);

                Assert.Contains(context.Nodes, node => node.EndPoint.Equals(removed));
            }
        }
        public async Task Test_Filter_Removed_Nodes(string oldConfigPath, string newConfigPath)
        {
            var oldConfig = ResourceHelper.ReadResource <BucketConfig>(oldConfigPath);
            var newConfig = ResourceHelper.ReadResource <BucketConfig>(newConfigPath);

            var options     = new ClusterOptions();
            var bucketNodes = new ConcurrentDictionary <IPEndPoint, IClusterNode>();
            var context     = new ClusterContext(new CancellationTokenSource(), options);

            var ipEndpointService = context.ServiceProvider.GetRequiredService <IIpEndPointService>();

            //load up the initial state after bootstrapping
            foreach (var server in oldConfig.GetNodes())
            {
                var endPoint = await ipEndpointService.GetIpEndPointAsync(server).ConfigureAwait(false);

                var clusterNode = new ClusterNode(context, new Mock <IConnectionPoolFactory>().Object,
                                                  new Mock <ILogger <ClusterNode> >().Object,
                                                  new DefaultObjectPool <OperationBuilder>(new OperationBuilderPoolPolicy()),
                                                  new Mock <ICircuitBreaker>().Object,
                                                  new Mock <ISaslMechanismFactory>().Object,
                                                  new Mock <IRedactor>().Object,
                                                  endPoint,
                                                  BucketType.Couchbase,
                                                  server,
                                                  NoopRequestTracer.Instance,
                                                  NoopValueRecorder.Instance);

                context.AddNode(clusterNode);
                bucketNodes.TryAdd(endPoint, clusterNode);
            }

            foreach (var nodesExt in newConfig.GetNodes())
            {
                var endPoint = await ipEndpointService.GetIpEndPointAsync(nodesExt).ConfigureAwait(false);

                if (bucketNodes.ContainsKey(endPoint))
                {
                    continue;
                }

                var clusterNode = new ClusterNode(context, new Mock <IConnectionPoolFactory>().Object,
                                                  new Mock <ILogger <ClusterNode> >().Object,
                                                  new DefaultObjectPool <OperationBuilder>(new OperationBuilderPoolPolicy()),
                                                  new Mock <ICircuitBreaker>().Object, new Mock <ISaslMechanismFactory>().Object,
                                                  new Mock <IRedactor>().Object, endPoint, BucketType.Memcached, nodesExt,
                                                  NoopRequestTracer.Instance,
                                                  NoopValueRecorder.Instance);

                context.AddNode(clusterNode);
                bucketNodes.TryAdd(endPoint, clusterNode);
            }

            await context.PruneNodesAsync(newConfig).ConfigureAwait(false);

            Assert.Equal(newConfig.NodesExt.Count, context.Nodes.Count);
        }