Esempio n. 1
0
        private IInternalSession MockSession(string keyspace, bool coreEngine)
        {
            var keyspaces = new ConcurrentDictionary <string, KeyspaceMetadata>();

            // unique configurations
            keyspaces.AddOrUpdate(
                keyspace,
                FakeSchemaParserFactory.CreateSimpleKeyspace(keyspace, 2, graphEngine: coreEngine ? "Core" : null),
                (s, keyspaceMetadata) => keyspaceMetadata);

            var schemaParser = new FakeSchemaParser(keyspaces);
            var config       = new TestConfigurationBuilder
            {
                ConnectionFactory = new FakeConnectionFactory()
            }.Build();

            var metadata = new Metadata(config, schemaParser)
            {
                Partitioner = "Murmur3Partitioner"
            };

            var cluster = Mock.Of <ICluster>();

            Mock.Get(cluster).SetupGet(c => c.Metadata).Returns(metadata);

            var session = Mock.Of <IInternalSession>();

            Mock.Get(session).SetupGet(s => s.Cluster).Returns(cluster);

            metadata.ControlConnection = new ControlConnection(
                Mock.Of <IInternalCluster>(),
                new ProtocolEventDebouncer(new TaskBasedTimerFactory(), TimeSpan.FromMilliseconds(20), TimeSpan.FromSeconds(100)),
                ProtocolVersion.V3,
                config,
                metadata,
                new List <IContactPoint>
            {
                new IpLiteralContactPoint(IPAddress.Parse("127.0.0.1"), config.ProtocolOptions, config.ServerNameResolver)
            });
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.1"), 9042));
            metadata.Hosts.First().SetInfo(new TestHelper.DictionaryBasedRow(new Dictionary <string, object>
            {
                { "data_center", "dc1" },
                { "rack", "rack1" },
                { "tokens", new [] { "100" } },
                { "release_version", "3.11.1" }
            }));
            metadata.RebuildTokenMapAsync(false, true).GetAwaiter().GetResult();
            Assert.IsNotNull(metadata.GetKeyspace(keyspace));
            return(session);
        }
Esempio n. 2
0
        public void RefreshSingleKeyspace_Should_BuildTokenMap_When_TokenMapIsNull()
        {
            var keyspaces = new ConcurrentDictionary <string, KeyspaceMetadata>();

            keyspaces.GetOrAdd("ks1", TokenTests.CreateSimpleKeyspace("ks1", 1));
            var schemaParser = new FakeSchemaParser(keyspaces);
            var metadata     = new Metadata(new Configuration(), schemaParser)
            {
                Partitioner = "Murmur3Partitioner"
            };

            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.1"), 9042));;
            metadata.Hosts.First().SetInfo(new TestHelper.DictionaryBasedRow(new Dictionary <string, object>
            {
                { "data_center", "dc1" },
                { "rack", "rack1" },
                { "tokens", GenerateTokens(1, 256) },
                { "release_version", "3.11.1" }
            }));

            Assert.IsNull(metadata.TokenToReplicasMap);
            metadata.RefreshSingleKeyspace(true, "ks1").GetAwaiter().GetResult();
            Assert.NotNull(metadata.TokenToReplicasMap);
        }
Esempio n. 3
0
        public void TokenMapUpdates_Should_FunctionCorrectly_When_MultipleThreadsCallingRebuildAndUpdateKeyspace()
        {
            var keyspaces = new ConcurrentDictionary <string, KeyspaceMetadata>();

            // unique configurations
            keyspaces.AddOrUpdate("ks1", TokenTests.CreateSimpleKeyspace("ks1", 2), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks2", TokenTests.CreateSimpleKeyspace("ks2", 10), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks3", TokenTests.CreateSimpleKeyspace("ks3", 5), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks4", TokenTests.CreateNetworkTopologyKeyspace("ks4", new Dictionary <string, int> {
                { "dc1", 2 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks5", TokenTests.CreateNetworkTopologyKeyspace("ks5", new Dictionary <string, int> {
                { "dc1", 1 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks6", TokenTests.CreateNetworkTopologyKeyspace("ks6", new Dictionary <string, int> {
                { "dc1", 1 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);

            // duplicate configurations
            keyspaces.AddOrUpdate("ks7", TokenTests.CreateNetworkTopologyKeyspace("ks7", new Dictionary <string, int> {
                { "dc1", 2 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks8", TokenTests.CreateNetworkTopologyKeyspace("ks8", new Dictionary <string, int> {
                { "dc1", 1 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks9", TokenTests.CreateNetworkTopologyKeyspace("ks9", new Dictionary <string, int> {
                { "dc1", 1 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks10", TokenTests.CreateSimpleKeyspace("ks10", 10), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks11", TokenTests.CreateSimpleKeyspace("ks11", 2), (s, keyspaceMetadata) => keyspaceMetadata);

            var schemaParser = new FakeSchemaParser(keyspaces);
            var metadata     = new Metadata(new Configuration(), schemaParser)
            {
                Partitioner = "Murmur3Partitioner"
            };

            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.1"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.2"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.3"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.4"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.5"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.6"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.7"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.8"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.9"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.10"), 9042));
            var initialToken = 1;

            foreach (var h in metadata.Hosts)
            {
                h.SetInfo(new TestHelper.DictionaryBasedRow(new Dictionary <string, object>
                {
                    { "data_center", initialToken % 2 == 0 ? "dc1" : "dc2" },
                    { "rack", "rack1" },
                    { "tokens", GenerateTokens(initialToken, 256) },
                    { "release_version", "3.11.1" }
                }));
                initialToken++;
            }
            metadata.RefreshKeyspaces().GetAwaiter().GetResult();
            var expectedTokenMap = metadata.TokenToReplicasMap;

            Assert.NotNull(expectedTokenMap);
            var bag   = new ConcurrentBag <string>();
            var tasks = new List <Task>();

            for (var i = 0; i < 100; i++)
            {
                var index = i;
                tasks.Add(Task.Factory.StartNew(
                              () =>
                {
                    for (var j = 0; j < 11; j++)
                    {
                        if (j % 5 == 0)
                        {
                            metadata.RefreshKeyspaces().GetAwaiter().GetResult();
                        }
                        else if (j % 2 == 1)
                        {
                            if (bag.TryTake(out var ksName))
                            {
                                if (keyspaces.TryRemove(ksName, out var ks))
                                {
                                    if (!metadata.RemoveKeyspace(ks.Name).GetAwaiter().GetResult())
                                    {
                                        // one rebuild finished between keyspace remove and metadata removekeyspace
                                    }
                                }
                            }
                        }
                        else
                        {
                            var keyspaceName = $"ks_____{index}_____{j}";
                            var ks           = TokenTests.CreateSimpleKeyspace(keyspaceName, (index * j) % 10);
                            keyspaces.AddOrUpdate(
                                keyspaceName,
                                ks,
                                (s, keyspaceMetadata) => ks);
                            ks = metadata.RefreshSingleKeyspace(true, keyspaceName).GetAwaiter().GetResult();
                            if (ks == null)
                            {
                                throw new Exception($"refresh for {keyspaceName} returned null.");
                            }
                            bag.Add(keyspaceName);
                        }
                    }
                },
                              TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach));
            }
            Task.WaitAll(tasks.ToArray());
            AssertSameReplicas(keyspaces.Values, expectedTokenMap, metadata.TokenToReplicasMap);
        }
Esempio n. 4
0
        public void Should_UpdateKeyspacesAndTokenMapCorrectly_When_MultipleThreadsCallingRefreshKeyspace()
        {
            var keyspaces = new ConcurrentDictionary <string, KeyspaceMetadata>();

            // unique configurations
            keyspaces.AddOrUpdate("ks1", FakeSchemaParserFactory.CreateSimpleKeyspace("ks1", 2), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks2", FakeSchemaParserFactory.CreateSimpleKeyspace("ks2", 10), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks3", FakeSchemaParserFactory.CreateSimpleKeyspace("ks3", 5), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks4", FakeSchemaParserFactory.CreateNetworkTopologyKeyspace("ks4", new Dictionary <string, int> {
                { "dc1", 2 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks5", FakeSchemaParserFactory.CreateNetworkTopologyKeyspace("ks5", new Dictionary <string, int> {
                { "dc1", 1 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks6", FakeSchemaParserFactory.CreateNetworkTopologyKeyspace("ks6", new Dictionary <string, int> {
                { "dc1", 1 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);

            // duplicate configurations
            keyspaces.AddOrUpdate("ks7", FakeSchemaParserFactory.CreateNetworkTopologyKeyspace("ks7", new Dictionary <string, int> {
                { "dc1", 2 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks8", FakeSchemaParserFactory.CreateNetworkTopologyKeyspace("ks8", new Dictionary <string, int> {
                { "dc1", 1 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks9", FakeSchemaParserFactory.CreateNetworkTopologyKeyspace("ks9", new Dictionary <string, int> {
                { "dc1", 1 }, { "dc2", 2 }
            }), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks10", FakeSchemaParserFactory.CreateSimpleKeyspace("ks10", 10), (s, keyspaceMetadata) => keyspaceMetadata);
            keyspaces.AddOrUpdate("ks11", FakeSchemaParserFactory.CreateSimpleKeyspace("ks11", 2), (s, keyspaceMetadata) => keyspaceMetadata);

            var schemaParser = new FakeSchemaParser(keyspaces);
            var config       = new TestConfigurationBuilder
            {
                ConnectionFactory = new FakeConnectionFactory()
            }.Build();
            var metadata = new Metadata(config, schemaParser)
            {
                Partitioner = "Murmur3Partitioner"
            };

            metadata.ControlConnection = new ControlConnection(
                Mock.Of <IInternalCluster>(),
                new ProtocolEventDebouncer(new TaskBasedTimerFactory(), TimeSpan.FromMilliseconds(20), TimeSpan.FromSeconds(100)),
                ProtocolVersion.V3,
                config,
                metadata,
                new List <IContactPoint>
            {
                new IpLiteralContactPoint(IPAddress.Parse("127.0.0.1"), config.ProtocolOptions, config.ServerNameResolver)
            });
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.1"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.2"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.3"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.4"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.5"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.6"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.7"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.8"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.9"), 9042));
            metadata.Hosts.Add(new IPEndPoint(IPAddress.Parse("192.168.0.10"), 9042));
            var initialToken = 1;

            foreach (var h in metadata.Hosts)
            {
                h.SetInfo(new TestHelper.DictionaryBasedRow(new Dictionary <string, object>
                {
                    { "data_center", initialToken % 2 == 0 ? "dc1" : "dc2" },
                    { "rack", "rack1" },
                    { "tokens", GenerateTokens(initialToken, 256) },
                    { "release_version", "3.11.1" }
                }));
                initialToken++;
            }
            metadata.RebuildTokenMapAsync(false, true).GetAwaiter().GetResult();
            var expectedTokenMap = metadata.TokenToReplicasMap;

            Assert.NotNull(expectedTokenMap);
            var bag   = new ConcurrentBag <string>();
            var tasks = new List <Task>();

            for (var i = 0; i < 100; i++)
            {
                var index = i;
                tasks.Add(Task.Factory.StartNew(
                              () =>
                {
                    for (var j = 0; j < 35; j++)
                    {
                        if (j % 10 == 0 && index % 2 == 0)
                        {
                            metadata.RefreshSchemaAsync().GetAwaiter().GetResult();
                        }
                        else if (j % 16 == 0)
                        {
                            if (bag.TryTake(out var ksName))
                            {
                                if (keyspaces.TryRemove(ksName, out var ks))
                                {
                                    metadata.RefreshSchemaAsync(ksName).GetAwaiter().GetResult();
                                    ks = metadata.GetKeyspace(ksName);
                                    if (ks != null)
                                    {
                                        throw new Exception($"refresh for {ks.Name} returned non null after refresh single.");
                                    }
                                }
                            }
                        }
                        else
                        if (j % 2 == 0)
                        {
                            if (bag.TryTake(out var ksName))
                            {
                                if (keyspaces.TryRemove(ksName, out var ks))
                                {
                                    metadata.ControlConnection.HandleKeyspaceRefreshLaterAsync(ks.Name).GetAwaiter().GetResult();
                                    ks = metadata.GetKeyspace(ksName);
                                    if (ks != null)
                                    {
                                        throw new Exception($"refresh for {ks.Name} returned non null after remove.");
                                    }
                                }
                            }
                        }
                        else
                        {
                            var keyspaceName = $"ks_____{index}_____{j}";
                            var ks           = FakeSchemaParserFactory.CreateSimpleKeyspace(keyspaceName, (index * j) % 10);
                            keyspaces.AddOrUpdate(
                                keyspaceName,
                                ks,
                                (s, keyspaceMetadata) => ks);
                            metadata.ControlConnection.HandleKeyspaceRefreshLaterAsync(ks.Name).GetAwaiter().GetResult();
                            ks = metadata.GetKeyspace(ks.Name);
                            if (ks == null)
                            {
                                throw new Exception($"refresh for {keyspaceName} returned null after add.");
                            }
                            bag.Add(keyspaceName);
                        }
                    }
                },
                              TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach));
            }
            Task.WaitAll(tasks.ToArray());
            AssertSameReplicas(keyspaces.Values, expectedTokenMap, metadata.TokenToReplicasMap);
        }