upstream module

Author: Chrono Law

modules/upstream/ModNdgUpstream.cpp

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

modules/upstream/NdgUpstreamConf.hpp

@@ -0,0 +1,34 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_UPSTREAM_CONF_HPP
+#define _NDG_UPSTREAM_CONF_HPP
+
+#include "NgxAll.hpp"
+
+class NdgUpstreamConf final
+{
+public:
+    typedef NdgUpstreamConf this_type;
+public:
+    NdgUpstreamConf() = default;
+    ~NdgUpstreamConf() = default;
+public:
+    ngx_http_upstream_conf_t upstream;
+public:
+    static void* create(ngx_conf_t* cf)
+    {
+        auto& c = *NgxPool(cf).alloc<this_type>();
+
+        c.upstream.connect_timeout = 1000*30;
+        c.upstream.send_timeout = 1000*30;
+        c.upstream.read_timeout = 1000*30;
+        c.upstream.buffer_size = ngx_pagesize;
+
+        return &c;
+    }
+
+};
+
+NGX_MOD_INSTANCE(NdgUpstreamModule, ndg_upstream_module, NdgUpstreamConf)
+
+#endif  //_NDG_UPSTREAM_CONF_HPP

modules/upstream/NdgUpstreamHandler.hpp

@@ -0,0 +1,115 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_UPSTREAM_HANDLER_HPP
+#define _NDG_UPSTREAM_HANDLER_HPP
+
+#include "NdgUpstreamConf.hpp"
+
+class NdgUpstreamCallback final
+{
+public:
+    typedef NgxUpstream upstream_type;
+    typedef NgxLogDebug log;
+public:
+    static ngx_int_t create_request(ngx_http_request_t* r)
+    {
+        ngx_str_t msgs[] = {
+            r->request_line,
+            ngx_string("\r\n"),
+            ngx_string("Host: localhost\r\n"),
+            ngx_string("\r\n"),
+            ngx_null_string
+        };
+
+        NgxPool pool(r);
+        NgxUpstream u(r);
+
+        NgxString s = msgs[0];
+        for(auto i = 0u;!s.empty();s = msgs[++i])
+        {
+            NgxBuf buf = pool.buffer();
+            buf.range(s);
+
+            NgxChainNode ch = pool.chain();
+            ch.set(buf);
+
+            log(r).print("proxy %V", s.get());
+            u.request(ch);
+        }
+
+        log(r).print("send:%V", &r->request_line);
+
+        return NGX_OK;
+    }
+
+    static ngx_int_t process_header(ngx_http_request_t* r)
+    {
+        NgxUpstream u(r);
+
+        u.headers().status_n = NGX_HTTP_OK;
+        u.headers().content_length_n = 192;
+
+        u.state().status = NGX_HTTP_OK;
+
+        // do others ...
+
+        return NGX_OK;
+    }
+
+    // input_filter
+};
+
+class NdgUpstreamHandler final
+{
+public:
+    typedef NdgUpstreamHandler this_type;
+    typedef NdgUpstreamCallback callback_type;
+
+    typedef NdgUpstreamModule this_module;
+    typedef NgxUpstreamHelper<&callback_type::create_request,
+                     &callback_type::process_header>
+            this_upstream;
+public:
+    static ngx_int_t handler(ngx_http_request_t *r)
+    try
+    {
+        NgxRequest req(r);
+        if(!req.method(NGX_HTTP_GET))
+        {
+            return NGX_HTTP_NOT_ALLOWED;
+        }
+
+        this_upstream u(r);
+
+        // get config
+        auto& cf = this_module::instance().conf().loc(r);
+
+        // set upstream confg
+        u.conf(cf.upstream);
+        //u.buffering(cf.upstream.buffering);
+
+        //u->resolved = NgxPool(r).alloc<ngx_http_upstream_resolved_t>();
+        //u->resolved->sockaddr = local_addr();
+        //u->resolved->socklen = sizeof(sockaddr_in);
+        //u->resolved->naddrs = 1;
+
+        return u.start();
+    }
+    catch(const NgxException& e)
+    {
+        return e.code();
+    }
+
+    static sockaddr* local_addr()
+    {
+        static sockaddr_in addr;
+
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(80);
+        addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+
+        return (sockaddr*)&addr;
+    }
+};
+
+#endif  //_NDG_UPSTREAM_HANDLER_HPP

modules/upstream/NdgUpstreamInit.hpp

@@ -0,0 +1,84 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_UPSTREAM_INIT_HPP
+#define _NDG_UPSTREAM_INIT_HPP
+
+#include "NdgUpstreamConf.hpp"
+#include "NdgUpstreamHandler.hpp"
+
+class NdgUpstreamInit final
+{
+public:
+    typedef NdgUpstreamConf conf_type;
+    typedef NdgUpstreamHandler handler_type;
+    typedef NdgUpstreamInit this_type;
+public:
+    static ngx_command_t* cmds()
+    {
+        static ngx_command_t n[] =
+        {
+            NgxCommand(
+                ngx_string("ndg_upstream_pass"),
+                NgxTake(NGX_HTTP_LOC_CONF, 1),
+                &this_type::set_upstream_pass
+            ),
+
+            NgxCommand()
+        };
+
+        return n;
+    }
+public:
+    static ngx_http_module_t* ctx()
+    {
+        static ngx_http_module_t c =
+        {
+            NGX_MODULE_NULL(6),
+            &conf_type::create,
+            NGX_MODULE_NULL(1),
+        };
+
+        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_upstream_pass(ngx_conf_t* cf, ngx_command_t* cmd, void* conf)
+    {
+        ngx_url_t u;
+
+        u.url = NgxStrArray(cf->args)[1];
+        u.no_resolve = true;
+
+        auto& lcf = *reinterpret_cast<conf_type*>(conf);
+
+        lcf.upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
+
+        if(!lcf.upstream.upstream)
+        {
+            return reinterpret_cast<char*>(NGX_CONF_ERROR);
+        }
+
+        NgxHttpCoreModule::instance().handler(
+                        cf, &handler_type::handler);
+
+        return NGX_CONF_OK;
+    }
+};
+
+#endif  //_NDG_UPSTREAM_INIT_HPP

modules/upstream/config

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