opal-up 0.0.2 → 0.0.3

data/ext/up_ext/HttpRouter.h

@@ -0,0 +1,380 @@
+/*
+ * Authored by Alex Hultman, 2018-2020.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPROUTER_HPP
+#define UWS_HTTPROUTER_HPP
+
+#include <map>
+#include <vector>
+#include <cstring>
+#include <string_view>
+#include <string>
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+#include <iostream>
+
+#include "MoveOnlyFunction.h"
+
+namespace uWS {
+
+template <class USERDATA>
+struct HttpRouter {
+    static constexpr std::string_view ANY_METHOD_TOKEN = "*";
+    static const uint32_t HIGH_PRIORITY = 0xd0000000, MEDIUM_PRIORITY = 0xe0000000, LOW_PRIORITY = 0xf0000000;
+
+private:
+    USERDATA userData;
+    static const unsigned int MAX_URL_SEGMENTS = 100;
+
+    /* Handler ids are 32-bit */
+    static const uint32_t HANDLER_MASK = 0x0fffffff;
+
+    /* List of handlers */
+    std::vector<MoveOnlyFunction<bool(HttpRouter *)>> handlers;
+
+    /* Current URL cache */
+    std::string_view currentUrl;
+    std::string_view urlSegmentVector[MAX_URL_SEGMENTS];
+    int urlSegmentTop;
+
+    /* The matching tree */
+    struct Node {
+        std::string name;
+        std::vector<std::unique_ptr<Node>> children;
+        std::vector<uint32_t> handlers;
+        bool isHighPriority;
+
+        Node(std::string name) : name(name) {}
+    } root = {"rootNode"};
+
+    /* Sort wildcards after alphanum */
+    int lexicalOrder(std::string &name) {
+        if (!name.length()) {
+            return 2;
+        }
+        if (name[0] == ':') {
+            return 1;
+        }
+        if (name[0] == '*') {
+            return 0;
+        }
+        return 2;
+    }
+
+    /* Advance from parent to child, adding child if necessary */
+    Node *getNode(Node *parent, std::string child, bool isHighPriority) {
+        for (std::unique_ptr<Node> &node : parent->children) {
+            if (node->name == child && node->isHighPriority == isHighPriority) {
+                return node.get();
+            }
+        }
+
+        /* Insert sorted, but keep order if parent is root (we sort methods by priority elsewhere) */
+        std::unique_ptr<Node> newNode(new Node(child));
+        newNode->isHighPriority = isHighPriority;
+        return parent->children.emplace(std::upper_bound(parent->children.begin(), parent->children.end(), newNode, [parent, this](auto &a, auto &b) {
+
+            if (a->isHighPriority != b->isHighPriority) {
+                return a->isHighPriority;
+            }
+
+            return b->name.length() && (parent != &root) && (lexicalOrder(b->name) < lexicalOrder(a->name));
+        }), std::move(newNode))->get();
+    }
+
+    /* Basically a pre-allocated stack */
+    struct RouteParameters {
+        friend struct HttpRouter;
+    private:
+        std::string_view params[MAX_URL_SEGMENTS];
+        int paramsTop;
+
+        void reset() {
+            paramsTop = -1;
+        }
+
+        void push(std::string_view param) {
+            /* We check these bounds indirectly via the urlSegments limit */
+            params[++paramsTop] = param;
+        }
+
+        void pop() {
+            /* Same here, we cannot pop outside */
+            paramsTop--;
+        }
+    } routeParameters;
+
+    /* Set URL for router. Will reset any URL cache */
+    inline void setUrl(std::string_view url) {
+
+        /* Todo: URL may also start with "http://domain/" or "*", not only "/" */
+
+        /* We expect to stand on a slash */
+        currentUrl = url;
+        urlSegmentTop = -1;
+    }
+
+    /* Lazily parse or read from cache */
+    inline std::pair<std::string_view, bool> getUrlSegment(int urlSegment) {
+        if (urlSegment > urlSegmentTop) {
+            /* Signal as STOP when we have no more URL or stack space */
+            if (!currentUrl.length() || urlSegment > int(MAX_URL_SEGMENTS - 1)) {
+                return {{}, true};
+            }
+
+            /* We always stand on a slash here, so step over it */
+            currentUrl.remove_prefix(1);
+
+            auto segmentLength = currentUrl.find('/');
+            if (segmentLength == std::string::npos) {
+                segmentLength = currentUrl.length();
+
+                /* Push to url segment vector */
+                urlSegmentVector[urlSegment] = currentUrl.substr(0, segmentLength);
+                urlSegmentTop++;
+
+                /* Update currentUrl */
+                currentUrl = currentUrl.substr(segmentLength);
+            } else {
+                /* Push to url segment vector */
+                urlSegmentVector[urlSegment] = currentUrl.substr(0, segmentLength);
+                urlSegmentTop++;
+
+                /* Update currentUrl */
+                currentUrl = currentUrl.substr(segmentLength);
+            }
+        }
+        /* In any case we return it */
+        return {urlSegmentVector[urlSegment], false};
+    }
+
+    /* Executes as many handlers it can */
+    bool executeHandlers(Node *parent, int urlSegment, USERDATA &userData) {
+
+        auto [segment, isStop] = getUrlSegment(urlSegment);
+
+        /* If we are on STOP, return where we may stand */
+        if (isStop) {
+            /* We have reached accross the entire URL with no stoppage, execute */
+            for (uint32_t handler : parent->handlers) {
+                if (handlers[handler & HANDLER_MASK](this)) {
+                    return true;
+                }
+            }
+            /* We reached the end, so go back */
+            return false;
+        }
+
+        for (auto &p : parent->children) {
+            if (p->name.length() && p->name[0] == '*') {
+                /* Wildcard match (can be seen as a shortcut) */
+                for (uint32_t handler : p->handlers) {
+                    if (handlers[handler & HANDLER_MASK](this)) {
+                        return true;
+                    }
+                }
+            } else if (p->name.length() && p->name[0] == ':' && segment.length()) {
+                /* Parameter match */
+                routeParameters.push(segment);
+                if (executeHandlers(p.get(), urlSegment + 1, userData)) {
+                    return true;
+                }
+                routeParameters.pop();
+            } else if (p->name == segment) {
+                /* Static match */
+                if (executeHandlers(p.get(), urlSegment + 1, userData)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /* Scans for one matching handler, returning the handler and its priority or UINT32_MAX for not found */
+    uint32_t findHandler(std::string method, std::string pattern, uint32_t priority) {
+        for (std::unique_ptr<Node> &node : root.children) {
+            if (method == node->name) {
+                setUrl(pattern);
+                Node *n = node.get();
+                for (int i = 0; !getUrlSegment(i).second; i++) {
+                    /* Go to next segment or quit */
+                    std::string segment = std::string(getUrlSegment(i).first);
+                    Node *next = nullptr;
+                    for (std::unique_ptr<Node> &child : n->children) {
+                        if (child->name == segment && child->isHighPriority == (priority == HIGH_PRIORITY)) {
+                            next = child.get();
+                            break;
+                        }
+                    }
+                    if (!next) {
+                        return UINT32_MAX;
+                    }
+                    n = next;
+                }
+                /* Seek for a priority match in the found node */
+                for (unsigned int i = 0; i < n->handlers.size(); i++) {
+                    if ((n->handlers[i] & ~HANDLER_MASK) == priority) {
+                        return n->handlers[i];
+                    }
+                }
+                return UINT32_MAX;
+            }
+        }
+        return UINT32_MAX;
+    }
+
+public:
+    HttpRouter() {
+        /* Always have ANY route */
+        getNode(&root, std::string(ANY_METHOD_TOKEN.data(), ANY_METHOD_TOKEN.length()), false);
+    }
+
+    std::pair<int, std::string_view *> getParameters() {
+        return {routeParameters.paramsTop, routeParameters.params};
+    }
+
+    USERDATA &getUserData() {
+        return userData;
+    }
+
+    /* Fast path */
+    bool route(std::string_view method, std::string_view url) {
+        /* Reset url parsing cache */
+        setUrl(url);
+        routeParameters.reset();
+
+        /* Begin by finding the method node */
+        for (auto &p : root.children) {
+            if (p->name == method) {
+                /* Then route the url */
+                if (executeHandlers(p.get(), 0, userData)) {
+                    return true;
+                } else {
+                    break;
+                }
+            }
+        }
+
+        /* Always test any route last */
+        return executeHandlers(root.children.back().get(), 0, userData);
+    }
+
+    /* Adds the corresponding entires in matching tree and handler list */
+    void add(std::vector<std::string> methods, std::string pattern, MoveOnlyFunction<bool(HttpRouter *)> &&handler, uint32_t priority = MEDIUM_PRIORITY) {
+        /* First remove existing handler */
+        remove(methods[0], pattern, priority);
+        
+        for (std::string method : methods) {
+            /* Lookup method */
+            Node *node = getNode(&root, method, false);
+            /* Iterate over all segments */
+            setUrl(pattern);
+            for (int i = 0; !getUrlSegment(i).second; i++) {
+                std::string strippedSegment(getUrlSegment(i).first);
+                if (strippedSegment.length() && strippedSegment[0] == ':') {
+                    /* Parameter routes must be named only : */
+                    strippedSegment = ":";
+                }
+                node = getNode(node, strippedSegment, priority == HIGH_PRIORITY);
+            }
+            /* Insert handler in order sorted by priority (most significant 1 byte) */
+            node->handlers.insert(std::upper_bound(node->handlers.begin(), node->handlers.end(), (uint32_t) (priority | handlers.size())), (uint32_t) (priority | handlers.size()));
+        }
+
+        /* Alloate this handler */
+        handlers.emplace_back(std::move(handler));
+
+        /* ANY method must be last, GET must be first */
+        std::sort(root.children.begin(), root.children.end(), [](const auto &a, const auto &b) {
+            /* Assuming the list of methods is unique, non-repeating */
+            if (a->name == "GET") {
+                return true;
+            } else if (b->name == "GET") {
+                return false;
+            } else if (a->name == ANY_METHOD_TOKEN) {
+                return false;
+            } else if (b->name == ANY_METHOD_TOKEN) {
+                return true;
+            } else {
+                return a->name < b->name;
+            }
+        });
+    }
+
+    bool cullNode(Node *parent, Node *node, uint32_t handler) {
+        /* For all children */
+        for (unsigned int i = 0; i < node->children.size(); ) {
+            /* Optimization todo: only enter those with same isHighPrioirty */
+            /* Enter child so we get depth first */
+            if (!cullNode(node, node->children[i].get(), handler)) {
+                /* Only increase if this node was not removed */
+                i++;
+            }
+        }
+
+        /* Cull this node (but skip the root node) */
+        if (parent /*&& parent != &root*/) {
+            /* Scan for equal (remove), greater (lower by 1) */
+            for (auto it = node->handlers.begin(); it != node->handlers.end(); ) {
+                if ((*it & HANDLER_MASK) > (handler & HANDLER_MASK)) {
+                    *it = ((*it & HANDLER_MASK) - 1) | (*it & ~HANDLER_MASK);
+                } else if (*it == handler) {
+                    it = node->handlers.erase(it);
+                    continue;
+                }
+                it++;
+            }
+
+            /* If we have no children and no handlers, remove us from the parent->children list */
+            if (!node->handlers.size() && !node->children.size()) {
+                parent->children.erase(std::find_if(parent->children.begin(), parent->children.end(), [node](const std::unique_ptr<Node> &a) {
+                    return a.get() == node;
+                }));
+                /* Returning true means we removed node from parent */
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /* Removes ALL routes with the same handler as can be found with the given parameters.
+     * Removing a wildcard is done by removing ONE OF the methods the wildcard would match with.
+     * Example: If wildcard includes POST, GET, PUT, you can remove ALL THREE by removing GET. */
+    void remove(std::string method, std::string pattern, uint32_t priority) {
+        uint32_t handler = findHandler(method, pattern, priority);
+        if (handler == UINT32_MAX) {
+            /* Not found or already removed, do nothing */
+            return;
+        }
+
+        /* Cull the entire tree */
+        /* For all nodes in depth first tree traveral;
+         * if node contains handler - remove the handler -
+         * if node holds no handlers after removal, remove the node and return */
+        cullNode(nullptr, &root, handler);
+
+        /* Now remove the actual handler */
+        handlers.erase(handlers.begin() + (handler & HANDLER_MASK));
+    }
+};
+
+}
+
+#endif // UWS_HTTPROUTER_HPP

data/ext/up_ext/Loop.h

@@ -0,0 +1,204 @@
+/*
+ * Authored by Alex Hultman, 2018-2020.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_LOOP_H
+#define UWS_LOOP_H
+
+/* The loop is lazily created per-thread and run with run() */
+
+#include "LoopData.h"
+#include "libusockets.h"
+#include <iostream>
+
+namespace uWS {
+struct Loop {
+private:
+    static void wakeupCb(us_loop_t *loop) {
+        LoopData *loopData = (LoopData *) us_loop_ext(loop);
+
+        /* Swap current deferQueue */
+        loopData->deferMutex.lock();
+        int oldDeferQueue = loopData->currentDeferQueue;
+        loopData->currentDeferQueue = (loopData->currentDeferQueue + 1) % 2;
+        loopData->deferMutex.unlock();
+
+        /* Drain the queue */
+        for (auto &x : loopData->deferQueues[oldDeferQueue]) {
+            x();
+        }
+        loopData->deferQueues[oldDeferQueue].clear();
+    }
+
+    static void preCb(us_loop_t *loop) {
+        LoopData *loopData = (LoopData *) us_loop_ext(loop);
+
+        for (auto &p : loopData->preHandlers) {
+            p.second((Loop *) loop);
+        }
+    }
+
+    static void postCb(us_loop_t *loop) {
+        LoopData *loopData = (LoopData *) us_loop_ext(loop);
+
+        for (auto &p : loopData->postHandlers) {
+            p.second((Loop *) loop);
+        }
+
+        /* After every event loop iteration, we must not hold the cork buffer */
+        if (loopData->corkedSocket) {
+            std::cerr << "Error: Cork buffer must not be held across event loop iterations!" << std::endl;
+            std::terminate();
+        }
+    }
+
+    Loop() = delete;
+    ~Loop() = default;
+
+    Loop *init() {
+        new (us_loop_ext((us_loop_t *) this)) LoopData;
+        return this;
+    }
+
+    static Loop *create(void *hint) {
+        Loop *loop = ((Loop *) us_create_loop(hint, wakeupCb, preCb, postCb, sizeof(LoopData)))->init();
+
+        /* We also need some timers (should live off the one 4 second timer rather) */
+        LoopData *loopData = (LoopData *) us_loop_ext((struct us_loop_t *) loop);
+        loopData->dateTimer = us_create_timer((struct us_loop_t *) loop, 1, sizeof(LoopData *));
+        memcpy(us_timer_ext(loopData->dateTimer), &loopData, sizeof(LoopData *));
+        us_timer_set(loopData->dateTimer, [](struct us_timer_t *t) {
+            LoopData *loopData;
+            memcpy(&loopData, us_timer_ext(t), sizeof(LoopData *));
+            loopData->updateDate();
+        }, 1000, 1000);
+
+        return loop;
+    }
+
+    /* What to do with loops created with existingNativeLoop? */
+    struct LoopCleaner {
+        ~LoopCleaner() {
+            if(loop && cleanMe) {
+                loop->free();
+            }
+        }
+        Loop *loop = nullptr;
+        bool cleanMe = false;
+    };
+
+    static LoopCleaner &getLazyLoop() {
+        static thread_local LoopCleaner lazyLoop;
+        return lazyLoop;
+    }
+
+public:
+    /* Lazily initializes a per-thread loop and returns it.
+     * Will automatically free all initialized loops at exit. */
+    static Loop *get(void *existingNativeLoop = nullptr) {
+        if (!getLazyLoop().loop) {
+            /* If we are given a native loop pointer we pass that to uSockets and let it deal with it */
+            if (existingNativeLoop) {
+                /* Todo: here we want to pass the pointer, not a boolean */
+                getLazyLoop().loop = create(existingNativeLoop);
+                /* We cannot register automatic free here, must be manually done */
+            } else {
+                getLazyLoop().loop = create(nullptr);
+                getLazyLoop().cleanMe = true;
+            }
+        }
+
+        return getLazyLoop().loop;
+    }
+
+    /* Freeing the default loop should be done once */
+    void free() {
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        /* Stop and free dateTimer first */
+        us_timer_close(loopData->dateTimer);
+
+        loopData->~LoopData();
+        /* uSockets will track whether this loop is owned by us or a borrowed alien loop */
+        us_loop_free((us_loop_t *) this);
+
+        /* Reset lazyLoop */
+        getLazyLoop().loop = nullptr;
+    }
+
+    void addPostHandler(void *key, MoveOnlyFunction<void(Loop *)> &&handler) {
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        loopData->postHandlers.emplace(key, std::move(handler));
+    }
+
+    /* Bug: what if you remove a handler while iterating them? */
+    void removePostHandler(void *key) {
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        loopData->postHandlers.erase(key);
+    }
+
+    void addPreHandler(void *key, MoveOnlyFunction<void(Loop *)> &&handler) {
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        loopData->preHandlers.emplace(key, std::move(handler));
+    }
+
+    /* Bug: what if you remove a handler while iterating them? */
+    void removePreHandler(void *key) {
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        loopData->preHandlers.erase(key);
+    }
+
+    /* Defer this callback on Loop's thread of execution */
+    void defer(MoveOnlyFunction<void()> &&cb) {
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        //if (std::thread::get_id() == ) // todo: add fast path for same thread id
+        loopData->deferMutex.lock();
+        loopData->deferQueues[loopData->currentDeferQueue].emplace_back(std::move(cb));
+        loopData->deferMutex.unlock();
+
+        us_wakeup_loop((us_loop_t *) this);
+    }
+
+    /* Actively block and run this loop */
+    void run() {
+        us_loop_run((us_loop_t *) this);
+    }
+
+    /* Passively integrate with the underlying default loop */
+    /* Used to seamlessly integrate with third parties such as Node.js */
+    void integrate() {
+        us_loop_integrate((us_loop_t *) this);
+    }
+
+    /* Dynamically change this */
+    void setSilent(bool silent) {
+        ((LoopData *) us_loop_ext((us_loop_t *) this))->noMark = silent;
+    }
+};
+
+/* Can be called from any thread to run the thread local loop */
+inline void run() {
+    Loop::get()->run();
+}
+
+}
+
+#endif // UWS_LOOP_H

data/ext/up_ext/LoopData.h

@@ -0,0 +1,112 @@
+/*
+ * Authored by Alex Hultman, 2018-2020.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_LOOPDATA_H
+#define UWS_LOOPDATA_H
+
+#include <thread>
+#include <functional>
+#include <vector>
+#include <mutex>
+#include <map>
+#include <ctime>
+#include <cstdint>
+
+#include "PerMessageDeflate.h"
+#include "MoveOnlyFunction.h"
+
+struct us_timer_t;
+
+namespace uWS {
+
+struct Loop;
+
+struct alignas(16) LoopData {
+    friend struct Loop;
+private:
+    std::mutex deferMutex;
+    int currentDeferQueue = 0;
+    std::vector<MoveOnlyFunction<void()>> deferQueues[2];
+
+    /* Map from void ptr to handler */
+    std::map<void *, MoveOnlyFunction<void(Loop *)>> postHandlers, preHandlers;
+
+public:
+    LoopData() {
+        updateDate();
+    }
+
+    ~LoopData() {
+        /* If we have had App.ws called with compression we need to clear this */
+        if (zlibContext) {
+            delete zlibContext;
+            delete inflationStream;
+            delete deflationStream;
+        }
+        delete [] corkBuffer;
+    }
+
+    void updateDate() {
+        time_t now = time(0);
+        struct tm tstruct = {};
+#ifdef _WIN32
+        /* Micro, fucking soft never follows spec. */
+        gmtime_s(&tstruct, &now);
+#else
+        gmtime_r(&now, &tstruct);
+#endif
+        static const char wday_name[][4] = {
+            "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+        };
+        static const char mon_name[][4] = {
+            "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+            "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+        };
+        snprintf(date, 32, "%.3s, %.2u %.3s %.4u %.2u:%.2u:%.2u GMT",
+            wday_name[tstruct.tm_wday],
+            tstruct.tm_mday % 99,
+            mon_name[tstruct.tm_mon],
+            (1900 + tstruct.tm_year) % 9999,
+            tstruct.tm_hour % 99,
+            tstruct.tm_min % 99,
+            tstruct.tm_sec % 99);
+    }
+
+    char date[32];
+
+    /* Be silent */
+    bool noMark = false;
+
+    /* Good 16k for SSL perf. */
+    static const unsigned int CORK_BUFFER_SIZE = 16 * 1024;
+
+    /* Cork data */
+    char *corkBuffer = new char[CORK_BUFFER_SIZE];
+    unsigned int corkOffset = 0;
+    void *corkedSocket = nullptr;
+
+    /* Per message deflate data */
+    ZlibContext *zlibContext = nullptr;
+    InflationStream *inflationStream = nullptr;
+    DeflationStream *deflationStream = nullptr;
+
+    us_timer_t *dateTimer;
+};
+
+}
+
+#endif // UWS_LOOPDATA_H