more benching

* rename payload to body

* Fixed ws cmd line tool to use the renamed body

Co-authored-by: Jay <jasoncarr@Jasons-MacBook-Pro.local>

.github/workflows/docker.yml

@@ -0,0 +1,66 @@
+name: docker
+
+# When its time to do a release do a build for amd64
+# and push all of them to Docker Hub.
+# Only trigger on semver shaped tags.
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  login:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Prepare
+        id: prep
+        run: |
+          DOCKER_IMAGE=machinezone/ws
+          VERSION=edge
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/v}
+          fi
+          if [ "${{ github.event_name }}" = "schedule" ]; then
+            VERSION=nightly
+          fi
+          TAGS="${DOCKER_IMAGE}:${VERSION}"
+          if [[ $VERSION =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
+            TAGS="$TAGS,${DOCKER_IMAGE}:latest"
+          fi
+          echo ::set-output name=tags::${TAGS}
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@master
+
+      - name: Cache Docker layers
+        uses: actions/cache@v2
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+
+      - name: Login to GitHub Package Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_TOKEN }}
+
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v2-build-push
+        with:
+          builder: ${{ steps.buildx.outputs.name }}
+          context: .
+          file: ./Dockerfile
+          target: prod
+          platforms: linux/amd64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.prep.outputs.tags }}
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache

CMake/FindDeflate.cmake

@@ -0,0 +1,19 @@
+# Find package structure taken from libcurl
+
+include(FindPackageHandleStandardArgs)
+
+find_path(DEFLATE_INCLUDE_DIRS libdeflate.h)
+find_library(DEFLATE_LIBRARY deflate)
+
+find_package_handle_standard_args(DEFLATE
+    FOUND_VAR
+      DEFLATE_FOUND
+    REQUIRED_VARS
+      DEFLATE_LIBRARY
+      DEFLATE_INCLUDE_DIRS
+    FAIL_MESSAGE
+      "Could NOT find deflate"
+)
+
+set(DEFLATE_INCLUDE_DIRS ${DEFLATE_INCLUDE_DIRS})
+set(DEFLATE_LIBRARIES ${DEFLATE_LIBRARY})

CMakeLists.txt

@@ -31,6 +31,7 @@ set( IXWEBSOCKET_SOURCES
     ixwebsocket/IXDNSLookup.cpp
     ixwebsocket/IXExponentialBackoff.cpp
     ixwebsocket/IXGetFreePort.cpp
+    ixwebsocket/IXGzipCodec.cpp
     ixwebsocket/IXHttp.cpp
     ixwebsocket/IXHttpClient.cpp
     ixwebsocket/IXHttpServer.cpp
@@ -62,11 +63,11 @@ set( IXWEBSOCKET_SOURCES
 set( IXWEBSOCKET_HEADERS
     ixwebsocket/IXBench.h
     ixwebsocket/IXCancellationRequest.h
-    ixwebsocket/IXConnectionInfo.h
     ixwebsocket/IXConnectionState.h
     ixwebsocket/IXDNSLookup.h
     ixwebsocket/IXExponentialBackoff.h
     ixwebsocket/IXGetFreePort.h
+    ixwebsocket/IXGzipCodec.h
     ixwebsocket/IXHttp.h
     ixwebsocket/IXHttpClient.h
     ixwebsocket/IXHttpServer.h
@@ -201,6 +202,14 @@ if (USE_ZLIB)
   target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_ZLIB)
 endif()
 
+# brew install libdeflate
+find_package(DEFLATE)
+if (DEFLATE_FOUND)
+  include_directories(${DEFLATE_INCLUDE_DIRS})
+  target_link_libraries(ixwebsocket ${DEFLATE_LIBRARIES})
+  target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_DEFLATE)
+endif()
+
 if (WIN32)
   target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
@@ -252,7 +261,16 @@ if (USE_WS OR USE_TEST)
   add_subdirectory(ixsentry)
   add_subdirectory(ixbots)
 
-  add_subdirectory(third_party/spdlog spdlog)
+  include(FetchContent)
+  FetchContent_Declare(spdlog
+      GIT_REPOSITORY "https://github.com/gabime/spdlog"
+      GIT_TAG "v1.8.0") 
+
+  FetchContent_Declare(jsoncpp
+      GIT_REPOSITORY "https://github.com/open-source-parsers/jsoncpp"
+      GIT_TAG "1.9.4") 
+
+  FetchContent_MakeAvailable(spdlog jsoncpp)
 
   if (USE_WS)
       add_subdirectory(ws)

README.md

@@ -2,7 +2,7 @@
 
 IXWebSocket is a C++ library for WebSocket client and server development. It has minimal dependencies (no boost), is very simple to use and support everything you'll likely need for websocket dev (SSL, deflate compression, compiles on most platforms, etc...). HTTP client and server code is also available, but it hasn't received as much testing.
 
-It is been used on big mobile video game titles sending and receiving tons of messages since 2017 (iOS and Android). It was tested on macOS, iOS, Linux, Android, Windows and FreeBSD. Two important design goals are simplicity and correctness.
+It is been used on big mobile video game titles sending and receiving tons of messages since 2017 (iOS and Android). It was tested on macOS, iOS, Linux, Android, Windows and FreeBSD. Note that the MinGW compiler is not supported at this point. Two important design goals are simplicity and correctness.
 
 ```cpp
 /*

docker-compose.yml

@@ -1,67 +1,11 @@
-version: "3"
+version: "3.3"
 services:
-  # snake:
-  #   image: bsergean/ws:build
-  #   entrypoint: ws snake --port 8767 --host 0.0.0.0 --redis_hosts redis1
-  #   ports:
-  #     - "8767:8767"
-  #   networks:
-  #     - ws-net
-  #   depends_on:
-  #     - redis1
+  push:
+    entrypoint: ws push_server --host 0.0.0.0
+    image: ${DOCKER_REPO}/ws:build
 
-  # proxy:
-  #   image: bsergean/ws:build
-  #   entrypoint: strace ws proxy_server --remote_host 'wss://cobra.addsrv.com' --host 0.0.0.0 --port 8765 -v
-  #   ports:
-  #     - "8765:8765"
-  #   networks:
-  #     - ws-net
-
-  #pyproxy:
-  #  image: bsergean/ws_proxy:build
-  #  entrypoint: /usr/bin/ws_proxy.py --remote_url 'wss://cobra.addsrv.com' --host 0.0.0.0 --port 8765
-  #  ports:
-  #    - "8765:8765"
-  #  networks:
-  #    - ws-net
-
-  #      #  ws:
-  #      #    security_opt:
-  #      #    - seccomp:unconfined
-  #      #    cap_add:
-  #      #    - SYS_PTRACE
-  #      #    stdin_open: true
-  #      #    tty: true
-  #      #    image: bsergean/ws:build
-  #      #    entrypoint: sh
-  #      #    networks:
-  #      #      - ws-net
-  #      #    depends_on:
-  #      #      - redis1
-  #      #
-  #      #  redis1:
-  #      #    image: redis:alpine
-  #      #    networks:
-  #      #      - ws-net
-  #      #
-  #      #  statsd:
-  #      #    image: jaconel/statsd
-  #      #    ports:
-  #      #      - "8125:8125"
-  #      #    environment:
-  #      #      - STATSD_DUMP_MSG=true
-  #      #      - GRAPHITE_HOST=127.0.0.1
-  #      #    networks:
-  #      #      - ws-net
-
-  compile:
-    image: alpine
-    entrypoint: sh
-    stdin_open: true
-    tty: true
-    volumes:
-      - /Users/bsergeant/src/foss:/home/bsergean/src/foss
-
-networks:
-  ws-net:
+  autoroute:
+    entrypoint: ws autoroute ws://push:8008
+    image: ${DOCKER_REPO}/ws:build
+    depends_on:
+      - push

docker/Dockerfile.alpine

@@ -2,7 +2,7 @@ FROM alpine:3.12 as build
 
 RUN apk add --no-cache \
     gcc g++ musl-dev linux-headers \
-    cmake mbedtls-dev make zlib-dev python3-dev ninja
+    cmake mbedtls-dev make zlib-dev python3-dev ninja git
 
 RUN addgroup -S app && \
     adduser -S -G app app && \
@@ -20,7 +20,7 @@ RUN make ws_mbedtls_install && \
 
 FROM alpine:3.12 as runtime
 
-RUN apk add --no-cache libstdc++ mbedtls ca-certificates python3 && \
+RUN apk add --no-cache libstdc++ mbedtls ca-certificates python3 strace && \
     addgroup -S app && \
     adduser -S -G app app
 

docs/CHANGELOG.md

@@ -2,6 +2,114 @@
 
 All changes to this project will be documented in this file.
 
+## [10.4.7] - 2020-09-28
+
+(ws) add gzip and gunzip ws sub commands
+
+## [10.4.6] - 2020-09-26
+
+(cmake) use FetchContent cmake module to retrieve jsoncpp third party dependency
+
+## [10.4.5] - 2020-09-26
+
+(cmake) use FetchContent cmake module to retrieve spdlog third party dependency
+
+## [10.4.4] - 2020-09-22
+
+(cobra connection) retrieve cobra server connection id from the cobra handshake message and display it in ws clients, metrics publisher and bots
+
+## [10.4.3] - 2020-09-22
+
+(cobra 2 cobra) specify as an HTTP header which channel we will republish to
+
+## [10.4.2] - 2020-09-18
+
+(cobra bots) change an error log to a warning log when reconnecting because no messages were received for a minute
+
+## [10.4.1] - 2020-09-18
+
+(cobra connection and bots) set an HTTP header when connecting to help with debugging bots
+
+## [10.4.0] - 2020-09-12
+
+(http server) read body request when the Content-Length is specified + set timeout to read the request to 30 seconds max by default, and make it configurable as a constructor parameter
+
+## [10.3.5] - 2020-09-09
+
+(ws) autoroute command exit on its own once all messages have been received
+
+## [10.3.4] - 2020-09-04
+
+(docker) ws docker file installs strace
+
+## [10.3.3] - 2020-09-02
+
+(ws) echo_client command renamed to autoroute. Command exit once the server close the connection. push_server commands exit once N messages have been sent.
+
+## [10.3.2] - 2020-08-31
+
+(ws + cobra bots) add a cobra_to_cobra ws subcommand to subscribe to a channel and republish received events to a different channel
+
+## [10.3.1] - 2020-08-28
+
+(socket servers) merge the ConnectionInfo class with the ConnectionState one, which simplify all the server apis
+
+## [10.3.0] - 2020-08-26
+
+(ws) set the main thread name, to help with debugging in XCode, gdb, lldb etc...
+
+## [10.2.9] - 2020-08-19
+
+(ws) cobra to python bot / take a module python name as argument foo.bar.baz instead of a path foo/bar/baz.py
+
+## [10.2.8] - 2020-08-19
+
+(ws) on Linux with mbedtls, when the system ca certs are specified (the default) pick up sensible OS supplied paths (tested with CentOS and Alpine)
+
+## [10.2.7] - 2020-08-18
+
+(ws push_server) on the server side, stop sending and close the connection when the remote end has disconnected
+
+## [10.2.6] - 2020-08-17
+
+(ixwebsocket) replace std::unique_ptr<unsigned char[]> with std::array for some fixed arrays (which are in C++11)
+
+## [10.2.5] - 2020-08-15
+
+(ws) merge all ws_*.cpp files into a single one to speedup compilation
+
+## [10.2.4] - 2020-08-15
+
+(socket server) in the loop accepting connections, call select without a timeout on unix to avoid busy looping, and only wake up when a new connection happens
+
+## [10.2.3] - 2020-08-15
+
+(socket server) instead of busy looping with a sleep, only wake up the GC thread when a new thread will have to be joined, (we know that thanks to the ConnectionState OnSetTerminated callback
+
+## [10.2.2] - 2020-08-15
+
+(socket server) add a callback to the ConnectionState to be invoked when the connection is terminated. This will be used by the SocketServer in the future to know on time that the associated connection thread can be terminated.
+
+## [10.2.1] - 2020-08-15
+
+(socket server) do not create a select interrupt object everytime when polling for notifications while waiting for new connections, instead use a persistent one which is a member variable
+
+## [10.2.0] - 2020-08-14
+
+(ixwebsocket client) handle HTTP redirects
+
+## [10.2.0] - 2020-08-13
+
+(ws) upgrade to latest version of nlohmann json (3.9.1 from 3.2.0)
+
+## [10.1.9] - 2020-08-13
+
+(websocket proxy server) add ability to map different hosts to different websocket servers, using a json config file
+
+## [10.1.8] - 2020-08-12
+
+(ws) on macOS, with OpenSSL or MbedTLS, use /etc/ssl/cert.pem as the system certs
+
 ## [10.1.7] - 2020-08-11
 
 (ws) -q option imply info log level, not warning log level

docs/usage.md

@@ -280,10 +280,9 @@ ix::WebSocketServer server(port);
 
 server.setOnConnectionCallback(
     [&server](std::weak_ptr<WebSocket> webSocket,
-              std::shared_ptr<ConnectionState> connectionState,
-              std::unique_ptr<ConnectionInfo> connectionInfo)
+              std::shared_ptr<ConnectionState> connectionState)
     {
-        std::cout << "Remote ip: " << connectionInfo->remoteIp << std::endl;
+        std::cout << "Remote ip: " << connectionState->remoteIp << std::endl;
 
         auto ws = webSocket.lock();
         if (ws)
@@ -359,13 +358,12 @@ The webSocket reference is guaranteed to be always valid ; by design the callbac
 ix::WebSocketServer server(port);
 
 server.setOnClientMessageCallback(std::shared_ptr<ConnectionState> connectionState,
-                                  ConnectionInfo& connectionInfo,
                                   WebSocket& webSocket,
                                   const WebSocketMessagePtr& msg)
 {
-    // The ConnectionInfo object contains information about the connection,
+    // The ConnectionState object contains information about the connection,
     // at this point only the client ip address and the port.
-    std::cout << "Remote ip: " << connectionInfo.remoteIp << std::endl;
+    std::cout << "Remote ip: " << connectionState->getRemoteIp();
 
     if (msg->type == ix::WebSocketMessageType::Open)
     {
@@ -471,7 +469,7 @@ out = httpClient.post(url, std::string("foo=bar"), args);
 auto statusCode = response->statusCode; // Can be HttpErrorCode::Ok, HttpErrorCode::UrlMalformed, etc...
 auto errorCode = response->errorCode; // 200, 404, etc...
 auto responseHeaders = response->headers; // All the headers in a special case-insensitive unordered_map of (string, string)
-auto payload = response->payload; // All the bytes from the response as an std::string
+auto body = response->body; // All the bytes from the response as an std::string
 auto errorMsg = response->errorMsg; // Descriptive error message in case of failure
 auto uploadSize = response->uploadSize; // Byte count of uploaded data
 auto downloadSize = response->downloadSize; // Byte count of downloaded data
@@ -519,12 +517,11 @@ If you want to handle how requests are processed, implement the setOnConnectionC
 ```cpp
 setOnConnectionCallback(
     [this](HttpRequestPtr request,
-           std::shared_ptr<ConnectionState> /*connectionState*/,
-           std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr
+           std::shared_ptr<ConnectionState> connectionState) -> HttpResponsePtr
     {
         // Build a string for the response
         std::stringstream ss;
-        ss << connectionInfo->remoteIp
+        ss << connectionState->getRemoteIp();
            << " "
            << request->method
            << " "

docs/ws.md

@@ -204,6 +204,24 @@ Listening on 127.0.0.1:8008
 
 If you connect to ws://127.0.0.1:8008, the proxy will connect to ws://127.0.0.1:9000 and pass all traffic to this server.
 
+You can also use a more complex setup if you want to redirect to different websocket servers based on the hostname your client is trying to connect to. If you have multiple CNAME aliases that point to the same server.
+
+A JSON config file is used to express that mapping ; here connecting to echo.jeanserge.com will proxy the client to ws://localhost:8008 on the local machine (which actually runs ws echo_server), while connecting to bavarde.jeanserge.com will proxy the client to ws://localhost:5678 where a cobra python server is running. As a side note you will need a wildcard SSL certificate if you want to have SSL enabled on that machine.
+
+```json
+{
+        "remote_urls": {
+                "echo.jeanserge.com": "ws://localhost:8008",
+                "bavarde.jeanserge.com": "ws://localhost:5678"
+        }
+}
+```
+The --config_path option is required to instruct ws proxy_server to read that file.
+
+```
+ws proxy_server --config_path proxyConfig.json --port 8765
+```
+
 ## File transfer
 
 ```

ixbots/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 set (IXBOTS_SOURCES
     ixbots/IXCobraBot.cpp
+    ixbots/IXCobraToCobraBot.cpp
     ixbots/IXCobraToSentryBot.cpp
     ixbots/IXCobraToStatsdBot.cpp
     ixbots/IXCobraToStdoutBot.cpp
@@ -16,6 +17,7 @@ set (IXBOTS_SOURCES
 set (IXBOTS_HEADERS
     ixbots/IXCobraBot.h
     ixbots/IXCobraBotConfig.h
+    ixbots/IXCobraToCobraBot.h
     ixbots/IXCobraToSentryBot.h
     ixbots/IXCobraToStatsdBot.h
     ixbots/IXCobraToStdoutBot.h
@@ -29,11 +31,6 @@ add_library(ixbots STATIC
     ${IXBOTS_HEADERS}
 )
 
-find_package(JsonCpp)
-if (NOT JSONCPP_FOUND)
-  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
-endif()
-
 if (USE_PYTHON)
   target_compile_definitions(ixbots PUBLIC IXBOTS_USE_PYTHON)
   find_package(Python COMPONENTS Development)
@@ -46,12 +43,11 @@ set(IXBOTS_INCLUDE_DIRS
     ../ixwebsocket
     ../ixcobra
     ../ixredis
-    ../ixsentry
-    ${JSONCPP_INCLUDE_DIRS}
-    ${SPDLOG_INCLUDE_DIRS})
+    ../ixsentry)
 
 if (USE_PYTHON)
   set(IXBOTS_INCLUDE_DIRS ${IXBOTS_INCLUDE_DIRS} ${Python_INCLUDE_DIRS})
 endif()
 
 target_include_directories( ixbots PUBLIC ${IXBOTS_INCLUDE_DIRS} )
+target_link_libraries( ixbots jsoncpp_static )

ixbots/ixbots/IXCobraBot.cpp

@@ -31,6 +31,8 @@ namespace ix
         auto limitReceivedEvents = botConfig.limitReceivedEvents;
         auto batchSize = botConfig.batchSize;
 
+        config.headers["X-Cobra-Channel"] = channel;
+
         ix::CobraConnection conn;
         conn.configure(config);
         conn.connect();
@@ -128,7 +130,7 @@ namespace ix
                     ss << "no messages received or sent for "
                        << heartBeatTimeout << " seconds, reconnecting";
 
-                    CoreLogger::error(ss.str());
+                    CoreLogger::warn(ss.str());
                     stalledConnection = true;
                 }
                 state = currentState;
@@ -168,7 +170,11 @@ namespace ix
             }
             else if (event->type == ix::CobraEventType::Closed)
             {
-                CoreLogger::info("Subscriber closed: {}" + event->errMsg);
+                CoreLogger::info("Subscriber closed: " + event->errMsg);
+            }
+            else if (event->type == ix::CobraEventType::Handshake)
+            {
+                CoreLogger::info("Subscriber: Cobra handshake connection id: " + event->connectionId);
             }
             else if (event->type == ix::CobraEventType::Authenticated)
             {

ixbots/ixbots/IXCobraToCobraBot.cpp

@@ -0,0 +1,45 @@
+/*
+ *  IXCobraToCobraBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraToCobraBot.h"
+
+#include "IXCobraBot.h"
+#include <ixcobra/IXCobraMetricsPublisher.h>
+#include <sstream>
+
+namespace ix
+{
+    int64_t cobra_to_cobra_bot(const ix::CobraBotConfig& cobraBotConfig,
+                               const std::string& republishChannel,
+                               const std::string& publisherRolename,
+                               const std::string& publisherRolesecret)
+    {
+        CobraBot bot;
+
+        CobraMetricsPublisher cobraMetricsPublisher;
+        CobraConfig cobraPublisherConfig = cobraBotConfig.cobraConfig;
+        cobraPublisherConfig.rolename = publisherRolename;
+        cobraPublisherConfig.rolesecret = publisherRolesecret;
+        cobraPublisherConfig.headers["X-Cobra-Republish-Channel"] = republishChannel;
+
+        cobraMetricsPublisher.configure(cobraPublisherConfig, republishChannel);
+
+        bot.setOnBotMessageCallback(
+            [&republishChannel, &cobraMetricsPublisher](const Json::Value& msg,
+                                                        const std::string& /*position*/,
+                                                        std::atomic<bool>& /*throttled*/,
+                                                        std::atomic<bool>& /*fatalCobraError*/,
+                                                        std::atomic<uint64_t>& sentCount) -> void {
+                Json::Value msgWithNoId(msg);
+                msgWithNoId.removeMember("id");
+            
+                cobraMetricsPublisher.push(republishChannel, msg);
+                sentCount++;
+            });
+
+        return bot.run(cobraBotConfig);
+    }
+} // namespace ix

ixbots/ixbots/IXCobraToCobraBot.h

@@ -0,0 +1,20 @@
+/*
+ *  IXCobraToCobraBot.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+#pragma once
+
+#include <cstdint>
+#include <ixbots/IXStatsdClient.h>
+#include "IXCobraBotConfig.h"
+#include <stddef.h>
+#include <string>
+
+namespace ix
+{
+    int64_t cobra_to_cobra_bot(const ix::CobraBotConfig& config,
+                               const std::string& republishChannel,
+                               const std::string& publisherRolename,
+                               const std::string& publisherRolesecret);
+} // namespace ix

ixbots/ixbots/IXCobraToPythonBot.cpp

@@ -102,7 +102,7 @@ namespace ix
 {
     int64_t cobra_to_python_bot(const ix::CobraBotConfig& config,
                                 StatsdClient& statsdClient,
-                                const std::string& scriptPath)
+                                const std::string& moduleName)
     {
 #ifndef IXBOTS_USE_PYTHON
         CoreLogger::error("Command is disabled. "
@@ -113,10 +113,7 @@ namespace ix
         Py_InitializeEx(0); // 0 arg so that we do not install signal handlers 
                             // which prevent us from using Ctrl-C
 
-        size_t lastIndex = scriptPath.find_last_of("."); 
-        std::string modulePath = scriptPath.substr(0, lastIndex);
-
-        PyObject* pyModuleName = PyUnicode_DecodeFSDefault(modulePath.c_str());
+        PyObject* pyModuleName = PyUnicode_DecodeFSDefault(moduleName.c_str());
 
         if (pyModuleName == nullptr)
         {

ixbots/ixbots/IXCobraToPythonBot.h

@@ -15,5 +15,5 @@ namespace ix
 {
     int64_t cobra_to_python_bot(const ix::CobraBotConfig& config,
                                 StatsdClient& statsdClient,
-                                const std::string& scriptPath);
+                                const std::string& moduleName);
 } // namespace ix

ixbots/ixbots/IXCobraToSentryBot.cpp

@@ -41,7 +41,7 @@ namespace ix
                 else
                 {
                     CoreLogger::error("Error sending data to sentry: " + std::to_string(response->statusCode));
-                    CoreLogger::error("Response: " + response->payload);
+                    CoreLogger::error("Response: " + response->body);
 
                     // Error 429 Too Many Requests
                     if (response->statusCode == 429)

ixcobra/CMakeLists.txt

@@ -22,16 +22,11 @@ add_library(ixcobra STATIC
     ${IXCOBRA_HEADERS}
 )
 
-find_package(JsonCpp)
-if (NOT JSONCPP_FOUND)
-  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
-endif()
-
 set(IXCOBRA_INCLUDE_DIRS
     .
     ..
     ../ixcore
-    ../ixcrypto
-    ${JSONCPP_INCLUDE_DIRS})
+    ../ixcrypto)
 
 target_include_directories( ixcobra PUBLIC ${IXCOBRA_INCLUDE_DIRS} )
+target_link_libraries( ixcobra jsoncpp_static )

ixcobra/ixcobra/IXCobraConfig.h

@@ -8,6 +8,7 @@
 
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocketPerMessageDeflateOptions.h>
+#include <ixwebsocket/IXWebSocketHttpHeaders.h>
 
 namespace ix
 {
@@ -19,6 +20,7 @@ namespace ix
         std::string rolesecret;
         WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions;
         SocketTLSOptions socketTLSOptions;
+        WebSocketHttpHeaders headers;
 
         CobraConfig(const std::string& a = std::string(),
                     const std::string& e = std::string(),

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -91,13 +91,14 @@ namespace ix
                                               const std::string& errorMsg,
                                               const WebSocketHttpHeaders& headers,
                                               const std::string& subscriptionId,
-                                              CobraConnection::MsgId msgId)
+                                              CobraConnection::MsgId msgId,
+                                              const std::string& connectionId)
     {
         std::lock_guard<std::mutex> lock(_eventCallbackMutex);
         if (_eventCallback)
         {
             _eventCallback(
-                std::make_unique<CobraEvent>(eventType, errorMsg, headers, subscriptionId, msgId));
+                std::make_unique<CobraEvent>(eventType, errorMsg, headers, subscriptionId, msgId, connectionId));
         }
     }
 
@@ -255,7 +256,8 @@ namespace ix
         const std::string& rolename,
         const std::string& rolesecret,
         const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
-        const SocketTLSOptions& socketTLSOptions)
+        const SocketTLSOptions& socketTLSOptions,
+        const WebSocketHttpHeaders& headers)
     {
         _roleName = rolename;
         _roleSecret = rolesecret;
@@ -269,6 +271,7 @@ namespace ix
         _webSocket->setUrl(url);
         _webSocket->setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
         _webSocket->setTLSOptions(socketTLSOptions);
+        _webSocket->setExtraHeaders(headers);
 
         // Send a websocket ping every N seconds (N = 30) now
         // This should keep the connection open and prevent some load balancers such as
@@ -283,7 +286,8 @@ namespace ix
                   config.rolename,
                   config.rolesecret,
                   config.webSocketPerMessageDeflateOptions,
-                  config.socketTLSOptions);
+                  config.socketTLSOptions,
+                  config.headers);
     }
 
     //
@@ -349,6 +353,18 @@ namespace ix
 
         if (!nonce.isString()) return false;
 
+        if (!data.isMember("connection_id")) return false;
+        Json::Value connectionId = data["connection_id"];
+
+        if (!connectionId.isString()) return false;
+
+        invokeEventCallback(ix::CobraEventType::Handshake,
+                            std::string(),
+                            WebSocketHttpHeaders(),
+                            std::string(),
+                            0,
+                            connectionId.asString());
+
         return sendAuthMessage(nonce.asString());
     }
 

ixcobra/ixcobra/IXCobraConnection.h

@@ -56,7 +56,8 @@ namespace ix
                        const std::string& rolename,
                        const std::string& rolesecret,
                        const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
-                       const SocketTLSOptions& socketTLSOptions);
+                       const SocketTLSOptions& socketTLSOptions,
+                       const WebSocketHttpHeaders& headers);
 
         void configure(const ix::CobraConfig& config);
 
@@ -157,7 +158,9 @@ namespace ix
                                  const std::string& errorMsg = std::string(),
                                  const WebSocketHttpHeaders& headers = WebSocketHttpHeaders(),
                                  const std::string& subscriptionId = std::string(),
-                                 uint64_t msgId = std::numeric_limits<uint64_t>::max());
+                                 uint64_t msgId = std::numeric_limits<uint64_t>::max(),
+                                 const std::string& connectionId = std::string());
+
         void invokeErrorCallback(const std::string& errorMsg, const std::string& serializedPdu);
 
         /// Tells whether the internal queue is empty or not

ixcobra/ixcobra/IXCobraEvent.h

@@ -21,17 +21,20 @@ namespace ix
         const ix::WebSocketHttpHeaders& headers;
         const std::string& subscriptionId;
         uint64_t msgId; // CobraConnection::MsgId
+        const std::string& connectionId;
 
         CobraEvent(ix::CobraEventType t,
                    const std::string& e,
                    const ix::WebSocketHttpHeaders& h,
                    const std::string& s,
-                   uint64_t m)
+                   uint64_t m,
+                   const std::string& c)
             : type(t)
             , errMsg(e)
             , headers(h)
             , subscriptionId(s)
             , msgId(m)
+            , connectionId(c)
         {
             ;
         }

ixcobra/ixcobra/IXCobraEventType.h

@@ -20,6 +20,7 @@ namespace ix
         Pong = 7,
         HandshakeError = 8,
         AuthenticationError = 9,
-        SubscriptionError = 10
+        SubscriptionError = 10,
+        Handshake = 11
     };
 }

ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.cpp

@@ -24,6 +24,7 @@ namespace ix
     {
         _cobra_connection.setEventCallback([](const CobraEventPtr& event) {
             std::stringstream ss;
+            ix::LogLevel logLevel = LogLevel::Info;
 
             if (event->type == ix::CobraEventType::Open)
             {
@@ -34,6 +35,10 @@ namespace ix
                     ss << it.first << ": " << it.second << std::endl;
                 }
             }
+            else if (event->type == ix::CobraEventType::Handshake)
+            {
+                ss << "Cobra handshake connection id: " << event->connectionId;
+            }
             else if (event->type == ix::CobraEventType::Authenticated)
             {
                 ss << "Authenticated";
@@ -41,6 +46,7 @@ namespace ix
             else if (event->type == ix::CobraEventType::Error)
             {
                 ss << "Error: " << event->errMsg;
+                logLevel = ix::LogLevel::Error;
             }
             else if (event->type == ix::CobraEventType::Closed)
             {
@@ -57,6 +63,7 @@ namespace ix
             else if (event->type == ix::CobraEventType::Published)
             {
                 ss << "Published message " << event->msgId << " acked";
+                logLevel = ix::LogLevel::Debug;
             }
             else if (event->type == ix::CobraEventType::Pong)
             {
@@ -65,17 +72,20 @@ namespace ix
             else if (event->type == ix::CobraEventType::HandshakeError)
             {
                 ss << "Handshake error: " << event->errMsg;
+                logLevel = ix::LogLevel::Error;
             }
             else if (event->type == ix::CobraEventType::AuthenticationError)
             {
                 ss << "Authentication error: " << event->errMsg;
+                logLevel = ix::LogLevel::Error;
             }
             else if (event->type == ix::CobraEventType::SubscriptionError)
             {
                 ss << "Subscription error: " << event->errMsg;
+                logLevel = ix::LogLevel::Error;
             }
 
-            CoreLogger::log(ss.str().c_str());
+            CoreLogger::log(ss.str().c_str(), logLevel);
         });
     }
 

ixcrypto/ixcrypto/IXHash.cpp

@@ -19,4 +19,16 @@ namespace ix
 
         return hashAddress;
     }
+
+    uint64_t djb2HashStr(const std::string& data)
+    {
+        uint64_t hashAddress = 5381;
+
+        for (size_t i = 0; i < data.size(); ++i)
+        {
+            hashAddress = ((hashAddress << 5) + hashAddress) + data[i];
+        }
+
+        return hashAddress;
+    }
 } // namespace ix

ixcrypto/ixcrypto/IXHash.h

@@ -8,8 +8,10 @@
 
 #include <cstdint>
 #include <vector>
+#include <string>
 
 namespace ix
 {
     uint64_t djb2Hash(const std::vector<uint8_t>& data);
+    uint64_t djb2HashStr(const std::string& data);
 }

ixredis/ixredis/IXRedisServer.cpp

@@ -45,10 +45,9 @@ namespace ix
     }
 
     void RedisServer::handleConnection(std::unique_ptr<Socket> socket,
-                                       std::shared_ptr<ConnectionState> connectionState,
-                                       std::unique_ptr<ConnectionInfo> connectionInfo)
+                                       std::shared_ptr<ConnectionState> connectionState)
     {
-        logInfo("New connection from remote ip " + connectionInfo->remoteIp);
+        logInfo("New connection from remote ip " + connectionState->getRemoteIp());
 
         _connectedClientsCount++;
 

ixredis/ixredis/IXRedisServer.h

@@ -44,8 +44,7 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo) final;
+                                      std::shared_ptr<ConnectionState> connectionState) final;
         virtual size_t getConnectedClientsCount() final;
 
         bool startsWith(const std::string& str, const std::string& start);

ixsentry/CMakeLists.txt

@@ -16,15 +16,10 @@ add_library(ixsentry STATIC
   ${IXSENTRY_HEADERS}
 )
 
-find_package(JsonCpp)
-if (NOT JSONCPP_FOUND)
-  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
-endif()
-
 set(IXSENTRY_INCLUDE_DIRS
     .
     ..
-    ../ixcore
-    ${JSONCPP_INCLUDE_DIRS})
+    ../ixcore)
 
 target_include_directories( ixsentry PUBLIC ${IXSENTRY_INCLUDE_DIRS} )
+target_link_libraries( ixsentry jsoncpp_static )

ixsnake/ixsnake/IXSnakeServer.cpp

@@ -61,11 +61,10 @@ namespace snake
 
         _server.setOnClientMessageCallback(
             [this](std::shared_ptr<ix::ConnectionState> connectionState,
-                   ix::ConnectionInfo& connectionInfo,
                    ix::WebSocket& webSocket,
                    const ix::WebSocketMessagePtr& msg) {
                 auto state = std::dynamic_pointer_cast<SnakeConnectionState>(connectionState);
-                auto remoteIp = connectionInfo.remoteIp;
+                auto remoteIp = connectionState->getRemoteIp();
             
                 std::stringstream ss;
                 ss << "[" << state->getId() << "] ";

ixwebsocket/IXBench.cpp

@@ -12,10 +12,8 @@ namespace ix
 {
     Bench::Bench(const std::string& description)
         : _description(description)
-        , _start(std::chrono::high_resolution_clock::now())
-        , _reported(false)
     {
-        ;
+        reset();
     }
 
     Bench::~Bench()
@@ -26,19 +24,38 @@ namespace ix
         }
     }
 
+    void Bench::reset()
+    {
+        _start = std::chrono::high_resolution_clock::now();
+        _reported = false;
+    }
+
     void Bench::report()
     {
         auto now = std::chrono::high_resolution_clock::now();
-        auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now - _start);
+        auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(now - _start);
 
-        _ms = milliseconds.count();
-        std::cerr << _description << " completed in " << _ms << "ms" << std::endl;
+        _duration = microseconds.count();
+        std::cerr << _description << " completed in " << _duration << " us" << std::endl;
 
+        setReported();
+    }
+
+    void Bench::record()
+    {
+        auto now = std::chrono::high_resolution_clock::now();
+        auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(now - _start);
+
+        _duration = microseconds.count();
+    }
+
+    void Bench::setReported()
+    {
         _reported = true;
     }
 
     uint64_t Bench::getDuration() const
     {
-        return _ms;
+        return _duration;
     }
 } // namespace ix

ixwebsocket/IXBench.h

@@ -3,6 +3,7 @@
  *  Author: Benjamin Sergeant
  *  Copyright (c) 2017-2020 Machine Zone, Inc. All rights reserved.
  */
+#pragma once
 
 #include <chrono>
 #include <stdint.h>
@@ -16,13 +17,16 @@ namespace ix
         Bench(const std::string& description);
         ~Bench();
 
+        void reset();
+        void record();
         void report();
+        void setReported();
         uint64_t getDuration() const;
 
     private:
         std::string _description;
         std::chrono::time_point<std::chrono::high_resolution_clock> _start;
-        uint64_t _ms;
+        uint64_t _duration;
         bool _reported;
     };
 } // namespace ix

ixwebsocket/IXConnectionInfo.h

@@ -1,25 +0,0 @@
-/*
- *  IXConnectionInfo.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <string>
-
-namespace ix
-{
-    struct ConnectionInfo
-    {
-        std::string remoteIp;
-        int remotePort;
-
-        ConnectionInfo(const std::string& r = std::string(), int p = 0)
-            : remoteIp(r)
-            , remotePort(p)
-        {
-            ;
-        }
-    };
-} // namespace ix

ixwebsocket/IXConnectionState.cpp

@@ -31,6 +31,11 @@ namespace ix
         return std::make_shared<ConnectionState>();
     }
 
+    void ConnectionState::setOnSetTerminatedCallback(const OnSetTerminatedCallback& callback)
+    {
+        _onSetTerminatedCallback = callback;
+    }
+
     bool ConnectionState::isTerminated() const
     {
         return _terminated;
@@ -39,5 +44,30 @@ namespace ix
     void ConnectionState::setTerminated()
     {
         _terminated = true;
+
+        if (_onSetTerminatedCallback)
+        {
+            _onSetTerminatedCallback();
+        }
+    }
+
+    const std::string& ConnectionState::getRemoteIp()
+    {
+        return _remoteIp;
+    }
+
+    int ConnectionState::getRemotePort()
+    {
+        return _remotePort;
+    }
+
+    void ConnectionState::setRemoteIp(const std::string& remoteIp)
+    {
+        _remoteIp = remoteIp;
+    }
+
+    void ConnectionState::setRemotePort(int remotePort)
+    {
+        _remotePort = remotePort;
     }
 } // namespace ix

ixwebsocket/IXConnectionState.h

@@ -7,12 +7,15 @@
 #pragma once
 
 #include <atomic>
+#include <functional>
 #include <memory>
 #include <stdint.h>
 #include <string>
 
 namespace ix
 {
+    using OnSetTerminatedCallback = std::function<void()>;
+
     class ConnectionState
     {
     public:
@@ -25,12 +28,27 @@ namespace ix
         void setTerminated();
         bool isTerminated() const;
 
+        const std::string& getRemoteIp();
+        int getRemotePort();
+
         static std::shared_ptr<ConnectionState> createConnectionState();
 
+    private:
+        void setOnSetTerminatedCallback(const OnSetTerminatedCallback& callback);
+
+        void setRemoteIp(const std::string& remoteIp);
+        void setRemotePort(int remotePort);
+
     protected:
         std::atomic<bool> _terminated;
         std::string _id;
+        OnSetTerminatedCallback _onSetTerminatedCallback;
 
         static std::atomic<uint64_t> _globalId;
+
+        std::string _remoteIp;
+        int _remotePort;
+
+        friend class SocketServer;
     };
 } // namespace ix

ixwebsocket/IXGzipCodec.cpp

@@ -0,0 +1,170 @@
+/*
+ *  IXGzipCodec.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXGzipCodec.h"
+#include "IXBench.h"
+
+#include <array>
+#include <string.h>
+
+#ifdef IXWEBSOCKET_USE_ZLIB
+#include <zlib.h>
+#endif
+
+#ifdef IXWEBSOCKET_USE_DEFLATE
+#include <libdeflate.h>
+#endif
+
+namespace ix
+{
+#ifdef IXWEBSOCKET_USE_ZLIB
+    std::string gzipCompress(const std::string& str)
+    {
+#ifdef IXWEBSOCKET_USE_DEFLATE
+        int compressionLevel = 6;
+        struct libdeflate_compressor *compressor;
+
+        {
+            Bench bench("creating compressor");
+            compressor =
+                libdeflate_alloc_compressor(compressionLevel);
+        }
+
+        const void *uncompressed_data = str.data();
+        size_t uncompressed_size = str.size();
+        void *compressed_data;
+        size_t actual_compressed_size;
+        size_t max_compressed_size;
+
+        max_compressed_size = libdeflate_gzip_compress_bound(compressor,
+                                                             uncompressed_size);
+        {
+            Bench bench("alloc data");
+            compressed_data = malloc(max_compressed_size);
+        }
+
+        if (compressed_data == NULL)
+        {
+            return std::string();
+        }
+
+        {
+            Bench bench("compressing data");
+            actual_compressed_size = libdeflate_gzip_compress(
+                compressor,
+                uncompressed_data,
+                uncompressed_size,
+                compressed_data,
+                max_compressed_size);
+        }
+
+        if (actual_compressed_size == 0)
+        {
+            free(compressed_data);
+            return std::string();
+        }
+
+        libdeflate_free_compressor(compressor);
+
+        std::string out;
+        {
+            Bench bench("append data");
+            out.append(reinterpret_cast<char*>(compressed_data), actual_compressed_size);
+        }
+
+        {
+            Bench bench("free data");
+            free(compressed_data);
+        }
+
+        return out;
+#else
+        z_stream zs; // z_stream is zlib's control structure
+        memset(&zs, 0, sizeof(zs));
+
+        // deflateInit2 configure the file format: request gzip instead of deflate
+        const int windowBits = 15;
+        const int GZIP_ENCODING = 16;
+
+        deflateInit2(&zs,
+                     Z_DEFAULT_COMPRESSION,
+                     Z_DEFLATED,
+                     windowBits | GZIP_ENCODING,
+                     8,
+                     Z_DEFAULT_STRATEGY);
+
+        zs.next_in = (Bytef*) str.data();
+        zs.avail_in = (uInt) str.size(); // set the z_stream's input
+
+        int ret;
+        char outbuffer[32768];
+        std::string outstring;
+
+        // retrieve the compressed bytes blockwise
+        do
+        {
+            zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
+            zs.avail_out = sizeof(outbuffer);
+
+            ret = deflate(&zs, Z_FINISH);
+
+            if (outstring.size() < zs.total_out)
+            {
+                // append the block to the output string
+                outstring.append(outbuffer, zs.total_out - outstring.size());
+            }
+        } while (ret == Z_OK);
+
+        deflateEnd(&zs);
+
+        return outstring;
+#endif
+    }
+
+    bool gzipDecompress(const std::string& in, std::string& out)
+    {
+        z_stream inflateState;
+        memset(&inflateState, 0, sizeof(inflateState));
+
+        inflateState.zalloc = Z_NULL;
+        inflateState.zfree = Z_NULL;
+        inflateState.opaque = Z_NULL;
+        inflateState.avail_in = 0;
+        inflateState.next_in = Z_NULL;
+
+        if (inflateInit2(&inflateState, 16 + MAX_WBITS) != Z_OK)
+        {
+            return false;
+        }
+
+        inflateState.avail_in = (uInt) in.size();
+        inflateState.next_in = (unsigned char*) (const_cast<char*>(in.data()));
+
+        const int kBufferSize = 1 << 14;
+        std::array<unsigned char, kBufferSize> compressBuffer;
+
+        do
+        {
+            inflateState.avail_out = (uInt) kBufferSize;
+            inflateState.next_out = &compressBuffer.front();
+
+            int ret = inflate(&inflateState, Z_SYNC_FLUSH);
+
+            if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR)
+            {
+                inflateEnd(&inflateState);
+                return false;
+            }
+
+            out.append(reinterpret_cast<char*>(&compressBuffer.front()),
+                       kBufferSize - inflateState.avail_out);
+        } while (inflateState.avail_out == 0);
+
+        inflateEnd(&inflateState);
+        return true;
+    }
+#endif
+} // namespace ix

ixwebsocket/IXGzipCodec.h

@@ -0,0 +1,15 @@
+/*
+ *  IXGzipCodec.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ix
+{
+    std::string gzipCompress(const std::string& str);
+    bool gzipDecompress(const std::string& in, std::string& out);
+} // namespace ix

ixwebsocket/IXHttp.cpp

@@ -93,14 +93,12 @@ namespace ix
     }
 
     std::tuple<bool, std::string, HttpRequestPtr> Http::parseRequest(
-        std::unique_ptr<Socket>& socket)
+        std::unique_ptr<Socket>& socket, int timeoutSecs)
     {
         HttpRequestPtr httpRequest;
 
         std::atomic<bool> requestInitCancellation(false);
 
-        int timeoutSecs = 5; // FIXME
-
         auto isCancellationRequested =
             makeCancellationRequestWithTimeout(timeoutSecs, requestInitCancellation);
 
@@ -130,7 +128,36 @@ namespace ix
             return std::make_tuple(false, "Error parsing HTTP headers", httpRequest);
         }
 
-        httpRequest = std::make_shared<HttpRequest>(uri, method, httpVersion, headers);
+        std::string body;
+        if (headers.find("Content-Length") != headers.end())
+        {
+            int contentLength = 0;
+            try
+            {
+                contentLength = std::stoi(headers["Content-Length"]);
+            }
+            catch (std::exception)
+            {
+                return std::make_tuple(
+                    false, "Error parsing HTTP Header 'Content-Length'", httpRequest);
+            }
+
+            if (contentLength < 0)
+            {
+                return std::make_tuple(
+                    false, "Error: 'Content-Length' should be a positive integer", httpRequest);
+            }
+
+            auto res = socket->readBytes(contentLength, nullptr, isCancellationRequested);
+            if (!res.first)
+            {
+                return std::make_tuple(
+                    false, std::string("Error reading request: ") + res.second, httpRequest);
+            }
+            body = res.second;
+        }
+
+        httpRequest = std::make_shared<HttpRequest>(uri, method, httpVersion, body, headers);
         return std::make_tuple(true, "", httpRequest);
     }
 
@@ -151,7 +178,7 @@ namespace ix
 
         // Write headers
         ss.str("");
-        ss << "Content-Length: " << response->payload.size() << "\r\n";
+        ss << "Content-Length: " << response->body.size() << "\r\n";
         for (auto&& it : response->headers)
         {
             ss << it.first << ": " << it.second << "\r\n";
@@ -163,6 +190,6 @@ namespace ix
             return false;
         }
 
-        return response->payload.empty() ? true : socket->writeBytes(response->payload, nullptr);
+        return response->body.empty() ? true : socket->writeBytes(response->body, nullptr);
     }
 } // namespace ix

ixwebsocket/IXHttp.h

@@ -39,7 +39,7 @@ namespace ix
         std::string description;
         HttpErrorCode errorCode;
         WebSocketHttpHeaders headers;
-        std::string payload;
+        std::string body;
         std::string errorMsg;
         uint64_t uploadSize;
         uint64_t downloadSize;
@@ -48,7 +48,7 @@ namespace ix
                      const std::string& des = std::string(),
                      const HttpErrorCode& c = HttpErrorCode::Ok,
                      const WebSocketHttpHeaders& h = WebSocketHttpHeaders(),
-                     const std::string& p = std::string(),
+                     const std::string& b = std::string(),
                      const std::string& e = std::string(),
                      uint64_t u = 0,
                      uint64_t d = 0)
@@ -56,7 +56,7 @@ namespace ix
             , description(des)
             , errorCode(c)
             , headers(h)
-            , payload(p)
+            , body(b)
             , errorMsg(e)
             , uploadSize(u)
             , downloadSize(d)
@@ -95,15 +95,18 @@ namespace ix
         std::string uri;
         std::string method;
         std::string version;
+        std::string body;
         WebSocketHttpHeaders headers;
 
         HttpRequest(const std::string& u,
                     const std::string& m,
                     const std::string& v,
+                    const std::string& b,
                     const WebSocketHttpHeaders& h = WebSocketHttpHeaders())
             : uri(u)
             , method(m)
             , version(v)
+            , body(b)
             , headers(h)
         {
         }
@@ -115,7 +118,7 @@ namespace ix
     {
     public:
         static std::tuple<bool, std::string, HttpRequestPtr> parseRequest(
-            std::unique_ptr<Socket>& socket);
+            std::unique_ptr<Socket>& socket, int timeoutSecs);
         static bool sendResponse(HttpResponsePtr response, std::unique_ptr<Socket>& socket);
 
         static std::pair<std::string, int> parseStatusLine(const std::string& line);

ixwebsocket/IXHttpClient.cpp

@@ -6,6 +6,7 @@
 
 #include "IXHttpClient.h"
 
+#include "IXGzipCodec.h"
 #include "IXSocketFactory.h"
 #include "IXUrlParser.h"
 #include "IXUserAgent.h"
@@ -17,10 +18,6 @@
 #include <sstream>
 #include <vector>
 
-#ifdef IXWEBSOCKET_USE_ZLIB
-#include <zlib.h>
-#endif
-
 namespace ix
 {
     const std::string HttpClient::kPost = "POST";
@@ -500,12 +497,12 @@ namespace ix
 
         downloadSize = payload.size();
 
-#ifdef IXWEBSOCKET_USE_ZLIB
         // If the content was compressed with gzip, decode it
         if (headers["Content-Encoding"] == "gzip")
         {
+#ifdef IXWEBSOCKET_USE_ZLIB
             std::string decompressedPayload;
-            if (!gzipInflate(payload, decompressedPayload))
+            if (!gzipDecompress(payload, decompressedPayload))
             {
                 std::string errorMsg("Error decompressing payload");
                 return std::make_shared<HttpResponse>(code,
@@ -518,8 +515,18 @@ namespace ix
                                                       downloadSize);
             }
             payload = decompressedPayload;
-        }
+#else
+            std::string errorMsg("ixwebsocket was not compiled with gzip support on");
+            return std::make_shared<HttpResponse>(code,
+                                                  description,
+                                                  HttpErrorCode::Gzip,
+                                                  headers,
+                                                  payload,
+                                                  errorMsg,
+                                                  uploadSize,
+                                                  downloadSize);
 #endif
+        }
 
         return std::make_shared<HttpResponse>(code,
                                               description,
@@ -679,53 +686,6 @@ namespace ix
         return ss.str();
     }
 
-#ifdef IXWEBSOCKET_USE_ZLIB
-    bool HttpClient::gzipInflate(const std::string& in, std::string& out)
-    {
-        z_stream inflateState;
-        std::memset(&inflateState, 0, sizeof(inflateState));
-
-        inflateState.zalloc = Z_NULL;
-        inflateState.zfree = Z_NULL;
-        inflateState.opaque = Z_NULL;
-        inflateState.avail_in = 0;
-        inflateState.next_in = Z_NULL;
-
-        if (inflateInit2(&inflateState, 16 + MAX_WBITS) != Z_OK)
-        {
-            return false;
-        }
-
-        inflateState.avail_in = (uInt) in.size();
-        inflateState.next_in = (unsigned char*) (const_cast<char*>(in.data()));
-
-        const int kBufferSize = 1 << 14;
-
-        std::unique_ptr<unsigned char[]> compressBuffer =
-            std::make_unique<unsigned char[]>(kBufferSize);
-
-        do
-        {
-            inflateState.avail_out = (uInt) kBufferSize;
-            inflateState.next_out = compressBuffer.get();
-
-            int ret = inflate(&inflateState, Z_SYNC_FLUSH);
-
-            if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR)
-            {
-                inflateEnd(&inflateState);
-                return false;
-            }
-
-            out.append(reinterpret_cast<char*>(compressBuffer.get()),
-                       kBufferSize - inflateState.avail_out);
-        } while (inflateState.avail_out == 0);
-
-        inflateEnd(&inflateState);
-        return true;
-    }
-#endif
-
     void HttpClient::log(const std::string& msg, HttpRequestArgsPtr args)
     {
         if (args->logger)

ixwebsocket/IXHttpClient.h

@@ -90,10 +90,6 @@ namespace ix
     private:
         void log(const std::string& msg, HttpRequestArgsPtr args);
 
-#ifdef IXWEBSOCKET_USE_ZLIB
-        bool gzipInflate(const std::string& in, std::string& out);
-#endif
-
         // Async API background thread runner
         void run();
         // Async API

ixwebsocket/IXHttpServer.cpp

@@ -6,6 +6,7 @@
 
 #include "IXHttpServer.h"
 
+#include "IXGzipCodec.h"
 #include "IXNetSystem.h"
 #include "IXSocketConnect.h"
 #include "IXUserAgent.h"
@@ -14,10 +15,6 @@
 #include <sstream>
 #include <vector>
 
-#ifdef IXWEBSOCKET_USE_ZLIB
-#include <zlib.h>
-#endif
-
 namespace
 {
     std::pair<bool, std::vector<uint8_t>> load(const std::string& path)
@@ -43,59 +40,21 @@ namespace
         auto vec = res.second;
         return std::make_pair(res.first, std::string(vec.begin(), vec.end()));
     }
-
-#ifdef IXWEBSOCKET_USE_ZLIB
-    std::string gzipCompress(const std::string& str)
-    {
-        z_stream zs; // z_stream is zlib's control structure
-        memset(&zs, 0, sizeof(zs));
-
-        // deflateInit2 configure the file format: request gzip instead of deflate
-        const int windowBits = 15;
-        const int GZIP_ENCODING = 16;
-
-        deflateInit2(&zs,
-                     Z_DEFAULT_COMPRESSION,
-                     Z_DEFLATED,
-                     windowBits | GZIP_ENCODING,
-                     8,
-                     Z_DEFAULT_STRATEGY);
-
-        zs.next_in = (Bytef*) str.data();
-        zs.avail_in = (uInt) str.size(); // set the z_stream's input
-
-        int ret;
-        char outbuffer[32768];
-        std::string outstring;
-
-        // retrieve the compressed bytes blockwise
-        do
-        {
-            zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
-            zs.avail_out = sizeof(outbuffer);
-
-            ret = deflate(&zs, Z_FINISH);
-
-            if (outstring.size() < zs.total_out)
-            {
-                // append the block to the output string
-                outstring.append(outbuffer, zs.total_out - outstring.size());
-            }
-        } while (ret == Z_OK);
-
-        deflateEnd(&zs);
-
-        return outstring;
-    }
-#endif
 } // namespace
 
 namespace ix
 {
-    HttpServer::HttpServer(
-        int port, const std::string& host, int backlog, size_t maxConnections, int addressFamily)
+    const int HttpServer::kDefaultTimeoutSecs(30);
+
+    HttpServer::HttpServer(int port,
+                           const std::string& host,
+                           int backlog,
+                           size_t maxConnections,
+                           int addressFamily,
+                           int timeoutSecs)
         : SocketServer(port, host, backlog, maxConnections, addressFamily)
         , _connectedClientsCount(0)
+        , _timeoutSecs(timeoutSecs)
     {
         setDefaultConnectionCallback();
     }
@@ -120,18 +79,16 @@ namespace ix
     }
 
     void HttpServer::handleConnection(std::unique_ptr<Socket> socket,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo)
+                                      std::shared_ptr<ConnectionState> connectionState)
     {
         _connectedClientsCount++;
 
-        auto ret = Http::parseRequest(socket);
+        auto ret = Http::parseRequest(socket, _timeoutSecs);
         // FIXME: handle errors in parseRequest
 
         if (std::get<0>(ret))
         {
-            auto response =
-                _onConnectionCallback(std::get<2>(ret), connectionState, std::move(connectionInfo));
+            auto response = _onConnectionCallback(std::get<2>(ret), connectionState);
             if (!Http::sendResponse(response, socket))
             {
                 logError("Cannot send response");
@@ -151,8 +108,7 @@ namespace ix
     {
         setOnConnectionCallback(
             [this](HttpRequestPtr request,
-                   std::shared_ptr<ConnectionState> /*connectionState*/,
-                   std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
+                   std::shared_ptr<ConnectionState> connectionState) -> HttpResponsePtr {
                 std::string uri(request->uri);
                 if (uri.empty() || uri == "/")
                 {
@@ -184,8 +140,8 @@ namespace ix
 
                 // Log request
                 std::stringstream ss;
-                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
-                   << request->method << " " << request->headers["User-Agent"] << " "
+                ss << connectionState->getRemoteIp() << ":" << connectionState->getRemotePort()
+                   << " " << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri << " " << content.size();
                 logInfo(ss.str());
 
@@ -209,16 +165,16 @@ namespace ix
         // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Redirections
         //
         setOnConnectionCallback(
-            [this, redirectUrl](HttpRequestPtr request,
-                                std::shared_ptr<ConnectionState> /*connectionState*/,
-                                std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
+            [this,
+             redirectUrl](HttpRequestPtr request,
+                          std::shared_ptr<ConnectionState> connectionState) -> HttpResponsePtr {
                 WebSocketHttpHeaders headers;
                 headers["Server"] = userAgent();
 
                 // Log request
                 std::stringstream ss;
-                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
-                   << request->method << " " << request->headers["User-Agent"] << " "
+                ss << connectionState->getRemoteIp() << ":" << connectionState->getRemotePort()
+                   << " " << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri;
                 logInfo(ss.str());
 

ixwebsocket/IXHttpServer.h

@@ -23,15 +23,14 @@ namespace ix
     {
     public:
         using OnConnectionCallback =
-            std::function<HttpResponsePtr(HttpRequestPtr,
-                                          std::shared_ptr<ConnectionState>,
-                                          std::unique_ptr<ConnectionInfo> connectionInfo)>;
+            std::function<HttpResponsePtr(HttpRequestPtr, std::shared_ptr<ConnectionState>)>;
 
         HttpServer(int port = SocketServer::kDefaultPort,
                    const std::string& host = SocketServer::kDefaultHost,
                    int backlog = SocketServer::kDefaultTcpBacklog,
                    size_t maxConnections = SocketServer::kDefaultMaxConnections,
-                   int addressFamily = SocketServer::kDefaultAddressFamily);
+                   int addressFamily = SocketServer::kDefaultAddressFamily,
+                   int timeoutSecs = HttpServer::kDefaultTimeoutSecs);
         virtual ~HttpServer();
         virtual void stop() final;
 
@@ -44,10 +43,12 @@ namespace ix
         OnConnectionCallback _onConnectionCallback;
         std::atomic<int> _connectedClientsCount;
 
+        const static int kDefaultTimeoutSecs;
+        int _timeoutSecs;
+
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo) final;
+                                      std::shared_ptr<ConnectionState> connectionState) final;
         virtual size_t getConnectedClientsCount() final;
 
         void setDefaultConnectionCallback();

ixwebsocket/IXSelectInterrupt.cpp

@@ -8,6 +8,9 @@
 
 namespace ix
 {
+    const uint64_t SelectInterrupt::kSendRequest = 1;
+    const uint64_t SelectInterrupt::kCloseRequest = 2;
+
     SelectInterrupt::SelectInterrupt()
     {
         ;

ixwebsocket/IXSelectInterrupt.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <memory>
 #include <stdint.h>
 #include <string>
 
@@ -23,5 +24,11 @@ namespace ix
         virtual bool clear();
         virtual uint64_t read();
         virtual int getFd() const;
+
+        // Used as special codes for pipe communication
+        static const uint64_t kSendRequest;
+        static const uint64_t kCloseRequest;
     };
+
+    using SelectInterruptPtr = std::unique_ptr<SelectInterrupt>;
 } // namespace ix

ixwebsocket/IXSocket.cpp

@@ -27,8 +27,6 @@ namespace ix
 {
     const int Socket::kDefaultPollNoTimeout = -1; // No poll timeout by default
     const int Socket::kDefaultPollTimeout = kDefaultPollNoTimeout;
-    const uint64_t Socket::kSendRequest = 1;
-    const uint64_t Socket::kCloseRequest = 2;
     constexpr size_t Socket::kChunkSize;
 
     Socket::Socket(int fd)
@@ -96,11 +94,11 @@ namespace ix
         {
             uint64_t value = selectInterrupt->read();
 
-            if (value == kSendRequest)
+            if (value == SelectInterrupt::kSendRequest)
             {
                 pollResult = PollResultType::SendRequest;
             }
-            else if (value == kCloseRequest)
+            else if (value == SelectInterrupt::kCloseRequest)
             {
                 pollResult = PollResultType::CloseRequest;
             }

ixwebsocket/IXSocket.h

@@ -34,12 +34,10 @@ typedef SSIZE_T ssize_t;
 
 #include "IXCancellationRequest.h"
 #include "IXProgressCallback.h"
+#include "IXSelectInterrupt.h"
 
 namespace ix
 {
-    class SelectInterrupt;
-    using SelectInterruptPtr = std::unique_ptr<SelectInterrupt>;
-
     enum class PollResultType
     {
         ReadyForRead = 0,
@@ -96,11 +94,6 @@ namespace ix
                                    int sockfd,
                                    const SelectInterruptPtr& selectInterrupt);
 
-
-        // Used as special codes for pipe communication
-        static const uint64_t kSendRequest;
-        static const uint64_t kCloseRequest;
-
     protected:
         std::atomic<int> _sockfd;
         std::mutex _socketMutex;

ixwebsocket/IXSocketServer.cpp

@@ -8,6 +8,7 @@
 
 #include "IXNetSystem.h"
 #include "IXSelectInterrupt.h"
+#include "IXSelectInterruptFactory.h"
 #include "IXSetThreadName.h"
 #include "IXSocket.h"
 #include "IXSocketConnect.h"
@@ -36,6 +37,7 @@ namespace ix
         , _stop(false)
         , _stopGc(false)
         , _connectionStateFactory(&ConnectionState::createConnectionState)
+        , _acceptSelectInterrupt(createSelectInterrupt())
     {
     }
 
@@ -58,6 +60,16 @@ namespace ix
 
     std::pair<bool, std::string> SocketServer::listen()
     {
+        std::string acceptSelectInterruptInitErrorMsg;
+        if (!_acceptSelectInterrupt->init(acceptSelectInterruptInitErrorMsg))
+        {
+            std::stringstream ss;
+            ss << "SocketServer::listen() error in SelectInterrupt::init: "
+               << acceptSelectInterruptInitErrorMsg;
+
+            return std::make_pair(false, ss.str());
+        }
+
         if (_addressFamily != AF_INET && _addressFamily != AF_INET6)
         {
             std::string errMsg("SocketServer::listen() AF_INET and AF_INET6 are currently "
@@ -193,6 +205,12 @@ namespace ix
         if (_thread.joinable())
         {
             _stop = true;
+            // Wake up select
+            if (!_acceptSelectInterrupt->notify(SelectInterrupt::kCloseRequest))
+            {
+                logError("SocketServer::stop: Cannot wake up from select");
+            }
+
             _thread.join();
             _stop = false;
         }
@@ -201,6 +219,7 @@ namespace ix
         if (_gcThread.joinable())
         {
             _stopGc = true;
+            _conditionVariableGC.notify_one();
             _gcThread.join();
             _stopGc = false;
         }
@@ -249,18 +268,22 @@ namespace ix
         // Set the socket to non blocking mode, so that accept calls are not blocking
         SocketConnect::configure(_serverFd);
 
-        setThreadName("SocketServer::listen");
+        setThreadName("SocketServer::accept");
 
         for (;;)
         {
             if (_stop) return;
 
             // Use poll to check whether a new connection is in progress
-            int timeoutMs = 10;
+            int timeoutMs = -1;
+#ifdef _WIN32
+            // select cannot be interrupted on Windows so we need to pass a small timeout
+            timeoutMs = 10;
+#endif
+
             bool readyToRead = true;
-            auto selectInterrupt = std::make_unique<SelectInterrupt>();
             PollResultType pollResult =
-                Socket::poll(readyToRead, timeoutMs, _serverFd, selectInterrupt);
+                Socket::poll(readyToRead, timeoutMs, _serverFd, _acceptSelectInterrupt);
 
             if (pollResult == PollResultType::Error)
             {
@@ -308,12 +331,14 @@ namespace ix
                 continue;
             }
 
-            std::unique_ptr<ConnectionInfo> connectionInfo;
+            // Retrieve connection info, the ip address of the remote peer/client)
+            std::string remoteIp;
+            int remotePort;
 
             if (_addressFamily == AF_INET)
             {
-                char remoteIp[INET_ADDRSTRLEN];
-                if (inet_ntop(AF_INET, &client.sin_addr, remoteIp, INET_ADDRSTRLEN) == nullptr)
+                char remoteIp4[INET_ADDRSTRLEN];
+                if (inet_ntop(AF_INET, &client.sin_addr, remoteIp4, INET_ADDRSTRLEN) == nullptr)
                 {
                     int err = Socket::getErrno();
                     std::stringstream ss;
@@ -326,12 +351,13 @@ namespace ix
                     continue;
                 }
 
-                connectionInfo = std::make_unique<ConnectionInfo>(remoteIp, client.sin_port);
+                remotePort = client.sin_port;
+                remoteIp = remoteIp4;
             }
             else // AF_INET6
             {
-                char remoteIp[INET6_ADDRSTRLEN];
-                if (inet_ntop(AF_INET6, &client.sin_addr, remoteIp, INET6_ADDRSTRLEN) == nullptr)
+                char remoteIp6[INET6_ADDRSTRLEN];
+                if (inet_ntop(AF_INET6, &client.sin_addr, remoteIp6, INET6_ADDRSTRLEN) == nullptr)
                 {
                     int err = Socket::getErrno();
                     std::stringstream ss;
@@ -344,7 +370,8 @@ namespace ix
                     continue;
                 }
 
-                connectionInfo = std::make_unique<ConnectionInfo>(remoteIp, client.sin_port);
+                remotePort = client.sin_port;
+                remoteIp = remoteIp6;
             }
 
             std::shared_ptr<ConnectionState> connectionState;
@@ -352,6 +379,9 @@ namespace ix
             {
                 connectionState = _connectionStateFactory();
             }
+            connectionState->setOnSetTerminatedCallback([this] { onSetTerminatedCallback(); });
+            connectionState->setRemoteIp(remoteIp);
+            connectionState->setRemotePort(remotePort);
 
             if (_stop) return;
 
@@ -379,13 +409,10 @@ namespace ix
 
             // Launch the handleConnection work asynchronously in its own thread.
             std::lock_guard<std::mutex> lock(_connectionsThreadsMutex);
-            _connectionsThreads.push_back(
-                std::make_pair(connectionState,
-                               std::thread(&SocketServer::handleConnection,
-                                           this,
-                                           std::move(socket),
-                                           connectionState,
-                                           std::move(connectionInfo))));
+            _connectionsThreads.push_back(std::make_pair(
+                connectionState,
+                std::thread(
+                    &SocketServer::handleConnection, this, std::move(socket), connectionState)));
         }
     }
 
@@ -411,8 +438,14 @@ namespace ix
                 break;
             }
 
-            // Sleep a little bit then keep cleaning up
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            // Unless we are stopping the server, wait for a connection
+            // to be terminated to run the threads GC, instead of busy waiting
+            // with a sleep
+            if (!_stopGc)
+            {
+                std::unique_lock<std::mutex> lock(_conditionVariableMutexGC);
+                _conditionVariableGC.wait(lock);
+            }
         }
     }
 
@@ -420,4 +453,11 @@ namespace ix
     {
         _socketTLSOptions = socketTLSOptions;
     }
+
+    void SocketServer::onSetTerminatedCallback()
+    {
+        // a connection got terminated, we can run the connection thread GC,
+        // so wake up the thread responsible for that
+        _conditionVariableGC.notify_one();
+    }
 } // namespace ix

ixwebsocket/IXSocketServer.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include "IXConnectionInfo.h"
 #include "IXConnectionState.h"
+#include "IXSelectInterrupt.h"
 #include "IXSocketTLSOptions.h"
 #include <atomic>
 #include <condition_variable>
@@ -84,6 +84,7 @@ namespace ix
         // background thread to wait for incoming connections
         std::thread _thread;
         void run();
+        void onSetTerminatedCallback();
 
         // background thread to cleanup (join) terminated threads
         std::atomic<bool> _stopGc;
@@ -103,8 +104,7 @@ namespace ix
         ConnectionStateFactory _connectionStateFactory;
 
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo) = 0;
+                                      std::shared_ptr<ConnectionState> connectionState) = 0;
         virtual size_t getConnectedClientsCount() = 0;
 
         // Returns true if all connection threads are joined
@@ -112,5 +112,13 @@ namespace ix
         size_t getConnectionsThreadsCount();
 
         SocketTLSOptions _socketTLSOptions;
+
+        // to wake up from select
+        SelectInterruptPtr _acceptSelectInterrupt;
+
+        // used by the gc thread, to know that a thread needs to be garbage collected
+        // as a connection
+        std::condition_variable _conditionVariableGC;
+        std::mutex _conditionVariableMutexGC;
     };
 } // namespace ix

ixwebsocket/IXWebSocket.cpp

@@ -54,6 +54,7 @@ namespace ix
         std::lock_guard<std::mutex> lock(_configMutex);
         _url = url;
     }
+
     void WebSocket::setExtraHeaders(const WebSocketHttpHeaders& headers)
     {
         std::lock_guard<std::mutex> lock(_configMutex);

ixwebsocket/IXWebSocketHandshake.cpp

@@ -170,20 +170,11 @@ namespace ix
         {
             std::stringstream ss;
             ss << "Expecting HTTP/1.1, got " << httpVersion << ". "
-               << "Rejecting connection to " << host << ":" << port << ", status: " << status
+               << "Rejecting connection to " << url << ", status: " << status
                << ", HTTP Status line: " << line;
             return WebSocketInitResult(false, status, ss.str());
         }
 
-        // We want an 101 HTTP status
-        if (status != 101)
-        {
-            std::stringstream ss;
-            ss << "Expecting status 101 (Switching Protocol), got " << status
-               << " status connecting to " << host << ":" << port << ", HTTP Status line: " << line;
-            return WebSocketInitResult(false, status, ss.str());
-        }
-
         auto result = parseHttpHeaders(_socket, isCancellationRequested);
         auto headersValid = result.first;
         auto headers = result.second;
@@ -193,6 +184,17 @@ namespace ix
             return WebSocketInitResult(false, status, "Error parsing HTTP headers");
         }
 
+        // We want an 101 HTTP status for websocket, otherwise it could be
+        // a redirection (like 301)
+        if (status != 101)
+        {
+            std::stringstream ss;
+            ss << "Expecting status 101 (Switching Protocol), got " << status
+               << " status connecting to " << url << ", HTTP Status line: " << line;
+
+            return WebSocketInitResult(false, status, ss.str(), headers, path);
+        }
+
         // Check the presence of the connection field
         if (headers.find("connection") == headers.end())
         {

ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp

@@ -16,8 +16,6 @@ namespace
     // is treated as a char* and the null termination (\x00) makes it
     // look like an empty string.
     const std::string kEmptyUncompressedBlock = std::string("\x00\x00\xff\xff", 4);
-
-    const int kBufferSize = 1 << 14;
 } // namespace
 
 namespace ix
@@ -26,7 +24,6 @@ namespace ix
     // Compressor
     //
     WebSocketPerMessageDeflateCompressor::WebSocketPerMessageDeflateCompressor()
-        : _compressBufferSize(kBufferSize)
     {
 #ifdef IXWEBSOCKET_USE_ZLIB
         memset(&_deflateState, 0, sizeof(_deflateState));
@@ -57,8 +54,6 @@ namespace ix
 
         if (ret != Z_OK) return false;
 
-        _compressBuffer = std::make_unique<unsigned char[]>(_compressBufferSize);
-
         _flush = (clientNoContextTakeOver) ? Z_FULL_FLUSH : Z_SYNC_FLUSH;
 
         return true;
@@ -145,14 +140,14 @@ namespace ix
         do
         {
             // Output to local buffer
-            _deflateState.avail_out = (uInt) _compressBufferSize;
-            _deflateState.next_out = _compressBuffer.get();
+            _deflateState.avail_out = (uInt) _compressBuffer.size();
+            _deflateState.next_out = &_compressBuffer.front();
 
             deflate(&_deflateState, _flush);
 
-            output = _compressBufferSize - _deflateState.avail_out;
+            output = _compressBuffer.size() - _deflateState.avail_out;
 
-            out.insert(out.end(), _compressBuffer.get(), _compressBuffer.get() + output);
+            out.insert(out.end(), _compressBuffer.begin(), _compressBuffer.begin() + output);
         } while (_deflateState.avail_out == 0);
 
         if (endsWithEmptyUnCompressedBlock(out))
@@ -170,7 +165,6 @@ namespace ix
     // Decompressor
     //
     WebSocketPerMessageDeflateDecompressor::WebSocketPerMessageDeflateDecompressor()
-        : _compressBufferSize(kBufferSize)
     {
 #ifdef IXWEBSOCKET_USE_ZLIB
         memset(&_inflateState, 0, sizeof(_inflateState));
@@ -198,8 +192,6 @@ namespace ix
 
         if (ret != Z_OK) return false;
 
-        _compressBuffer = std::make_unique<unsigned char[]>(_compressBufferSize);
-
         _flush = (clientNoContextTakeOver) ? Z_FULL_FLUSH : Z_SYNC_FLUSH;
 
         return true;
@@ -232,8 +224,8 @@ namespace ix
 
         do
         {
-            _inflateState.avail_out = (uInt) _compressBufferSize;
-            _inflateState.next_out = _compressBuffer.get();
+            _inflateState.avail_out = (uInt) _compressBuffer.size();
+            _inflateState.next_out = &_compressBuffer.front();
 
             int ret = inflate(&_inflateState, Z_SYNC_FLUSH);
 
@@ -242,8 +234,8 @@ namespace ix
                 return false; // zlib error
             }
 
-            out.append(reinterpret_cast<char*>(_compressBuffer.get()),
-                       _compressBufferSize - _inflateState.avail_out);
+            out.append(reinterpret_cast<char*>(&_compressBuffer.front()),
+                       _compressBuffer.size() - _inflateState.avail_out);
         } while (_inflateState.avail_out == 0);
 
         return true;

ixwebsocket/IXWebSocketPerMessageDeflateCodec.h

@@ -9,7 +9,7 @@
 #ifdef IXWEBSOCKET_USE_ZLIB
 #include "zlib.h"
 #endif
-#include <memory>
+#include <array>
 #include <string>
 #include <vector>
 
@@ -34,8 +34,7 @@ namespace ix
         bool endsWithEmptyUnCompressedBlock(const T& value);
 
         int _flush;
-        size_t _compressBufferSize;
-        std::unique_ptr<unsigned char[]> _compressBuffer;
+        std::array<unsigned char, 1 << 14> _compressBuffer;
 
 #ifdef IXWEBSOCKET_USE_ZLIB
         z_stream _deflateState;
@@ -53,8 +52,7 @@ namespace ix
 
     private:
         int _flush;
-        size_t _compressBufferSize;
-        std::unique_ptr<unsigned char[]> _compressBuffer;
+        std::array<unsigned char, 1 << 14> _compressBuffer;
 
 #ifdef IXWEBSOCKET_USE_ZLIB
         z_stream _inflateState;

ixwebsocket/IXWebSocketProxyServer.cpp

@@ -43,6 +43,7 @@ namespace ix
                                     const std::string& hostname,
                                     const ix::SocketTLSOptions& tlsOptions,
                                     const std::string& remoteUrl,
+                                    const RemoteUrlsMapping& remoteUrlsMapping,
                                     bool /*verbose*/)
     {
         ix::WebSocketServer server(port, hostname);
@@ -53,61 +54,74 @@ namespace ix
         };
         server.setConnectionStateFactory(factory);
 
-        server.setOnConnectionCallback([remoteUrl](std::weak_ptr<ix::WebSocket> webSocket,
-                                                   std::shared_ptr<ConnectionState> connectionState,
-                                                   std::unique_ptr<ConnectionInfo> connectionInfo) {
-            auto state = std::dynamic_pointer_cast<ProxyConnectionState>(connectionState);
-            auto remoteIp = connectionInfo->remoteIp;
+        server.setOnConnectionCallback(
+            [remoteUrl, remoteUrlsMapping](std::weak_ptr<ix::WebSocket> webSocket,
+                                           std::shared_ptr<ConnectionState> connectionState) {
+                auto state = std::dynamic_pointer_cast<ProxyConnectionState>(connectionState);
+                auto remoteIp = connectionState->getRemoteIp();
 
-            // Server connection
-            state->webSocket().setOnMessageCallback(
-                [webSocket, state, remoteIp](const WebSocketMessagePtr& msg) {
-                    if (msg->type == ix::WebSocketMessageType::Close)
-                    {
-                        state->setTerminated();
-                    }
-                    else if (msg->type == ix::WebSocketMessageType::Message)
-                    {
-                        auto ws = webSocket.lock();
-                        if (ws)
+                // Server connection
+                state->webSocket().setOnMessageCallback(
+                    [webSocket, state, remoteIp](const WebSocketMessagePtr& msg) {
+                        if (msg->type == ix::WebSocketMessageType::Close)
                         {
-                            ws->send(msg->str, msg->binary);
+                            state->setTerminated();
                         }
-                    }
-                });
-
-            // Client connection
-            auto ws = webSocket.lock();
-            if (ws)
-            {
-                ws->setOnMessageCallback([state, remoteUrl](const WebSocketMessagePtr& msg) {
-                    if (msg->type == ix::WebSocketMessageType::Open)
-                    {
-                        // Connect to the 'real' server
-                        std::string url(remoteUrl);
-                        url += msg->openInfo.uri;
-                        state->webSocket().setUrl(url);
-                        state->webSocket().disableAutomaticReconnection();
-                        state->webSocket().start();
-
-                        // we should sleep here for a bit until we've established the
-                        // connection with the remote server
-                        while (state->webSocket().getReadyState() != ReadyState::Open)
+                        else if (msg->type == ix::WebSocketMessageType::Message)
                         {
-                            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                            auto ws = webSocket.lock();
+                            if (ws)
+                            {
+                                ws->send(msg->str, msg->binary);
+                            }
                         }
-                    }
-                    else if (msg->type == ix::WebSocketMessageType::Close)
-                    {
-                        state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
-                    }
-                    else if (msg->type == ix::WebSocketMessageType::Message)
-                    {
-                        state->webSocket().send(msg->str, msg->binary);
-                    }
-                });
-            }
-        });
+                    });
+
+                // Client connection
+                auto ws = webSocket.lock();
+                if (ws)
+                {
+                    ws->setOnMessageCallback([state, remoteUrl, remoteUrlsMapping](
+                                                 const WebSocketMessagePtr& msg) {
+                        if (msg->type == ix::WebSocketMessageType::Open)
+                        {
+                            // Connect to the 'real' server
+                            std::string url(remoteUrl);
+
+                            // maybe we want a different url based on the mapping
+                            std::string host = msg->openInfo.headers["Host"];
+                            auto it = remoteUrlsMapping.find(host);
+                            if (it != remoteUrlsMapping.end())
+                            {
+                                url = it->second;
+                            }
+
+                            // append the uri to form the full url
+                            // (say ws://localhost:1234/foo/?bar=baz)
+                            url += msg->openInfo.uri;
+
+                            state->webSocket().setUrl(url);
+                            state->webSocket().disableAutomaticReconnection();
+                            state->webSocket().start();
+
+                            // we should sleep here for a bit until we've established the
+                            // connection with the remote server
+                            while (state->webSocket().getReadyState() != ReadyState::Open)
+                            {
+                                std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                            }
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Close)
+                        {
+                            state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Message)
+                        {
+                            state->webSocket().send(msg->str, msg->binary);
+                        }
+                    });
+                }
+            });
 
         auto res = server.listen();
         if (!res.first)

ixwebsocket/IXWebSocketProxyServer.h

@@ -7,14 +7,18 @@
 
 #include "IXSocketTLSOptions.h"
 #include <cstdint>
+#include <map>
 #include <stddef.h>
 #include <string>
 
 namespace ix
 {
+    using RemoteUrlsMapping = std::map<std::string, std::string>;
+
     int websocket_proxy_server_main(int port,
                                     const std::string& hostname,
                                     const ix::SocketTLSOptions& tlsOptions,
                                     const std::string& remoteUrl,
+                                    const RemoteUrlsMapping& remoteUrlsMapping,
                                     bool verbose);
 } // namespace ix

ixwebsocket/IXWebSocketServer.cpp

@@ -77,15 +77,14 @@ namespace ix
     }
 
     void WebSocketServer::handleConnection(std::unique_ptr<Socket> socket,
-                                           std::shared_ptr<ConnectionState> connectionState,
-                                           std::unique_ptr<ConnectionInfo> connectionInfo)
+                                           std::shared_ptr<ConnectionState> connectionState)
     {
         setThreadName("WebSocketServer::" + connectionState->getId());
 
         auto webSocket = std::make_shared<WebSocket>();
         if (_onConnectionCallback)
         {
-            _onConnectionCallback(webSocket, connectionState, std::move(connectionInfo));
+            _onConnectionCallback(webSocket, connectionState);
 
             if (!webSocket->isOnMessageCallbackRegistered())
             {
@@ -99,9 +98,8 @@ namespace ix
         else if (_onClientMessageCallback)
         {
             webSocket->setOnMessageCallback(
-                [this, &ws = *webSocket.get(), connectionState, &ci = *connectionInfo.get()](
-                    const WebSocketMessagePtr& msg) {
-                    _onClientMessageCallback(connectionState, ci, ws, msg);
+                [this, &ws = *webSocket.get(), connectionState](const WebSocketMessagePtr& msg) {
+                    _onClientMessageCallback(connectionState, ws, msg);
                 });
         }
         else

ixwebsocket/IXWebSocketServer.h

@@ -23,14 +23,10 @@ namespace ix
     {
     public:
         using OnConnectionCallback =
-            std::function<void(std::weak_ptr<WebSocket>,
-                               std::shared_ptr<ConnectionState>,
-                               std::unique_ptr<ConnectionInfo> connectionInfo)>;
+            std::function<void(std::weak_ptr<WebSocket>, std::shared_ptr<ConnectionState>)>;
 
-        using OnClientMessageCallback = std::function<void(std::shared_ptr<ConnectionState>,
-                                                           ConnectionInfo&,
-                                                           WebSocket&,
-                                                           const WebSocketMessagePtr&)>;
+        using OnClientMessageCallback = std::function<void(
+            std::shared_ptr<ConnectionState>, WebSocket&, const WebSocketMessagePtr&)>;
 
         WebSocketServer(int port = SocketServer::kDefaultPort,
                         const std::string& host = SocketServer::kDefaultHost,
@@ -69,8 +65,7 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket> socket,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo);
+                                      std::shared_ptr<ConnectionState> connectionState);
         virtual size_t getConnectedClientsCount() final;
     };
 } // namespace ix

ixwebsocket/IXWebSocketTransport.cpp

@@ -107,36 +107,62 @@ namespace ix
 
         std::string protocol, host, path, query;
         int port;
+        std::string remoteUrl(url);
 
-        if (!UrlParser::parse(url, protocol, host, path, query, port))
+        WebSocketInitResult result;
+        const int maxRedirections = 10;
+
+        for (int i = 0; i < maxRedirections; ++i)
         {
-            std::stringstream ss;
-            ss << "Could not parse url: '" << url << "'";
-            return WebSocketInitResult(false, 0, ss.str());
+            if (!UrlParser::parse(remoteUrl, protocol, host, path, query, port))
+            {
+                std::stringstream ss;
+                ss << "Could not parse url: '" << url << "'";
+                return WebSocketInitResult(false, 0, ss.str());
+            }
+
+            std::string errorMsg;
+            bool tls = protocol == "wss";
+            _socket = createSocket(tls, -1, errorMsg, _socketTLSOptions);
+            _perMessageDeflate = std::make_unique<WebSocketPerMessageDeflate>();
+
+            if (!_socket)
+            {
+                return WebSocketInitResult(false, 0, errorMsg);
+            }
+
+            WebSocketHandshake webSocketHandshake(_requestInitCancellation,
+                                                  _socket,
+                                                  _perMessageDeflate,
+                                                  _perMessageDeflateOptions,
+                                                  _enablePerMessageDeflate);
+
+            result = webSocketHandshake.clientHandshake(
+                remoteUrl, headers, host, path, port, timeoutSecs);
+
+            if (result.http_status >= 300 && result.http_status < 400)
+            {
+                auto it = result.headers.find("Location");
+                if (it == result.headers.end())
+                {
+                    std::stringstream ss;
+                    ss << "Missing Location Header for HTTP Redirect response. "
+                       << "Rejecting connection to " << url << ", status: " << result.http_status;
+                    result.errorStr = ss.str();
+                    break;
+                }
+
+                remoteUrl = it->second;
+                continue;
+            }
+
+            if (result.success)
+            {
+                setReadyState(ReadyState::OPEN);
+            }
+            return result;
         }
 
-        std::string errorMsg;
-        bool tls = protocol == "wss";
-        _socket = createSocket(tls, -1, errorMsg, _socketTLSOptions);
-        _perMessageDeflate = std::make_unique<WebSocketPerMessageDeflate>();
-
-        if (!_socket)
-        {
-            return WebSocketInitResult(false, 0, errorMsg);
-        }
-
-        WebSocketHandshake webSocketHandshake(_requestInitCancellation,
-                                              _socket,
-                                              _perMessageDeflate,
-                                              _perMessageDeflateOptions,
-                                              _enablePerMessageDeflate);
-
-        auto result =
-            webSocketHandshake.clientHandshake(url, headers, host, path, port, timeoutSecs);
-        if (result.success)
-        {
-            setReadyState(ReadyState::OPEN);
-        }
         return result;
     }
 
@@ -633,7 +659,7 @@ namespace ix
                     // send back the CLOSE frame
                     sendCloseFrame(code, reason);
 
-                    wakeUpFromPoll(Socket::kCloseRequest);
+                    wakeUpFromPoll(SelectInterrupt::kCloseRequest);
 
                     bool remote = true;
                     closeSocketAndSwitchToClosedState(code, reason, _rxbuf.size(), remote);
@@ -853,7 +879,7 @@ namespace ix
         // Request to flush the send buffer on the background thread if it isn't empty
         if (!isSendBufferEmpty())
         {
-            wakeUpFromPoll(Socket::kSendRequest);
+            wakeUpFromPoll(SelectInterrupt::kSendRequest);
 
             // FIXME: we should have a timeout when sending large messages: see #131
             if (_blockingSend && !flushSendBuffer())
@@ -1122,7 +1148,7 @@ namespace ix
         sendCloseFrame(code, reason);
 
         // wake up the poll, but do not close yet
-        wakeUpFromPoll(Socket::kSendRequest);
+        wakeUpFromPoll(SelectInterrupt::kSendRequest);
     }
 
     size_t WebSocketTransport::bufferedAmount() const

ixwebsocket/IXWebSocketVersion.h

@@ -6,4 +6,4 @@
 
 #pragma once
 
-#define IX_WEBSOCKET_VERSION "10.1.7"
+#define IX_WEBSOCKET_VERSION "10.4.7"

makefile

@@ -39,8 +39,8 @@ ws_install:
 ws_install_release:
 	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. -DUSE_TEST=0 && ninja install)
 
-ws_openssl:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; make -j 4)
+ws_openssl_install:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; ninja install)
 
 ws_mbedtls:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4)
@@ -48,6 +48,9 @@ ws_mbedtls:
 ws_no_ssl:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_WS=1 .. ; make -j 4)
 
+ws_no_python:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; ninja install)
+
 uninstall:
 	xargs rm -fv < build/install_manifest.txt
 

test/CMakeLists.txt

@@ -2,39 +2,22 @@
 # Author: Benjamin Sergeant
 # Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
 #
-cmake_minimum_required (VERSION 3.4.1)
+cmake_minimum_required (VERSION 3.14)
 project (ixwebsocket_unittest)
 
 set (CMAKE_CXX_STANDARD 14)
 
-if (MAC)
-  set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../third_party/sanitizers-cmake/cmake" ${CMAKE_MODULE_PATH})
-  find_package(Sanitizers)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
-  set(CMAKE_LD_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
-  option(USE_TLS "Add TLS support" ON)
-endif()
+option(USE_TLS "Add TLS support" ON)
 
 include_directories(
   ${PROJECT_SOURCE_DIR}/Catch2/single_include
   ../third_party
   ../third_party/msgpack11
-  ../third_party/spdlog/include
   ../ws
 )
 
-add_definitions(-DSPDLOG_COMPILED_LIB=1)
-
-find_package(JsonCpp)
-if (NOT JSONCPP_FOUND)
-  include_directories(../third_party/jsoncpp)
-  set(JSONCPP_SOURCES ../third_party/jsoncpp/jsoncpp.cpp)
-endif()
-
 # Shared sources
 set (SOURCES
-  ${JSONCPP_SOURCES}
-
   test_runner.cpp
   IXTest.cpp
   ../third_party/msgpack11/msgpack11.cpp
@@ -115,6 +98,7 @@ target_link_libraries(ixwebsocket_unittest ixcrypto)
 target_link_libraries(ixwebsocket_unittest ixcore)
 
 target_link_libraries(ixwebsocket_unittest spdlog)
+target_link_libraries(ixwebsocket_unittest jsoncpp_static)
 if (USE_PYTHON)
   target_link_libraries(ixwebsocket_unittest ${Python_LIBRARIES})
 endif()

test/IXCobraToSentryBotTest.cpp

@@ -95,15 +95,14 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")
 
         sentryServer.setOnConnectionCallback(
             [](HttpRequestPtr request,
-               std::shared_ptr<ConnectionState> /*connectionState*/,
-               std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
+               std::shared_ptr<ConnectionState> connectionState) -> HttpResponsePtr {
                 WebSocketHttpHeaders headers;
                 headers["Server"] = userAgent();
 
                 // Log request
                 std::stringstream ss;
-                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
-                   << request->method << " " << request->headers["User-Agent"] << " "
+                ss << connectionState->getRemoteIp() << ":" << connectionState->getRemotePort()
+                   << " " << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri;
 
                 if (request->method == "POST")

test/IXHttpServerTest.cpp

@@ -63,6 +63,54 @@ TEST_CASE("http server", "[httpd]")
 
         server.stop();
     }
+
+    SECTION("Posting plain text data to a local HTTP server")
+    {
+        int port = getFreePort();
+        ix::HttpServer server(port, "127.0.0.1");
+
+        server.setOnConnectionCallback(
+            [](HttpRequestPtr request, std::shared_ptr<ConnectionState>) -> HttpResponsePtr {
+                if (request->method == "POST")
+                {
+                    return std::make_shared<HttpResponse>(
+                        200, "OK", HttpErrorCode::Ok, WebSocketHttpHeaders(), request->body);
+                }
+
+                return std::make_shared<HttpResponse>(400, "BAD REQUEST");
+            });
+
+        auto res = server.listen();
+        REQUIRE(res.first);
+        server.start();
+
+        HttpClient httpClient;
+        WebSocketHttpHeaders headers;
+        headers["Content-Type"] = "text/plain";
+
+        std::string url("http://127.0.0.1:");
+        url += std::to_string(port);
+        auto args = httpClient.createRequest(url);
+
+        args->extraHeaders = headers;
+        args->connectTimeout = 60;
+        args->transferTimeout = 60;
+        args->verbose = true;
+        args->logger = [](const std::string& msg) { std::cout << msg; };
+        args->body = "Hello World!";
+
+        auto response = httpClient.post(url, args->body, args);
+
+        std::cerr << "Status: " << response->statusCode << std::endl;
+        std::cerr << "Error message: " << response->errorMsg << std::endl;
+        std::cerr << "Body: " << response->body << std::endl;
+
+        REQUIRE(response->errorCode == HttpErrorCode::Ok);
+        REQUIRE(response->statusCode == 200);
+        REQUIRE(response->body == args->body);
+
+        server.stop();
+    }
 }
 
 TEST_CASE("http server redirection", "[httpd_redirect]")

test/IXTest.cpp

@@ -85,11 +85,10 @@ namespace ix
     bool startWebSocketEchoServer(ix::WebSocketServer& server)
     {
         server.setOnClientMessageCallback(
-            [&server](std::shared_ptr<ConnectionState> /*connectionState*/,
-                      ConnectionInfo& connectionInfo,
+            [&server](std::shared_ptr<ConnectionState> connectionState,
                       WebSocket& webSocket,
                       const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
+                auto remoteIp = connectionState->getRemoteIp();
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";

test/IXWebSocketBroadcastTest.cpp

@@ -191,11 +191,9 @@ namespace
 
         server.setOnClientMessageCallback(
             [&server, &connectionId](std::shared_ptr<ConnectionState> connectionState,
-                                     ConnectionInfo& connectionInfo,
                                      WebSocket& webSocket,
                                      const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-
+                auto remoteIp = connectionState->getRemoteIp();
 
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {

test/IXWebSocketChatTest.cpp

@@ -195,10 +195,9 @@ namespace
     {
         server.setOnClientMessageCallback(
             [&server](std::shared_ptr<ConnectionState> connectionState,
-                      ConnectionInfo& connectionInfo,
                       WebSocket& webSocket,
                       const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
+                auto remoteIp = connectionState->getRemoteIp();
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";
@@ -286,27 +285,27 @@ TEST_CASE("Websocket_chat", "[websocket_chat]")
         int attempts = 0;
         while (chatA.getReceivedMessagesCount() != 3 || chatB.getReceivedMessagesCount() != 3)
         {
-            REQUIRE(attempts++ < 10);
+            CHECK(attempts++ < 10);
             ix::msleep(1000);
         }
 
         chatA.stop();
         chatB.stop();
 
-        REQUIRE(chatA.getReceivedMessagesCount() == 3);
-        REQUIRE(chatB.getReceivedMessagesCount() == 3);
+        CHECK(chatA.getReceivedMessagesCount() == 3);
+        CHECK(chatB.getReceivedMessagesCount() == 3);
 
-        REQUIRE(chatB.getReceivedMessages()[0] == "from A1");
-        REQUIRE(chatB.getReceivedMessages()[1] == "from A2");
-        REQUIRE(chatB.getReceivedMessages()[2] == "from A3");
+        CHECK(chatB.getReceivedMessages()[0] == "from A1");
+        CHECK(chatB.getReceivedMessages()[1] == "from A2");
+        CHECK(chatB.getReceivedMessages()[2] == "from A3");
 
-        REQUIRE(chatA.getReceivedMessages()[0] == "from B1");
-        REQUIRE(chatA.getReceivedMessages()[1] == "from B2");
-        REQUIRE(chatA.getReceivedMessages()[2].size() == bigMessage.size());
+        CHECK(chatA.getReceivedMessages()[0] == "from B1");
+        CHECK(chatA.getReceivedMessages()[1] == "from B2");
+        CHECK(chatA.getReceivedMessages()[2].size() == bigMessage.size());
 
         // Give us 1000ms for the server to notice that clients went away
         ix::msleep(1000);
-        REQUIRE(server.getClients().size() == 0);
+        CHECK(server.getClients().size() == 0);
 
         ix::reportWebSocketTraffic();
     }

test/IXWebSocketCloseTest.cpp

@@ -171,10 +171,9 @@ namespace
         server.setOnClientMessageCallback(
             [&receivedCloseCode, &receivedCloseReason, &receivedCloseRemote, &mutexWrite](
                 std::shared_ptr<ConnectionState> connectionState,
-                ConnectionInfo& connectionInfo,
                 WebSocket& /*webSocket*/,
                 const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
+                auto remoteIp = connectionState->getRemoteIp();
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New server connection";

test/IXWebSocketServerTest.cpp

@@ -35,11 +35,9 @@ namespace ix
 
         server.setOnClientMessageCallback(
             [&server, &connectionId](std::shared_ptr<ConnectionState> connectionState,
-                                     ConnectionInfo& connectionInfo,
                                      WebSocket& webSocket,
                                      const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-
+                auto remoteIp = connectionState->getRemoteIp();
 
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {

test/IXWebSocketSubProtocolTest.cpp

@@ -18,10 +18,9 @@ bool startServer(ix::WebSocketServer& server, std::string& subProtocols)
 {
     server.setOnClientMessageCallback(
         [&server, &subProtocols](std::shared_ptr<ConnectionState> connectionState,
-                                 ConnectionInfo& connectionInfo,
                                  WebSocket& webSocket,
                                  const ix::WebSocketMessagePtr& msg) {
-            auto remoteIp = connectionInfo.remoteIp;
+            auto remoteIp = connectionState->getRemoteIp();
             if (msg->type == ix::WebSocketMessageType::Open)
             {
                 TLogger() << "New connection";

test/compatibility/ruby/README.md

@@ -0,0 +1,6 @@
+```
+export GEM_HOME=$HOME/local/gems
+bundle install faye-websocket
+```
+
+https://stackoverflow.com/questions/486995/ruby-equivalent-of-virtualenv

test/compatibility/ruby/devnull_client.rb

@@ -0,0 +1,59 @@
+#
+# $ ruby --version
+# ruby 2.6.3p62 (2019-04-16 revision 67580) [universal.x86_64-darwin19]
+# 
+# Install a gem locally by setting GEM_HOME
+# https://stackoverflow.com/questions/486995/ruby-equivalent-of-virtualenv
+# export GEM_HOME=$HOME/local/gems
+# bundle install faye-websocket
+#
+# In a different terminal, start a push server:
+# $ ws push_server -q
+#
+# $ ruby devnull_client.rb
+# [:open]
+# Connected to server
+# messages received per second: 115926
+# messages received per second: 119156
+# messages received per second: 119156
+# messages received per second: 119157
+# messages received per second: 119156
+# messages received per second: 119156
+# messages received per second: 119157
+# messages received per second: 119156
+# messages received per second: 119156
+# messages received per second: 119157
+# messages received per second: 119156
+# messages received per second: 119157
+# messages received per second: 119156
+# ^C[:close, 1006, ""]
+# 
+require 'faye/websocket'
+require 'eventmachine'
+
+EM.run {
+  ws = Faye::WebSocket::Client.new('ws://127.0.0.1:8008')
+
+  counter = 0
+
+  EM.add_periodic_timer(1) do
+    print "messages received per second: #{counter}\n"
+    counter = 0  # reset counter
+  end
+
+  ws.on :open do |event|
+    p [:open]
+    print "Connected to server\n"
+  end
+
+  ws.on :message do |event|
+    # Uncomment the next line to validate that we receive something correct
+    # p [:message, event.data]
+    counter += 1
+  end
+
+  ws.on :close do |event|
+    p [:close, event.code, event.reason]
+    ws = nil
+  end
+}

third_party/jsoncpp/json/json-forwards.h

@@ -1,316 +0,0 @@
-/// Json-cpp amalgamated forward header (http://jsoncpp.sourceforge.net/).
-/// It is intended to be used with #include "json/json-forwards.h"
-/// This header provides forward declaration for all JsonCpp types.
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-/*
-The JsonCpp library's source code, including accompanying documentation,
-tests and demonstration applications, are licensed under the following
-conditions...
-
-Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
-jurisdictions which recognize such a disclaimer. In such jurisdictions,
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
-The JsonCpp Authors, and is released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this
-software may choose to accept it either as 1) Public Domain, 2) under the
-conditions of the MIT License (see below), or 3) under the terms of dual
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
-   http://en.wikipedia.org/wiki/MIT_License
-
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.
-
-*/
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED
-# define JSON_FORWARD_AMALGAMATED_H_INCLUDED
-/// If defined, indicates that the source file is amalgamated
-/// to prevent private header inclusion.
-#define JSON_IS_AMALGAMATION
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_CONFIG_H_INCLUDED
-#define JSON_CONFIG_H_INCLUDED
-#include <cstddef>
-#include <cstdint>
-#include <istream>
-#include <memory>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-
-// If non-zero, the library uses exceptions to report bad input instead of C
-// assertion macros. The default is to use exceptions.
-#ifndef JSON_USE_EXCEPTION
-#define JSON_USE_EXCEPTION 1
-#endif
-
-// Temporary, tracked for removal with issue #982.
-#ifndef JSON_USE_NULLREF
-#define JSON_USE_NULLREF 1
-#endif
-
-/// If defined, indicates that the source file is amalgamated
-/// to prevent private header inclusion.
-/// Remarks: it is automatically defined in the generated amalgamated header.
-// #define JSON_IS_AMALGAMATION
-
-// Export macros for DLL visibility
-#if defined(JSON_DLL_BUILD)
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#define JSON_API __declspec(dllexport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#elif defined(__GNUC__) || defined(__clang__)
-#define JSON_API __attribute__((visibility("default")))
-#endif // if defined(_MSC_VER)
-
-#elif defined(JSON_DLL)
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#define JSON_API __declspec(dllimport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#endif // if defined(_MSC_VER)
-#endif // ifdef JSON_DLL_BUILD
-
-#if !defined(JSON_API)
-#define JSON_API
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER < 1800
-#error                                                                         \
-    "ERROR:  Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-// As recommended at
-// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
-extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
-                                              const char* format, ...);
-#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
-#else
-#define jsoncpp_snprintf std::snprintf
-#endif
-
-// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
-// integer
-// Storages, and 64 bits integer support is disabled.
-// #define JSON_NO_INT64 1
-
-// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
-// C++11 should be used directly in JSONCPP.
-#define JSONCPP_OVERRIDE override
-
-#if __cplusplus >= 201103L
-#define JSONCPP_NOEXCEPT noexcept
-#define JSONCPP_OP_EXPLICIT explicit
-#elif defined(_MSC_VER) && _MSC_VER < 1900
-#define JSONCPP_NOEXCEPT throw()
-#define JSONCPP_OP_EXPLICIT explicit
-#elif defined(_MSC_VER) && _MSC_VER >= 1900
-#define JSONCPP_NOEXCEPT noexcept
-#define JSONCPP_OP_EXPLICIT explicit
-#else
-#define JSONCPP_NOEXCEPT throw()
-#define JSONCPP_OP_EXPLICIT
-#endif
-
-#ifdef __clang__
-#if __has_extension(attribute_deprecated_with_message)
-#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
-#endif
-#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
-#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
-#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
-#endif                  // GNUC version
-#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
-                        // MSVC)
-#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
-#endif // __clang__ || __GNUC__ || _MSC_VER
-
-#if !defined(JSONCPP_DEPRECATED)
-#define JSONCPP_DEPRECATED(message)
-#endif // if !defined(JSONCPP_DEPRECATED)
-
-#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
-#define JSON_USE_INT64_DOUBLE_CONVERSION 1
-#endif
-
-#if !defined(JSON_IS_AMALGAMATION)
-
-#include "allocator.h"
-#include "version.h"
-
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-using Int = int;
-using UInt = unsigned int;
-#if defined(JSON_NO_INT64)
-using LargestInt = int;
-using LargestUInt = unsigned int;
-#undef JSON_HAS_INT64
-#else                 // if defined(JSON_NO_INT64)
-// For Microsoft Visual use specific types as long long is not supported
-#if defined(_MSC_VER) // Microsoft Visual Studio
-using Int64 = __int64;
-using UInt64 = unsigned __int64;
-#else                 // if defined(_MSC_VER) // Other platforms, use long long
-using Int64 = int64_t;
-using UInt64 = uint64_t;
-#endif                // if defined(_MSC_VER)
-using LargestInt = Int64;
-using LargestUInt = UInt64;
-#define JSON_HAS_INT64
-#endif // if defined(JSON_NO_INT64)
-
-template <typename T>
-using Allocator =
-    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
-                              std::allocator<T>>::type;
-using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
-using IStringStream =
-    std::basic_istringstream<String::value_type, String::traits_type,
-                             String::allocator_type>;
-using OStringStream =
-    std::basic_ostringstream<String::value_type, String::traits_type,
-                             String::allocator_type>;
-using IStream = std::istream;
-using OStream = std::ostream;
-} // namespace Json
-
-// Legacy names (formerly macros).
-using JSONCPP_STRING = Json::String;
-using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
-using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
-using JSONCPP_ISTREAM = Json::IStream;
-using JSONCPP_OSTREAM = Json::OStream;
-
-#endif // JSON_CONFIG_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_FORWARDS_H_INCLUDED
-#define JSON_FORWARDS_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-// writer.h
-class StreamWriter;
-class StreamWriterBuilder;
-class Writer;
-class FastWriter;
-class StyledWriter;
-class StyledStreamWriter;
-
-// reader.h
-class Reader;
-class CharReader;
-class CharReaderBuilder;
-
-// json_features.h
-class Features;
-
-// value.h
-using ArrayIndex = unsigned int;
-class StaticString;
-class Path;
-class PathArgument;
-class Value;
-class ValueIteratorBase;
-class ValueIterator;
-class ValueConstIterator;
-
-} // namespace Json
-
-#endif // JSON_FORWARDS_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#endif //ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED

third_party/spdlog/.clang-format

@@ -1,108 +0,0 @@
----
-Language:        Cpp
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -4
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Right
-AlignOperands:   true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: true
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: true
-BinPackArguments: true
-BinPackParameters: true
-BraceWrapping:     
-  AfterClass:      true
-  AfterControlStatement: true
-  AfterEnum:       true
-  AfterFunction:   true
-  AfterNamespace:  false
-  AfterObjCDeclaration: true
-  AfterStruct:     true
-  AfterUnion:      true
-  BeforeCatch:     true
-  BeforeElse:      true
-  IndentBraces:    false
-  SplitEmptyFunction: false
-  SplitEmptyRecord: false
-  SplitEmptyNamespace: false
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Custom
-BreakBeforeInheritanceComma: false
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: true
-BreakConstructorInitializers: BeforeColon
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     140
-CommentPragmas:  '^ IWYU pragma:'
-CompactNamespaces:  false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: true
-ForEachMacros:   
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-IncludeCategories: 
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-    Priority:        2
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
-    Priority:        3
-  - Regex:           '.*'
-    Priority:        1
-IncludeIsMainRegex: '(Test)?$'
-IndentCaseLabels: false
-IndentWidth:     4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBlockIndentWidth: 2
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Right
-ReflowComments:  true
-SortIncludes:    false
-SortUsingDeclarations: true
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: false
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-Standard:        Cpp11
-TabWidth:        8
-UseTab:          Never
-...
-

third_party/spdlog/.clang-tidy

@@ -1,54 +0,0 @@
-Checks: 'cppcoreguidelines-*,
-performance-*,
-modernize-*,
-google-*,
-misc-*,
-cert-*,
-readability-*,
-clang-analyzer-*,
--performance-unnecessary-value-param,
--modernize-use-trailing-return-type,
--google-runtime-references,
--misc-non-private-member-variables-in-classes,
--readability-braces-around-statements,
--google-readability-braces-around-statements,
--cppcoreguidelines-avoid-magic-numbers,
--readability-magic-numbers,
--readability-magic-numbers,
--cppcoreguidelines-pro-type-vararg,
--cppcoreguidelines-pro-bounds-pointer-arithmetic,
--cppcoreguidelines-avoid-c-arrays,
--modernize-avoid-c-arrays,
--cppcoreguidelines-pro-bounds-array-to-pointer-decay,
--readability-named-parameter,
--cert-env33-c
-'
-
-
-WarningsAsErrors: ''
-HeaderFilterRegex: '*spdlog/[^f].*'
-AnalyzeTemporaryDtors: false
-FormatStyle:     none
-
-CheckOptions:    
-  - key:             google-readability-braces-around-statements.ShortStatementLines
-    value:           '1'
-  - key:             google-readability-function-size.StatementThreshold
-    value:           '800'
-  - key:             google-readability-namespace-comments.ShortNamespaceLines
-    value:           '10'
-  - key:             google-readability-namespace-comments.SpacesBeforeComments
-    value:           '2'
-  - key:             modernize-loop-convert.MaxCopySize
-    value:           '16'
-  - key:             modernize-loop-convert.MinConfidence
-    value:           reasonable
-  - key:             modernize-loop-convert.NamingStyle
-    value:           CamelCase
-  - key:             modernize-pass-by-value.IncludeStyle
-    value:           llvm
-  - key:             modernize-replace-auto-ptr.IncludeStyle
-    value:           llvm
-  - key:             modernize-use-nullptr.NullMacros
-    value:           'NULL'
-

third_party/spdlog/.gitattributes

@@ -1 +0,0 @@
-* text=false

third_party/spdlog/.gitignore

@@ -1,83 +0,0 @@
-# Auto generated files
-build/*
-*.slo
-*.lo
-*.o
-*.obj
-*.suo
-*.tlog
-*.ilk
-*.log
-*.pdb
-*.idb
-*.iobj
-*.ipdb
-*.opensdf
-*.sdf
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Codelite
-.codelite
-
-# KDevelop
-*.kdev4
-
-# .orig files
-*.orig
-
-# example  files
-example/*
-!example/example.cpp
-!example/bench.cpp
-!example/utils.h
-!example/Makefile*
-!example/example.sln
-!example/example.vcxproj
-!example/CMakeLists.txt
-!example/meson.build
-!example/multisink.cpp
-!example/jni
-
-# generated files
-generated
-
-# Cmake
-CMakeCache.txt
-CMakeFiles
-CMakeScripts
-Makefile
-cmake_install.cmake
-install_manifest.txt
-/tests/tests.VC.VC.opendb
-/tests/tests.VC.db
-/tests/tests
-/tests/logs/*
-
-# idea
-.idea/
-cmake-build-*/
-*.db
-*.ipch
-*.filters
-*.db-wal
-*.opendb
-*.db-shm
-*.vcxproj
-*.tcl
-*.user
-*.sln

third_party/spdlog/.travis.yml

@@ -1,112 +0,0 @@
-# Adapted from various sources, including:
-# - Louis Dionne's Hana: https://github.com/ldionne/hana
-# - Paul Fultz II's FIT: https://github.com/pfultz2/Fit
-# - Eric Niebler's range-v3: https://github.com/ericniebler/range-v3
-sudo: required
-language: cpp
-
-# gcc 4.8
-addons: &gcc48
-  apt:
-    packages:
-      - g++-4.8
-    sources:
-      - ubuntu-toolchain-r-test
-
-# gcc 7.0
-addons: &gcc7
-  apt:
-    packages:
-      - g++-7
-    sources:
-      - ubuntu-toolchain-r-test
-
-# Clang 3.5
-addons: &clang35
-  apt:
-    packages:
-      - clang-3.5
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-precise-3.5
-      
-# Clang 7.0
-addons: &clang70
-  apt:
-    packages:
-      - clang-7      
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-7
-
-
-
-matrix:
-  include:
-    # Test gcc-4.8: C++11, Build=Debug/Release
-    - env: GCC_VERSION=4.8 BUILD_TYPE=Debug CPP=11
-      os: linux
-      addons: *gcc48
-
-    - env: GCC_VERSION=4.8 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *gcc48
-
-    - env: GCC_VERSION=7 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *gcc7
-
-    # Test clang-3.5: C++11, Build=Debug/Release
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11
-      os: linux
-      addons: *clang35
-
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *clang35
-
-      # Test clang-7.0: C++11, Build=Debug, ASAN=On
-    - env: CLANG_VERSION=7 BUILD_TYPE=Debug CPP=11 ASAN=On TSAN=Off
-      dist: bionic      
-
-    - env: CLANG_VERSION=7 BUILD_TYPE=Release CPP=11 ASAN=On TSAN=Off
-      dist: bionic
-      
-      # osx
-    - env: BUILD_TYPE=Release CPP=11 ASAN=Off TSAN=Off
-      os: osx
-
-
-
-before_script:
-  - if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
-  - if [ -n "$CLANG_VERSION" ]; then export CXX="clang++-${CLANG_VERSION}" CC="clang-${CLANG_VERSION}"; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export CXX="clang++" CC="clang"; fi
-  - which $CXX
-  - which $CC
-  - $CXX --version
-  - cmake --version
-
-script:
-  - cd ${TRAVIS_BUILD_DIR}
-  - mkdir -p build && cd build
-  - |
-    cmake .. \
-      --warn-uninitialized \
-      -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-      -DCMAKE_CXX_STANDARD=$CPP \
-      -DSPDLOG_BUILD_EXAMPLE=ON \
-      -DSPDLOG_BUILD_EXAMPLE_HO=ON \
-      -DSPDLOG_ENABLE_WARNINGS=ON \
-      -DSPDLOG_BUILD_BENCH=OFF \
-      -DSPDLOG_BUILD_TESTS=ON \
-      -DSPDLOG_BUILD_TESTS_HO=OFf \
-      -DSPDLOG_SANITIZE_ADDRESS=$ASAN 
-      
-  - make VERBOSE=1 -j2
-  - ctest -j2 --output-on-failure
-
-
-
-notifications:
-  email: false

third_party/spdlog/CMakeLists.txt

@@ -1,335 +0,0 @@
-# Copyright(c) 2019 spdlog authors
-# Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.2)
-
-if(${CMAKE_VERSION} VERSION_LESS 3.11)
-    cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-    cmake_policy(VERSION 3.11)
-endif()
-
-ENABLE_LANGUAGE(C)
-
-#---------------------------------------------------------------------------------------
-# Start spdlog project
-#---------------------------------------------------------------------------------------
-include(cmake/utils.cmake)
-include(cmake/ide.cmake)
-
-spdlog_extract_version()
-
-project(spdlog VERSION ${SPDLOG_VERSION} LANGUAGES CXX)
-message(STATUS "Build spdlog: ${SPDLOG_VERSION}")
-
-include(GNUInstallDirs)
-
-#---------------------------------------------------------------------------------------
-# Set default build to release
-#---------------------------------------------------------------------------------------
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif()
-
-
-#---------------------------------------------------------------------------------------
-# Compiler config
-#---------------------------------------------------------------------------------------
-if (NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif()
-
-set(CMAKE_CXX_EXTENSIONS  OFF)
-
-if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN")
-	set(CMAKE_CXX_EXTENSIONS ON)
-endif()
-
-
-#---------------------------------------------------------------------------------------
-# Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
-#---------------------------------------------------------------------------------------
-# Check if spdlog is being used directly or via add_subdirectory, but allow overriding
-if (NOT DEFINED SPDLOG_MASTER_PROJECT)
-    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-        set(SPDLOG_MASTER_PROJECT ON)
-    else()
-        set(SPDLOG_MASTER_PROJECT OFF)
-    endif()
-endif ()
-
-# build shared option
-option(SPDLOG_BUILD_SHARED "Build shared library" OFF)
-
-# precompiled headers option
-option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" OFF)
-
-# example options
-option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
-option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
-
-# testing options
-option(SPDLOG_BUILD_TESTS "Build tests" OFF)
-option(SPDLOG_BUILD_TESTS_HO "Build tests using the header only version" OFF)
-
-# bench options
-option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF)
-
-# sanitizer options
-option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
-
-# warning options
-option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
-
-# install options
-option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
-option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
-option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
-option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
-
-if (SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
-    message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif()
-
-# misc tweakme options
-if(WIN32)
-    option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
-    option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
-endif()
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    option(SPDLOG_CLOCK_COARSE "Use the much faster (but much less accurate) CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
-endif()
-
-option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
-option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
-option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" OFF)
-option(SPDLOG_NO_ATOMIC_LEVELS "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently" OFF)
-
-# clang-tidy
-if(${CMAKE_VERSION} VERSION_GREATER "3.5") 
-    option(SPDLOG_TIDY "run clang-tidy" OFF)
-endif()
-
-if(SPDLOG_TIDY)
-    set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
-    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-    message(STATUS "Enabled clang-tidy")
-endif()
-
-find_package(Threads REQUIRED)
-message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
-#---------------------------------------------------------------------------------------
-# Static/Shared library (shared not supported in windows yet)
-#---------------------------------------------------------------------------------------
-set(SPDLOG_SRCS
-        src/spdlog.cpp
-        src/stdout_sinks.cpp
-        src/color_sinks.cpp 
-        src/file_sinks.cpp
-        src/async.cpp
-        src/cfg.cpp)
-
-if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-    list(APPEND SPDLOG_SRCS src/fmt.cpp)
-endif()
-
-if(WIN32 AND SPDLOG_BUILD_SHARED)
-    list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-endif()
-
-if (SPDLOG_BUILD_SHARED)
-    add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-    target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if(WIN32)
-        target_compile_options(spdlog PUBLIC /wd4251 /wd4275)
-	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)        
-    endif()
-    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
-    endif()
-else()
-    add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-endif()
-
-add_library(spdlog::spdlog ALIAS spdlog)
-
-target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
-target_include_directories(spdlog PUBLIC
-        "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-target_link_libraries(spdlog PUBLIC Threads::Threads)
-spdlog_enable_warnings(spdlog)
-
-set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR})
-set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
-
-if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
-    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
-    target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
-endif()
-
-#---------------------------------------------------------------------------------------
-# Header only version
-#---------------------------------------------------------------------------------------
-add_library(spdlog_header_only INTERFACE)
-add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
-
-target_include_directories(spdlog_header_only INTERFACE
-        "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
-
-
-#---------------------------------------------------------------------------------------
-# Use fmt package if using external fmt
-#---------------------------------------------------------------------------------------
-if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    if (NOT TARGET fmt::fmt)
-        find_package(fmt REQUIRED)
-    endif ()
-    target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)
-
-    # use external fmt-header-nly
-    if(SPDLOG_FMT_EXTERNAL_HO)
-        target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
-        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
-    else() # use external compile fmt
-        target_link_libraries(spdlog PUBLIC fmt::fmt)
-        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
-    endif()
-
-    set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
-endif()
-
-#---------------------------------------------------------------------------------------
-# Misc definitions according to tweak options
-#---------------------------------------------------------------------------------------
-if(SPDLOG_WCHAR_SUPPORT)
-	target_compile_definitions(spdlog PUBLIC SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-	target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_WCHAR_TO_UTF8_SUPPORT)
- endif()
-
- if(SPDLOG_WCHAR_FILENAMES)
-	target_compile_definitions(spdlog PUBLIC SPDLOG_WCHAR_FILENAMES)
-	target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_WCHAR_FILENAMES)
- endif()
-
- if(SPDLOG_NO_EXCEPTIONS)
-	target_compile_definitions(spdlog PUBLIC SPDLOG_NO_EXCEPTIONS)	
-
-	target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_EXCEPTIONS)
-
-    if(NOT MSVC)
-        target_compile_options(spdlog PRIVATE -fno-exceptions)
-    endif()
-endif()
-
-if(SPDLOG_CLOCK_COARSE)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_CLOCK_COARSE)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_CLOCK_COARSE)
-endif()
-
-if(SPDLOG_PREVENT_CHILD_FD)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_PREVENT_CHILD_FD)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_PREVENT_CHILD_FD)
-endif()
-
-if(SPDLOG_NO_THREAD_ID)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_NO_THREAD_ID)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_THREAD_ID)
-endif()
-
-if(SPDLOG_NO_TLS)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_NO_TLS)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_TLS)
-endif()
-
-if(SPDLOG_NO_ATOMIC_LEVELS)
-    target_compile_definitions(spdlog PUBLIC SPDLOG_NO_ATOMIC_LEVELS)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_ATOMIC_LEVELS)
-endif()
-
-
-#---------------------------------------------------------------------------------------
-# Build binaries
-#---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO)
-    message(STATUS "Generating example(s)")
-    add_subdirectory(example)
-    spdlog_enable_warnings(example)
-    if(SPDLOG_BUILD_EXAMPLE_HO)
-        spdlog_enable_warnings(example_header_only)
-    endif()
-endif()
-
-if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO)
-    message(STATUS "Generating tests")
-    enable_testing()
-    add_subdirectory(tests)
-endif()
-
-if(SPDLOG_BUILD_BENCH)
-    message(STATUS "Generating benchmarks")
-    add_subdirectory(bench)
-endif()
-
-#---------------------------------------------------------------------------------------
-# Install
-#---------------------------------------------------------------------------------------
-if (SPDLOG_INSTALL)
-    message(STATUS "Generating install")
-    set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
-    set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
-    set(config_targets_file "spdlogConfigTargets.cmake")
-    set(version_config_file "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfigVersion.cmake")
-    set(export_dest_dir "${CMAKE_INSTALL_LIBDIR}/cmake/spdlog")
-    set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-    set(pkg_config "${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc")
-
-    #---------------------------------------------------------------------------------------
-    # Include files
-    #---------------------------------------------------------------------------------------
-    install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
-    install(TARGETS spdlog spdlog_header_only EXPORT spdlog
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
-                DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
-    endif()
-
-    #---------------------------------------------------------------------------------------
-    # Install pkg-config file
-    #---------------------------------------------------------------------------------------
-    get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)
-    string(REPLACE ";" " -D" PKG_CONFIG_DEFINES "${PKG_CONFIG_DEFINES}")
-    string(CONCAT PKG_CONFIG_DEFINES "-D" "${PKG_CONFIG_DEFINES}")
-    configure_file("cmake/${PROJECT_NAME}.pc.in" "${pkg_config}" @ONLY)
-    install(FILES "${pkg_config}" DESTINATION "${pkgconfig_install_dir}")
-
-    #---------------------------------------------------------------------------------------
-    # Install CMake config files
-    #---------------------------------------------------------------------------------------
-    install(EXPORT spdlog
-            DESTINATION ${export_dest_dir}
-            NAMESPACE spdlog::
-            FILE ${config_targets_file})
-
-    include(CMakePackageConfigHelpers)
-    configure_file("${project_config_in}" "${project_config_out}" @ONLY)
-
-    write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion)
-    install(FILES
-            "${project_config_out}"
-            "${version_config_file}" DESTINATION "${export_dest_dir}")
-
-    #---------------------------------------------------------------------------------------
-    # Support creation of installable packages
-    #---------------------------------------------------------------------------------------
-    include(cmake/spdlogCPack.cmake)
-endif ()
-

third_party/spdlog/INSTALL

@@ -1,24 +0,0 @@
-Header only version:
-==================================================================
-Just copy the files to your build tree and use a C++11 compiler.
-Or use CMake:
-  add_executable(example_header_only example.cpp)
-  target_link_libraries(example_header_only spdlog::spdlog_header_only)
-
-
-Compiled library version:
-==================================================================
-CMake:
-  add_executable(example example.cpp)
-  target_link_libraries(example spdlog::spdlog)
-
-Or copy src/spdlog.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
-
-Tested on:
-gcc 4.8.1 and above
-clang 3.5
-Visual Studio 2013
-
-
-
-

third_party/spdlog/LICENSE

@@ -1,26 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Gabi Melman.                                       
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
--- NOTE: Third party dependecy used by this sofware --
-This software depends on the fmt lib (MIT License),
-and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
-

third_party/spdlog/README.md

@@ -1,406 +0,0 @@
-# spdlog
-
-Very fast, header-only/compiled, C++ logging library. [![Build Status](https://travis-ci.org/gabime/spdlog.svg?branch=master)](https://travis-ci.org/gabime/spdlog)  [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
-
-## Install 
-#### Header only version
-Copy the source [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
-
-#### Static lib version (recommended - much faster compile times)
-```console
-$ git clone https://github.com/gabime/spdlog.git
-$ cd spdlog && mkdir build && cd build
-$ cmake .. && make -j
-```
-      
-   see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.
-
-## Platforms
- * Linux, FreeBSD, OpenBSD, Solaris, AIX
- * Windows (msvc 2013+, cygwin)
- * macOS (clang 3.5+)
- * Android
-
-## Package managers:
-* Homebrew: `brew install spdlog`
-* MacPorts: `sudo port install spdlog`
-* FreeBSD:  `cd /usr/ports/devel/spdlog/ && make install clean`
-* Fedora: `yum install spdlog`
-* Gentoo: `emerge dev-libs/spdlog`
-* Arch Linux: `pacman -S spdlog`
-* vcpkg: `vcpkg install spdlog`
-* conan: `spdlog/[>=1.4.1]`
-* conda: `conda install -c conda-forge spdlog`
-
-
-## Features
-* Very fast (see [benchmarks](#benchmarks) below).
-* Headers only or compiled version
-* Feature rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
-* **New!** [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display later on demand.
-* Asynchronous mode (optional)
-* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
-* Multi/Single threaded loggers.
-* Various log targets:
-    * Rotating log files.
-    * Daily log files.
-    * Console logging (colors supported).
-    * syslog.
-    * Windows debugger (```OutputDebugString(..)```)
-    * Easily extendable with custom log targets  (just implement a single function in the [sink](include/spdlog/sinks/sink.h) interface).
-* Log filtering - log levels can be modified in runtime as well as in compile time.
-* Support for loading log levels from argv or from environment var.
-
- 
-## Usage samples
-
-#### Basic usage
-```c++
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/basic_file_sink.h"
-
-int main() 
-{
-    spdlog::info("Welcome to spdlog!");
-    spdlog::error("Some error message with arg: {}", 1);
-    
-    spdlog::warn("Easy padding in numbers like {:08d}", 12);
-    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    spdlog::info("Support for floats {:03.2f}", 1.23456);
-    spdlog::info("Positional args are {1} {0}..", "too", "supported");
-    spdlog::info("{:<30}", "left aligned");
-    
-    spdlog::set_level(spdlog::level::debug); // Set global log level to debug
-    spdlog::debug("This message should be displayed..");    
-    
-    // change log pattern
-    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
-    
-    // Compile time log levels
-    // define SPDLOG_ACTIVE_LEVEL to desired level
-    SPDLOG_TRACE("Some trace message with param {}", 42);
-    SPDLOG_DEBUG("Some debug message");
-    
-    // Set the default logger to file logger
-    auto file_logger = spdlog::basic_logger_mt("basic_logger", "logs/basic.txt");
-    spdlog::set_default_logger(file_logger);            
-}
-
-```
-#### Load log levels from env variable or from argv
-```c++
-#include "spdlog/cfg/env.h"
-void load_levels_example()
-{
-    // Set the log level to "info" and mylogger to to "trace":
-    // SPDLOG_LEVEL=info,mylogger=trace && ./example
-    spdlog::cfg::load_env_levels();
-    // or from command line:
-    // ./example SPDLOG_LEVEL=info,mylogger=trace
-    // #include "spdlog/cfg/argv.h" // for loading levels from argv
-    // spdlog::cfg::load_argv_levels(args, argv);
-}
-```
-#### Create stdout/stderr logger object
-```c++
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-void stdout_example()
-{
-    // create color multi threaded logger
-    auto console = spdlog::stdout_color_mt("console");    
-    auto err_logger = spdlog::stderr_color_mt("stderr");    
-    spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
-}
-```
----
-#### Basic file logger
-```c++
-#include "spdlog/sinks/basic_file_sink.h"
-void basic_logfile_example()
-{
-    try 
-    {
-        auto my_logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
-    }
-    catch (const spdlog::spdlog_ex &ex)
-    {
-        std::cout << "Log init failed: " << ex.what() << std::endl;
-    }
-}
-```
----
-#### Rotating files
-```c++
-#include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example()
-{
-    // Create a file rotating logger with 5mb size max and 3 rotated files
-    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-}
-```
-
----
-#### Daily files
-```c++
-
-#include "spdlog/sinks/daily_file_sink.h"
-void daily_example()
-{
-    // Create a daily logger - a new file is created every day on 2:30am
-    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-}
-
-```
-
----
-#### Backtrace support
-```c++
-// Loggers can store in a ring buffer all messages (including debug/trace) and display later on demand.
-// When needed, call dump_backtrace() to see them
-spdlog::enable_backtrace(32); // create ring buffer with capacity of 32  messages
-// or my_logger->enable_backtrace(32)..
-for(int i = 0; i < 100; i++)
-{
-  spdlog::debug("Backtrace message {}", i); // not logged yet..
-}
-// e.g. if some error happened:
-spdlog::dump_backtrace(); // log them now! show the last 32 messages
-
-// or my_logger->dump_backtrace(32)..
-```
-
----
-#### Periodic flush
-```c++
-// periodically flush all *registered* loggers every 3 seconds:
-// warning: only use if all your loggers are thread safe ("_mt" loggers)
-spdlog::flush_every(std::chrono::seconds(3));
-
-```
-
----
-#### Log binary data in hex
-```c++
-// many types of std::container<char> types can be used.
-// ranges are supported too.
-// format flags:
-// {:X} - print in uppercase.
-// {:s} - don't separate each byte with space.
-// {:p} - don't print the position on each line start.
-// {:n} - don't split the output to lines.
-
-#include "spdlog/fmt/bin_to_hex.h"
-
-void binary_example()
-{
-    auto console = spdlog::get("console");
-    std::array<char, 80> buf;
-    console->info("Binary example: {}", spdlog::to_hex(buf));
-    console->info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-    // more examples:
-    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
-}
-
-```
-
----
-#### Logger with multi sinks - each with different format and log level
-```c++
-
-// create logger with 2 targets with different log levels and formats.
-// the console will show only warnings or errors, while the file will log all.
-void multi_sink_example()
-{
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::warn);
-    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
-
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::trace);
-
-    spdlog::logger logger("multi_sink", {console_sink, file_sink});
-    logger.set_level(spdlog::level::debug);
-    logger.warn("this should appear in both console and file");
-    logger.info("this message should not appear in the console, only in the file");
-}
-```
-
----
-#### Asynchronous logging
-```c++
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-void async_example()
-{
-    // default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread.
-    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-    // alternatively:
-    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");   
-}
-
-```
-
----
-#### Asynchronous logger with multi sinks  
-```c++
-#include "spdlog/sinks/stdout_color_sinks.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-void multi_sink_example2()
-{
-    spdlog::init_thread_pool(8192, 1);
-    auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >();
-    auto rotating_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("mylog.txt", 1024*1024*10, 3);
-    std::vector<spdlog::sink_ptr> sinks {stdout_sink, rotating_sink};
-    auto logger = std::make_shared<spdlog::async_logger>("loggername", sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::block);
-    spdlog::register_logger(logger);
-}
-```
- 
----
-#### User defined types
-```c++
-// user defined types logging by implementing operator<<
-#include "spdlog/fmt/ostr.h" // must be included
-struct my_type
-{
-    int i;
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
-    {
-        return os << "[my_type i=" << c.i << "]";
-    }
-};
-
-void user_defined_example()
-{
-    spdlog::get("console")->info("user defined type: {}", my_type{14});
-}
-
-```
-
----
-#### User defined flags in the log pattern
-```c++ 
-// Log patterns can contain custom flags.
-// the following example will add new flag '%*' - which will be bound to a <my_formatter_flag> instance.
-#include "spdlog/pattern_formatter.h"
-class my_formatter_flag : public spdlog::custom_flag_formatter
-{
-public:
-    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
-    {
-        std::string some_txt = "custom-flag";
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-
-    std::unique_ptr<custom_flag_formatter> clone() const override
-    {
-        return spdlog::details::make_unique<my_formatter_flag>();
-    }
-};
-
-void custom_flags_example()
-{    
-    auto formatter = std::make_unique<spdlog::pattern_formatter>();
-    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    spdlog::set_formatter(std::move(formatter));
-}
-
-```
-
----
-#### Custom error handler
-```c++
-void err_handler_example()
-{
-    // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** LOGGER ERROR ***: {}", msg); });
-    spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-}
-
-```
-
-
----
-#### syslog 
-```c++
-#include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
-{
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-}
-```
----
-#### Android example 
-```c++
-#include "spdlog/sinks/android_sink.h"
-void android_example()
-{
-    std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-```
-
-## Benchmarks
-
-Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
-
-#### Synchronous mode
-```
-[info] **************************************************************
-[info] Single thread, 1,000,000 iterations
-[info] **************************************************************
-[info] basic_st         Elapsed: 0.17 secs        5,777,626/sec
-[info] rotating_st      Elapsed: 0.18 secs        5,475,894/sec
-[info] daily_st         Elapsed: 0.20 secs        5,062,659/sec
-[info] empty_logger     Elapsed: 0.07 secs       14,127,300/sec
-[info] **************************************************************
-[info] C-string (400 bytes). Single thread, 1,000,000 iterations
-[info] **************************************************************
-[info] basic_st         Elapsed: 0.41 secs        2,412,483/sec
-[info] rotating_st      Elapsed: 0.72 secs        1,389,196/sec
-[info] daily_st         Elapsed: 0.42 secs        2,393,298/sec
-[info] null_st          Elapsed: 0.04 secs       27,446,957/sec
-[info] **************************************************************
-[info] 10 threads, competing over the same logger object, 1,000,000 iterations
-[info] **************************************************************
-[info] basic_mt         Elapsed: 0.60 secs        1,659,613/sec
-[info] rotating_mt      Elapsed: 0.62 secs        1,612,493/sec
-[info] daily_mt         Elapsed: 0.61 secs        1,638,305/sec
-[info] null_mt          Elapsed: 0.16 secs        6,272,758/sec
-```
-#### ASynchronous mode
-```
-[info] -------------------------------------------------
-[info] Messages     : 1,000,000
-[info] Threads      : 10
-[info] Queue        : 8,192 slots
-[info] Queue memory : 8,192 x 272 = 2,176 KB 
-[info] -------------------------------------------------
-[info] 
-[info] *********************************
-[info] Queue Overflow Policy: block
-[info] *********************************
-[info] Elapsed: 1.70784 secs     585,535/sec
-[info] Elapsed: 1.69805 secs     588,910/sec
-[info] Elapsed: 1.7026 secs      587,337/sec
-[info] 
-[info] *********************************
-[info] Queue Overflow Policy: overrun
-[info] *********************************
-[info] Elapsed: 0.372816 secs    2,682,285/sec
-[info] Elapsed: 0.379758 secs    2,633,255/sec
-[info] Elapsed: 0.373532 secs    2,677,147/sec
-
-```
-
-## Documentation
-Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.

third_party/spdlog/appveyor.yml

@@ -1,38 +0,0 @@
-version: 1.0.{build}
-image: Visual Studio 2017
-environment:
-  matrix:
-  - GENERATOR: '"Visual Studio 14 2015"'
-    BUILD_TYPE: Debug
-    WCHAR: 'OFF'
-  - GENERATOR: '"Visual Studio 14 2015"'
-    BUILD_TYPE: Release
-    WCHAR: 'ON'
-  - GENERATOR: '"Visual Studio 14 2015 Win64"'
-    BUILD_TYPE: Debug
-    WCHAR: 'ON'
-  - GENERATOR: '"Visual Studio 14 2015 Win64"'
-    BUILD_TYPE: Release
-    WCHAR: 'ON'
-  - GENERATOR: '"Visual Studio 15 2017 Win64"'
-    BUILD_TYPE: Debug
-    WCHAR: 'ON'
-  - GENERATOR: '"Visual Studio 15 2017 Win64"'
-    BUILD_TYPE: Release
-    WCHAR: 'OFf'
-build_script:
-- cmd: >-
-    set
-    
-    mkdir build
-    
-    cd build 
-
-    set PATH=%PATH%:C:\Program Files\Git\usr\bin
-    
-    cmake .. -G %GENERATOR% -DCMAKE_BUILD_TYPE=%BUILD_TYPE% -DSPDLOG_WCHAR_SUPPORT=%WCHAR% -DSPDLOG_BUILD_EXAMPLE=ON -DSPDLOG_BUILD_EXAMPLE_HO=ON -DSPDLOG_BUILD_TESTS=ON -DSPDLOG_BUILD_TESTS_HO=OFF -DSPDLOG_ENABLE_WARNINGS=ON
-
-    cmake --build . --config %BUILD_TYPE%
-
-test_script:
-- ctest -VV -C "%BUILD_TYPE%"

third_party/spdlog/bench/CMakeLists.txt

@@ -1,26 +0,0 @@
-# Copyright(c) 2019 spdlog authors
-# Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.1)
-project(spdlog_bench CXX)
-
-if(NOT TARGET spdlog)
-  # Stand-alone build
-  find_package(spdlog CONFIG REQUIRED)
-endif()
-
-find_package(Threads REQUIRED)
-find_package(benchmark CONFIG REQUIRED)
-
-add_executable(bench bench.cpp)
-spdlog_enable_warnings(bench)
-target_link_libraries(bench PRIVATE spdlog::spdlog)
-
-add_executable(async_bench async_bench.cpp)
-target_link_libraries(async_bench PRIVATE spdlog::spdlog)
-
-add_executable(latency latency.cpp)
-target_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog)
-
-add_executable(formatter-bench formatter-bench.cpp)
-target_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog)

third_party/spdlog/bench/async_bench.cpp

@@ -1,179 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-
-#include "utils.h"
-#include <atomic>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <thread>
-
-using namespace std;
-using namespace std::chrono;
-using namespace spdlog;
-using namespace spdlog::sinks;
-using namespace utils;
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996) // disable fopen warning under msvc
-#endif                          // _MSC_VER
-
-int count_lines(const char *filename)
-{
-    int counter = 0;
-    auto *infile = fopen(filename, "r");
-    int ch;
-    while (EOF != (ch = getc(infile)))
-    {
-        if ('\n' == ch)
-            counter++;
-    }
-    fclose(infile);
-
-    return counter;
-}
-
-void verify_file(const char *filename, int expected_count)
-{
-    spdlog::info("Verifying {} to contain {:n} line..", filename, expected_count);
-    auto count = count_lines(filename);
-    if (count != expected_count)
-    {
-        spdlog::error("Test failed. {} has {:n} lines instead of {:n}", filename, count, expected_count);
-        exit(1);
-    }
-    spdlog::info("Line count OK ({:n})\n", count);
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    int howmany = 1000000;
-    int queue_size = std::min(howmany + 2, 8192);
-    int threads = 10;
-    int iters = 3;
-
-    try
-    {
-        spdlog::set_pattern("[%^%l%$] %v");
-        if (argc == 1)
-        {
-            spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
-            return 0;
-        }
-
-        if (argc > 1)
-            howmany = atoi(argv[1]);
-        if (argc > 2)
-            threads = atoi(argv[2]);
-        if (argc > 3)
-        {
-            queue_size = atoi(argv[3]);
-            if (queue_size > 500000)
-            {
-                spdlog::error("Max queue size allowed: 500,000");
-                exit(1);
-            }
-        }
-
-        if (argc > 4)
-            iters = atoi(argv[4]);
-
-        auto slot_size = sizeof(spdlog::details::async_msg);
-        spdlog::info("-------------------------------------------------");
-        spdlog::info("Messages     : {:n}", howmany);
-        spdlog::info("Threads      : {:n}", threads);
-        spdlog::info("Queue        : {:n} slots", queue_size);
-        spdlog::info("Queue memory : {:n} x {} = {:n} KB ", queue_size, slot_size, (queue_size * slot_size) / 1024);
-        spdlog::info("Total iters  : {:n}", iters);
-        spdlog::info("-------------------------------------------------");
-
-        const char *filename = "logs/basic_async.log";
-        spdlog::info("");
-        spdlog::info("*********************************");
-        spdlog::info("Queue Overflow Policy: block");
-        spdlog::info("*********************************");
-        for (int i = 0; i < iters; i++)
-        {
-            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
-            bench_mt(howmany, std::move(logger), threads);
-            // verify_file(filename, howmany);
-        }
-
-        spdlog::info("");
-        spdlog::info("*********************************");
-        spdlog::info("Queue Overflow Policy: overrun");
-        spdlog::info("*********************************");
-        // do same test but discard oldest if queue is full instead of blocking
-        filename = "logs/basic_async-overrun.log";
-        for (int i = 0; i < iters; i++)
-        {
-            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger =
-                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::overrun_oldest);
-            bench_mt(howmany, std::move(logger), threads);
-        }
-        spdlog::shutdown();
-    }
-    catch (std::exception &ex)
-    {
-        std::cerr << "Error: " << ex.what() << std::endl;
-        perror("Last error");
-        return 1;
-    }
-    return 0;
-}
-
-void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany)
-{
-    for (int i = 0; i < howmany; i++)
-    {
-        logger->info("Hello logger: msg number {}", i);
-    }
-}
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count)
-{
-    using std::chrono::high_resolution_clock;
-    vector<thread> threads;
-    auto start = high_resolution_clock::now();
-
-    int msgs_per_thread = howmany / thread_count;
-    int msgs_per_thread_mod = howmany % thread_count;
-    for (int t = 0; t < thread_count; ++t)
-    {
-        if (t == 0 && msgs_per_thread_mod)
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
-        else
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
-    }
-
-    for (auto &t : threads)
-    {
-        t.join();
-    };
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info("Elapsed: {} secs\t {:n}/sec", delta_d, int(howmany / delta_d));
-}

third_party/spdlog/bench/bench.cpp

@@ -1,238 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-#include "utils.h"
-#include <atomic>
-#include <cstdlib> // EXIT_FAILURE
-#include <memory>
-#include <string>
-#include <thread>
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log);
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
-
-// void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log);
-// void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log);
-
-static const size_t file_size = 30 * 1024 * 1024;
-static const size_t rotating_files = 5;
-static const int max_threads = 1000;
-
-void bench_threaded_logging(int threads, int iters)
-{
-    spdlog::info("**************************************************************");
-    spdlog::info("Multi threaded: {:n} threads, {:n} messages", threads, iters);
-    spdlog::info("**************************************************************");
-
-    auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
-    bench_mt(iters, std::move(basic_mt), threads);
-    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
-    basic_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(basic_mt_tracing), threads);
-
-    spdlog::info("");
-    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
-    bench_mt(iters, std::move(rotating_mt), threads);
-    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
-    rotating_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(rotating_mt_tracing), threads);
-
-    spdlog::info("");
-    auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
-    bench_mt(iters, std::move(daily_mt), threads);
-    auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log");
-    daily_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(daily_mt_tracing), threads);
-
-    spdlog::info("");
-    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
-    empty_logger->set_level(spdlog::level::off);
-    bench(iters, empty_logger);
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
-}
-
-void bench_single_threaded(int iters)
-{
-    spdlog::info("**************************************************************");
-    spdlog::info("Single threaded: {:n} messages", iters);
-    spdlog::info("**************************************************************");
-
-    auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
-    bench(iters, std::move(basic_st));
-
-    auto basic_st_tracing = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
-    bench(iters, std::move(basic_st_tracing));
-
-    spdlog::info("");
-    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
-    bench(iters, std::move(rotating_st));
-    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
-    rotating_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(rotating_st_tracing));
-
-    spdlog::info("");
-    auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
-    bench(iters, std::move(daily_st));
-    auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log");
-    daily_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(daily_st_tracing));
-
-    spdlog::info("");
-    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
-    empty_logger->set_level(spdlog::level::off);
-    bench(iters, empty_logger);
-
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
-}
-
-int main(int argc, char *argv[])
-{
-    spdlog::set_automatic_registration(false);
-    spdlog::default_logger()->set_pattern("[%^%l%$] %v");
-    int iters = 250000;
-    int threads = 4;
-    try
-    {
-
-        if (argc > 1)
-        {
-            iters = std::stoi(argv[1]);
-        }
-        if (argc > 2)
-        {
-            threads = std::stoi(argv[2]);
-        }
-
-        if (threads > max_threads)
-        {
-            throw std::runtime_error(fmt::format("Number of threads exceeds maximum({}})", max_threads));
-        }
-
-        bench_single_threaded(iters);
-        bench_threaded_logging(1, iters);
-        bench_threaded_logging(threads, iters);
-    }
-    catch (std::exception &ex)
-    {
-        spdlog::error(ex.what());
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
-}
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-    using std::chrono::high_resolution_clock;
-
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        log->info("Hello logger: msg number {}", i);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-    spdlog::drop(log->name());
-}
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
-{
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-    using std::chrono::high_resolution_clock;
-
-    std::vector<std::thread> threads;
-    threads.reserve(thread_count);
-    auto start = high_resolution_clock::now();
-    for (int t = 0; t < thread_count; ++t)
-    {
-        threads.emplace_back([&]() {
-            for (int j = 0; j < howmany / thread_count; j++)
-            {
-                log->info("Hello logger: msg number {}", j);
-            }
-        });
-    }
-
-    for (auto &t : threads)
-    {
-        t.join();
-    };
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-    spdlog::drop(log->name());
-}
-
-/*
-void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        spdlog::info("Hello logger: msg number {}", i);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-}
-
-void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-
-    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
-                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
-                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
-                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
-                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
-
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        spdlog::log(spdlog::level::info, msg);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-}
-
-*/

third_party/spdlog/bench/formatter-bench.cpp

@@ -1,80 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#include "benchmark/benchmark.h"
-
-#include "spdlog/spdlog.h"
-#include "spdlog/pattern_formatter.h"
-
-void bench_formatter(benchmark::State &state, std::string pattern)
-{
-    auto formatter = spdlog::details::make_unique<spdlog::pattern_formatter>(pattern);
-    spdlog::memory_buf_t dest;
-    std::string logger_name = "logger-name";
-    const char *text = "Hello. This is some message with length of 80                                   ";
-
-    spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
-
-    for (auto _ : state)
-    {
-        dest.clear();
-        formatter->format(msg, dest);
-        benchmark::DoNotOptimize(dest);
-    }
-}
-
-void bench_formatters()
-{
-    // basic patterns(single flag)
-    std::string all_flags = "+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%";
-    std::vector<std::string> basic_patterns;
-    for (auto &flag : all_flags)
-    {
-        auto pattern = std::string("%") + flag;
-        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-
-        //        pattern = std::string("%16") + flag;
-        //        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-        //
-        //        // bench center padding
-        //        pattern = std::string("%=16") + flag;
-        //        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-    }
-
-    // complex patterns
-    std::vector<std::string> patterns = {
-        "[%D %X] [%l] [%n] %v",
-        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] %v",
-        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v",
-    };
-    for (auto &pattern : patterns)
-    {
-        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern)->Iterations(2500000);
-    }
-}
-
-int main(int argc, char *argv[])
-{
-
-    spdlog::set_pattern("[%^%l%$] %v");
-    if (argc != 2)
-    {
-        spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
-        exit(1);
-    }
-
-    std::string pattern = argv[1];
-    if (pattern == "all")
-    {
-        bench_formatters();
-    }
-    else
-    {
-        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-    }
-    benchmark::Initialize(&argc, argv);
-    benchmark::RunSpecifiedBenchmarks();
-}

third_party/spdlog/bench/latency.cpp

@@ -1,166 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// latency.cpp : spdlog latency benchmarks
-//
-
-#include "benchmark/benchmark.h"
-
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-{
-    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
-                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
-                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
-                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
-                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
-
-    for (auto _ : state)
-    {
-        logger->info(msg);
-    }
-}
-
-void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-{
-    int i = 0;
-    for (auto _ : state)
-    {
-        logger->info("Hello logger: msg number {}...............", ++i);
-    }
-}
-
-void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-{
-    int i = 0;
-    benchmark::DoNotOptimize(i);      // prevent unused warnings
-    benchmark::DoNotOptimize(logger); // prevent unused warnings
-    for (auto _ : state)
-    {
-        SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
-        SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
-    }
-}
-
-#ifdef __linux__
-void bench_dev_null()
-{
-    auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
-    spdlog::drop("/dev/null_st");
-
-    auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
-    spdlog::drop("/dev/null_mt");
-}
-#endif // __linux__
-
-int main(int argc, char *argv[])
-{
-    using spdlog::sinks::null_sink_mt;
-    using spdlog::sinks::null_sink_st;
-
-    size_t file_size = 30 * 1024 * 1024;
-    size_t rotating_files = 5;
-    int n_threads = benchmark::CPUInfo::Get().num_cpus;
-
-    auto full_bench = argc > 1 && std::string(argv[1]) == "full";
-
-    // disabled loggers
-    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    disabled_logger->set_level(spdlog::level::off);
-    benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
-    // with backtrace of 64
-    auto tracing_disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    tracing_disabled_logger->enable_backtrace(64);
-    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
-
-    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
-    benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
-    // with backtrace of 64
-    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    tracing_null_logger_st->enable_backtrace(64);
-    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
-
-#ifdef __linux
-    bench_dev_null();
-#endif // __linux__
-
-    if (full_bench)
-    {
-        // basic_st
-        auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
-        benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
-        spdlog::drop("basic_st");
-        // with backtrace of 64
-        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
-        tracing_basic_st->enable_backtrace(64);
-        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
-        spdlog::drop("tracing_basic_st");
-
-        // rotating st
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
-        spdlog::drop("rotating_st");
-        // with backtrace of 64
-        auto tracing_rotating_st =
-            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
-        spdlog::drop("tracing_rotating_st");
-
-        // daily st
-        auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
-        spdlog::drop("daily_st");
-        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
-        spdlog::drop("tracing_daily_st");
-
-        //
-        // Multi threaded bench, 10 loggers using same logger concurrently
-        //
-        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
-
-        // basic_mt
-        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
-        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("basic_mt");
-
-        // rotating mt
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("rotating_mt");
-
-        // daily mt
-        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
-        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("daily_mt");
-    }
-
-    // async
-    auto queue_size = 1024 * 1024 * 3;
-    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-    auto async_logger = std::make_shared<spdlog::async_logger>(
-        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
-
-    auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
-        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-    async_logger_tracing->enable_backtrace(32);
-    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
-
-    benchmark::Initialize(&argc, argv);
-    benchmark::RunSpecifiedBenchmarks();
-}

third_party/spdlog/bench/meson.build

@@ -1,14 +0,0 @@
-benchmark = dependency('benchmark')
-
-bench_matrix = [
-  ['bench',           [spdlog_dep],            []],
-  ['async_bench',     [spdlog_dep],            []],
-  ['formatter-bench', [spdlog_dep, benchmark], ['all']],
-  ['latency',         [spdlog_dep, benchmark], []],
-]
-
-foreach i : bench_matrix
-  bench_exe = executable(i[0], i[0] + '.cpp', dependencies: i[1])
-  benchmark('bench_' + i[0], bench_exe, args: i[2])
-endforeach
-

third_party/spdlog/bench/utils.h

@@ -1,34 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <iomanip>
-#include <locale>
-#include <sstream>
-
-namespace utils {
-
-template<typename T>
-inline std::string format(const T &value)
-{
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << value;
-    return ss.str();
-}
-
-template<>
-inline std::string format(const double &value)
-{
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << std::fixed << std::setprecision(1) << value;
-    return ss.str();
-}
-
-} // namespace utils

third_party/spdlog/cmake/ide.cmake

@@ -1,18 +0,0 @@
-#---------------------------------------------------------------------------------------
-# IDE support for headers
-#---------------------------------------------------------------------------------------
-set(SPDLOG_HEADERS_DIR "${CMAKE_CURRENT_LIST_DIR}/../include")
-
-file(GLOB SPDLOG_TOP_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/*.h")
-file(GLOB SPDLOG_DETAILS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/details/*.h")
-file(GLOB SPDLOG_SINKS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/sinks/*.h")
-file(GLOB SPDLOG_FMT_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/*.h")
-file(GLOB SPDLOG_FMT_BUNDELED_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/bundled/*.h")
-set(SPDLOG_ALL_HEADERS ${SPDLOG_TOP_HEADERS} ${SPDLOG_DETAILS_HEADERS} ${SPDLOG_SINKS_HEADERS} ${SPDLOG_FMT_HEADERS} ${SPDLOG_FMT_BUNDELED_HEADERS})
-
-source_group("Header Files\\spdlog" FILES ${SPDLOG_TOP_HEADERS})
-source_group("Header Files\\spdlog\\details" FILES ${SPDLOG_DETAILS_HEADERS})
-source_group("Header Files\\spdlog\\sinks" FILES ${SPDLOG_SINKS_HEADERS})
-source_group("Header Files\\spdlog\\fmt" FILES ${SPDLOG_FMT_HEADERS})
-source_group("Header Files\\spdlog\\fmt\\bundled\\" FILES ${SPDLOG_FMT_BUNDELED_HEADERS})
-

third_party/spdlog/cmake/pch.h.in

@@ -1,258 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-// details/pattern_formatter-inl.h
-// fmt/bin_to_hex.h
-// fmt/bundled/format-inl.h
-#include <cctype>
-
-// details/file_helper-inl.h
-// details/os-inl.h
-// fmt/bundled/core.h
-// fmt/bundled/posix.h
-// logger-inl.h
-// sinks/daily_file_sink.h
-// sinks/stdout_sinks.h
-#include <cstdio>
-
-// details/os-inl.h
-// fmt/bundled/posix.h
-#include <cstdlib>
-
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// fmt/bundled/core.h
-// fmt/bundled/format-inl.h
-#include <cstring>
-
-// details/os-inl.h
-// details/os.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// fmt/bundled/chrono.h
-// sinks/daily_file_sink.h
-// sinks/rotating_file_sink-inl.h
-#include <ctime>
-
-// fmt/bundled/format-inl.h
-#include <climits>
-
-// fmt/bundled/format-inl.h
-#include <cwchar>
-
-// fmt/bundled/format-inl.h
-// fmt/bundled/format.h
-#include <cmath>
-
-// fmt/bundled/format-inl.h
-#include <cstdarg>
-
-// details/file_helper-inl.h
-// fmt/bundled/format.h
-// fmt/bundled/posix.h
-// sinks/rotating_file_sink-inl.h
-#include <cerrno>
-
-// details/circular_q.h
-// details/thread_pool-inl.h
-// fmt/bundled/format-inl.h
-#include <cassert>
-
-// async_logger-inl.h
-// cfg/helpers-inl.h
-// log_levels.h
-// common.h
-// details/file_helper-inl.h
-// details/log_msg.h
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/registry-inl.h
-// details/registry.h
-// details/tcp_client-windows.h
-// details/tcp_client.h
-// fmt/bundled/core.h
-// sinks/android_sink.h
-// sinks/ansicolor_sink.h
-// sinks/basic_file_sink.h
-// sinks/daily_file_sink.h
-// sinks/dup_filter_sink.h
-// sinks/msvc_sink.h
-// sinks/ringbuffer_sink.h
-// sinks/rotating_file_sink-inl.h
-// sinks/rotating_file_sink.h
-// sinks/syslog_sink.h
-// sinks/tcp_sink.h
-// sinks/win_eventlog_sink.h
-// sinks/wincolor_sink.h
-// spdlog.h:
-#include <string>
-
-// cfg/helpers-inl.h
-// fmt/bundled/chrono.h
-#include <sstream>
-
-// fmt/bundled/ostream.h
-// sinks/ostream_sink.h
-#include <ostream>
-
-// cfg/log_levels.h
-// details/registry-inl.h
-// details/registry.h
-#include <unordered_map>
-
-// details/circular_q.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/thread_pool.h
-// fmt/bundled/compile.h
-// logger.h
-// sinks/dist_sink.h
-// sinks/ringbuffer_sink.h
-// sinks/win_eventlog_sink.h
-#include <vector>
-
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// sinks/ansicolor_sink.h
-// sinks/syslog_sink.h
-// sinks/systemd_sink.h
-// sinks/wincolor_sink.h
-#include <array>
-
-// details/file_helper-inl.h
-// details/file_helper.h
-// sinks/rotating_file_sink-inl.h
-#include <tuple>
-
-// details/os-inl.h
-// fmt/bundled/format.h
-// fmt/bundled/printf.h
-#include <limits>
-
-// common.h
-// details/backtracer.h
-// details/null_mutex.h
-#include <atomic>
-
-// common.h
-// details/backtracer.h
-// details/null_mutex.h
-#include <locale>
-
-// common.h
-#include <initializer_list>
-
-// common.h
-#include <exception>
-
-// common.h
-// details/fmt_helper.h
-// fmt/bundled/core.h
-// fmt/bundled/ranges.h
-#include <type_traits>
-
-// cfg/helpers-inl.h
-// details/null_mutex.h
-// details/pattern_formatter-inl.h
-#include <utility>
-
-// async.h
-// async_logger-inl.h
-// common.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/registry-inl.h
-// details/registry.h
-// details/thread_pool.h
-// fmt/bundled/format.h
-// sinks/ansicolor_sink.h
-// sinks/base_sink-inl.h
-// sinks/dist_sink.h
-// sinks/stdout_sinks-inl.h
-// sinks/wincolor_sink.h
-// spdlog.h
-#include <memory>
-
-// async.h
-// common.h
-// details/backtracer.h
-// details/periodic_worker.h
-// details/registry-inl.h
-// details/registry.h
-// details/thread_pool.h
-// sinks/tcp_sink.h
-// spdlog.h
-#include <functional>
-
-// details/mpmc_blocking_q.h
-// details/periodic_worker.h
-#include <condition_variable>
-
-// details/os-inl.h
-// fmt/bundled/format.h
-// fmt/bundled/printf.h
-// sinks/dist_sink.h
-#include <algorithm>
-
-// common.h
-// details/file_helper-inl.h
-// details/fmt_helper.h
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/periodic_worker.h
-// details/registry-inl.h
-// details/registry.h
-// details/thread_pool.h
-// fmt/bundled/chrono.h
-// sinks/android_sink.h
-// sinks/daily_file_sink.h
-// sinks/dup_filter_sink.h
-// sinks/rotating_file_sink-inl.h
-// sinks/rotating_file_sink.h
-// sinks/tcp_sink.h
-// spdlog.h
-#include <chrono>
-
-// details/file_helper-inl.h
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// details/periodic_worker.h
-// details/thread_pool.h
-// sinks/android_sink.h
-#include <thread>
-
-// async.h
-// details/backtracer.h
-// details/console_globals.h
-// details/mpmc_blocking_q.h
-// details/pattern_formatter-inl.h
-// details/periodic_worker.h
-// details/registry.h
-// sinks/android_sink.h
-// sinks/ansicolor_sink.h
-// sinks/basic_file_sink.h
-// sinks/daily_file_sink.h
-// sinks/dist_sink.h
-// sinks/dup_filter_sink.h
-// sinks/msvc_sink.h
-// sinks/null_sink.h
-// sinks/ostream_sink.h
-// sinks/ringbuffer_sink.h
-// sinks/rotating_file_sink-inl.h
-// sinks/rotating_file_sink.h
-// sinks/tcp_sink.h
-// sinks/win_eventlog_sink.h
-// sinks/wincolor_sink.h
-//
-// color_sinks.cpp
-// file_sinks.cpp
-// spdlog.cpp
-// stdout_sinks.cpp
-#include <mutex>
-
-// spdlog
-#include <spdlog/common.h>

third_party/spdlog/cmake/spdlog.pc.in

@@ -1,13 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-includedir=${prefix}/include
-libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
-
-Name: lib@PROJECT_NAME@
-Description: Fast C++ logging library.
-URL: https://github.com/gabime/@PROJECT_NAME@
-Version: @SPDLOG_VERSION@
-CFlags: -I${includedir} @PKG_CONFIG_DEFINES@
-Libs: -L${libdir} -lspdlog -pthread
-Requires: @PKG_CONFIG_REQUIRES@
-

third_party/spdlog/cmake/spdlogCPack.cmake

@@ -1,50 +0,0 @@
-set(CPACK_GENERATOR "TGZ;ZIP" CACHE STRING "Semicolon separated list of generators")
-
-set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)
-set(CPACK_INSTALL_CMAKE_PROJECTS
-    "${CMAKE_BINARY_DIR}"
-    "${PROJECT_NAME}"
-    ALL
-    .
-    )
-
-set(CPACK_PROJECT_URL "https://github.com/gabime/spdlog")
-set(CPACK_PACKAGE_VENDOR "Gabi Melman")
-set(CPACK_PACKAGE_CONTACT "Gabi Melman <gmelman1@gmail.com>")
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Fast C++ logging library")
-set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
-set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
-set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
-set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
-if (PROJECT_VERSION_TWEAK)
-    set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}.${PROJECT_VERSION_TWEAK})
-endif ()
-set(CPACK_PACKAGE_RELOCATABLE ON CACHE BOOL "Build relocatable package")
-
-set(CPACK_RPM_PACKAGE_LICENSE "MIT")
-set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
-set(CPACK_RPM_PACKAGE_URL ${CPACK_PROJECT_URL})
-set(CPACK_RPM_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
-
-if (CPACK_PACKAGE_NAME)
-    set(CPACK_RPM_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
-else()
-    set(CPACK_RPM_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
-endif()
-
-if (CPACK_RPM_PACKAGE_RELEASE)
-    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}-${CPACK_RPM_PACKAGE_RELEASE}")
-endif ()
-
-if (CPACK_RPM_PACKAGE_ARCHITECTURE)
-    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.${CPACK_RPM_PACKAGE_ARCHITECTURE}")
-endif ()
-set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.rpm")
-
-if (NOT CPACK_PACKAGE_RELOCATABLE)
-    # Depend on pkgconfig rpm to create the system pkgconfig folder
-    set(CPACK_RPM_PACKAGE_REQUIRES pkgconfig)
-    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "${CPACK_PACKAGING_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-endif ()
-
-include(CPack)

third_party/spdlog/cmake/spdlogConfig.cmake.in

@@ -1,15 +0,0 @@
-# Copyright(c) 2019 spdlog authors
-# Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-find_package(Threads REQUIRED)
-
-set(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@)
-set(config_targets_file @config_targets_file@)
-
-if(SPDLOG_FMT_EXTERNAL)
-    include(CMakeFindDependencyMacro)
-    find_dependency(fmt CONFIG)
-endif()
-
-
-include("${CMAKE_CURRENT_LIST_DIR}/${config_targets_file}")

third_party/spdlog/cmake/utils.cmake

@@ -1,59 +0,0 @@
-# Get spdlog version from include/spdlog/version.h and put it in SPDLOG_VERSION
-function(spdlog_extract_version)
-	file(READ "${CMAKE_CURRENT_LIST_DIR}/include/spdlog/version.h" file_contents)
-	string(REGEX MATCH "SPDLOG_VER_MAJOR ([0-9]+)" _  "${file_contents}")
-	if(NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Could not extract major version number from spdlog/version.h")
-	endif()
-	set(ver_major ${CMAKE_MATCH_1})
-
-	string(REGEX MATCH "SPDLOG_VER_MINOR ([0-9]+)" _  "${file_contents}")
-	if(NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Could not extract minor version number from spdlog/version.h")
-	endif()
-
-	set(ver_minor ${CMAKE_MATCH_1})
-	string(REGEX MATCH "SPDLOG_VER_PATCH ([0-9]+)" _  "${file_contents}")
-	if(NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Could not extract patch version number from spdlog/version.h")
-	endif()
-	set(ver_patch ${CMAKE_MATCH_1})
-
-    set(SPDLOG_VERSION_MAJOR ${ver_major} PARENT_SCOPE)
-	set(SPDLOG_VERSION_MINOR ${ver_minor} PARENT_SCOPE)
-	set(SPDLOG_VERSION_PATCH ${ver_patch} PARENT_SCOPE)
-	set (SPDLOG_VERSION "${ver_major}.${ver_minor}.${ver_patch}" PARENT_SCOPE)
-endfunction()
-
-
-# Turn on warnings on the given target
-function(spdlog_enable_warnings target_name)
-    if(SPDLOG_BUILD_WARNINGS)
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-            list(APPEND MSVC_OPTIONS "/W3")
-            if(MSVC_VERSION GREATER  1900)  #Allow non fatal security wanrnings for msvc 2015
-                list(APPEND MSVC_OPTIONS "/WX")
-            endif()
-        endif()
-
-        target_compile_options(${target_name} PRIVATE
-            $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
-                -Wall -Wextra -Wconversion -pedantic -Wfatal-errors>
-            $<$<CXX_COMPILER_ID:MSVC>:${MSVC_OPTIONS}>)
-    endif()
-
-endfunction()
-
-
-# Enable address sanitizer (gcc/clang only)
-function(spdlog_enable_sanitizer target_name)
-	if (NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-		message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
-	endif()
-	message(STATUS "Address sanitizer enabled")
-	target_compile_options(${target_name} PRIVATE -fsanitize=address,undefined)
-	target_compile_options(${target_name} PRIVATE -fno-sanitize=signed-integer-overflow)
-	target_compile_options(${target_name} PRIVATE -fno-sanitize-recover=all)
-	target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
-	target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined -fuse-ld=gold)
-endfunction()

third_party/spdlog/cmake/version.rc.in

@@ -1,42 +0,0 @@
-#define APSTUDIO_READONLY_SYMBOLS
-#include "winres.h"
-#undef APSTUDIO_READONLY_SYMBOLS
-
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
- PRODUCTVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x40004L
- FILETYPE 0x2L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN            
-            VALUE "FileDescription", "spdlog dll\0"
-            VALUE "FileVersion", "@SPDLOG_VERSION@.0\0"
-            VALUE "InternalName", "spdlog.dll\0"
-            VALUE "LegalCopyright", "Copyright (C) spdlog\0"
-            VALUE "ProductName", "spdlog\0"
-            VALUE "ProductVersion", "@SPDLOG_VERSION@.0\0"
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
-
-
-
-

third_party/spdlog/example/CMakeLists.txt

@@ -1,25 +0,0 @@
-# Copyright(c) 2019 spdlog authors
-# Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.2)
-project(spdlog_examples CXX)
-
-if(NOT TARGET spdlog)
-    # Stand-alone build
-    find_package(spdlog REQUIRED)
-endif()
-
-#---------------------------------------------------------------------------------------
-# Example of using pre-compiled library
-#---------------------------------------------------------------------------------------
-add_executable(example example.cpp)
-target_link_libraries(example PRIVATE spdlog::spdlog)
-
-#---------------------------------------------------------------------------------------
-# Example of using header-only library
-#---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE_HO)
-    add_executable(example_header_only example.cpp)    
-    target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)
-endif()
-

third_party/spdlog/example/example.cpp

@@ -1,282 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-// spdlog usage example
-
-#include <cstdio>
-
-void load_levels_example();
-void stdout_logger_example();
-void basic_example();
-void rotating_example();
-void daily_example();
-void async_example();
-void binary_example();
-void trace_example();
-void multi_sink_example();
-void user_defined_example();
-void err_handler_example();
-void syslog_example();
-void custom_flags_example();
-
-#include "spdlog/spdlog.h"
-#include "spdlog/cfg/env.h" // for loading levels from the environment variable
-
-int main(int, char *[])
-{
-    // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
-    load_levels_example();
-
-    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
-
-    spdlog::warn("Easy padding in numbers like {:08d}", 12);
-    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    spdlog::info("Support for floats {:03.2f}", 1.23456);
-    spdlog::info("Positional args are {1} {0}..", "too", "supported");
-    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
-
-    // Runtime log levels
-    spdlog::set_level(spdlog::level::info); // Set global log level to info
-    spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
-    spdlog::debug("This message should be displayed..");
-
-    // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
-    spdlog::info("This an info message with custom format");
-    spdlog::set_pattern("%+"); // back to default format
-    spdlog::set_level(spdlog::level::info);
-
-    // Backtrace support
-    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
-    // When needed, call dump_backtrace() to see what happened:
-    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
-    for (int i = 0; i < 100; i++)
-    {
-        spdlog::debug("Backtrace message {}", i); // not logged..
-    }
-    // e.g. if some error happened:
-    spdlog::dump_backtrace(); // log them now!
-
-    try
-    {
-        stdout_logger_example();
-        basic_example();
-        rotating_example();
-        daily_example();
-        async_example();
-        binary_example();
-        multi_sink_example();
-        user_defined_example();
-        err_handler_example();
-        trace_example();
-        custom_flags_example();
-
-        // Flush all *registered* loggers using a worker thread every 3 seconds.
-        // note: registered loggers *must* be thread safe for this to work correctly!
-        spdlog::flush_every(std::chrono::seconds(3));
-
-        // Apply some function on all registered loggers
-        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
-
-        // Release all spdlog resources, and drop all loggers in the registry.
-        // This is optional (only mandatory if using windows + async log).
-        spdlog::shutdown();
-    }
-
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
-    catch (const spdlog::spdlog_ex &ex)
-    {
-        std::printf("Log initialization failed: %s\n", ex.what());
-        return 1;
-    }
-}
-
-#include "spdlog/sinks/stdout_color_sinks.h"
-// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
-void stdout_logger_example()
-{
-    // Create color multi threaded logger.
-    auto console = spdlog::stdout_color_mt("console");
-    // or for stderr:
-    // auto console = spdlog::stderr_color_mt("error-logger");
-}
-
-#include "spdlog/sinks/basic_file_sink.h"
-void basic_example()
-{
-    // Create basic file logger (not rotated).
-    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt");
-}
-
-#include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example()
-{
-    // Create a file rotating logger with 5mb size max and 3 rotated files.
-    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-}
-
-#include "spdlog/sinks/daily_file_sink.h"
-void daily_example()
-{
-    // Create a daily logger - a new file is created every day on 2:30am.
-    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-}
-
-#include "spdlog/cfg/env.h"
-void load_levels_example()
-{
-    // Set the log level to "info" and mylogger to to "trace":
-    // SPDLOG_LEVEL=info,mylogger=trace && ./example
-    spdlog::cfg::load_env_levels();
-    // or from command line:
-    // ./example SPDLOG_LEVEL=info,mylogger=trace
-    // #include "spdlog/cfg/argv.h" // for loading levels from argv
-    // spdlog::cfg::load_argv_levels(args, argv);
-}
-
-#include "spdlog/async.h"
-void async_example()
-{
-    // Default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
-    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-    // alternatively:
-    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
-
-    for (int i = 1; i < 101; ++i)
-    {
-        async_file->info("Async message #{}", i);
-    }
-}
-
-// Log binary data as hex.
-// Many types of std::container<char> types can be used.
-// Iterator ranges are supported too.
-// Format flags:
-// {:X} - print in uppercase.
-// {:s} - don't separate each byte with space.
-// {:p} - don't print the position on each line start.
-// {:n} - don't split the output to lines.
-
-#include "spdlog/fmt/bin_to_hex.h"
-void binary_example()
-{
-    std::vector<char> buf(80);
-    for (int i = 0; i < 80; i++)
-    {
-        buf.push_back(static_cast<char>(i & 0xff));
-    }
-    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
-    spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-    // more examples:
-    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
-    // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
-    // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
-}
-
-// Compile time log levels.
-// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
-void trace_example()
-{
-    // trace from default logger
-    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
-    // debug from default logger
-    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
-
-    // trace from logger object
-    auto logger = spdlog::get("file_logger");
-    SPDLOG_LOGGER_TRACE(logger, "another trace message");
-}
-
-// A logger with multiple sinks (stdout and file) - each with a different format and log level.
-void multi_sink_example()
-{
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::warn);
-    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
-
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::trace);
-
-    spdlog::logger logger("multi_sink", {console_sink, file_sink});
-    logger.set_level(spdlog::level::debug);
-    logger.warn("this should appear in both console and file");
-    logger.info("this message should not appear in the console, only in the file");
-}
-
-// User defined types logging by implementing operator<<
-#include "spdlog/fmt/ostr.h" // must be included
-struct my_type
-{
-    int i;
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
-    {
-        return os << "[my_type i=" << c.i << "]";
-    }
-};
-
-void user_defined_example()
-{
-    spdlog::info("user defined type: {}", my_type{14});
-}
-
-// Custom error handler. Will be triggered on log failure.
-void err_handler_example()
-{
-    // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
-}
-
-// syslog example (linux/osx/freebsd)
-#ifndef _WIN32
-#include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
-{
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-}
-#endif
-
-// Android example.
-#if defined(__ANDROID__)
-#include "spdlog/sinks/android_sink.h"
-void android_example()
-{
-    std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-#endif
-
-// Log patterns can contain custom flags.
-// this will add custom flag '%*' which will be bound to a <my_formatter_flag> instance
-#include "spdlog/pattern_formatter.h"
-class my_formatter_flag : public spdlog::custom_flag_formatter
-{
-public:
-    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
-    {
-        std::string some_txt = "custom-flag";
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-
-    std::unique_ptr<custom_flag_formatter> clone() const override
-    {
-        return spdlog::details::make_unique<my_formatter_flag>();
-    }
-};
-
-void custom_flags_example()
-{
-
-    using spdlog::details::make_unique; // for pre c++14
-    auto formatter = make_unique<spdlog::pattern_formatter>();
-    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    spdlog::set_formatter(std::move(formatter));
-}