load balance module

Author: Chrono Law

modules/loadbalance/ModNdgLoadBalance.cpp

@@ -0,0 +1,7 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+
+#include "NdgLoadBalanceInit.hpp"
+
+auto ndg_load_balance_module = NdgLoadBalanceInit::module();
+

modules/loadbalance/NdgLoadBalanceConf.hpp

@@ -0,0 +1,10 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_LOAD_BALANCE_CONF_HPP
+#define _NDG_LOAD_BALANCE_CONF_HPP
+
+#include "NgxAll.hpp"
+
+//NGX_MOD_INSTANCE(NdgLoadBalanceModule, ndg_load_balance_module)
+
+#endif  //_NDG_LOAD_BALANCE_CONF_HPP

modules/loadbalance/NdgLoadBalanceHandler.hpp

@@ -0,0 +1,88 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_LOAD_BALANCE_HANDLER_HPP
+#define _NDG_LOAD_BALANCE_HANDLER_HPP
+
+#include <boost/random.hpp>
+
+#include "NdgLoadBalanceConf.hpp"
+
+class NdgLoadBalanceCallback final
+{
+public:
+    typedef NgxLogDebug log;
+    typedef NdgLoadBalanceCallback this_type;
+    typedef boost::rand48 random_type;
+public:
+    // the round robin data must be first
+    ngx_http_upstream_rr_peer_data_t   rrp;
+
+    u_char  tries = 0;
+    ngx_event_get_peer_pt get_rr_peer = ngx_http_upstream_get_round_robin_peer;
+public:
+    static ngx_int_t get(ngx_peer_connection_t *pc, void *data)
+    {
+        auto& peer_data = *reinterpret_cast<this_type*>(data);
+        auto& peers = *peer_data.rrp.peers;
+
+        if(peer_data.tries++ > 5 || peers.single)
+        {
+            return peer_data.get_rr_peer(pc, &peer_data.rrp);
+        }
+
+        static random_type rand(time(0));
+
+        auto& peer = peers.peer[rand() % peers.number];
+
+        pc->sockaddr = peer.sockaddr;
+        pc->socklen = peer.socklen;
+        pc->name = &peer.name;
+
+        log(pc->log).print("peer=%V", &peer.name);
+
+        pc->cached = false;
+        pc->connection = nullptr;
+
+        return NGX_OK;
+    }
+
+public:
+    static void free(ngx_peer_connection_t *pc, void *data, ngx_uint_t state)
+    {
+        //auto peer_data = reinterpret_cast<this_type*>(data);
+    }
+};
+
+class NdgLoadBalanceHandler final
+{
+public:
+    typedef NdgLoadBalanceHandler this_type;
+    typedef NdgLoadBalanceCallback callback_type;
+    typedef NdgLoadBalanceCallback peer_data_type;
+
+    //typedef NdgLoadBalanceModule this_module;
+    typedef NgxLoadBalance<peer_data_type,
+                           &callback_type::get>
+                           //&callback_type::free>
+                           this_load_balance;
+public:
+    static ngx_int_t init(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
+    try
+    {
+        this_load_balance::init(cf, us, &this_type::init_peer);
+        return NGX_OK;
+    }
+    catch(const NgxException& e)
+    {
+        return e.code();
+    }
+public:
+    static ngx_int_t init_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)
+    {
+        this_load_balance::init(r, us);
+
+        return NGX_OK;
+    }
+};
+
+#endif  //_NDG_LOAD_BALANCE_HANDLER_HPP

modules/loadbalance/NdgLoadBalanceInit.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_LOAD_BALANCE_INIT_HPP
+#define _NDG_LOAD_BALANCE_INIT_HPP
+
+#include "NdgLoadBalanceConf.hpp"
+#include "NdgLoadBalanceHandler.hpp"
+
+class NdgLoadBalanceInit final
+{
+public:
+    typedef NdgLoadBalanceHandler handler_type;
+    typedef NdgLoadBalanceInit this_type;
+public:
+    static ngx_command_t* cmds()
+    {
+        static ngx_command_t n[] =
+        {
+            NgxCommand(
+                ngx_string("ndg_load_balance"),
+                NgxTake(NGX_HTTP_UPS_CONF, 0),
+                &this_type::set_load_balance
+            ),
+
+            NgxCommand()
+        };
+
+        return n;
+    }
+public:
+    static ngx_http_module_t* ctx()
+    {
+        static ngx_http_module_t c =
+        {
+            NGX_MODULE_NULL(8)
+        };
+
+        return &c;
+    }
+public:
+    static const ngx_module_t& module()
+    {
+        static ngx_module_t m =
+        {
+            NGX_MODULE_V1,
+
+            ctx(),
+            cmds(),
+
+            NGX_HTTP_MODULE,
+            NGX_MODULE_NULL(7),
+            NGX_MODULE_V1_PADDING
+        };
+
+        return m;
+    }
+private:
+    static char* set_load_balance(ngx_conf_t* cf, ngx_command_t* cmd, void* conf)
+    {
+        NgxHttpUpstreamModule::instance().init(cf, &handler_type::init);
+
+        return NGX_CONF_OK;
+    }
+};
+
+#endif  //_NDG_LOAD_BALANCE_INIT_HPP

modules/loadbalance/config

@@ -0,0 +1,6 @@
+#./configure --add-module=$HOME/ngx_cpp_dev/modules/loadbalance
+
+ngx_addon_name=ndg_load_balance_module
+
+HTTP_MODULES="$HTTP_MODULES ndg_load_balance_module"
+NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_addon_dir/ModNdgLoadBalance.cpp"