Add zookeeper support

include/cppkafka/config.h.in

@@ -0,0 +1,7 @@
+#ifndef CPPKAFKA_CONFIG_H
+#define CPPKAFKA_CONFIG_H
+
+/* Define if the zookeeper extensions are enabled */
+#cmakedefine CPPKAFKA_HAVE_ZOOKEEPER
+
+#endif // CPPKAFKA_CONFIG_H

include/cppkafka/configuration.h

@@ -33,6 +33,8 @@
 #include <memory>
 #include <string>
 #include <functional>
+#include <unordered_map>
+#include <unordered_set>
 #include <chrono>
 #include <boost/optional.hpp>
 #include <librdkafka/rdkafka.h>
@@ -79,6 +81,7 @@ public:
     void set_socket_callback(SocketCallback callback);
     void set_default_topic_configuration(boost::optional<TopicConfiguration> config);
 
+    bool has_property(const std::string& name) const;
     rd_kafka_conf_t* get_handle() const;
     std::string get(const std::string& name) const;
     const DeliveryReportCallback& get_delivery_report_callback() const;
@@ -91,8 +94,10 @@ public:
     const boost::optional<TopicConfiguration>& get_default_topic_configuration() const;
     boost::optional<TopicConfiguration>& get_default_topic_configuration();
 private:
+    static const std::unordered_set<std::string> VALID_EXTENSIONS;
     using HandlePtr = ClonablePtr<rd_kafka_conf_t, decltype(&rd_kafka_conf_destroy),
                                   decltype(&rd_kafka_conf_dup)>;
+    using PropertiesMap = std::unordered_map<std::string, std::string>;
 
     Configuration(rd_kafka_conf_t* ptr);
     static HandlePtr make_handle(rd_kafka_conf_t* ptr);
@@ -106,6 +111,7 @@ private:
     LogCallback log_callback_;
     StatsCallback stats_callback_;
     SocketCallback socket_callback_;
+    PropertiesMap extension_properties_;
 };
 
 } // cppkafka

include/cppkafka/kafka_handle_base.h

@@ -42,6 +42,10 @@
 #include "topic_partition_list.h"
 #include "topic_configuration.h"
 #include "configuration.h"
+#include "config.h"
+#ifdef CPPKAFKA_HAVE_ZOOKEEPER
+    #include "zookeeper/zookeeper_subscriber.h"
+#endif // CPPKAFKA_HAVE_ZOOKEEPER
 
 namespace cppkafka {
 
@@ -93,6 +97,10 @@ private:
     Configuration config_;
     TopicConfigurationMap topic_configurations_;
     std::mutex topic_configurations_mutex_;
+    #ifdef CPPKAFKA_HAVE_ZOOKEEPER
+        // This could be an optional but apparently move construction is only supported as of 1.56
+        std::unique_ptr<ZookeeperSubscriber> zookeeper_subscriber_;
+    #endif // CPPKAFKA_HAVE_ZOOKEEPER
 };
 
 } // cppkafka

include/cppkafka/zookeeper/zookeeper_pool.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2016, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef CPPKAFKA_ZOOKEEPER_POOL_H
+#define CPPKAFKA_ZOOKEEPER_POOL_H
+
+#include <map>
+#include <string>
+#include <chrono>
+#include <mutex>
+#include "zookeeper/zookeeper_watcher.h"
+
+namespace cppkafka {
+
+class ZookeeperSubscriber;
+
+class ZookeeperPool {
+public:
+    static ZookeeperPool& instance();
+
+    ZookeeperSubscriber subscribe(const std::string& endpoint,
+                                  std::chrono::milliseconds receive_timeout,
+                                  ZookeeperWatcher::WatcherCallback callback);
+    void unsubscribe(const ZookeeperSubscriber& subscriber);
+    std::string get_brokers(const std::string& endpoint);
+
+    size_t get_subscriber_count(const std::string& endpoint) const;
+private:
+    using WatchersMap = std::map<std::string, ZookeeperWatcher>;
+
+    WatchersMap watchers_;
+    mutable std::mutex watchers_mutex_;
+};
+
+} // cppkafka
+
+#endif // CPPKAFKA_ZOOKEEPER_POOL_H

include/cppkafka/zookeeper/zookeeper_subscriber.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016, Matias Fontanini
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following disclaimer
+ *   in the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef CPPKAFKA_ZOOKEEPER_SUBSCRIBER_H
+#define CPPKAFKA_ZOOKEEPER_SUBSCRIBER_H
+
+#include <string>
+
+namespace cppkafka {
+
+class ZookeeperSubscriber {
+public:
+    ZookeeperSubscriber(std::string endpoint, std::string subscription_id);
+    ZookeeperSubscriber(ZookeeperSubscriber&&) = default;
+    ZookeeperSubscriber(const ZookeeperSubscriber&) = delete;
+    ZookeeperSubscriber& operator=(ZookeeperSubscriber&&);
+    ZookeeperSubscriber& operator=(const ZookeeperSubscriber&) = delete;
+    ~ZookeeperSubscriber();
+
+    const std::string& get_endpoint() const;
+    const std::string& get_subscription_id() const;
+private:
+    std::string endpoint_;
+    std::string subscription_id_;
+};
+
+} // cppkafka
+
+#endif // CPPKAFKA_ZOOKEEPER_SUBSCRIBER_H

include/cppkafka/zookeeper/zookeeper_watcher.h

@@ -33,6 +33,9 @@
 #include <memory>
 #include <string>
 #include <chrono>
+#include <map>
+#include <functional>
+#include <mutex>
 #include <zookeeper/zookeeper.h>
 
 namespace cppkafka {
@@ -41,21 +44,33 @@ class ZookeeperWatcher {
 public:
     static const std::chrono::milliseconds DEFAULT_RECEIVE_TIMEOUT;
 
+    using WatcherCallback = std::function<void(const std::string& brokers)>;
+
     ZookeeperWatcher(const std::string& endpoint);
     ZookeeperWatcher(const std::string& endpoint, std::chrono::milliseconds receive_timeout);
 
+    void setup_watcher();
+
+    std::string subscribe(WatcherCallback callback); 
+    void unsubscribe(const std::string& id);
 
     std::string get_brokers();
+    size_t get_subscriber_count() const;
 private:
-    using HandlePtr = std::unique_ptr<zhandle_t, decltype(&zookeeper_close)>;
-
     static const std::string BROKERS_PATH;
 
+    using HandlePtr = std::unique_ptr<zhandle_t, decltype(&zookeeper_close)>;
+    using CallbackMap = std::map<std::string, WatcherCallback>;
+
     static void handle_event_proxy(zhandle_t* zh, int type, int state, const char* path,
                                    void* ctx);
     void handle_event(int type, int state, const char* path);
+    std::string generate_id();
 
     HandlePtr handle_;
+    CallbackMap callbacks_;
+    mutable std::mutex callbacks_mutex_;
+    size_t id_counter_{0};
 };
 
 } // cppkafka