uws-react-native 0.0.1-alpha.1

package/cpp/uWebSockets/uWebSockets/Loop.h

@@ -0,0 +1,238 @@
+/*
+ * 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 {
+
+/* A prepared message is dependent on the Loop, so it belongs here */
+struct PreparedMessage {
+    /* These should be a single alloation along with the PreparedMessage itself (they are static) */
+    std::string originalMessage, compressedMessage;
+    bool compressed;
+    int opCode;
+};
+
+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:
+
+    /* Preformatted messages need the Loop */
+    PreparedMessage prepareMessage(std::string_view message, int opCode, bool compress = true) {
+        /* The message could be formatted right here, but this optimization is not done yet */
+        PreparedMessage preparedMessage;
+        preparedMessage.compressed = compress;
+        preparedMessage.opCode = opCode;
+        preparedMessage.originalMessage = message;
+
+        LoopData *loopData = (LoopData *) us_loop_ext((us_loop_t *) this);
+
+        if (compress) {
+            /* Initialize loop's deflate inflate streams */
+            if (!loopData->zlibContext) {
+                loopData->zlibContext = new ZlibContext;
+                loopData->inflationStream = new InflationStream(CompressOptions::DEDICATED_DECOMPRESSOR);
+                loopData->deflationStream = new DeflationStream(CompressOptions::DEDICATED_COMPRESSOR);
+            }
+
+            preparedMessage.compressedMessage = loopData->deflationStream->deflate(loopData->zlibContext, {preparedMessage.originalMessage.data(), preparedMessage.originalMessage.length()}, true);
+        }
+
+        return preparedMessage;
+    }
+
+    /* 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

package/cpp/uWebSockets/uWebSockets/LoopData.h

@@ -0,0 +1,113 @@
+/*
+ * 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() {
+        cacheTimepoint = time(0);
+        struct tm tstruct = {};
+#ifdef _WIN32
+        /* Micro, fucking soft never follows spec. */
+        gmtime_s(&tstruct, &cacheTimepoint);
+#else
+        gmtime_r(&cacheTimepoint, &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];
+    time_t cacheTimepoint = 0;
+
+    /* 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

package/cpp/uWebSockets/uWebSockets/MessageParser.h

@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+/* Implements the common parser (RFC 822) used in both HTTP and Multipart parsing */
+
+#ifndef UWS_MESSAGE_PARSER_H
+#define UWS_MESSAGE_PARSER_H
+
+#include <string_view>
+#include <utility>
+#include <cstring>
+
+/* For now we have this one here */
+#define MAX_HEADERS 10
+
+namespace uWS {
+
+    // should be templated on whether it needs at lest one header (http), or not (multipart)
+    static inline unsigned int getHeaders(char *postPaddedBuffer, char *end, std::pair<std::string_view, std::string_view> *headers) {
+        char *preliminaryKey, *preliminaryValue, *start = postPaddedBuffer;
+
+        for (unsigned int i = 0; i < MAX_HEADERS; i++) {
+            for (preliminaryKey = postPaddedBuffer; (*postPaddedBuffer != ':') & (*(unsigned char *)postPaddedBuffer > 32); *(postPaddedBuffer++) |= 32);
+            if (*postPaddedBuffer == '\r') {
+                if ((postPaddedBuffer != end) & (postPaddedBuffer[1] == '\n') /* & (i > 0) */) { // multipart does not require any headers like http does
+                    headers->first = std::string_view(nullptr, 0);
+                    return (unsigned int) ((postPaddedBuffer + 2) - start);
+                } else {
+                    return 0;
+                }
+            } else {
+                headers->first = std::string_view(preliminaryKey, (size_t) (postPaddedBuffer - preliminaryKey));
+                for (postPaddedBuffer++; (*postPaddedBuffer == ':' || *(unsigned char *)postPaddedBuffer < 33) && *postPaddedBuffer != '\r'; postPaddedBuffer++);
+                preliminaryValue = postPaddedBuffer;
+                postPaddedBuffer = (char *) memchr(postPaddedBuffer, '\r', end - postPaddedBuffer);
+                if (postPaddedBuffer && postPaddedBuffer[1] == '\n') {
+                    headers->second = std::string_view(preliminaryValue, (size_t) (postPaddedBuffer - preliminaryValue));
+                    postPaddedBuffer += 2;
+                    headers++;
+                } else {
+                    return 0;
+                }
+            }
+        }
+        return 0;
+    }
+
+}
+
+#endif