Fetch broker info like ID, host, port and number of partitions from ZooKeeper.
Used when zookeeper based auto partition discovery is enabled
Inheritance: IBrokerPartitionInfo, IZooKeeperStateListener
        public void WhenBrokerIsRemovedBrokerTopicsListenerUpdatesBrokersList()
        {
            var prodConfig = this.ZooKeeperBasedSyncProdConfig;

            IDictionary<string, SortedSet<Partition>> mappings;
            IDictionary<int, Broker> brokers;
            string brokerPath = ZooKeeperClient.DefaultBrokerIdsPath + "/" + 2345;
            using (IZooKeeperClient client = new ZooKeeperClient(
                prodConfig.ZooKeeper.ZkConnect,
                prodConfig.ZooKeeper.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                {
                    brokers = brokerPartitionInfo.GetAllBrokerInfo();
                    mappings =
                        ReflectionHelper.GetInstanceField<IDictionary<string, SortedSet<Partition>>>(
                            "topicBrokerPartitions", brokerPartitionInfo);
                }
            }

            Assert.NotNull(brokers);
            Assert.Greater(brokers.Count, 0);
            Assert.NotNull(mappings);
            Assert.Greater(mappings.Count, 0);
            using (IZooKeeperClient client = new ZooKeeperClient(
                prodConfig.ZooKeeper.ZkConnect,
                prodConfig.ZooKeeper.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                client.Connect();
                WaitUntillIdle(client, 500);
                var brokerTopicsListener = new BrokerTopicsListener(client, mappings, brokers, null);
                client.Subscribe(ZooKeeperClient.DefaultBrokerIdsPath, brokerTopicsListener);
                client.CreatePersistent(brokerPath, true);
                client.WriteData(brokerPath, "192.168.1.39-1310449279123:192.168.1.39:9102");
                WaitUntillIdle(client, 500);
                Assert.IsTrue(brokers.ContainsKey(2345));
                client.DeleteRecursive(brokerPath);
                WaitUntillIdle(client, 500);
                Assert.IsFalse(brokers.ContainsKey(2345));
            }
        }
        public void WhenBrokerIsRemovedZKBrokerPartitionInfoUpdatesBrokersList()
        {
            var producerConfig = new ProducerConfig(clientConfig);
            IDictionary<int, Broker> brokers;
            string brokerPath = ZooKeeperClient.DefaultBrokerIdsPath + "/" + 2345;
            using (IZooKeeperClient client = new ZooKeeperClient(
                producerConfig.ZkConnect,
                producerConfig.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                {
                    brokers = brokerPartitionInfo.GetAllBrokerInfo();
                    client.CreatePersistent(brokerPath, true);
                    client.WriteData(brokerPath, "192.168.1.39-1310449279123:192.168.1.39:9102");
                    WaitUntillIdle(client, 500);
                    Assert.NotNull(brokers);
                    Assert.Greater(brokers.Count, 0);
                    Assert.IsTrue(brokers.ContainsKey(2345));
                    client.DeleteRecursive(brokerPath);
                    WaitUntillIdle(client, 500);
                }
            }

            Assert.NotNull(brokers);
            Assert.Greater(brokers.Count, 0);
            Assert.IsFalse(brokers.ContainsKey(2345));
        }
        public void ZKBrokerPartitionInfoGetsBrokerPartitionInfo()
        {
            SortedSet<Partition> partitions;
            using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(zkConfig, null))
            {
                partitions = brokerPartitionInfo.GetBrokerPartitionInfo("test");
            }

            Assert.NotNull(partitions);
            Assert.GreaterOrEqual(partitions.Count, 2);
            var partition = partitions.ToList()[0];
            Assert.AreEqual(0, partition.BrokerId);
        }
 public void ZkBrokerPartitionInfoGetsBrokerInfo()
 {
     using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(zkConfig, null))
     {
         var testBroker = clientConfig.BrokerPartitionInfos[0];
         Broker broker = brokerPartitionInfo.GetBrokerInfo(testBroker.Id);
         Assert.NotNull(broker);
         Assert.AreEqual(testBroker.Address, broker.Host);
         Assert.AreEqual(testBroker.Port, broker.Port);
     }
 }
        public void ZKBrokerPartitionInfoGetsAllBrokerInfo()
        {
            IDictionary<int, Broker> allBrokerInfo;
            using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(zkConfig, null))
            {
                allBrokerInfo = brokerPartitionInfo.GetAllBrokerInfo();
            }

            Assert.AreEqual(clientConfig.BrokerPartitionInfos.Count, allBrokerInfo.Count);
            foreach (BrokerPartitionInfo cfgBrPartInfo in clientConfig.BrokerPartitionInfos)
            {
                Assert.IsTrue(allBrokerInfo.ContainsKey(cfgBrPartInfo.Id));
                Assert.AreEqual(cfgBrPartInfo.Address, allBrokerInfo[cfgBrPartInfo.Id].Host);
                Assert.AreEqual(cfgBrPartInfo.Port, allBrokerInfo[cfgBrPartInfo.Id].Port);
            }
        }
        public void WhenSessionIsExpiredListenerRecreatesEphemeralNodes()
        {
            {
                var producerConfig = new ProducerConfig(clientConfig);
                IDictionary<string, SortedSet<Partition>> mappings;
                IDictionary<int, Broker> brokers;
                IDictionary<string, SortedSet<Partition>> mappings2;
                IDictionary<int, Broker> brokers2;
                using (IZooKeeperClient client = new ZooKeeperClient(
                    producerConfig.ZkConnect,
                    producerConfig.ZkSessionTimeoutMs,
                    ZooKeeperStringSerializer.Serializer))
                {
                    using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                    {
                        brokers = brokerPartitionInfo.GetAllBrokerInfo();
                        mappings =
                            ReflectionHelper.GetInstanceField<IDictionary<string, SortedSet<Partition>>>(
                                "topicBrokerPartitions", brokerPartitionInfo);
                        Assert.NotNull(brokers);
                        Assert.Greater(brokers.Count, 0);
                        Assert.NotNull(mappings);
                        Assert.Greater(mappings.Count, 0);
                        client.Process(new WatchedEvent(KeeperState.Expired, EventType.None, null));
                        WaitUntillIdle(client, 3000);
                        brokers2 = brokerPartitionInfo.GetAllBrokerInfo();
                        mappings2 =
                            ReflectionHelper.GetInstanceField<IDictionary<string, SortedSet<Partition>>>(
                                "topicBrokerPartitions", brokerPartitionInfo);
                    }
                }

                Assert.NotNull(brokers2);
                Assert.Greater(brokers2.Count, 0);
                Assert.NotNull(mappings2);
                Assert.Greater(mappings2.Count, 0);
                Assert.AreEqual(brokers.Count, brokers2.Count);
                Assert.AreEqual(mappings.Count, mappings2.Count);
            }
        }
        public void WhenNewTopicIsAddedZKBrokerPartitionInfoUpdatesMappings()
        {
            var producerConfig = new ProducerConfig(clientConfig);
            IDictionary<string, SortedSet<Partition>> mappings;
            string topicPath = ZooKeeperClient.DefaultBrokerTopicsPath + "/" + CurrentTestTopic;

            using (IZooKeeperClient client = new ZooKeeperClient(
                producerConfig.ZkConnect,
                producerConfig.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                {
                    mappings =
                        ReflectionHelper.GetInstanceField<IDictionary<string, SortedSet<Partition>>>(
                            "topicBrokerPartitions", brokerPartitionInfo);
                    client.CreatePersistent(topicPath, true);
                    WaitUntillIdle(client, 500);
                    client.UnsubscribeAll();
                    client.DeleteRecursive(topicPath);
                }
            }

            Assert.NotNull(mappings);
            Assert.Greater(mappings.Count, 0);
            Assert.IsTrue(mappings.ContainsKey(CurrentTestTopic));
        }
        public void WhenNewBrokerInTopicIsAddedZKBrokerPartitionInfoUpdatesMappings()
        {
            var producerConfig = new ProducerConfig(clientConfig);
            IDictionary<string, SortedSet<Partition>> mappings;
            IDictionary<int, Broker> brokers;
            string brokerPath = ZooKeeperClient.DefaultBrokerIdsPath + "/" + 2345;
            string topicPath = ZooKeeperClient.DefaultBrokerTopicsPath + "/" + CurrentTestTopic;
            string topicBrokerPath = topicPath + "/" + 2345;
            using (IZooKeeperClient client = new ZooKeeperClient(
                producerConfig.ZkConnect,
                producerConfig.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                {
                    brokers = brokerPartitionInfo.GetAllBrokerInfo();
                    mappings =
                        ReflectionHelper.GetInstanceField<IDictionary<string, SortedSet<Partition>>>(
                            "topicBrokerPartitions", brokerPartitionInfo);
                    client.CreatePersistent(brokerPath, true);
                    client.WriteData(brokerPath, "192.168.1.39-1310449279123:192.168.1.39:9102");
                    client.CreatePersistent(topicPath, true);
                    WaitUntillIdle(client, 500);
                    Assert.IsTrue(brokers.ContainsKey(2345));
                    Assert.IsTrue(mappings.ContainsKey(CurrentTestTopic));
                    client.CreatePersistent(topicBrokerPath, true);
                    client.WriteData(topicBrokerPath, 5);
                    WaitUntillIdle(client, 500);
                    client.UnsubscribeAll();
                    client.DeleteRecursive(brokerPath);
                    client.DeleteRecursive(topicPath);
                }
            }

            Assert.NotNull(brokers);
            Assert.Greater(brokers.Count, 0);
            Assert.NotNull(mappings);
            Assert.Greater(mappings.Count, 0);
            Assert.IsTrue(brokers.ContainsKey(2345));
            Assert.IsTrue(mappings.Keys.Contains(CurrentTestTopic));
            Assert.AreEqual(5, mappings[CurrentTestTopic].Count);
        }
        public void ZkBrokerPartitionInfoGetsBrokerPartitionInfo()
        {
            var prodconfig = this.ZooKeeperBasedSyncProdConfig;
            SortedSet<Partition> partitions;
            using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(prodconfig, null))
            {
                partitions = brokerPartitionInfo.GetBrokerPartitionInfo("test");
            }

            Assert.NotNull(partitions);
            Assert.GreaterOrEqual(partitions.Count, 2);
        }
        public void ZkBrokerPartitionInfoGetsBrokerInfo()
        {
            var prodConfig = this.ZooKeeperBasedSyncProdConfig;
            var prodConfigNotZk = this.ConfigBasedSyncProdConfig;

            using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(prodConfig, null))
            {
                var testBroker = prodConfigNotZk.Brokers[0];
                Broker broker = brokerPartitionInfo.GetBrokerInfo(testBroker.BrokerId);
                Assert.NotNull(broker);
                Assert.AreEqual(testBroker.Host, broker.Host);
                Assert.AreEqual(testBroker.Port, broker.Port);
            }
        }
        public void ZkBrokerPartitionInfoGetsAllBrokerInfo()
        {
            var prodConfig = this.ZooKeeperBasedSyncProdConfig;
            var prodConfigNotZk = this.ConfigBasedSyncProdConfig;

            IDictionary<int, Broker> allBrokerInfo;
            using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(prodConfig, null))
            {
                allBrokerInfo = brokerPartitionInfo.GetAllBrokerInfo();
            }

            Assert.AreEqual(prodConfigNotZk.Brokers.Count, allBrokerInfo.Count);
            allBrokerInfo.Values.All(x => prodConfigNotZk.Brokers.Any(
                y => x.Id == y.BrokerId
                && x.Host == y.Host
                && x.Port == y.Port));
        }
        public void WhenNewTopicIsAddedBrokerTopicsListenerCreatesNewMapping()
        {
            var prodConfig = this.ZooKeeperBasedSyncProdConfig;

            IDictionary<string, SortedSet<Partition>> mappings;
            IDictionary<int, Broker> brokers;
            string topicPath = ZooKeeperClient.DefaultBrokerTopicsPath + "/" + CurrentTestTopic;

            using (IZooKeeperClient client = new ZooKeeperClient(
                prodConfig.ZooKeeper.ZkConnect,
                prodConfig.ZooKeeper.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                {
                    brokers = brokerPartitionInfo.GetAllBrokerInfo();
                    mappings =
                        ReflectionHelper.GetInstanceField<IDictionary<string, SortedSet<Partition>>>(
                            "topicBrokerPartitions", brokerPartitionInfo);
                }
            }

            Assert.NotNull(brokers);
            Assert.Greater(brokers.Count, 0);
            Assert.NotNull(mappings);
            Assert.Greater(mappings.Count, 0);
            using (IZooKeeperClient client = new ZooKeeperClient(
                prodConfig.ZooKeeper.ZkConnect,
                prodConfig.ZooKeeper.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                client.Connect();
                WaitUntillIdle(client, 500);
                var brokerTopicsListener = new BrokerTopicsListener(client, mappings, brokers, null);
                client.Subscribe(ZooKeeperClient.DefaultBrokerTopicsPath, brokerTopicsListener);
                client.CreatePersistent(topicPath, true);
                WaitUntillIdle(client, 500);
                client.UnsubscribeAll();
                WaitUntillIdle(client, 500);
                client.DeleteRecursive(topicPath);
            }

            Assert.IsTrue(mappings.ContainsKey(CurrentTestTopic));
        }
        public void WhenNewBrokerIsAddedZkBrokerPartitionInfoUpdatesBrokersList()
        {
            var prodConfig = this.ZooKeeperBasedSyncProdConfig;

            IDictionary<int, Broker> brokers;
            string brokerPath = ZooKeeperClient.DefaultBrokerIdsPath + "/" + 2345;
            using (IZooKeeperClient client = new ZooKeeperClient(
                prodConfig.ZooKeeper.ZkConnect,
                prodConfig.ZooKeeper.ZkSessionTimeoutMs,
                ZooKeeperStringSerializer.Serializer))
            {
                using (var brokerPartitionInfo = new ZKBrokerPartitionInfo(client))
                {
                    brokers = brokerPartitionInfo.GetAllBrokerInfo();
                    client.CreatePersistent(brokerPath, true);
                    client.WriteData(brokerPath, "192.168.1.39-1310449279123:192.168.1.39:9102");
                    WaitUntillIdle(client, 500);
                    client.UnsubscribeAll();
                    WaitUntillIdle(client, 500);
                    client.DeleteRecursive(brokerPath);
                }
            }

            Assert.NotNull(brokers);
            Assert.Greater(brokers.Count, 0);
            Assert.IsTrue(brokers.ContainsKey(2345));
            Assert.AreEqual("192.168.1.39", brokers[2345].Host);
            Assert.AreEqual(9102, brokers[2345].Port);
            Assert.AreEqual(2345, brokers[2345].Id);
        }