Add implementation for the CLIENT KILL command

Author: YiuRULE

includes/cpp_redis/future_client.hpp

@@ -93,7 +93,8 @@ class future_client {
   future blpop(const std::vector<std::string>& keys, int timeout);
   future brpop(const std::vector<std::string>& keys, int timeout);
   future brpoplpush(const std::string& src, const std::string& dst, int timeout);
-  // future client_kill() [ip:port] [id client-id] [type normal|master|slave|pubsub] [addr ip:port] [skipme yes/no]
+  template <typename T, typename... Ts>
+  future client_kill(const T&, const Ts&...);
   future client_list();
   future client_getname();
   future client_pause(int timeout);
@@ -305,4 +306,11 @@ class future_client {
   redis_client m_client;
 };
 
+
+template <typename T, typename... Ts>
+future_client::future
+future_client::client_kill(const T& arg, const Ts&... args) {
+  return exec_cmd([=](const rcb_t& cb) -> rc& { return m_client.client_kill(arg, args..., cb); });
+}
+
 } //! cpp_redis

includes/cpp_redis/helpers/variadic_template.hpp

@@ -0,0 +1,69 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015-2017 Simon Ninon <[email protected]>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <type_traits>
+
+namespace cpp_redis {
+namespace helpers {
+
+template <typename T, typename... Args>
+struct back {
+  using type = typename back<Args...>::type;
+};
+
+template <typename T>
+struct back<T> {
+  using type = T;
+};
+
+template <typename T, typename... Ts>
+struct front {
+  using type = T;
+};
+
+template <typename T1, typename T2, typename... Ts>
+struct is_type_present {
+  static constexpr bool value = std::is_same<T1, T2>::value
+                                  ? true
+                                  : is_type_present<T1, Ts...>::value;
+};
+
+template <typename T1, typename T2>
+struct is_type_present<T1, T2> {
+  static constexpr bool value = std::is_same<T1, T2>::value;
+};
+
+template <typename T, typename... Args>
+struct is_different_types {
+  static constexpr bool value = is_type_present<T, Args...>::value
+                                  ? false
+                                  : is_different_types<Args...>::value;
+};
+
+template <typename T1>
+struct is_different_types<T1> {
+  static constexpr bool value = true;
+};
+} //! helpers
+} //! cpp_redis

includes/cpp_redis/redis_client.hpp

@@ -30,13 +30,15 @@
 #include <string>
 #include <vector>
 
+#include <cpp_redis/helpers/variadic_template.hpp>
 #include <cpp_redis/logger.hpp>
 #include <cpp_redis/network/redis_connection.hpp>
 #include <cpp_redis/network/tcp_client_iface.hpp>
+#include <cpp_redis/special_command/client_kill_impl.hpp>
 
 namespace cpp_redis {
 
-class redis_client {
+class redis_client : public client_kill {
 public:
 //! ctor & dtor
 #ifndef __CPP_REDIS_USE_CUSTOM_TCP_CLIENT
@@ -94,7 +96,13 @@ class redis_client {
   redis_client& blpop(const std::vector<std::string>& keys, int timeout, const reply_callback_t& reply_callback = nullptr);
   redis_client& brpop(const std::vector<std::string>& keys, int timeout, const reply_callback_t& reply_callback = nullptr);
   redis_client& brpoplpush(const std::string& src, const std::string& dst, int timeout, const reply_callback_t& reply_callback = nullptr);
-  // redis_client& client_kill(const reply_callback_t& reply_callback = nullptr) [ip:port] [id client-id] [type normal|master|slave|pubsub] [addr ip:port] [skipme yes/no]
+  template <typename T, typename... Ts>
+  redis_client& client_kill(const std::string& host, int port, const T& arg, const Ts&... args);
+  redis_client& client_kill(const std::string& host, int port);
+  template <typename... Ts>
+  redis_client& client_kill(const char* host, int port, const Ts&... args);
+  template <typename T, typename... Ts>
+  redis_client& client_kill(const T&, const Ts&...);
   redis_client& client_list(const reply_callback_t& reply_callback = nullptr);
   redis_client& client_getname(const reply_callback_t& reply_callback = nullptr);
   redis_client& client_pause(int timeout, const reply_callback_t& reply_callback = nullptr);
@@ -332,4 +340,47 @@ class redis_client {
   std::atomic<unsigned int> m_callbacks_running = ATOMIC_VAR_INIT(0);
 };
 
+template <typename T, typename... Ts>
+inline redis_client&
+redis_client::client_kill(const T& arg, const Ts&... args) {
+  static_assert(helpers::is_different_types<T, Ts...>::value, "Should only have one distinct value per filter type");
+  static_assert(!(std::is_class<T>::value && std::is_same<T, typename helpers::back<T, Ts...>::type>::value), "Should have at least one filter");
+
+  std::vector<std::string> redis_cmd({"CLIENT", "KILL"});
+  reply_callback_t reply_cb = nullptr;
+  client_kill_impl<T, Ts...>(redis_cmd, reply_cb, arg, args...);
+
+  return send(redis_cmd, reply_cb);
+}
+
+template <typename T, typename... Ts>
+inline redis_client&
+redis_client::client_kill(const std::string& host, int port, const T& arg, const Ts&... args) {
+  static_assert(helpers::is_different_types<T, Ts...>::value, "Should only have one distinct value per filter type");
+  std::vector<std::string> redis_cmd({"CLIENT", "KILL"});
+
+  /** If we have other type than lambda, then it's a filter
+   */
+  if (!std::is_class<T>::value) {
+    redis_cmd.emplace_back("ADDR");
+  }
+
+  redis_cmd.emplace_back(host + ":" + std::to_string(port));
+  reply_callback_t reply_cb = nullptr;
+  client_kill_impl<T, Ts...>(redis_cmd, reply_cb, arg, args...);
+
+  return send(redis_cmd, reply_cb);
+}
+
+inline redis_client&
+redis_client::client_kill(const std::string& host, int port) {
+  return client_kill(host, port, reply_callback_t(nullptr));
+}
+
+template <typename... Ts>
+inline redis_client&
+redis_client::client_kill(const char* host, int port, const Ts&... args) {
+  return client_kill(std::string(host), port, args...);
+}
+
 } //! cpp_redis

includes/cpp_redis/special_command/client_kill_impl.hpp

@@ -0,0 +1,93 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015-2017 Simon Ninon <[email protected]>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <functional>
+#include <iostream>
+
+namespace cpp_redis {
+class client_kill {
+
+public:
+  enum class type {
+    normal,
+    master,
+    pubsub,
+    slave
+  };
+
+private:
+  using CB = std::function<void(cpp_redis::reply&)>;
+
+  template <typename T>
+  typename std::enable_if<std::is_same<T, type>::value>::type
+  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, CB& /* */, type type) {
+    redis_cmd.emplace_back("TYPE");
+    std::string type_string;
+
+    switch (type) {
+    case client_kill::type::normal: type_string = "normal"; break;
+    case client_kill::type::master: type_string = "master"; break;
+    case client_kill::type::pubsub: type_string = "pubsub"; break;
+    case client_kill::type::slave: type_string  = "slave"; break;
+    }
+
+    redis_cmd.emplace_back(type_string);
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_same<T, bool>::value>::type
+  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, CB& /* */, bool skip) {
+    redis_cmd.emplace_back("SKIPME");
+    redis_cmd.emplace_back(skip ? "yes" : "no");
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value>::type
+  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, CB& /* */, uint64_t id) {
+    redis_cmd.emplace_back("ID");
+    redis_cmd.emplace_back(std::to_string(id));
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_class<T>::value>::type
+  client_kill_unpack_arg(std::vector<std::string>& /* */, CB& reply_callback, const T& cb) {
+    reply_callback = cb;
+  }
+
+protected:
+  template <typename T, typename... Ts>
+  void
+  client_kill_impl(std::vector<std::string>& redis_cmd, CB& reply, const T& arg, const Ts&... args) {
+    static_assert(!std::is_class<T>::value, "Reply callback should be in the end of the argument list");
+    client_kill_unpack_arg<T>(redis_cmd, reply, arg);
+    client_kill_impl(redis_cmd, reply, args...);
+  };
+
+  template <typename T>
+  void
+  client_kill_impl(std::vector<std::string>& redis_cmd, CB& reply, const T& arg) {
+    client_kill_unpack_arg<T>(redis_cmd, reply, arg);
+  };
+};
+} //! cpp_redis