echo mdule

Author: Chrono Law

modules/echo/ModNdgEcho.cpp

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

modules/echo/NdgEchoConf.hpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_ECHO_CONF_HPP
+#define _NDG_ECHO_CONF_HPP
+
+#include "NgxAll.hpp"
+
+class NdgEchoConf final
+{
+public:
+    typedef NdgEchoConf this_type;
+public:
+    NdgEchoConf() = default;
+    ~NdgEchoConf() = default;
+public:
+    ngx_str_t msg;
+public:
+    static void* create(ngx_conf_t* cf)
+    {
+        return NgxPool(cf).alloc<this_type>();
+    }
+
+};
+
+NGX_MOD_INSTANCE(NdgEchoModule, ndg_echo_module, NdgEchoConf)
+
+#endif  //_NDG_ECHO_CONF_HPP

modules/echo/NdgEchoHandler.hpp

@@ -0,0 +1,138 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_ECHO_HANDLER_HPP
+#define _NDG_ECHO_HANDLER_HPP
+
+#include <iostream>
+
+#include "NdgEchoConf.hpp"
+
+class NdgEchoHandler final
+{
+public:
+    typedef NdgEchoHandler this_type;
+public:
+    static ngx_int_t handler(ngx_http_request_t *r)
+    {
+        //req_line(r);
+        //req_headers(r);
+
+        return process(r);
+    }
+private:
+    static ngx_int_t process(ngx_http_request_t *r)
+    try
+    {
+        using namespace std;
+
+        NgxRequest req(r);
+        //NgxPool pool(r);
+
+        if(!req.method(NGX_HTTP_GET))
+        {
+            return NGX_HTTP_NOT_ALLOWED;
+        }
+
+        req.body().discard();
+
+        auto& cf = NdgEchoModule::instance().conf().loc(r);
+        NgxString msg = cf.msg;
+        cout << "msg = " << msg << endl;
+
+        // check args
+        NgxString args = req->args;
+
+        auto len = msg.size();
+        if(!args.empty())
+        {
+            len += args.size()+1;
+        }
+        //cout << "len = "<< len << endl;
+
+        NgxResponse resp(r);
+
+        //auto h = resp.headers();
+
+        resp.length(len);
+        resp.status(NGX_HTTP_OK);
+        //h->content_length_n = len;
+        //h->status = NGX_HTTP_OK;
+        //h->content_length_n = msg.size();
+        //h->status = NGX_HTTP_OK;
+
+        //NgxBuf buf = pool.buffer();
+        //buf.range(msg);
+        //resp.send(buf);
+        if(!args.empty())
+        {
+            resp.send(args);
+            resp.send(",");
+        }
+
+        resp.send(msg);
+        cout << "send buf" << endl;
+        //buf.finish();
+
+        //buf->memory= true;
+        //buf->last_buf = true;
+        //cout << buf.range() << endl;
+
+        //NgxChainNode ch = pool.chain();
+        //ch.set(buf);
+        //ch.finish();
+        //assert(!ch->next);
+        //assert(ch->buf == buf.get());
+
+        resp.flush();
+        cout << "flush" << endl;
+        return resp.eof();
+    }
+    catch(const NgxException& e)
+    {
+        return e.code();
+    }
+
+    static void req_line(ngx_http_request_t *r)
+    {
+        using namespace std;
+
+        cout << r->request_line<< endl;
+        cout << r->method_name << endl;
+        cout << r->http_protocol<< endl;
+        cout << r->uri<< endl;
+        cout << r->args<< endl;
+        cout << r->exten<< endl;
+        cout << r->unparsed_uri<< endl;
+
+        NgxVarManager var(r);
+        cout << "var:";
+        //cout << var.get("request_method")<< endl;
+        cout << var["request_method"]<< endl;
+        cout << var["var1"]<< endl;
+        assert(!var.get("abc").len);
+
+        //var.set("var1", "1234567");
+        var["var1"] = "1234567";
+        cout << var["var1"]<< endl;
+    }
+
+    static void req_headers(ngx_http_request_t *r)
+    {
+        using namespace std;
+
+        NgxRequest req(r);
+
+        auto hi = req.headers();
+
+        cout << "host = "<<hi.has("host") << endl;
+        cout << "agent= "<<hi.has("user-agent") << endl;
+
+        hi.list().visit(
+            [](ngx_table_elt_t& kv){
+                cout << kv.key << "=>"<< kv.value
+                    << ":"<<kv.hash << endl;
+            });
+    }
+};
+
+#endif  //_NDG_ECHO_HANDLER_HPP

modules/echo/NdgEchoInit.hpp

@@ -0,0 +1,79 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NDG_ECHO_INIT_HPP
+#define _NDG_ECHO_INIT_HPP
+
+#include "NdgEchoConf.hpp"
+#include "NdgEchoHandler.hpp"
+
+class NdgEchoInit final
+{
+public:
+    typedef NdgEchoConf conf_type;
+    typedef NdgEchoHandler handler_type;
+    typedef NdgEchoInit this_type;
+public:
+    static ngx_command_t* cmds()
+    {
+        static ngx_command_t n[] =
+        {
+            NgxCommand(
+                ngx_string("ndg_echo"),
+                NgxTake(NGX_HTTP_LOC_CONF, 1),
+                &this_type::set_echo,
+                NGX_HTTP_LOC_CONF_OFFSET,
+                offsetof(conf_type, msg)
+            ),
+
+            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_echo(ngx_conf_t* cf, ngx_command_t* cmd, void* conf)
+    {
+        auto rc = ngx_conf_set_str_slot(cf, cmd, conf);
+
+        if(rc != NGX_CONF_OK)
+        {
+            return rc;
+        }
+
+        NgxHttpCoreModule::instance().handler(
+                        cf, &handler_type::handler);
+
+        return NGX_CONF_OK;
+    }
+};
+
+#endif  //_NDG_ECHO_INIT_HPP

modules/echo/config

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