stream discard

Author: chronolaw

stream/discard/ModNdgStreamDiscard.cpp

@@ -0,0 +1,5 @@
+// Copyright (c) 2016-2017
+// Author: Chrono Law
+#include "NdgStreamDiscardInit.hpp"
+
+auto ndg_stream_discard_module = NdgStreamDiscardInit::module();

stream/discard/NdgStreamDiscardConf.hpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2016-2017
+// Author: Chrono Law
+#ifndef _NDG_STREAM_DISCARD_CONF_HPP
+#define _NDG_STREAM_DISCARD_CONF_HPP
+
+#include "NgxStreamAll.hpp"
+
+class NdgStreamDiscardConf final
+{
+public:
+    typedef NdgStreamDiscardConf this_type;
+public:
+    NdgStreamDiscardConf() = default;
+    ~NdgStreamDiscardConf() = default;
+public:
+    ngx_msec_t timeout = ngx_nil;
+public:
+    static void* create(ngx_conf_t* cf)
+    {
+        return NgxPool(cf).alloc<this_type>();
+    }
+
+    static char* merge(ngx_conf_t *cf, void *parent, void *child)
+    {
+        boost::ignore_unused(cf);
+
+        auto& prev = cast(parent);
+        auto& conf = cast(child);
+
+        NgxValue::merge(conf.timeout, prev.timeout, 5000);
+
+        return NGX_CONF_OK;
+    }
+public:
+    static this_type& cast(void* p)
+    {
+        return *reinterpret_cast<this_type*>(p);
+    }
+};
+
+NGX_MOD_INSTANCE(NdgStreamDiscardModule,
+        ndg_stream_discard_module, NdgStreamDiscardConf)
+
+#endif  //_NDG_STREAM_DISCARD_CONF_HPP

stream/discard/NdgStreamDiscardHandler.hpp

@@ -0,0 +1,98 @@
+// Copyright (c) 2016-2017
+// Author: Chrono Law
+#ifndef _NDG_STREAM_DISCARD_HANDLER_HPP
+#define _NDG_STREAM_DISCARD_HANDLER_HPP
+
+#include <array>
+
+#include "NdgStreamDiscardConf.hpp"
+
+class NdgStreamDiscardHandler final
+{
+public:
+    typedef NdgStreamDiscardHandler this_type;
+    typedef NdgStreamDiscardModule  this_module;
+public:
+    static void handler(ngx_stream_session_t *s)
+    try
+    {
+        NgxConnection conn(s);
+
+        NgxWriteEvent wev = conn.write_event();
+        //wev.handler(&this_type::block_write_handler);
+        wev.handler([](ngx_event_t *ev){});
+
+        NgxReadEvent rev = conn.read_event();
+
+        rev.handler(&this_type::discard_read_handler);
+
+        rev.process();
+    }
+    catch(const NgxException& e)
+    {
+        NgxLogError(s).print("error = %d", e.code());
+        NgxStreamSession(s).close();
+    }
+private:
+    static void discard_read_handler(ngx_event_t *ev)
+    try
+    {
+        NgxReadEvent rev(ev);
+        NgxConnection conn(ev);
+
+        // check timedout and error
+        NgxException::fail(rev.expired(), NGX_ETIMEDOUT);
+        NgxException::fail(conn.closed());
+
+        if(rev.ready())
+        {
+            // read from client
+            std::array<u_char, 64> buf;
+            NgxLogError log(conn);
+
+            ssize_t n = 0;
+
+            // read until can not read
+            for(;;)
+            {
+                n = conn.recv(buf.data(), buf.size());
+
+                if(n <= 0)  // error accured
+                {
+                    break;
+                }
+
+                log.print("recv %d bytes", n);
+
+                conn.reusable(false);
+            }   // end for
+
+            //NgxException::fail(n == NGX_ERROR || n == 0);
+            NgxException::fail(n != NGX_AGAIN);
+
+            //(n == NGX_AGAIN)
+        }
+
+        NgxStreamSession s(ev);
+        auto& cf = this_module::conf().srv(s);
+
+        //rev.timeout(cf.timeout, true);
+        //rev.wait();
+        rev.wait_for(cf.timeout, true);
+    }
+    catch(const NgxException& e)
+    {
+        NgxStreamSession s(ev);
+
+        NgxLogError(s).print("error = %d", e.code());
+        s.close();
+    }
+private:
+    static void block_write_handler(ngx_event_t *ev)
+    {
+        // do nothing
+    }
+
+};
+
+#endif  //_NDG_STREAM_DISCARD_HANDLER_HPP

stream/discard/NdgStreamDiscardInit.hpp

@@ -0,0 +1,85 @@
+// Copyright (c) 2016-2017
+// Author: Chrono Law
+#ifndef _NDG_STREAM_DISCARD_INIT_HPP
+#define _NDG_STREAM_DISCARD_INIT_HPP
+
+#include "NdgStreamDiscardConf.hpp"
+#include "NdgStreamDiscardHandler.hpp"
+
+class NdgStreamDiscardInit final
+{
+public:
+    typedef NdgStreamDiscardConf       conf_type;
+    typedef NdgStreamDiscardHandler    handler_type;
+    typedef NdgStreamDiscardInit       this_type;
+public:
+    static ngx_command_t* cmds()
+    {
+        static ngx_command_t n[] =
+        {
+            {
+                ngx_string("ndg_discard_time_out"),
+                NgxTake(NGX_STREAM_SRV_CONF, 1),
+                ngx_conf_set_msec_slot,
+                NGX_STREAM_SRV_CONF_OFFSET,
+                offsetof(conf_type, timeout),
+                nullptr
+            },
+
+            {
+                ngx_string("ndg_stream_discard"),
+                NgxTake(NGX_STREAM_SRV_CONF, 0),
+                &this_type::set_discard,
+                NGX_STREAM_SRV_CONF_OFFSET,
+                0, nullptr
+            },
+
+            ngx_null_command
+        };
+
+        return n;
+    }
+public:
+    static ngx_stream_module_t* ctx()
+    {
+        static ngx_stream_module_t c =
+        {
+            NGX_MODULE_NULL(4),
+
+            &conf_type::create,
+            &conf_type::merge,
+        };
+
+        return &c;
+    }
+public:
+    static const ngx_module_t& module()
+    {
+        static ngx_module_t m =
+        {
+            NGX_MODULE_V1,
+
+            ctx(),
+            cmds(),
+
+            NGX_STREAM_MODULE,
+            NGX_MODULE_NULL(7),
+            NGX_MODULE_V1_PADDING
+        };
+
+        return m;
+    }
+private:
+    static char* set_discard(ngx_conf_t* cf, ngx_command_t* cmd, void* conf)
+    {
+        boost::ignore_unused(cmd, conf);
+
+        NgxStreamCoreModule::handler(
+            cf, &handler_type::handler);
+
+        return NGX_CONF_OK;
+    }
+};
+
+#endif  //_NDG_STREAM_DISCARD_INIT_HPP
+

stream/discard/config

@@ -0,0 +1,10 @@
+#./configure --add-module=$HOME/ngx_cpp_dev/modules/test
+
+ngx_module_type=STREAM
+ngx_module_name=ndg_stream_discard_module
+ngx_module_srcs="$ngx_addon_dir/ModNdgStreamDiscard.cpp"
+
+. auto/module
+
+ngx_addon_name=ndg_stream_discard_module
+