uwp build fix + more ivp6 support

just have to provide OPENSSL_ROOT_DIR to cmake

.github/workflows/unittest_linux.yml

@@ -0,0 +1,13 @@
+name: linux
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: make test_make
+      run: make test_make

.github/workflows/unittest_mac_tsan_mbedtls.yml

@@ -0,0 +1,15 @@
+name: mac_tsan_mbedtls
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  mac_tsan_mbedtls:
+    runs-on: macOS-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: install mbedtls
+      run: brew install mbedtls
+    - name: make test
+      run: make test_tsan_mbedtls

.github/workflows/unittest_mac_tsan_openssl.yml

@@ -0,0 +1,15 @@
+name: mac_tsan_openssl
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  mac_tsan_openssl:
+    runs-on: macOS-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: install openssl
+      run: brew install openssl@1.1
+    - name: make test
+      run: make test_tsan_openssl

.github/workflows/unittest_mac_tsan_sectransport.yml

@@ -0,0 +1,13 @@
+name: mac_tsan_sectransport
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  mac_tsan_sectransport:
+    runs-on: macOS-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: make test_tsan
+      run: make test_tsan

.github/workflows/unittest_uwp.yml

@@ -1,48 +1,23 @@
-name: unittest
+name: uwp
 on:
   push:
     paths-ignore:
     - 'docs/**'
 
 jobs:
-  linux:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-    - name: make test
-      run: make test
-
-  mac_tsan_sectransport:
-    runs-on: macOS-latest
-    steps:
-    - uses: actions/checkout@v1
-    - name: make test_tsan
-      run: make test_tsan
-
-  mac_tsan_mbedtls:
-    runs-on: macOS-latest
-    steps:
-    - uses: actions/checkout@v1
-    - name: install mbedtls
-      run: brew install mbedtls
-    - name: make test
-      run: make test_tsan_mbedtls
-
-  windows_openssl:
+  uwp:
     runs-on: windows-latest
     steps:
     - uses: actions/checkout@v1
     - uses: seanmiddleditch/gha-setup-vsdevenv@master
+    - run: |
+        vcpkg install zlib:x64-uwp
     - run: |
         mkdir build
         cd build
-        cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_WS=1 -DUSE_TEST=1 ..
+        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0" -DCMAKE_CXX_COMPILER=cl.exe -DUSE_TEST=1 ..
     - run: cmake --build build
 
-    # Running the unittest does not work, the binary cannot be found
-    #- run: ../build/test/ixwebsocket_unittest.exe
-    # working-directory: test
-
 #
 #   Windows with OpenSSL is working but disabled as it takes 13 minutes (10 for openssl) to build with vcpkg
 #
@@ -63,4 +38,3 @@ jobs:
 #     # Running the unittest does not work, the binary cannot be found
 #     #- run: ../build/test/ixwebsocket_unittest.exe
 #     # working-directory: test
-

.github/workflows/unittest_windows.yml

@@ -0,0 +1,19 @@
+name: windows
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  windows:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: seanmiddleditch/gha-setup-vsdevenv@master
+    - run: |
+        vcpkg install zlib:x64-windows
+    - run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_WS=1 -DUSE_TEST=1 ..
+    - run: cmake --build build

.gitignore

@@ -5,3 +5,4 @@ ixsnake/ixsnake/.certs/
 site/
 ws/.certs/
 ws/.srl
+ixhttpd

CMake/FindMbedTLS.cmake

@@ -7,7 +7,7 @@ find_library(MBEDCRYPTO_LIBRARY mbedcrypto)
 set(MBEDTLS_LIBRARIES "${MBEDTLS_LIBRARY}" "${MBEDX509_LIBRARY}" "${MBEDCRYPTO_LIBRARY}")
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(MBEDTLS DEFAULT_MSG
+find_package_handle_standard_args(MbedTLS DEFAULT_MSG
     MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
 
 mark_as_advanced(MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)

CMakeLists.txt

@@ -3,7 +3,7 @@
 # Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
 #
 
-cmake_minimum_required(VERSION 3.4.1)
+cmake_minimum_required(VERSION 3.4.1...3.17.2)
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
 
 project(ixwebsocket C CXX)
@@ -12,6 +12,10 @@ set (CMAKE_CXX_STANDARD 14)
 set (CXX_STANDARD_REQUIRED ON)
 set (CMAKE_CXX_EXTENSIONS OFF)
 
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
 if (UNIX)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
 endif()
@@ -54,6 +58,7 @@ set( IXWEBSOCKET_SOURCES
 set( IXWEBSOCKET_HEADERS
     ixwebsocket/IXBench.h
     ixwebsocket/IXCancellationRequest.h
+    ixwebsocket/IXConnectionInfo.h
     ixwebsocket/IXConnectionState.h
     ixwebsocket/IXDNSLookup.h
     ixwebsocket/IXExponentialBackoff.h
@@ -119,6 +124,11 @@ if (USE_TLS)
       if (NOT USE_MBED_TLS AND NOT USE_OPEN_SSL) # unless we want something else
         set(USE_SECURE_TRANSPORT ON)
       endif()
+    # default to mbedtls on windows if nothing is configured
+    elseif (WIN32)
+      if (NOT USE_OPEN_SSL) # unless we want something else
+        set(USE_MBED_TLS ON)
+      endif()
     else() # default to OpenSSL on all other platforms
       if (NOT USE_MBED_TLS) # Unless mbedtls is requested
         set(USE_OPEN_SSL ON)
@@ -165,12 +175,14 @@ if (USE_TLS)
     if (APPLE)
       set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /usr/local/opt/openssl/lib)
       set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /usr/local/opt/openssl/include)
+
+      # This is for MacPort OpenSSL 1.0
+      # set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /opt/local/lib/openssl-1.0)
+      # set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /opt/local/include/openssl-1.0)
     endif()
 
-    # This OPENSSL_FOUND check is to help find a cmake manually configured OpenSSL
-    if (NOT OPENSSL_FOUND)
-      find_package(OpenSSL REQUIRED)
-    endif()
+    # Use OPENSSL_ROOT_DIR CMake variable if you need to use your own openssl
+    find_package(OpenSSL REQUIRED) 
     message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
 
     add_definitions(${OPENSSL_DEFINITIONS})
@@ -188,18 +200,10 @@ if (USE_TLS)
   endif()
 endif()
 
-# This ZLIB_FOUND check is to help find a cmake manually configured zlib
-if (NOT ZLIB_FOUND)
-  find_package(ZLIB)
-endif()
-if (ZLIB_FOUND)
-  include_directories(${ZLIB_INCLUDE_DIRS})
-  target_link_libraries(ixwebsocket ${ZLIB_LIBRARIES})
-else()
-  include_directories(third_party/zlib ${CMAKE_CURRENT_BINARY_DIR}/third_party/zlib)
-  add_subdirectory(third_party/zlib)
-  target_link_libraries(ixwebsocket zlibstatic)
-endif()
+# Use ZLIB_ROOT CMake variable if you need to use your own zlib
+find_package(ZLIB REQUIRED)
+include_directories(${ZLIB_INCLUDE_DIRS})
+target_link_libraries(ixwebsocket ${ZLIB_LIBRARIES})
 
 if (WIN32)
   target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
@@ -225,19 +229,29 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     target_compile_options(ixwebsocket PRIVATE /MP)
 endif()
 
-target_include_directories(ixwebsocket PUBLIC ${IXWEBSOCKET_INCLUDE_DIRS})
+target_include_directories(ixwebsocket PUBLIC
+  $<BUILD_INTERFACE:${IXWEBSOCKET_INCLUDE_DIRS}/>
+  $<INSTALL_INTERFACE:include/ixwebsocket>
+)
 
 set_target_properties(ixwebsocket PROPERTIES PUBLIC_HEADER "${IXWEBSOCKET_HEADERS}")
 
 install(TARGETS ixwebsocket
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_PREFIX}/include/ixwebsocket/
+        EXPORT ixwebsocket
+        ARCHIVE DESTINATION lib
+        PUBLIC_HEADER DESTINATION include/ixwebsocket/
 )
 
+install(EXPORT ixwebsocket
+        FILE ixwebsocket-config.cmake
+        NAMESPACE ixwebsocket::
+        DESTINATION lib/cmake/ixwebsocket)
+
 if (USE_WS OR USE_TEST)
   add_subdirectory(ixcore)
   add_subdirectory(ixcrypto)
   add_subdirectory(ixcobra)
+  add_subdirectory(ixredis)
   add_subdirectory(ixsnake)
   add_subdirectory(ixsentry)
   add_subdirectory(ixbots)
@@ -251,7 +265,3 @@ if (USE_WS OR USE_TEST)
       add_subdirectory(test)
   endif()
 endif()
-
-if (USE_LUAROCKS)
-    add_subdirectory(luarocks)
-endif()

README.md

@@ -1,37 +1,72 @@
 ## Hello world
 
-![Build status](https://github.com/machinezone/IXWebSocket/workflows/unittest/badge.svg)
-
 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.
 
 ```cpp
-// Required on Windows
-ix::initNetSystem();
+/*
+ *  main.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ *
+ *  Super simple standalone example. See ws folder, unittest and doc/usage.md for more.
+ *
+ *  On macOS
+ *  $ mkdir -p build ; cd build ; cmake -DUSE_TLS=1 .. ; make -j ; make install
+ *  $ clang++ --std=c++14 --stdlib=libc++ main.cpp -lixwebsocket -lz -framework Security -framework Foundation
+ *  $ ./a.out
+ */
 
-// Our websocket object
-ix::WebSocket webSocket;
+#include <ixwebsocket/IXNetSystem.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <iostream>
 
-std::string url("ws://localhost:8080/");
-webSocket.setUrl(url);
+int main()
+{
+    // Required on Windows
+    ix::initNetSystem();
 
-// Setup a callback to be fired (in a background thread, watch out for race conditions !)
-// when a message or an event (open, close, error) is received
-webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
-    {
-        if (msg->type == ix::WebSocketMessageType::Message)
+    // Our websocket object
+    ix::WebSocket webSocket;
+
+    std::string url("wss://echo.websocket.org");
+    webSocket.setUrl(url);
+
+    std::cout << "Connecting to " << url << "..." << std::endl;
+
+    // Setup a callback to be fired (in a background thread, watch out for race conditions !)
+    // when a message or an event (open, close, error) is received
+    webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
         {
-            std::cout << msg->str << std::endl;
+            if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                std::cout << "received message: " << msg->str << std::endl;
+            }
+            else if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                std::cout << "Connection established" << std::endl;
+            }
         }
+    );
+
+    // Now that our callback is setup, we can start our background thread and receive messages
+    webSocket.start();
+
+    // Send a message to the server (default to TEXT mode)
+    webSocket.send("hello world");
+
+    while (true)
+    {
+        std::string text;
+        std::cout << "> " << std::flush;
+        std::getline(std::cin, text);
+
+        webSocket.send(text);
     }
-);
 
-// Now that our callback is setup, we can start our background thread and receive messages
-webSocket.start();
-
-// Send a message to the server (default to TEXT mode)
-webSocket.send("hello world");
+    return 0;
+}
 ```
 
 Interested? Go read the [docs](https://machinezone.github.io/IXWebSocket/)! If things don't work as expected, please create an issue on GitHub, or even better a pull request if you know how to fix your problem.
@@ -45,3 +80,27 @@ IXWebSocket client code is autobahn compliant beginning with the 6.0.0 version.
 If your company or project is using this library, feel free to open an issue or PR to amend this list.
 
 - [Machine Zone](https://www.mz.com)
+- [Tokio](https://gitlab.com/HCInk/tokio), a discord library focused on audio playback with node bindings.
+- [libDiscordBot](https://github.com/tostc/libDiscordBot/tree/master), an easy to use Discord-bot framework.
+- [gwebsocket](https://github.com/norrbotten/gwebsocket), a websocket (lua) module for Garry's Mod
+- [DisCPP](https://github.com/DisCPP/DisCPP), a simple but feature rich Discord API wrapper
+
+## Continuous Integration
+
+| OS                | TLS               | Sanitizer         | Status            |
+|-------------------|-------------------|-------------------|-------------------|
+| Linux             | OpenSSL           | None              | [![Build2][1]][7] |
+| macOS             | Secure Transport  | Thread Sanitizer  | [![Build2][2]][7] |
+| macOS             | OpenSSL           | Thread Sanitizer  | [![Build2][3]][7] |
+| macOS             | MbedTLS           | Thread Sanitizer  | [![Build2][4]][7] |
+| Windows           | Disabled          | None              | [![Build2][5]][7] |
+| UWP               | Disabled          | None              | [![Build2][6]][7] |
+
+[1]: https://github.com/machinezone/IXWebSocket/workflows/linux/badge.svg
+[2]: https://github.com/machinezone/IXWebSocket/workflows/mac_tsan_sectransport/badge.svg
+[3]: https://github.com/machinezone/IXWebSocket/workflows/mac_tsan_openssl/badge.svg
+[4]: https://github.com/machinezone/IXWebSocket/workflows/mac_tsan_mbedtls/badge.svg
+[5]: https://github.com/machinezone/IXWebSocket/workflows/windows/badge.svg
+[6]: https://github.com/machinezone/IXWebSocket/workflows/uwp/badge.svg
+[7]: https://github.com/machinezone/IXWebSocket
+

docker/Dockerfile.alpine

@@ -1,8 +1,8 @@
-FROM alpine:3.11 as build
+FROM alpine:3.12 as build
 
 RUN apk add --no-cache \
     gcc g++ musl-dev linux-headers \
-    cmake mbedtls-dev make zlib-dev
+    cmake mbedtls-dev make zlib-dev python3-dev ninja
 
 RUN addgroup -S app && \
     adduser -S -G app app && \
@@ -18,9 +18,9 @@ USER app
 RUN make ws_mbedtls_install && \
     sh tools/trim_repo_for_docker.sh
 
-FROM alpine:3.11 as runtime
+FROM alpine:3.12 as runtime
 
-RUN apk add --no-cache libstdc++ mbedtls ca-certificates && \
+RUN apk add --no-cache libstdc++ mbedtls ca-certificates python3 && \
     addgroup -S app && \
     adduser -S -G app app
 

docs/CHANGELOG.md

@@ -1,6 +1,138 @@
 # Changelog
 All changes to this project will be documented in this file.
 
+## [9.9.0] - 2020-07-08
+
+(socket+websocket+http+redis+snake servers) expose the remote ip and remote port when a new connection is made
+
+## [9.8.6] - 2020-07-06
+
+(cmake) change the way zlib and openssl are searched
+
+## [9.8.5] - 2020-07-06
+
+(cobra python bots) remove the test which stop the bot when events do not follow cobra metrics system schema with an id and a device entry
+
+## [9.8.4] - 2020-06-26
+
+(cobra bots) remove bots which is not required now that we can use Python extensions
+
+## [9.8.3] - 2020-06-25
+
+(cmake) new python code is optional and enabled at cmake time with -DUSE_PYTHON=1
+
+## [9.8.2] - 2020-06-24
+
+(cobra bots) new cobra metrics bot to send data to statsd using Python for processing the message
+
+## [9.8.1] - 2020-06-19
+
+(cobra metrics to statsd bot) fps slow frame info : do not include os name
+
+## [9.8.0] - 2020-06-19
+
+(cobra metrics to statsd bot) send info about memory warnings
+
+## [9.7.9] - 2020-06-18
+
+(http client) fix deadlock when following redirects
+
+## [9.7.8] - 2020-06-18
+
+(cobra metrics to statsd bot) send info about net requests
+
+## [9.7.7] - 2020-06-17
+
+(cobra client and bots) add batch_size subscription option for retrieving multiple messages at once
+
+## [9.7.6] - 2020-06-15
+
+(websocket) WebSocketServer is not a final class, so that users can extend it (fix #215)
+
+## [9.7.5] - 2020-06-15
+
+(cobra bots) minor aesthetic change, in how we display http headers with a : then space as key value separator instead of :: with no space
+
+## [9.7.4] - 2020-06-11
+
+(cobra metrics to statsd bot) change from a statsd type of gauge to a timing one
+
+## [9.7.3] - 2020-06-11
+
+(redis cobra bots) capture most used devices in a zset
+
+## [9.7.2] - 2020-06-11
+
+(ws) add bare bone redis-cli like sub-command, with command line editing powered by libnoise
+
+## [9.7.1] - 2020-06-11
+
+(redis cobra bots) ws cobra metrics to redis / hostname invalid parsing
+
+## [9.7.0] - 2020-06-11
+
+(redis cobra bots) xadd with maxlen + fix bug in xadd client implementation and ws cobra metrics to redis command argument parsing
+
+## [9.6.9] - 2020-06-10
+
+(redis cobra bots) update the cobra to redis bot to use the bot framework, and change it to report fps metrics into redis streams.
+
+## [9.6.6] - 2020-06-04
+
+(statsd cobra bots) statsd improvement: prefix does not need a dot as a suffix, message size can be larger than 256 bytes, error handling was invalid, use core logger for logging instead of std::cerr
+
+## [9.6.5] - 2020-05-29
+
+(http server) support gzip compression
+
+## [9.6.4] - 2020-05-20
+
+(compiler fix) support clang 5 and earlier (contributed by @LunarWatcher)
+
+## [9.6.3] - 2020-05-18
+
+(cmake) revert CMake changes to fix #203 and be able to use an external OpenSSL
+
+## [9.6.2] - 2020-05-17
+
+(cmake) make install cmake files optional to not conflict with vcpkg
+
+## [9.6.1] - 2020-05-17
+
+(windows + tls) mbedtls is the default windows tls backend + add ability to load system certificates with mbdetls on windows
+
+## [9.6.0] - 2020-05-12
+
+(ixbots) add options to limit how many messages per minute should be processed
+
+## [9.5.9] - 2020-05-12
+
+(ixbots) add new class to configure a bot to simplify passing options around
+
+## [9.5.8] - 2020-05-08
+
+(openssl tls) (openssl < 1.1) logic inversion - crypto locking callback are not registered properly
+
+## [9.5.7] - 2020-05-08
+
+(cmake) default TLS back to mbedtls on Windows Universal Platform
+
+## [9.5.6] - 2020-05-06
+
+(cobra bots) add a --heartbeat_timeout option to specify when the bot should terminate because no events are received
+
+## [9.5.5] - 2020-05-06
+
+(openssl tls) when OpenSSL is older than 1.1, register the crypto locking callback to be thread safe. Should fix lots of CI failures
+
+## [9.5.4] - 2020-05-04
+
+(cobra bots) do not use a queue to store messages pending processing, let the bot handle queuing
+
+## [9.5.3] - 2020-04-29
+
+(http client) better current request cancellation support when the HttpClient destructor is invoked (see #189)
+
 ## [9.5.2] - 2020-04-27
 
 (cmake) fix cmake broken tls option parsing

docs/build.md

@@ -22,8 +22,9 @@ Options for building:
 * `-DUSE_MBED_TLS=1` will use [mbedlts](https://tls.mbed.org/) for the TLS support
 * `-DUSE_WS=1` will build the ws interactive command line tool
 * `-DUSE_TEST=1` will build the unittest
+* `-DUSE_PYTHON=1` will use Python3 for cobra bots, require Python3 to be installed.
 
-If you are on Windows, look at the [appveyor](https://github.com/machinezone/IXWebSocket/blob/master/appveyor.yml) file (not maintained much though) or rather the [github actions](https://github.com/machinezone/IXWebSocket/blob/master/.github/workflows/ccpp.yml#L40) which have instructions for building dependencies.
+If you are on Windows, look at the [appveyor](https://github.com/machinezone/IXWebSocket/blob/master/appveyor.yml) file (not maintained much though) or rather the [github actions](https://github.com/machinezone/IXWebSocket/blob/master/.github/workflows/unittest_windows.yml) which have instructions for building dependencies.
 
 It is also possible to externally include the project, so that everything is fetched over the wire when you build like so:
 
@@ -42,6 +43,19 @@ It is possible to get IXWebSocket through Microsoft [vcpkg](https://github.com/m
 ```
 vcpkg install ixwebsocket
 ```
+To use the installed package within a cmake project, use the following:
+```cmake
+ set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" CACHE STRING "") # this is super important in order for cmake to include the vcpkg search/lib paths!
+
+ # find library and its headers
+ find_path(IXWEBSOCKET_INCLUDE_DIR ixwebsocket/IXWebSocket.h)
+ find_library(IXWEBSOCKET_LIBRARY ixwebsocket)
+ # include headers
+ include_directories(${IXWEBSOCKET_INCLUDE_DIR})
+ # ...
+ target_link_libraries(${PROJECT_NAME} ... ${IXWEBSOCKET_LIBRARY}) # Cmake will automatically fail the generation if the lib was not found, i.e is set to NOTFOUNS
+
+```
 
 ### Conan
 

docs/index.md

@@ -1,5 +1,3 @@
-![Build status](https://github.com/machinezone/IXWebSocket/workflows/unittest/badge.svg)
-
 ## Introduction
 
 [*WebSocket*](https://en.wikipedia.org/wiki/WebSocket) is a computer communications protocol, providing full-duplex and bi-directionnal communication channels over a single TCP connection. *IXWebSocket* is a C++ library for client and server Websocket communication, and for client and server HTTP communication. *TLS* aka *SSL* is supported. The code is derived from [easywsclient](https://github.com/dhbaird/easywsclient) and from the [Satori C SDK](https://github.com/satori-com/satori-rtm-sdk-c). It has been tested on the following platforms.

docs/usage.md

@@ -257,28 +257,31 @@ ix::WebSocketServer server(port);
 
 server.setOnConnectionCallback(
     [&server](std::shared_ptr<WebSocket> webSocket,
-              std::shared_ptr<ConnectionState> connectionState)
+              std::shared_ptr<ConnectionState> connectionState,
+              std::unique_ptr<ConnectionInfo> connectionInfo)
     {
+        std::cout << "Remote ip: " << connectionInfo->remoteIp << std::endl;
+
         webSocket->setOnMessageCallback(
             [webSocket, connectionState, &server](const ix::WebSocketMessagePtr msg)
             {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    std::cerr << "New connection" << std::endl;
+                    std::cout << "New connection" << std::endl;
 
                     // A connection state object is available, and has a default id
                     // You can subclass ConnectionState and pass an alternate factory
                     // to override it. It is useful if you want to store custom
                     // attributes per connection (authenticated bool flag, attributes, etc...)
-                    std::cerr << "id: " << connectionState->getId() << std::endl;
+                    std::cout << "id: " << connectionState->getId() << std::endl;
 
                     // The uri the client did connect to.
-                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                    std::cout << "Uri: " << msg->openInfo.uri << std::endl;
 
-                    std::cerr << "Headers:" << std::endl;
+                    std::cout << "Headers:" << std::endl;
                     for (auto it : msg->openInfo.headers)
                     {
-                        std::cerr << it.first << ": " << it.second << std::endl;
+                        std::cout << it.first << ": " << it.second << std::endl;
                     }
                 }
                 else if (msg->type == ix::WebSocketMessageType::Message)
@@ -392,6 +395,8 @@ bool ok = httpClient.performRequest(args, [](const HttpResponsePtr& response)
 // ok will be false if your httpClient is not async
 ```
 
+See this [issue](https://github.com/machinezone/IXWebSocket/issues/209) for links about uploading files with HTTP multipart.
+
 ## HTTP server API
 
 ```cpp
@@ -415,11 +420,14 @@ If you want to handle how requests are processed, implement the setOnConnectionC
 ```cpp
 setOnConnectionCallback(
     [this](HttpRequestPtr request,
-           std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr
+           std::shared_ptr<ConnectionState> /*connectionState*/,
+           std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr
     {
         // Build a string for the response
         std::stringstream ss;
-        ss << request->method
+        ss << connectionInfo->remoteIp
+           << " "
+           << request->method
            << " "
            << request->uri;
 

httpd.cpp

@@ -0,0 +1,46 @@
+/*
+ *  httpd.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ *
+ *  Buid with make httpd
+ */
+
+#include <ixwebsocket/IXHttpServer.h>
+#include <sstream>
+#include <iostream>
+
+int main(int argc, char** argv)
+{
+    if (argc != 3)
+    {
+        std::cerr << "Usage: " << argv[0]
+                  << " <port> <host>" << std::endl;
+        std::cerr << " " << argv[0] << " 9090 127.0.0.1" << std::endl;
+        std::cerr << " " << argv[0] << " 9090 0.0.0.0" << std::endl;
+        return 1;
+    }
+
+    int port;
+    std::stringstream ss;
+    ss << argv[1];
+    ss >> port;
+    std::string hostname(argv[2]);
+
+    std::cout << "Listening on " << hostname
+              << ":" << port << std::endl;
+
+    ix::HttpServer server(port, hostname);
+
+    auto res = server.listen();
+    if (!res.first)
+    {
+        std::cout << res.second << std::endl;
+        return 1;
+    }
+
+    server.start();
+    server.wait();
+
+    return 0;
+}

ixbots/CMakeLists.txt

@@ -8,16 +8,19 @@ set (IXBOTS_SOURCES
     ixbots/IXCobraToSentryBot.cpp
     ixbots/IXCobraToStatsdBot.cpp
     ixbots/IXCobraToStdoutBot.cpp
-    ixbots/IXQueueManager.cpp
+    ixbots/IXCobraMetricsToRedisBot.cpp
+    ixbots/IXCobraToPythonBot.cpp
     ixbots/IXStatsdClient.cpp
 )
 
 set (IXBOTS_HEADERS
     ixbots/IXCobraBot.h
+    ixbots/IXCobraBotConfig.h
     ixbots/IXCobraToSentryBot.h
     ixbots/IXCobraToStatsdBot.h
     ixbots/IXCobraToStdoutBot.h
-    ixbots/IXQueueManager.h
+    ixbots/IXCobraMetricsToRedisBot.h
+    ixbots/IXCobraToPythonBot.h
     ixbots/IXStatsdClient.h
 )
 
@@ -31,14 +34,24 @@ 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)
+endif()
+
 set(IXBOTS_INCLUDE_DIRS
     .
     ..
     ../ixcore
     ../ixwebsocket
     ../ixcobra
+    ../ixredis
     ../ixsentry
     ${JSONCPP_INCLUDE_DIRS}
     ${SPDLOG_INCLUDE_DIRS})
 
+if (USE_PYTHON)
+  set(IXBOTS_INCLUDE_DIRS ${IXBOTS_INCLUDE_DIRS} ${Python_INCLUDE_DIRS})
+endif()
+
 target_include_directories( ixbots PUBLIC ${IXBOTS_INCLUDE_DIRS} )

ixbots/ixbots/IXCobraBot.cpp

@@ -6,9 +6,9 @@
 
 #include "IXCobraBot.h"
 
-#include "IXQueueManager.h"
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcore/utils/IXCoreLogger.h>
+#include <ixwebsocket/IXSetThreadName.h>
 
 #include <algorithm>
 #include <chrono>
@@ -18,32 +18,35 @@
 
 namespace ix
 {
-    int64_t CobraBot::run(const CobraConfig& config,
-                          const std::string& channel,
-                          const std::string& filter,
-                          const std::string& position,
-                          bool verbose,
-                          size_t maxQueueSize,
-                          bool useQueue,
-                          bool enableHeartbeat,
-                          int runtime)
+    int64_t CobraBot::run(const CobraBotConfig& botConfig)
     {
+        auto config = botConfig.cobraConfig;
+        auto channel = botConfig.channel;
+        auto filter = botConfig.filter;
+        auto position = botConfig.position;
+        auto enableHeartbeat = botConfig.enableHeartbeat;
+        auto heartBeatTimeout = botConfig.heartBeatTimeout;
+        auto runtime = botConfig.runtime;
+        auto maxEventsPerMinute = botConfig.maxEventsPerMinute;
+        auto limitReceivedEvents = botConfig.limitReceivedEvents;
+        auto batchSize = botConfig.batchSize;
+
         ix::CobraConnection conn;
         conn.configure(config);
         conn.connect();
 
-        Json::FastWriter jsonWriter;
         std::atomic<uint64_t> sentCount(0);
         std::atomic<uint64_t> receivedCount(0);
         uint64_t sentCountTotal(0);
         uint64_t receivedCountTotal(0);
         uint64_t sentCountPerSecs(0);
         uint64_t receivedCountPerSecs(0);
+        std::atomic<int> receivedCountPerMinutes(0);
         std::atomic<bool> stop(false);
         std::atomic<bool> throttled(false);
         std::atomic<bool> fatalCobraError(false);
-
-        QueueManager queueManager(maxQueueSize);
+        std::atomic<bool> stalledConnection(false);
+        int minuteCounter = 0;
 
         auto timer = [&sentCount,
                       &receivedCount,
@@ -51,7 +54,11 @@ namespace ix
                       &receivedCountTotal,
                       &sentCountPerSecs,
                       &receivedCountPerSecs,
+                      &receivedCountPerMinutes,
+                      &minuteCounter,
+                      &conn,
                       &stop] {
+            setThreadName("Bot progress");
             while (!stop)
             {
                 //
@@ -68,16 +75,26 @@ namespace ix
                    << sentCountPerSecs
                    << " "
                    << sentCountTotal;
-                CoreLogger::info(ss.str());
+
+                if (conn.isAuthenticated())
+                {
+                    CoreLogger::info(ss.str());
+                }
 
                 receivedCountPerSecs = receivedCount - receivedCountTotal;
-                sentCountPerSecs = sentCount - receivedCountTotal;
+                sentCountPerSecs = sentCount - sentCountTotal;
 
                 receivedCountTotal += receivedCountPerSecs;
                 sentCountTotal += sentCountPerSecs;
 
                 auto duration = std::chrono::seconds(1);
                 std::this_thread::sleep_for(duration);
+
+                if (minuteCounter++ == 60)
+                {
+                    receivedCountPerMinutes = 0;
+                    minuteCounter = 0;
+                }
             }
 
             CoreLogger::info("timer thread done");
@@ -85,7 +102,14 @@ namespace ix
 
         std::thread t1(timer);
 
-        auto heartbeat = [&sentCount, &receivedCount, &stop, &enableHeartbeat] {
+        auto heartbeat = [&sentCount,
+                          &receivedCount,
+                          &stop,
+                          &enableHeartbeat,
+                          &heartBeatTimeout,
+                          &stalledConnection]
+        {
+            setThreadName("Bot heartbeat");
             std::string state("na");
 
             if (!enableHeartbeat) return;
@@ -100,12 +124,16 @@ namespace ix
 
                 if (currentState == state)
                 {
-                    CoreLogger::error("no messages received or sent for 1 minute, exiting");
-                    exit(1);
+                    ss.str("");
+                    ss << "no messages received or sent for "
+                       << heartBeatTimeout << " seconds, reconnecting";
+
+                    CoreLogger::error(ss.str());
+                    stalledConnection = true;
                 }
                 state = currentState;
 
-                auto duration = std::chrono::minutes(1);
+                auto duration = std::chrono::seconds(heartBeatTimeout);
                 std::this_thread::sleep_for(duration);
             }
 
@@ -114,40 +142,6 @@ namespace ix
 
         std::thread t2(heartbeat);
 
-        auto sender =
-            [this, &queueManager, verbose, &sentCount, &stop, &throttled, &fatalCobraError] {
-                while (true)
-                {
-                    auto data = queueManager.pop();
-                    Json::Value msg = data.first;
-                    std::string position = data.second;
-
-                    if (stop) break;
-                    if (msg.isNull()) continue;
-
-                    if (_onBotMessageCallback &&
-                        _onBotMessageCallback(msg, position, verbose, throttled, fatalCobraError))
-                    {
-                        // That might be too noisy
-                        if (verbose)
-                        {
-                            CoreLogger::info("cobra bot: sending succesfull");
-                        }
-                        ++sentCount;
-                    }
-                    else
-                    {
-                        CoreLogger::error("cobra bot: error sending");
-                    }
-
-                    if (stop) break;
-                }
-
-                CoreLogger::info("sender thread done");
-            };
-
-        std::thread t3(sender);
-
         std::string subscriptionPosition(position);
 
         conn.setEventCallback([this,
@@ -155,13 +149,13 @@ namespace ix
                                &channel,
                                &filter,
                                &subscriptionPosition,
-                               &jsonWriter,
-                               verbose,
                                &throttled,
                                &receivedCount,
+                               &receivedCountPerMinutes,
+                               maxEventsPerMinute,
+                               limitReceivedEvents,
+                               batchSize,
                                &fatalCobraError,
-                               &useQueue,
-                               &queueManager,
                                &sentCount](const CobraEventPtr& event) {
             if (event->type == ix::CobraEventType::Open)
             {
@@ -169,7 +163,7 @@ namespace ix
 
                 for (auto&& it : event->headers)
                 {
-                    CoreLogger::info(it.first + "::" + it.second);
+                    CoreLogger::info(it.first + ": " + it.second);
                 }
             }
             else if (event->type == ix::CobraEventType::Closed)
@@ -182,58 +176,34 @@ namespace ix
                 CoreLogger::info("Subscribing to " + channel);
                 CoreLogger::info("Subscribing at position " + subscriptionPosition);
                 CoreLogger::info("Subscribing with filter " + filter);
-                conn.subscribe(channel,
-                               filter,
-                               subscriptionPosition,
-                               [this,
-                                &jsonWriter,
-                                verbose,
-                                &throttled,
-                                &receivedCount,
-                                &queueManager,
-                                &useQueue,
-                                &subscriptionPosition,
-                                &fatalCobraError,
-                                &sentCount](const Json::Value& msg, const std::string& position) {
-                                   if (verbose)
-                                   {
-                                       CoreLogger::info("Subscriber received message "
-                                                        + position + " -> " + jsonWriter.write(msg));
-                                   }
+                conn.subscribe(channel, filter, subscriptionPosition, batchSize,
+                    [&sentCount, &receivedCountPerMinutes,
+                     maxEventsPerMinute, limitReceivedEvents,
+                     &throttled, &receivedCount,
+                     &subscriptionPosition, &fatalCobraError,
+                     this](const Json::Value& msg, const std::string& position) {
+                        subscriptionPosition = position;
+                        ++receivedCount;
 
-                                   subscriptionPosition = position;
+                        ++receivedCountPerMinutes;
+                        if (limitReceivedEvents)
+                        {
+                            if (receivedCountPerMinutes > maxEventsPerMinute)
+                            {
+                                return;
+                            }
+                        }
 
-                                   // If we cannot send to sentry fast enough, drop the message
-                                   if (throttled)
-                                   {
-                                       return;
-                                   }
+                        // If we cannot send to sentry fast enough, drop the message
+                        if (throttled)
+                        {
+                            return;
+                        }
 
-                                   ++receivedCount;
-
-                                   if (useQueue)
-                                   {
-                                       queueManager.add(msg, position);
-                                   }
-                                   else
-                                   {
-                                       if (_onBotMessageCallback &&
-                                           _onBotMessageCallback(
-                                               msg, position, verbose, throttled, fatalCobraError))
-                                       {
-                                           // That might be too noisy
-                                           if (verbose)
-                                           {
-                                               CoreLogger::info("cobra bot: sending succesfull");
-                                           }
-                                           ++sentCount;
-                                       }
-                                       else
-                                       {
-                                           CoreLogger::error("cobra bot: error sending");
-                                       }
-                                   }
-                               });
+                        _onBotMessageCallback(
+                            msg, position, throttled,
+                            fatalCobraError, sentCount);
+                    });
             }
             else if (event->type == ix::CobraEventType::Subscribed)
             {
@@ -281,6 +251,13 @@ namespace ix
                 std::this_thread::sleep_for(duration);
 
                 if (fatalCobraError) break;
+
+                if (stalledConnection)
+                {
+                    conn.disconnect();
+                    conn.connect();
+                    stalledConnection = false;
+                }
             }
         }
         // Run for a duration, used by unittesting now
@@ -292,6 +269,13 @@ namespace ix
                 std::this_thread::sleep_for(duration);
 
                 if (fatalCobraError) break;
+
+                if (stalledConnection)
+                {
+                    conn.disconnect();
+                    conn.connect();
+                    stalledConnection = false;
+                }
             }
         }
 
@@ -308,9 +292,6 @@ namespace ix
         // heartbeat thread
         if (t2.joinable()) t2.join();
 
-        // sentry sender thread
-        t3.join();
-
         return fatalCobraError ? -1 : (int64_t) sentCount;
     }
 
@@ -318,4 +299,22 @@ namespace ix
     {
         _onBotMessageCallback = callback;
     }
+
+    std::string CobraBot::getDeviceIdentifier(const Json::Value& msg)
+    {
+        std::string deviceId("na");
+
+        auto osName = msg["device"]["os_name"];
+        if (osName == "Android")
+        {
+            deviceId = msg["device"]["model"].asString();
+        }
+        else if (osName == "iOS")
+        {
+            deviceId = msg["device"]["hardware_model"].asString();
+        }
+
+        return deviceId;
+    }
+
 } // namespace ix

ixbots/ixbots/IXCobraBot.h

@@ -8,35 +8,28 @@
 
 #include <atomic>
 #include <functional>
-#include <ixcobra/IXCobraConfig.h>
+#include "IXCobraBotConfig.h"
 #include <json/json.h>
 #include <stddef.h>
 
 namespace ix
 {
-    using OnBotMessageCallback = std::function<bool(const Json::Value&,
+    using OnBotMessageCallback = std::function<void(const Json::Value&,
                                                     const std::string&,
-                                                    const bool verbose,
                                                     std::atomic<bool>&,
-                                                    std::atomic<bool>&)>;
+                                                    std::atomic<bool>&,
+                                                    std::atomic<uint64_t>&)>;
 
     class CobraBot
     {
     public:
         CobraBot() = default;
 
-        int64_t run(const CobraConfig& config,
-                    const std::string& channel,
-                    const std::string& filter,
-                    const std::string& position,
-                    bool verbose,
-                    size_t maxQueueSize,
-                    bool useQueue,
-                    bool enableHeartbeat,
-                    int runtime);
-
+        int64_t run(const CobraBotConfig& botConfig);
         void setOnBotMessageCallback(const OnBotMessageCallback& callback);
 
+        std::string getDeviceIdentifier(const Json::Value& msg);
+
     private:
         OnBotMessageCallback _onBotMessageCallback;
     };

ixbots/ixbots/IXCobraBotConfig.h

@@ -0,0 +1,32 @@
+/*
+ *  IXCobraBotConfig.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+#include <limits>
+#include <ixcobra/IXCobraConfig.h>
+
+#ifdef max
+#undef max
+#endif
+
+namespace ix
+{
+    struct CobraBotConfig
+    {
+        CobraConfig cobraConfig;
+        std::string channel;
+        std::string filter;
+        std::string position = std::string("$");
+        bool enableHeartbeat = true;
+        int heartBeatTimeout = 60;
+        int runtime = -1;
+        int maxEventsPerMinute = std::numeric_limits<int>::max();
+        bool limitReceivedEvents = false;
+        int batchSize = 1;
+    };
+} // namespace ix

ixbots/ixbots/IXCobraMetricsToRedisBot.cpp

@@ -0,0 +1,149 @@
+/*
+ *  IXCobraMetricsToRedisBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraMetricsToRedisBot.h"
+
+#include "IXCobraBot.h"
+#include "IXStatsdClient.h"
+#include <chrono>
+#include <ixcobra/IXCobraConnection.h>
+#include <ixcore/utils/IXCoreLogger.h>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <cctype>
+
+
+namespace
+{
+    std::string removeSpaces(const std::string& str)
+    {
+        std::string out(str);
+        out.erase(
+            std::remove_if(out.begin(), out.end(), [](unsigned char x) { return std::isspace(x); }),
+            out.end());
+
+        return out;
+    }
+}
+
+namespace ix
+{
+    bool processPerfMetricsEventSlowFrames(const Json::Value& msg,
+                                           RedisClient& redisClient,
+                                           const std::string& deviceId)
+    {
+        auto frameRateHistogramCounts = msg["data"]["FrameRateHistogramCounts"];
+
+        int slowFrames = 0;
+        slowFrames += frameRateHistogramCounts[4].asInt();
+        slowFrames += frameRateHistogramCounts[5].asInt();
+        slowFrames += frameRateHistogramCounts[6].asInt();
+        slowFrames += frameRateHistogramCounts[7].asInt();
+
+        //
+        // XADD without a device id
+        //
+        std::stringstream ss;
+        ss << msg["id"].asString() << "_slow_frames" << "."
+           << msg["device"]["game"].asString() << "."
+           << msg["device"]["os_name"].asString() << "."
+           << removeSpaces(msg["data"]["Tag"].asString());
+
+        int maxLen;
+        maxLen = 100000;
+        std::string id = ss.str();
+        std::string errMsg;
+        if (redisClient.xadd(id, std::to_string(slowFrames), maxLen, errMsg).empty())
+        {
+            CoreLogger::info(std::string("redis XADD error: ") + errMsg);
+        }
+
+        //
+        // XADD with a device id
+        //
+        ss.str(""); // reset the stringstream
+        ss << msg["id"].asString() << "_slow_frames_by_device" << "."
+           << deviceId << "."
+           << msg["device"]["game"].asString() << "."
+           << msg["device"]["os_name"].asString() << "."
+           << removeSpaces(msg["data"]["Tag"].asString());
+
+        id = ss.str();
+        maxLen = 1000;
+        if (redisClient.xadd(id, std::to_string(slowFrames), maxLen, errMsg).empty())
+        {
+            CoreLogger::info(std::string("redis XADD error: ") + errMsg);
+        }
+
+        //
+        // Add device to the device zset, and increment the score
+        // so that we know which devices are used more than others
+        // ZINCRBY myzset 1 one
+        //
+        ss.str(""); // reset the stringstream
+        ss << msg["id"].asString() << "_slow_frames_devices" << "."
+           << msg["device"]["game"].asString();
+
+        id = ss.str();
+        std::vector<std::string> args = {
+            "ZINCRBY", id, "1", deviceId
+        };
+        auto response = redisClient.send(args, errMsg);
+        if (response.first == RespType::Error)
+        {
+            CoreLogger::info(std::string("redis ZINCRBY error: ") + errMsg);
+        }
+
+        return true;
+    }
+
+    int64_t cobra_metrics_to_redis_bot(const ix::CobraBotConfig& config,
+                                       RedisClient& redisClient,
+                                       bool verbose)
+    {
+        CobraBot bot;
+
+        bot.setOnBotMessageCallback(
+            [&redisClient, &verbose, &bot]
+             (const Json::Value& msg,
+              const std::string& /*position*/,
+              std::atomic<bool>& /*throttled*/,
+              std::atomic<bool>& /*fatalCobraError*/,
+              std::atomic<uint64_t>& sentCount) -> void {
+            if (msg["device"].isNull())
+            {
+                CoreLogger::info("no device entry, skipping event");
+                return;
+            }
+
+            if (msg["id"].isNull())
+            {
+                CoreLogger::info("no id entry, skipping event");
+                return;
+            }
+
+            //
+            // Display full message with
+            if (verbose)
+            {
+                CoreLogger::info(msg.toStyledString());
+            }
+
+            bool success = false;
+            if (msg["id"].asString() == "engine_performance_metrics_id")
+            {
+                auto deviceId = bot.getDeviceIdentifier(msg);
+                success = processPerfMetricsEventSlowFrames(msg, redisClient, deviceId);
+            }
+
+            if (success) sentCount++;
+        });
+
+        return bot.run(config);
+    }
+} // namespace ix

ixbots/ixbots/IXCobraMetricsToRedisBot.h

@@ -0,0 +1,20 @@
+/*
+ *  IXCobraMetricsToRedisBot.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+#pragma once
+
+#include <cstdint>
+#include <ixredis/IXRedisClient.h>
+#include "IXCobraBotConfig.h"
+#include <stddef.h>
+#include <string>
+
+namespace ix
+{
+    int64_t cobra_metrics_to_redis_bot(const ix::CobraBotConfig& config,
+                                       RedisClient& redisClient,
+                                       bool verbose);
+} // namespace ix
+

ixbots/ixbots/IXCobraToPythonBot.cpp

@@ -0,0 +1,332 @@
+/*
+ *  IXCobraToPythonBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraToPythonBot.h"
+
+#include "IXCobraBot.h"
+#include "IXStatsdClient.h"
+#include <chrono>
+#include <ixcobra/IXCobraConnection.h>
+#include <ixcore/utils/IXCoreLogger.h>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <cctype>
+
+//
+// I cannot get Windows to easily build on CI (github action) so support
+// is disabled for now. It should be a simple fix 
+// (linking error about missing debug build)
+//
+
+#ifdef IXBOTS_USE_PYTHON
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#endif
+
+#ifdef IXBOTS_USE_PYTHON
+namespace
+{
+    //
+    // This function is unused at this point. It produce a correct output,
+    // but triggers memory leaks when called repeateadly, as I cannot figure out how to
+    // make the reference counting Python functions to work properly (Py_DECREF and friends)
+    //
+    PyObject* jsonToPythonObject(const Json::Value& val)
+    {
+        switch(val.type())
+        {
+            case Json::nullValue:
+            {
+                return Py_None;
+            }
+
+            case Json::intValue:
+            {
+                return PyLong_FromLong(val.asInt64());
+            }
+
+            case Json::uintValue:
+            {
+                return PyLong_FromLong(val.asUInt64());
+            }
+
+            case Json::realValue:
+            {
+                return PyFloat_FromDouble(val.asDouble());
+            }
+
+            case Json::stringValue:
+            {
+                return PyUnicode_FromString(val.asCString());
+            }
+
+            case Json::booleanValue:
+            {
+                return val.asBool() ? Py_True : Py_False;
+            }
+
+            case Json::arrayValue:
+            {
+                PyObject* list = PyList_New(val.size());
+                Py_ssize_t i = 0;
+                for (auto&& it = val.begin(); it != val.end(); ++it)
+                {
+                    PyList_SetItem(list, i++, jsonToPythonObject(*it));
+                }
+                return list;
+            }
+
+            case Json::objectValue:
+            {
+                PyObject* dict = PyDict_New();
+                for (auto&& it = val.begin(); it != val.end(); ++it)
+                {
+                    PyObject* key = jsonToPythonObject(it.key());
+                    PyObject* value = jsonToPythonObject(*it);
+
+                    PyDict_SetItem(dict, key, value);
+                }
+                return dict;
+            }
+        }
+    }
+}
+#endif
+
+namespace ix
+{
+    int64_t cobra_to_python_bot(const ix::CobraBotConfig& config,
+                                StatsdClient& statsdClient,
+                                const std::string& scriptPath)
+    {
+#ifndef IXBOTS_USE_PYTHON
+        CoreLogger::error("Command is disabled. "
+                          "Needs to be configured with USE_PYTHON=1");
+        return -1;
+#else
+        CobraBot bot;
+        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());
+
+        if (pyModuleName == nullptr)
+        {
+            CoreLogger::error("Python error: Cannot decode file system path");
+            PyErr_Print();
+            return false;
+        }
+
+        // Import module
+        PyObject* pyModule = PyImport_Import(pyModuleName);
+        Py_DECREF(pyModuleName);
+        if (pyModule == nullptr)
+        {
+            CoreLogger::error("Python error: Cannot import module.");
+            CoreLogger::error("Module name cannot countain dash characters.");
+            CoreLogger::error("Is PYTHONPATH set correctly ?");
+            PyErr_Print();
+            return false;
+        }
+
+        // module main funtion name is named 'run'
+        const std::string entryPoint("run");
+        PyObject* pyFunc = PyObject_GetAttrString(pyModule, entryPoint.c_str());
+
+        if (!pyFunc)
+        {
+            CoreLogger::error("run symbol is missing from module.");
+            PyErr_Print();
+            return false;
+        }
+
+        if (!PyCallable_Check(pyFunc))
+        {
+            CoreLogger::error("run symbol is not a function.");
+            PyErr_Print();
+            return false;
+        }
+
+        bot.setOnBotMessageCallback(
+            [&statsdClient, pyFunc]
+                (const Json::Value& msg,
+                 const std::string& /*position*/,
+                 std::atomic<bool>& /*throttled*/,
+                 std::atomic<bool>& fatalCobraError,
+                 std::atomic<uint64_t>& sentCount) -> void {
+            //
+            // Invoke python script here. First build function parameters, a tuple
+            //
+            const int kVersion = 1; // We can bump this and let the interface evolve
+
+            PyObject *pyArgs = PyTuple_New(2);
+            PyTuple_SetItem(pyArgs, 0, PyLong_FromLong(kVersion)); // First argument
+
+            //
+            // It would be better to create a Python object (a dictionary) 
+            // from the json msg, but it is simpler to serialize it to a string
+            // and decode it on the Python side of the fence
+            //
+            PyObject* pySerializedJson = PyUnicode_FromString(msg.toStyledString().c_str());
+            PyTuple_SetItem(pyArgs, 1, pySerializedJson); // Second argument
+
+            // Invoke the python routine
+            PyObject* pyList = PyObject_CallObject(pyFunc, pyArgs);
+
+            // Error calling the function
+            if (pyList == nullptr)
+            {
+                fatalCobraError = true;
+                CoreLogger::error("run() function call failed. Input msg: ");
+                auto serializedMsg = msg.toStyledString();
+                CoreLogger::error(serializedMsg);
+                PyErr_Print();
+                CoreLogger::error("================");
+                return;
+            }
+
+            // Invalid return type
+            if (!PyList_Check(pyList))
+            {
+                fatalCobraError = true;
+                CoreLogger::error("run() return type should be a list");
+                return;
+            }
+
+            // The result is a list of dict containing sufficient info 
+            // to send messages to statsd
+            auto listSize = PyList_Size(pyList);
+            
+            for (Py_ssize_t i = 0 ; i < listSize; ++i)
+            {
+                PyObject* dict = PyList_GetItem(pyList, i);
+
+                // Make sure this is a dict
+                if (!PyDict_Check(dict))
+                {
+                    fatalCobraError = true;
+                    CoreLogger::error("list element is not a dict");
+                    continue;
+                }
+
+                //
+                // Retrieve object kind
+                //
+                PyObject* pyKind = PyDict_GetItemString(dict, "kind");
+                if (!PyUnicode_Check(pyKind))
+                {
+                    fatalCobraError = true;
+                    CoreLogger::error("kind entry is not a string");
+                    continue;
+                }
+                std::string kind(PyUnicode_AsUTF8(pyKind));
+
+                bool counter = false;
+                bool gauge = false;
+                bool timing = false;
+
+                if (kind == "counter")
+                {
+                    counter = true;
+                }
+                else if (kind == "gauge")
+                {
+                    gauge = true;
+                }
+                else if (kind == "timing")
+                {
+                    timing = true;
+                }
+                else
+                {
+                    fatalCobraError = true;
+                    CoreLogger::error(std::string("invalid kind entry: ") + kind +
+                                      ". Supported ones are counter, gauge, timing");
+                    continue;
+                }
+
+                //
+                // Retrieve object key
+                //
+                PyObject* pyKey = PyDict_GetItemString(dict, "key");
+                if (!PyUnicode_Check(pyKey))
+                {
+                    fatalCobraError = true;
+                    CoreLogger::error("key entry is not a string");
+                    continue;
+                }
+                std::string key(PyUnicode_AsUTF8(pyKey));
+
+                //
+                // Retrieve object value and send data to statsd
+                //
+                PyObject* pyValue = PyDict_GetItemString(dict, "value");
+
+                // Send data to statsd
+                if (PyFloat_Check(pyValue))
+                {
+                    double value = PyFloat_AsDouble(pyValue);
+
+                    if (counter)
+                    {
+                        statsdClient.count(key, value);
+                    }
+                    else if (gauge)
+                    {
+                        statsdClient.gauge(key, value);
+                    }
+                    else if (timing)
+                    {
+                        statsdClient.timing(key, value);
+                    }
+                }
+                else if (PyLong_Check(pyValue))
+                {
+                    long value = PyLong_AsLong(pyValue);
+
+                    if (counter)
+                    {
+                        statsdClient.count(key, value);
+                    }
+                    else if (gauge)
+                    {
+                        statsdClient.gauge(key, value);
+                    }
+                    else if (timing)
+                    {
+                        statsdClient.timing(key, value);
+                    }
+                }
+                else
+                {
+                    fatalCobraError = true;
+                    CoreLogger::error("value entry is neither an int or a float");
+                    continue;
+                }
+
+                sentCount++; // should we update this for each statsd object sent ?
+            }
+
+            Py_DECREF(pyArgs);
+            Py_DECREF(pyList);
+        });
+
+        bool status = bot.run(config);
+
+        // Cleanup - we should do something similar in all exit case ...
+        Py_DECREF(pyFunc);
+        Py_DECREF(pyModule);
+        Py_FinalizeEx();
+
+        return status;
+#endif
+    }
+}

ixbots/ixbots/IXCobraToPythonBot.h

@@ -0,0 +1,19 @@
+/*
+ *  IXCobraMetricsToStatsdBot.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_python_bot(const ix::CobraBotConfig& config,
+                                StatsdClient& statsdClient,
+                                const std::string& scriptPath);
+} // namespace ix

ixbots/ixbots/IXCobraToSentryBot.cpp

@@ -7,7 +7,6 @@
 #include "IXCobraToSentryBot.h"
 
 #include "IXCobraBot.h"
-#include "IXQueueManager.h"
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcore/utils/IXCoreLogger.h>
 
@@ -17,101 +16,61 @@
 
 namespace ix
 {
-    int64_t cobra_to_sentry_bot(const CobraConfig& config,
-                                const std::string& channel,
-                                const std::string& filter,
-                                const std::string& position,
+    int64_t cobra_to_sentry_bot(const CobraBotConfig& config,
                                 SentryClient& sentryClient,
-                                bool verbose,
-                                size_t maxQueueSize,
-                                bool enableHeartbeat,
-                                int runtime)
+                                bool verbose)
     {
         CobraBot bot;
-        bot.setOnBotMessageCallback([&sentryClient](const Json::Value& msg,
+        bot.setOnBotMessageCallback([&sentryClient, &verbose](const Json::Value& msg,
                                                     const std::string& /*position*/,
-                                                    const bool verbose,
                                                     std::atomic<bool>& throttled,
-                                                    std::atomic<bool> &
-                                                    /*fatalCobraError*/) -> bool {
-            auto ret = sentryClient.send(msg, verbose);
-            HttpResponsePtr response = ret.first;
-
-            if (!response)
-            {
-                CoreLogger::warn("Null HTTP Response");
-                return false;
-            }
-
-            if (verbose)
-            {
-                for (auto it : response->headers)
+                                                    std::atomic<bool>& /*fatalCobraError*/,
+                                                    std::atomic<uint64_t>& sentCount) -> void {
+            sentryClient.send(msg, verbose,
+                [&sentCount, &throttled](const HttpResponsePtr& response) {
+                if (!response)
                 {
-                    CoreLogger::info(it.first + ": " + it.second);
+                    CoreLogger::warn("Null HTTP Response");
+                    return;
                 }
 
-                CoreLogger::info("Upload size: " + std::to_string(response->uploadSize));
-                CoreLogger::info("Download size: " + std::to_string(response->downloadSize));
-
-                CoreLogger::info("Status: " + std::to_string(response->statusCode));
-                if (response->errorCode != HttpErrorCode::Ok)
+                if (response->statusCode == 200)
                 {
-                    CoreLogger::info("error message: " + response->errorMsg);
+                    sentCount++;
                 }
-
-                if (response->headers["Content-Type"] != "application/octet-stream")
+                else
                 {
-                    CoreLogger::info("payload: " + response->payload);
-                }
-            }
+                    CoreLogger::error("Error sending data to sentry: " + std::to_string(response->statusCode));
+                    CoreLogger::error("Response: " + response->payload);
 
-            bool success = response->statusCode == 200;
-
-            if (!success)
-            {
-                CoreLogger::error("Error sending data to sentry: " + std::to_string(response->statusCode));
-                CoreLogger::error("Body: " + ret.second);
-                CoreLogger::error("Response: " + response->payload);
-
-                // Error 429 Too Many Requests
-                if (response->statusCode == 429)
-                {
-                    auto retryAfter = response->headers["Retry-After"];
-                    std::stringstream ss;
-                    ss << retryAfter;
-                    int seconds;
-                    ss >> seconds;
-
-                    if (!ss.eof() || ss.fail())
+                    // Error 429 Too Many Requests
+                    if (response->statusCode == 429)
                     {
-                        seconds = 30;
-                        CoreLogger::warn("Error parsing Retry-After header. "
-                                         "Using " + retryAfter + " for the sleep duration");
+                        auto retryAfter = response->headers["Retry-After"];
+                        std::stringstream ss;
+                        ss << retryAfter;
+                        int seconds;
+                        ss >> seconds;
+
+                        if (!ss.eof() || ss.fail())
+                        {
+                            seconds = 30;
+                            CoreLogger::warn("Error parsing Retry-After header. "
+                                             "Using " + retryAfter + " for the sleep duration");
+                        }
+
+                        CoreLogger::warn("Error 429 - Too Many Requests. ws will sleep "
+                                         "and retry after " + retryAfter + " seconds");
+
+                        throttled = true;
+                        auto duration = std::chrono::seconds(seconds);
+                        std::this_thread::sleep_for(duration);
+                        throttled = false;
                     }
-
-                    CoreLogger::warn("Error 429 - Too Many Requests. ws will sleep "
-                                     "and retry after " + retryAfter + " seconds");
-
-                    throttled = true;
-                    auto duration = std::chrono::seconds(seconds);
-                    std::this_thread::sleep_for(duration);
-                    throttled = false;
                 }
-            }
-
-            return success;
+            });
         });
 
-        bool useQueue = true;
-
-        return bot.run(config,
-                       channel,
-                       filter,
-                       position,
-                       verbose,
-                       maxQueueSize,
-                       useQueue,
-                       enableHeartbeat,
-                       runtime);
+        return bot.run(config);
     }
 } // namespace ix

ixbots/ixbots/IXCobraToSentryBot.h

@@ -6,19 +6,13 @@
 #pragma once
 
 #include <cstdint>
-#include <ixcobra/IXCobraConfig.h>
+#include "IXCobraBotConfig.h"
 #include <ixsentry/IXSentryClient.h>
 #include <string>
 
 namespace ix
 {
-    int64_t cobra_to_sentry_bot(const CobraConfig& config,
-                                const std::string& channel,
-                                const std::string& filter,
-                                const std::string& position,
+    int64_t cobra_to_sentry_bot(const CobraBotConfig& config,
                                 SentryClient& sentryClient,
-                                bool verbose,
-                                size_t maxQueueSize,
-                                bool enableHeartbeat,
-                                int runtime);
+                                bool verbose);
 } // namespace ix

ixbots/ixbots/IXCobraToStatsdBot.cpp

@@ -7,7 +7,6 @@
 #include "IXCobraToStatsdBot.h"
 
 #include "IXCobraBot.h"
-#include "IXQueueManager.h"
 #include "IXStatsdClient.h"
 #include <chrono>
 #include <ixcobra/IXCobraConnection.h>
@@ -54,38 +53,34 @@ namespace ix
         return val;
     }
 
-    int64_t cobra_to_statsd_bot(const ix::CobraConfig& config,
-                                const std::string& channel,
-                                const std::string& filter,
-                                const std::string& position,
+    int64_t cobra_to_statsd_bot(const ix::CobraBotConfig& config,
                                 StatsdClient& statsdClient,
                                 const std::string& fields,
                                 const std::string& gauge,
                                 const std::string& timer,
-                                bool verbose,
-                                size_t maxQueueSize,
-                                bool enableHeartbeat,
-                                int runtime)
+                                bool verbose)
     {
-        ix::CobraConnection conn;
-        conn.configure(config);
-        conn.connect();
-
         auto tokens = parseFields(fields);
 
         CobraBot bot;
         bot.setOnBotMessageCallback(
-            [&statsdClient, &tokens, &gauge, &timer](const Json::Value& msg,
+            [&statsdClient, &tokens, &gauge, &timer, &verbose](const Json::Value& msg,
                                                      const std::string& /*position*/,
-                                                     const bool verbose,
                                                      std::atomic<bool>& /*throttled*/,
-                                                     std::atomic<bool>& fatalCobraError) -> bool {
+                                                     std::atomic<bool>& fatalCobraError,
+                                                     std::atomic<uint64_t>& sentCount) -> void {
                 std::string id;
+                size_t idx = 0;
                 for (auto&& attr : tokens)
                 {
-                    id += ".";
                     auto val = extractAttr(attr, msg);
                     id += val.asString();
+
+                    // We add a dot separator unless we are processing the last token
+                    if (idx++ != tokens.size() - 1)
+                    {
+                        id += ".";
+                    }
                 }
 
                 if (gauge.empty() && timer.empty())
@@ -122,7 +117,7 @@ namespace ix
                     {
                         CoreLogger::error("Gauge " + gauge + " is not a numeric type");
                         fatalCobraError = true;
-                        return false;
+                        return;
                     }
 
                     if (verbose)
@@ -140,19 +135,9 @@ namespace ix
                     }
                 }
 
-                return true;
+                sentCount++;
             });
 
-        bool useQueue = true;
-
-        return bot.run(config,
-                       channel,
-                       filter,
-                       position,
-                       verbose,
-                       maxQueueSize,
-                       useQueue,
-                       enableHeartbeat,
-                       runtime);
+        return bot.run(config);
     }
 } // namespace ix

ixbots/ixbots/IXCobraToStatsdBot.h

@@ -7,22 +7,16 @@
 
 #include <cstdint>
 #include <ixbots/IXStatsdClient.h>
-#include <ixcobra/IXCobraConfig.h>
+#include "IXCobraBotConfig.h"
 #include <stddef.h>
 #include <string>
 
 namespace ix
 {
-    int64_t cobra_to_statsd_bot(const ix::CobraConfig& config,
-                                const std::string& channel,
-                                const std::string& filter,
-                                const std::string& position,
+    int64_t cobra_to_statsd_bot(const ix::CobraBotConfig& config,
                                 StatsdClient& statsdClient,
                                 const std::string& fields,
                                 const std::string& gauge,
                                 const std::string& timer,
-                                bool verbose,
-                                size_t maxQueueSize,
-                                bool enableHeartbeat,
-                                int runtime);
+                                bool verbose);
 } // namespace ix

ixbots/ixbots/IXCobraToStdoutBot.cpp

@@ -7,7 +7,6 @@
 #include "IXCobraToStdoutBot.h"
 
 #include "IXCobraBot.h"
-#include "IXQueueManager.h"
 #include <chrono>
 #include <iostream>
 #include <sstream>
@@ -64,16 +63,9 @@ namespace ix
         }
     }
 
-    int64_t cobra_to_stdout_bot(const CobraConfig& config,
-                                const std::string& channel,
-                                const std::string& filter,
-                                const std::string& position,
+    int64_t cobra_to_stdout_bot(const ix::CobraBotConfig& config,
                                 bool fluentd,
-                                bool quiet,
-                                bool verbose,
-                                size_t maxQueueSize,
-                                bool enableHeartbeat,
-                                int runtime)
+                                bool quiet)
     {
         CobraBot bot;
         auto jsonWriter = makeStreamWriter();
@@ -81,27 +73,16 @@ namespace ix
         bot.setOnBotMessageCallback(
             [&fluentd, &quiet, &jsonWriter](const Json::Value& msg,
                                             const std::string& position,
-                                            const bool /*verbose*/,
                                             std::atomic<bool>& /*throttled*/,
-                                            std::atomic<bool> &
-                                            /*fatalCobraError*/) -> bool {
+                                            std::atomic<bool>& /*fatalCobraError*/,
+                                            std::atomic<uint64_t>& sentCount) -> void {
                 if (!quiet)
                 {
                     writeToStdout(fluentd, jsonWriter, msg, position);
                 }
-                return true;
+                sentCount++;
             });
 
-        bool useQueue = false;
-
-        return bot.run(config,
-                       channel,
-                       filter,
-                       position,
-                       verbose,
-                       maxQueueSize,
-                       useQueue,
-                       enableHeartbeat,
-                       runtime);
+        return bot.run(config);
     }
 } // namespace ix

ixbots/ixbots/IXCobraToStdoutBot.h

@@ -6,20 +6,13 @@
 #pragma once
 
 #include <cstdint>
-#include <ixcobra/IXCobraConfig.h>
+#include "IXCobraBotConfig.h"
 #include <stddef.h>
 #include <string>
 
 namespace ix
 {
-    int64_t cobra_to_stdout_bot(const ix::CobraConfig& config,
-                                const std::string& channel,
-                                const std::string& filter,
-                                const std::string& position,
+    int64_t cobra_to_stdout_bot(const ix::CobraBotConfig& config,
                                 bool fluentd,
-                                bool quiet,
-                                bool verbose,
-                                size_t maxQueueSize,
-                                bool enableHeartbeat,
-                                int runtime);
+                                bool quiet);
 } // namespace ix

ixbots/ixbots/IXQueueManager.cpp

@@ -1,67 +0,0 @@
-/*
- *  IXQueueManager.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
- */
-
-#include "IXQueueManager.h"
-
-#include <algorithm>
-#include <vector>
-
-namespace ix
-{
-    std::pair<Json::Value, std::string> QueueManager::pop()
-    {
-        std::unique_lock<std::mutex> lock(_mutex);
-
-        if (_queues.empty())
-        {
-            Json::Value val;
-            return std::make_pair(val, std::string());
-        }
-
-        std::vector<std::string> games;
-        for (auto it : _queues)
-        {
-            games.push_back(it.first);
-        }
-
-        std::random_shuffle(games.begin(), games.end());
-        std::string game = games[0];
-
-        auto duration = std::chrono::seconds(1);
-        _condition.wait_for(lock, duration);
-
-        if (_queues[game].empty())
-        {
-            Json::Value val;
-            return std::make_pair(val, std::string());
-        }
-
-        auto msg = _queues[game].front();
-        _queues[game].pop();
-        return msg;
-    }
-
-    void QueueManager::add(const Json::Value& msg, const std::string& position)
-    {
-        std::unique_lock<std::mutex> lock(_mutex);
-
-        std::string game;
-        if (msg.isMember("device") && msg["device"].isMember("game"))
-        {
-            game = msg["device"]["game"].asString();
-        }
-
-        if (game.empty()) return;
-
-        // if the sending is not fast enough there is no point
-        // in queuing too many events.
-        if (_queues[game].size() < _maxQueueSize)
-        {
-            _queues[game].push(std::make_pair(msg, position));
-            _condition.notify_one();
-        }
-    }
-} // namespace ix

ixbots/ixbots/IXQueueManager.h

@@ -1,35 +0,0 @@
-/*
- *  IXQueueManager.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <condition_variable>
-#include <json/json.h>
-#include <map>
-#include <mutex>
-#include <queue>
-#include <stddef.h>
-
-namespace ix
-{
-    class QueueManager
-    {
-    public:
-        QueueManager(size_t maxQueueSize)
-            : _maxQueueSize(maxQueueSize)
-        {
-        }
-
-        std::pair<Json::Value, std::string> pop();
-        void add(const Json::Value& msg, const std::string& position);
-
-    private:
-        std::map<std::string, std::queue<std::pair<Json::Value, std::string>>> _queues;
-        std::mutex _mutex;
-        std::condition_variable _condition;
-        size_t _maxQueueSize;
-    };
-} // namespace ix

ixbots/ixbots/IXStatsdClient.cpp

@@ -39,21 +39,28 @@
 
 #include "IXStatsdClient.h"
 
-#include <iostream>
 #include <ixwebsocket/IXNetSystem.h>
-#include <stdio.h>
+#include <ixwebsocket/IXSetThreadName.h>
+#include <ixcore/utils/IXCoreLogger.h>
+#include <sstream>
 #include <stdlib.h>
 #include <string.h>
 
 namespace ix
 {
-    StatsdClient::StatsdClient(const std::string& host, int port, const std::string& prefix)
+    StatsdClient::StatsdClient(const std::string& host,
+                               int port,
+                               const std::string& prefix,
+                               bool verbose)
         : _host(host)
         , _port(port)
         , _prefix(prefix)
         , _stop(false)
+        , _verbose(verbose)
     {
         _thread = std::thread([this] {
+            setThreadName("Statsd");
+
             while (!_stop)
             {
                 flushQueue();
@@ -115,11 +122,15 @@ namespace ix
     {
         cleanup(key);
 
-        char buf[256];
-        snprintf(
-            buf, sizeof(buf), "%s%s:%zd|%s\n", _prefix.c_str(), key.c_str(), value, type.c_str());
+        std::stringstream ss;
+        ss << _prefix << "." << key << ":" << value << "|" << type;
 
-        enqueue(buf);
+        if (_verbose)
+        {
+            CoreLogger::info(ss.str());
+        }
+
+        enqueue(ss.str() + "\n");
         return 0;
     }
 
@@ -137,10 +148,13 @@ namespace ix
         {
             auto message = _queue.front();
             auto ret = _socket.sendto(message);
-            if (ret != 0)
+            if (ret == -1)
             {
-                std::cerr << "error: " << strerror(UdpSocket::getErrno()) << std::endl;
+                CoreLogger::error(std::string("statsd error: ") + strerror(UdpSocket::getErrno()));
             }
+
+            // we always dequeue regardless of the ability to send the message
+            // so that we keep our queue size under control
             _queue.pop_front();
         }
     }

ixbots/ixbots/IXStatsdClient.h

@@ -20,7 +20,8 @@ namespace ix
     public:
         StatsdClient(const std::string& host = "127.0.0.1",
                      int port = 8125,
-                     const std::string& prefix = "");
+                     const std::string& prefix = "",
+                     bool verbose = false);
         ~StatsdClient();
 
         bool init(std::string& errMsg);
@@ -52,6 +53,7 @@ namespace ix
         std::mutex _mutex; // for the queue
 
         std::deque<std::string> _queue;
+        bool _verbose;
     };
 
 } // end namespace ix

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -562,11 +562,13 @@ namespace ix
     void CobraConnection::subscribe(const std::string& channel,
                                     const std::string& filter,
                                     const std::string& position,
+                                    int batchSize,
                                     SubscriptionCallback cb)
     {
         // Create and send a subscribe pdu
         Json::Value body;
         body["channel"] = channel;
+        body["batch_size"] = batchSize;
 
         if (!filter.empty())
         {

ixcobra/ixcobra/IXCobraConnection.h

@@ -88,6 +88,7 @@ namespace ix
         void subscribe(const std::string& channel,
                        const std::string& filter = std::string(),
                        const std::string& position = std::string(),
+                       int batchSize = 1,
                        SubscriptionCallback cb = nullptr);
 
         /// Unsubscribe from a channel

ixcrypto/CMakeLists.txt

@@ -37,9 +37,7 @@ if (USE_MBED_TLS)
     target_include_directories(ixcrypto PUBLIC ${MBEDTLS_INCLUDE_DIRS})
     target_link_libraries(ixcrypto ${MBEDTLS_LIBRARIES})
     target_compile_definitions(ixcrypto PUBLIC IXCRYPTO_USE_MBED_TLS)
-elseif (APPLE)
-elseif (WIN32)
-else()
+elseif (USE_OPEN_SSL)
     find_package(OpenSSL REQUIRED)
     add_definitions(${OPENSSL_DEFINITIONS})
     message(STATUS "OpenSSL: " ${OPENSSL_VERSION})

ixredis/CMakeLists.txt

@@ -0,0 +1,27 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+#
+
+set (IXREDIS_SOURCES
+    ixredis/IXRedisClient.cpp
+    ixredis/IXRedisServer.cpp
+)
+
+set (IXREDIS_HEADERS
+    ixredis/IXRedisClient.h
+    ixredis/IXRedisServer.h
+)
+
+add_library(ixredis STATIC
+    ${IXREDIS_SOURCES}
+    ${IXREDIS_HEADERS}
+)
+
+set(IXREDIS_INCLUDE_DIRS
+    .
+    ..
+    ../ixcore
+    ../ixwebsocket)
+
+target_include_directories( ixredis PUBLIC ${IXREDIS_INCLUDE_DIRS} )

ixredis/ixredis/IXRedisClient.cpp

@@ -9,6 +9,7 @@
 #include <cstring>
 #include <iomanip>
 #include <iostream>
+#include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXSocketFactory.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <sstream>
@@ -250,12 +251,16 @@ namespace ix
     }
 
     std::string RedisClient::prepareXaddCommand(const std::string& stream,
-                                                const std::string& message)
+                                                const std::string& message,
+                                                int maxLen)
     {
         std::stringstream ss;
-        ss << "*5\r\n";
+        ss << "*8\r\n";
         ss << writeString("XADD");
         ss << writeString(stream);
+        ss << writeString("MAXLEN");
+        ss << writeString("~");
+        ss << writeString(std::to_string(maxLen));
         ss << writeString("*");
         ss << writeString("field");
         ss << writeString(message);
@@ -265,6 +270,7 @@ namespace ix
 
     std::string RedisClient::xadd(const std::string& stream,
                                   const std::string& message,
+                                  int maxLen,
                                   std::string& errMsg)
     {
         errMsg.clear();
@@ -275,7 +281,7 @@ namespace ix
             return std::string();
         }
 
-        std::string command = prepareXaddCommand(stream, message);
+        std::string command = prepareXaddCommand(stream, message, maxLen);
 
         bool sent = _socket->writeBytes(command, nullptr);
         if (!sent)
@@ -348,4 +354,104 @@ namespace ix
 
         return success;
     }
+
+    std::pair<RespType, std::string> RedisClient::send(
+        const std::vector<std::string>& args,
+        std::string& errMsg)
+    {
+        std::stringstream ss;
+        ss << "*";
+        ss << std::to_string(args.size());
+        ss << "\r\n";
+
+        for (auto&& arg : args)
+        {
+            ss << writeString(arg);
+        }
+
+        bool sent = _socket->writeBytes(ss.str(), nullptr);
+        if (!sent)
+        {
+            errMsg = "Cannot write bytes to socket";
+            return std::make_pair(RespType::Error, "");
+        }
+
+        return readResponse(errMsg);
+    }
+
+    std::pair<RespType, std::string> RedisClient::readResponse(std::string& errMsg)
+    {
+        // Read result
+        auto pollResult = _socket->isReadyToRead(-1);
+        if (pollResult == PollResultType::Error)
+        {
+            errMsg = "Error while polling for result";
+            return std::make_pair(RespType::Error, "");
+        }
+
+        // First line is the string length
+        auto lineResult = _socket->readLine(nullptr);
+        auto lineValid = lineResult.first;
+        auto line = lineResult.second;
+
+        if (!lineValid)
+        {
+            errMsg = "Error while polling for result";
+            return std::make_pair(RespType::Error, "");
+        }
+
+        std::string response;
+
+        if (line[0] == '+') // Simple string
+        {
+            std::stringstream ss;
+            response = line.substr(1, line.size() - 3);
+            return std::make_pair(RespType::String, response);
+        }
+        else if (line[0] == '-') // Errors
+        {
+            std::stringstream ss;
+            response = line.substr(1, line.size() - 3);
+            return std::make_pair(RespType::Error, response);
+        }
+        else if (line[0] == ':') // Integers
+        {
+            std::stringstream ss;
+            response = line.substr(1, line.size() - 3);
+            return std::make_pair(RespType::Integer, response);
+        }
+        else if (line[0] == '$') // Bulk strings
+        {
+            int stringSize;
+            {
+                std::stringstream ss;
+                ss << line.substr(1, line.size() - 1);
+                ss >> stringSize;
+            }
+
+            // Read the result, which is the stream id computed by the redis server
+            lineResult = _socket->readLine(nullptr);
+            lineValid = lineResult.first;
+            line = lineResult.second;
+
+            std::string str = line.substr(0, stringSize);
+            return std::make_pair(RespType::String, str);
+        }
+        else
+        {
+            errMsg = "Unhandled response type";
+            return std::make_pair(RespType::Unknown, std::string());
+        }
+    }
+
+    std::string RedisClient::getRespTypeDescription(RespType respType)
+    {
+        switch (respType)
+        {
+            case RespType::Integer: return "integer";
+            case RespType::Error: return "error";
+            case RespType::String: return "string";
+            default: return "unknown";
+        }
+    }
 } // namespace ix

ixredis/ixredis/IXRedisClient.h

@@ -8,12 +8,20 @@
 
 #include <atomic>
 #include <functional>
-#include <ixwebsocket/IXSocket.h>
 #include <memory>
 #include <string>
+#include <ixwebsocket/IXSocket.h>
 
 namespace ix
 {
+    enum class RespType : int
+    {
+        String = 0,
+        Error = 1,
+        Integer = 2,
+        Unknown = 3
+    };
+
     class RedisClient
     {
     public:
@@ -40,13 +48,22 @@ namespace ix
         // XADD
         std::string xadd(const std::string& channel,
                          const std::string& message,
+                         int maxLen,
                          std::string& errMsg);
-
-        std::string prepareXaddCommand(const std::string& stream, const std::string& message);
-
+        std::string prepareXaddCommand(const std::string& stream,
+                                       const std::string& message,
+                                       int maxLen);
         std::string readXaddReply(std::string& errMsg);
+        bool sendCommand(
+            const std::string& commands, int commandsCount, std::string& errMsg);
 
-        bool sendCommand(const std::string& commands, int commandsCount, std::string& errMsg);
+        // Arbitrary commands
+        std::pair<RespType, std::string> send(
+            const std::vector<std::string>& args,
+            std::string& errMsg);
+        std::pair<RespType, std::string> readResponse(std::string& errMsg);
+
+        std::string getRespTypeDescription(RespType respType);
 
         void stop();
 

ixredis/ixredis/IXRedisServer.cpp

@@ -45,8 +45,11 @@ namespace ix
     }
 
     void RedisServer::handleConnection(std::unique_ptr<Socket> socket,
-                                       std::shared_ptr<ConnectionState> connectionState)
+                                       std::shared_ptr<ConnectionState> connectionState,
+                                       std::unique_ptr<ConnectionInfo> connectionInfo)
     {
+        logInfo("New connection from remote ip " + connectionInfo->remoteIp);
+
         _connectedClientsCount++;
 
         while (!_stopHandlingConnections)
@@ -112,7 +115,7 @@ namespace ix
             it.second.erase(socket.get());
         }
 
-        for (auto it : _subscribers)
+        for (auto&& it : _subscribers)
         {
             std::stringstream ss;
             ss << "Subscription id: " << it.first << " #subscribers: " << it.second.size();

ixredis/ixredis/IXRedisServer.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include "IXSocket.h"
-#include "IXSocketServer.h"
+#include <ixwebsocket/IXSocket.h>
+#include <ixwebsocket/IXSocketServer.h>
 #include <functional>
 #include <map>
 #include <memory>
@@ -44,7 +44,8 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState) final;
+                                      std::shared_ptr<ConnectionState> connectionState,
+                                      std::unique_ptr<ConnectionInfo> connectionInfo) final;
         virtual size_t getConnectedClientsCount() final;
 
         bool startsWith(const std::string& str, const std::string& start);

ixsentry/ixsentry/IXSentryClient.cpp

@@ -226,20 +226,23 @@ namespace ix
         return _jsonWriter.write(payload);
     }
 
-    std::pair<HttpResponsePtr, std::string> SentryClient::send(const Json::Value& msg, bool verbose)
+    void SentryClient::send(
+        const Json::Value& msg,
+        bool verbose,
+        const OnResponseCallback& onResponseCallback)
     {
         auto args = _httpClient->createRequest();
+        args->url = _url;
+        args->verb = HttpClient::kPost;
         args->extraHeaders["X-Sentry-Auth"] = SentryClient::computeAuthHeader();
         args->connectTimeout = 60;
         args->transferTimeout = 5 * 60;
         args->followRedirects = true;
         args->verbose = verbose;
         args->logger = [](const std::string& msg) { CoreLogger::log(msg.c_str()); };
+        args->body = computePayload(msg);
 
-        std::string body = computePayload(msg);
-        HttpResponsePtr response = _httpClient->post(_url, body, args);
-
-        return std::make_pair(response, body);
+        _httpClient->performRequest(args, onResponseCallback);
     }
 
     // https://sentry.io/api/12345/minidump?sentry_key=abcdefgh");

ixsentry/ixsentry/IXSentryClient.h

@@ -21,12 +21,9 @@ namespace ix
         SentryClient(const std::string& dsn);
         ~SentryClient() = default;
 
-        std::pair<HttpResponsePtr, std::string> send(const Json::Value& msg, bool verbose);
-
-        Json::Value parseLuaStackTrace(const std::string& stack);
-
-        // Mostly for testing
-        void setTLSOptions(const SocketTLSOptions& tlsOptions);
+        void send(const Json::Value& msg,
+                  bool verbose,
+                  const OnResponseCallback& onResponseCallback);
 
         void uploadMinidump(const std::string& sentryMetadata,
                             const std::string& minidumpBytes,
@@ -39,6 +36,12 @@ namespace ix
                            bool verbose,
                            const OnResponseCallback& onResponseCallback);
 
+        Json::Value parseLuaStackTrace(const std::string& stack);
+
+        // Mostly for testing
+        void setTLSOptions(const SocketTLSOptions& tlsOptions);
+
+
     private:
         int64_t getTimestamp();
         std::string computeAuthHeader();

ixsnake/CMakeLists.txt

@@ -7,16 +7,12 @@ set (IXSNAKE_SOURCES
     ixsnake/IXSnakeServer.cpp
     ixsnake/IXSnakeProtocol.cpp
     ixsnake/IXAppConfig.cpp
-    ixsnake/IXRedisClient.cpp
-    ixsnake/IXRedisServer.cpp
 )
 
 set (IXSNAKE_HEADERS
     ixsnake/IXSnakeServer.h
     ixsnake/IXSnakeProtocol.h
     ixsnake/IXAppConfig.h
-    ixsnake/IXRedisClient.h
-    ixsnake/IXRedisServer.h
 )
 
 add_library(ixsnake STATIC
@@ -30,6 +26,7 @@ set(IXSNAKE_INCLUDE_DIRS
     ../ixcore
     ../ixcrypto
     ../ixwebsocket
+    ../ixredis
     ../third_party)
 
 target_include_directories( ixsnake PUBLIC ${IXSNAKE_INCLUDE_DIRS} )

ixsnake/ixsnake/IXSnakeConnectionState.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "IXRedisClient.h"
+#include <ixredis/IXRedisClient.h>
 #include <future>
 #include <ixwebsocket/IXConnectionState.h>
 #include <string>

ixsnake/ixsnake/IXSnakeServer.cpp

@@ -61,16 +61,19 @@ namespace snake
 
         _server.setOnConnectionCallback(
             [this](std::shared_ptr<ix::WebSocket> webSocket,
-                   std::shared_ptr<ix::ConnectionState> connectionState) {
+                   std::shared_ptr<ix::ConnectionState> connectionState,
+                   std::unique_ptr<ix::ConnectionInfo> connectionInfo) {
                 auto state = std::dynamic_pointer_cast<SnakeConnectionState>(connectionState);
-
+                auto remoteIp = connectionInfo->remoteIp;
+            
                 webSocket->setOnMessageCallback(
-                    [this, webSocket, state](const ix::WebSocketMessagePtr& msg) {
+                    [this, webSocket, state, remoteIp](const ix::WebSocketMessagePtr& msg) {
                         std::stringstream ss;
                         ix::LogLevel logLevel = ix::LogLevel::Debug;
                         if (msg->type == ix::WebSocketMessageType::Open)
                         {
                             ss << "New connection" << std::endl;
+                            ss << "remote ip: " << remoteIp << std::endl;
                             ss << "id: " << state->getId() << std::endl;
                             ss << "Uri: " << msg->openInfo.uri << std::endl;
                             ss << "Headers:" << std::endl;

ixwebsocket/IXCancellationRequest.cpp

@@ -6,6 +6,7 @@
 
 #include "IXCancellationRequest.h"
 
+#include <cassert>
 #include <chrono>
 
 namespace ix
@@ -13,6 +14,8 @@ namespace ix
     CancellationRequest makeCancellationRequestWithTimeout(
         int secs, std::atomic<bool>& requestInitCancellation)
     {
+        assert(secs > 0);
+
         auto start = std::chrono::system_clock::now();
         auto timeout = std::chrono::seconds(secs);
 

ixwebsocket/IXConnectionInfo.h

@@ -0,0 +1,25 @@
+/*
+ *  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/IXDNSLookup.cpp

@@ -4,6 +4,19 @@
  *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
  */
 
+//
+// On Windows Universal Platform (uwp), gai_strerror defaults behavior is to returns wchar_t
+// which is different from all other platforms. We want the non unicode version.
+// See https://github.com/microsoft/vcpkg/pull/11030
+// We could do this in IXNetSystem.cpp but so far we are only using gai_strerror in here.
+//
+#ifdef _UNICODE
+#undef _UNICODE
+#endif
+#ifdef UNICODE
+#undef UNICODE
+#endif
+
 #include "IXDNSLookup.h"
 
 #include "IXNetSystem.h"

ixwebsocket/IXHttpClient.cpp

@@ -25,10 +25,12 @@ namespace ix
     const std::string HttpClient::kHead = "HEAD";
     const std::string HttpClient::kDel = "DEL";
     const std::string HttpClient::kPut = "PUT";
+    const std::string HttpClient::kPatch = "PATCH";
 
     HttpClient::HttpClient(bool async)
         : _async(async)
         , _stop(false)
+        , _forceBody(false)
     {
         if (!_async) return;
 
@@ -49,6 +51,11 @@ namespace ix
         _tlsOptions = tlsOptions;
     }
 
+    void HttpClient::setForceBody(bool value)
+    {
+        _forceBody = value;
+    }
+
     HttpRequestArgsPtr HttpClient::createRequest(const std::string& url, const std::string& verb)
     {
         auto request = std::make_shared<HttpRequestArgs>();
@@ -120,7 +127,7 @@ namespace ix
     {
         // We only have one socket connection, so we cannot
         // make multiple requests concurrently.
-        std::lock_guard<std::mutex> lock(_mutex);
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
 
         uint64_t uploadSize = 0;
         uint64_t downloadSize = 0;
@@ -192,7 +199,7 @@ namespace ix
             ss << "User-Agent: " << userAgent() << "\r\n";
         }
 
-        if (verb == kPost || verb == kPut)
+        if (verb == kPost || verb == kPut || verb == kPatch || _forceBody)
         {
             ss << "Content-Length: " << body.size() << "\r\n";
 
@@ -220,11 +227,10 @@ namespace ix
 
         std::string req(ss.str());
         std::string errMsg;
-        std::atomic<bool> requestInitCancellation(false);
 
         // Make a cancellation object dealing with connection timeout
         auto isCancellationRequested =
-            makeCancellationRequestWithTimeout(args->connectTimeout, requestInitCancellation);
+            makeCancellationRequestWithTimeout(args->connectTimeout, _stop);
 
         bool success = _socket->connect(host, port, errMsg, isCancellationRequested);
         if (!success)
@@ -242,8 +248,7 @@ namespace ix
         }
 
         // Make a new cancellation object dealing with transfer timeout
-        isCancellationRequested =
-            makeCancellationRequestWithTimeout(args->transferTimeout, requestInitCancellation);
+        isCancellationRequested = makeCancellationRequestWithTimeout(args->transferTimeout, _stop);
 
         if (args->verbose)
         {
@@ -562,6 +567,20 @@ namespace ix
         return request(url, kPut, body, args);
     }
 
+    HttpResponsePtr HttpClient::patch(const std::string& url,
+                                      const HttpParameters& httpParameters,
+                                      HttpRequestArgsPtr args)
+    {
+        return request(url, kPatch, serializeHttpParameters(httpParameters), args);
+    }
+
+    HttpResponsePtr HttpClient::patch(const std::string& url,
+                                      const std::string& body,
+                                      const HttpRequestArgsPtr args)
+    {
+        return request(url, kPatch, body, args);
+    }
+
     std::string HttpClient::urlEncode(const std::string& value)
     {
         std::ostringstream escaped;

ixwebsocket/IXHttpClient.h

@@ -46,12 +46,19 @@ namespace ix
                             const std::string& body,
                             HttpRequestArgsPtr args);
 
+        HttpResponsePtr patch(const std::string& url,
+                              const HttpParameters& httpParameters,
+                              HttpRequestArgsPtr args);
+        HttpResponsePtr patch(const std::string& url,
+                              const std::string& body,
+                              HttpRequestArgsPtr args);
+
         HttpResponsePtr request(const std::string& url,
                                 const std::string& verb,
                                 const std::string& body,
                                 HttpRequestArgsPtr args,
                                 int redirects = 0);
-
+        void setForceBody(bool value);
         // Async API
         HttpRequestArgsPtr createRequest(const std::string& url = std::string(),
                                          const std::string& verb = HttpClient::kGet);
@@ -78,6 +85,7 @@ namespace ix
         const static std::string kHead;
         const static std::string kDel;
         const static std::string kPut;
+        const static std::string kPatch;
 
     private:
         void log(const std::string& msg, HttpRequestArgsPtr args);
@@ -86,7 +94,6 @@ namespace ix
 
         // Async API background thread runner
         void run();
-
         // Async API
         bool _async;
         std::queue<std::pair<HttpRequestArgsPtr, OnResponseCallback>> _queue;
@@ -96,8 +103,12 @@ namespace ix
         std::thread _thread;
 
         std::unique_ptr<Socket> _socket;
-        std::mutex _mutex; // to protect accessing the _socket (only one socket per client)
+        std::recursive_mutex _mutex; // to protect accessing the _socket (only one socket per
+                                     // client) the mutex needs to be recursive as this function
+                                     // might be called recursively to follow HTTP redirections
 
         SocketTLSOptions _tlsOptions;
+
+        bool _forceBody;
     };
 } // namespace ix

ixwebsocket/IXHttpServer.cpp

@@ -9,9 +9,11 @@
 #include "IXNetSystem.h"
 #include "IXSocketConnect.h"
 #include "IXUserAgent.h"
+#include <cstring>
 #include <fstream>
 #include <sstream>
 #include <vector>
+#include <zlib.h>
 
 namespace
 {
@@ -38,6 +40,49 @@ namespace
         auto vec = res.second;
         return std::make_pair(res.first, std::string(vec.begin(), vec.end()));
     }
+
+    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;
+    }
 } // namespace
 
 namespace ix
@@ -70,7 +115,8 @@ namespace ix
     }
 
     void HttpServer::handleConnection(std::unique_ptr<Socket> socket,
-                                      std::shared_ptr<ConnectionState> connectionState)
+                                      std::shared_ptr<ConnectionState> connectionState,
+                                      std::unique_ptr<ConnectionInfo> connectionInfo)
     {
         _connectedClientsCount++;
 
@@ -79,7 +125,9 @@ namespace ix
 
         if (std::get<0>(ret))
         {
-            auto response = _onConnectionCallback(std::get<2>(ret), connectionState);
+            auto response = _onConnectionCallback(std::get<2>(ret),
+                                                  connectionState,
+                                                  std::move(connectionInfo));
             if (!Http::sendResponse(response, socket))
             {
                 logError("Cannot send response");
@@ -99,7 +147,8 @@ namespace ix
     {
         setOnConnectionCallback(
             [this](HttpRequestPtr request,
-                   std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr {
+                   std::shared_ptr<ConnectionState> /*connectionState*/,
+                   std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
                 std::string uri(request->uri);
                 if (uri.empty() || uri == "/")
                 {
@@ -120,9 +169,17 @@ namespace ix
 
                 std::string content = res.second;
 
+                std::string acceptEncoding = request->headers["Accept-encoding"];
+                if (acceptEncoding == "*" || acceptEncoding.find("gzip") != std::string::npos)
+                {
+                    content = gzipCompress(content);
+                    headers["Content-Encoding"] = "gzip";
+                }
+
                 // Log request
                 std::stringstream ss;
-                ss << request->method << " " << request->headers["User-Agent"] << " "
+                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
+                   << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri << " " << content.size();
                 logInfo(ss.str());
 
@@ -148,13 +205,15 @@ namespace ix
         setOnConnectionCallback(
             [this,
              redirectUrl](HttpRequestPtr request,
-                          std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr {
+                          std::shared_ptr<ConnectionState> /*connectionState*/,
+                          std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
                 WebSocketHttpHeaders headers;
                 headers["Server"] = userAgent();
 
                 // Log request
                 std::stringstream ss;
-                ss << request->method << " " << request->headers["User-Agent"] << " "
+                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
+                   << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri;
                 logInfo(ss.str());
 

ixwebsocket/IXHttpServer.h

@@ -23,7 +23,9 @@ namespace ix
     {
     public:
         using OnConnectionCallback =
-            std::function<HttpResponsePtr(HttpRequestPtr, std::shared_ptr<ConnectionState>)>;
+            std::function<HttpResponsePtr(HttpRequestPtr,
+                                          std::shared_ptr<ConnectionState>,
+                                          std::unique_ptr<ConnectionInfo> connectionInfo)>;
 
         HttpServer(int port = SocketServer::kDefaultPort,
                    const std::string& host = SocketServer::kDefaultHost,
@@ -44,7 +46,8 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState) final;
+                                      std::shared_ptr<ConnectionState> connectionState,
+                                      std::unique_ptr<ConnectionInfo> connectionInfo) final;
         virtual size_t getConnectedClientsCount() final;
 
         void setDefaultConnectionCallback();

ixwebsocket/IXNetSystem.h

@@ -19,6 +19,7 @@ typedef unsigned long int nfds_t;
 #else
 #include <arpa/inet.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>

ixwebsocket/IXSocketMbedTLS.cpp

@@ -43,6 +43,55 @@ namespace ix
         mbedtls_pk_init(&_pkey);
     }
 
+    bool SocketMbedTLS::loadSystemCertificates(std::string& errorMsg)
+    {
+#ifdef _WIN32
+        DWORD flags = CERT_STORE_READONLY_FLAG | CERT_STORE_OPEN_EXISTING_FLAG |
+                      CERT_SYSTEM_STORE_CURRENT_USER;
+        HCERTSTORE systemStore = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, 0, flags, L"Root");
+
+        if (!systemStore)
+        {
+            errorMsg = "CertOpenStore failed with ";
+            errorMsg += std::to_string(GetLastError());
+            return false;
+        }
+
+        PCCERT_CONTEXT certificateIterator = NULL;
+
+        int certificateCount = 0;
+        while (certificateIterator = CertEnumCertificatesInStore(systemStore, certificateIterator))
+        {
+            if (certificateIterator->dwCertEncodingType & X509_ASN_ENCODING)
+            {
+                int ret = mbedtls_x509_crt_parse(&_cacert,
+                                                 certificateIterator->pbCertEncoded,
+                                                 certificateIterator->cbCertEncoded);
+                if (ret == 0)
+                {
+                    ++certificateCount;
+                }
+            }
+        }
+
+        CertFreeCertificateContext(certificateIterator);
+        CertCloseStore(systemStore, 0);
+
+        if (certificateCount == 0)
+        {
+            errorMsg = "No certificates found";
+            return false;
+        }
+
+        return true;
+#else
+        // On macOS we can query the system cert location from the keychain
+        // On Linux we could try to fetch some local files based on the distribution
+        // On Android we could use JNI to get to the system certs
+        return false;
+#endif
+    }
+
     bool SocketMbedTLS::init(const std::string& host, bool isClient, std::string& errMsg)
     {
         initMBedTLS();
@@ -96,13 +145,15 @@ namespace ix
         }
         else
         {
-            mbedtls_ssl_conf_authmode(&_conf, MBEDTLS_SSL_VERIFY_REQUIRED);
-
             // FIXME: should we call mbedtls_ssl_conf_verify ?
+            mbedtls_ssl_conf_authmode(&_conf, MBEDTLS_SSL_VERIFY_REQUIRED);
 
             if (_tlsOptions.isUsingSystemDefaults())
             {
-                ; // FIXME
+                if (!loadSystemCertificates(errMsg))
+                {
+                    return false;
+                }
             }
             else
             {

ixwebsocket/IXSocketMbedTLS.h

@@ -52,6 +52,7 @@ namespace ix
 
         bool init(const std::string& host, bool isClient, std::string& errMsg);
         void initMBedTLS();
+        bool loadSystemCertificates(std::string& errMsg);
     };
 
 } // namespace ix

ixwebsocket/IXSocketOpenSSL.cpp

@@ -85,6 +85,8 @@ namespace ix
 
     std::atomic<bool> SocketOpenSSL::_openSSLInitializationSuccessful(false);
     std::once_flag SocketOpenSSL::_openSSLInitFlag;
+    std::unique_ptr<std::mutex[]> SocketOpenSSL::_openSSLMutexes =
+        std::make_unique<std::mutex[]>(CRYPTO_num_locks());
 
     SocketOpenSSL::SocketOpenSSL(const SocketTLSOptions& tlsOptions, int fd)
         : Socket(fd)
@@ -106,6 +108,11 @@ namespace ix
         if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, nullptr)) return;
 #else
         (void) OPENSSL_config(nullptr);
+
+        if (CRYPTO_get_locking_callback() == nullptr)
+        {
+            CRYPTO_set_locking_callback(SocketOpenSSL::openSSLLockingCallback);
+        }
 #endif
 
         (void) OpenSSL_add_ssl_algorithms();
@@ -114,6 +121,21 @@ namespace ix
         _openSSLInitializationSuccessful = true;
     }
 
+    void SocketOpenSSL::openSSLLockingCallback(int mode,
+                                               int type,
+                                               const char* /*file*/,
+                                               int /*line*/)
+    {
+        if (mode & CRYPTO_LOCK)
+        {
+            _openSSLMutexes[type].lock();
+        }
+        else
+        {
+            _openSSLMutexes[type].unlock();
+        }
+    }
+
     std::string SocketOpenSSL::getSSLError(int ret)
     {
         unsigned long e;

ixwebsocket/IXSocketOpenSSL.h

@@ -49,6 +49,9 @@ namespace ix
         bool handleTLSOptions(std::string& errMsg);
         bool openSSLServerHandshake(std::string& errMsg);
 
+        // Required for OpenSSL < 1.1
+        static void openSSLLockingCallback(int mode, int type, const char* /*file*/, int /*line*/);
+
         SSL* _ssl_connection;
         SSL_CTX* _ssl_context;
         const SSL_METHOD* _ssl_method;
@@ -58,6 +61,7 @@ namespace ix
 
         static std::once_flag _openSSLInitFlag;
         static std::atomic<bool> _openSSLInitializationSuccessful;
+        static std::unique_ptr<std::mutex[]> _openSSLMutexes;
     };
 
 } // namespace ix

ixwebsocket/IXSocketServer.cpp

@@ -276,6 +276,7 @@ namespace ix
             }
 
             // Accept a connection.
+            // FIXME: Is this working for ipv6 ?
             struct sockaddr_in client; // client address information
             int clientFd;              // socket connected to client
             socklen_t addressLen = sizeof(client);
@@ -307,6 +308,45 @@ namespace ix
                 continue;
             }
 
+            std::unique_ptr<ConnectionInfo> connectionInfo;
+
+            if (_addressFamily == AF_INET)
+            {
+                char remoteIp[INET_ADDRSTRLEN];
+                if (inet_ntop(AF_INET, &client.sin_addr, remoteIp, INET_ADDRSTRLEN) == nullptr)
+                {
+                    int err = Socket::getErrno();
+                    std::stringstream ss;
+                    ss << "SocketServer::run() error calling inet_ntop (ipv4): " << err << ", "
+                       << strerror(err);
+                    logError(ss.str());
+
+                    Socket::closeSocket(clientFd);
+
+                    continue;
+                }
+
+                connectionInfo = std::make_unique<ConnectionInfo>(remoteIp, client.sin_port);
+            }
+            else // AF_INET6
+            {
+                char remoteIp[INET6_ADDRSTRLEN];
+                if (inet_ntop(AF_INET6, &client.sin_addr, remoteIp, INET6_ADDRSTRLEN) == nullptr)
+                {
+                    int err = Socket::getErrno();
+                    std::stringstream ss;
+                    ss << "SocketServer::run() error calling inet_ntop (ipv6): " << err << ", "
+                       << strerror(err);
+                    logError(ss.str());
+
+                    Socket::closeSocket(clientFd);
+
+                    continue;
+                }
+
+                connectionInfo = std::make_unique<ConnectionInfo>(remoteIp, client.sin_port);
+            }
+
             std::shared_ptr<ConnectionState> connectionState;
             if (_connectionStateFactory)
             {
@@ -342,7 +382,7 @@ namespace ix
             _connectionsThreads.push_back(std::make_pair(
                 connectionState,
                 std::thread(
-                    &SocketServer::handleConnection, this, std::move(socket), connectionState)));
+                    &SocketServer::handleConnection, this, std::move(socket), connectionState, std::move(connectionInfo))));
         }
     }
 

ixwebsocket/IXSocketServer.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include "IXConnectionInfo.h"
 #include "IXConnectionState.h"
 #include "IXSocketTLSOptions.h"
 #include <atomic>
@@ -102,7 +103,8 @@ namespace ix
         ConnectionStateFactory _connectionStateFactory;
 
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState) = 0;
+                                      std::shared_ptr<ConnectionState> connectionState,
+                                      std::unique_ptr<ConnectionInfo> connectionInfo) = 0;
         virtual size_t getConnectedClientsCount() = 0;
 
         // Returns true if all connection threads are joined

ixwebsocket/IXUdpSocket.cpp

@@ -44,6 +44,18 @@ namespace ix
         return err;
     }
 
+    bool UdpSocket::isWaitNeeded()
+    {
+        int err = getErrno();
+
+        if (err == EWOULDBLOCK || err == EAGAIN || err == EINPROGRESS)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
     void UdpSocket::closeSocket(int fd)
     {
 #ifdef _WIN32
@@ -62,6 +74,13 @@ namespace ix
             return false;
         }
 
+#ifdef _WIN32
+        unsigned long nonblocking = 1;
+        ioctlsocket(_sockfd, FIONBIO, &nonblocking);
+#else
+        fcntl(_sockfd, F_SETFL, O_NONBLOCK); // make socket non blocking
+#endif
+
         memset(&_server, 0, sizeof(_server));
         _server.sin_family = AF_INET;
         _server.sin_port = htons(port);
@@ -93,4 +112,15 @@ namespace ix
         return (ssize_t)::sendto(
             _sockfd, buffer.data(), buffer.size(), 0, (struct sockaddr*) &_server, sizeof(_server));
     }
+
+    ssize_t UdpSocket::recvfrom(char* buffer, size_t length)
+    {
+#ifdef _WIN32
+        int addressLen = (int) sizeof(_server);
+#else
+        socklen_t addressLen = (socklen_t) sizeof(_server);
+#endif
+        return (ssize_t)::recvfrom(
+            _sockfd, buffer, length, 0, (struct sockaddr*) &_server, &addressLen);
+    }
 } // namespace ix

ixwebsocket/IXUdpSocket.h

@@ -28,9 +28,12 @@ namespace ix
         // Virtual methods
         bool init(const std::string& host, int port, std::string& errMsg);
         ssize_t sendto(const std::string& buffer);
+        ssize_t recvfrom(char* buffer, size_t length);
+
         void close();
 
         static int getErrno();
+        static bool isWaitNeeded();
         static void closeSocket(int fd);
 
     private:

ixwebsocket/IXUrlParser.cpp

@@ -32,6 +32,7 @@
 #include "IXUrlParser.h"
 
 #include <algorithm>
+#include <cstdlib>
 #include <cstring>
 
 namespace

ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp

@@ -59,14 +59,42 @@ namespace ix
         return true;
     }
 
-    bool WebSocketPerMessageDeflateCompressor::endsWith(const std::string& value,
-                                                        const std::string& ending)
+    template<typename T>
+    bool WebSocketPerMessageDeflateCompressor::endsWithEmptyUnCompressedBlock(const T& value)
     {
-        if (ending.size() > value.size()) return false;
-        return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+        if (kEmptyUncompressedBlock.size() > value.size()) return false;
+        auto N = value.size();
+        return value[N - 1] == kEmptyUncompressedBlock[3] &&
+               value[N - 2] == kEmptyUncompressedBlock[2] &&
+               value[N - 3] == kEmptyUncompressedBlock[1] &&
+               value[N - 4] == kEmptyUncompressedBlock[0];
     }
 
     bool WebSocketPerMessageDeflateCompressor::compress(const std::string& in, std::string& out)
+    {
+        return compressData(in, out);
+    }
+
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::string& in,
+                                                        std::vector<uint8_t>& out)
+    {
+        return compressData(in, out);
+    }
+
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::vector<uint8_t>& in,
+                                                        std::string& out)
+    {
+        return compressData(in, out);
+    }
+
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::vector<uint8_t>& in,
+                                                        std::vector<uint8_t>& out)
+    {
+        return compressData(in, out);
+    }
+
+    template<typename T, typename S>
+    bool WebSocketPerMessageDeflateCompressor::compressData(const T& in, S& out)
     {
         //
         // 7.2.1.  Compression
@@ -96,7 +124,8 @@ namespace ix
             // The normal buffer size should be 6 but
             // we remove the 4 octets from the tail (#4)
             uint8_t buf[2] = {0x02, 0x00};
-            out.append((char*) (buf), 2);
+            out.push_back(buf[0]);
+            out.push_back(buf[1]);
 
             return true;
         }
@@ -114,10 +143,10 @@ namespace ix
 
             output = _compressBufferSize - _deflateState.avail_out;
 
-            out.append((char*) (_compressBuffer.get()), output);
+            out.insert(out.end(), _compressBuffer.get(), _compressBuffer.get() + output);
         } while (_deflateState.avail_out == 0);
 
-        if (endsWith(out, kEmptyUncompressedBlock))
+        if (endsWithEmptyUnCompressedBlock(out))
         {
             out.resize(out.size() - 4);
         }

ixwebsocket/IXWebSocketPerMessageDeflateCodec.h

@@ -9,6 +9,7 @@
 #include "zlib.h"
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace ix
 {
@@ -20,9 +21,15 @@ namespace ix
 
         bool init(uint8_t deflateBits, bool clientNoContextTakeOver);
         bool compress(const std::string& in, std::string& out);
+        bool compress(const std::string& in, std::vector<uint8_t>& out);
+        bool compress(const std::vector<uint8_t>& in, std::string& out);
+        bool compress(const std::vector<uint8_t>& in, std::vector<uint8_t>& out);
 
     private:
-        static bool endsWith(const std::string& value, const std::string& ending);
+        template<typename T, typename S>
+        bool compressData(const T& in, S& out);
+        template<typename T>
+        bool endsWithEmptyUnCompressedBlock(const T& value);
 
         int _flush;
         size_t _compressBufferSize;

ixwebsocket/IXWebSocketServer.cpp

@@ -72,12 +72,13 @@ namespace ix
     }
 
     void WebSocketServer::handleConnection(std::unique_ptr<Socket> socket,
-                                           std::shared_ptr<ConnectionState> connectionState)
+                                           std::shared_ptr<ConnectionState> connectionState,
+                                           std::unique_ptr<ConnectionInfo> connectionInfo)
     {
         setThreadName("WebSocketServer::" + connectionState->getId());
 
         auto webSocket = std::make_shared<WebSocket>();
-        _onConnectionCallback(webSocket, connectionState);
+        _onConnectionCallback(webSocket, connectionState, std::move(connectionInfo));
 
         webSocket->disableAutomaticReconnection();
 

ixwebsocket/IXWebSocketServer.h

@@ -19,11 +19,12 @@
 
 namespace ix
 {
-    class WebSocketServer final : public SocketServer
+    class WebSocketServer : public SocketServer
     {
     public:
         using OnConnectionCallback =
-            std::function<void(std::shared_ptr<WebSocket>, std::shared_ptr<ConnectionState>)>;
+            std::function<void(std::shared_ptr<WebSocket>, std::shared_ptr<ConnectionState>,
+                               std::unique_ptr<ConnectionInfo> connectionInfo)>;
 
         WebSocketServer(int port = SocketServer::kDefaultPort,
                         const std::string& host = SocketServer::kDefaultHost,
@@ -60,7 +61,8 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket> socket,
-                                      std::shared_ptr<ConnectionState> connectionState) final;
+                                      std::shared_ptr<ConnectionState> connectionState,
+                                      std::unique_ptr<ConnectionInfo> connectionInfo);
         virtual size_t getConnectedClientsCount() final;
     };
 } // namespace ix

ixwebsocket/IXWebSocketTransport.cpp

@@ -326,9 +326,10 @@ namespace ix
         return _txbuf.empty();
     }
 
+    template<class Iterator>
     void WebSocketTransport::appendToSendBuffer(const std::vector<uint8_t>& header,
-                                                std::string::const_iterator begin,
-                                                std::string::const_iterator end,
+                                                Iterator begin,
+                                                Iterator end,
                                                 uint64_t message_size,
                                                 uint8_t masking_key[4])
     {
@@ -750,8 +751,9 @@ namespace ix
         return static_cast<unsigned>(seconds);
     }
 
+    template<class T>
     WebSocketSendInfo WebSocketTransport::sendData(wsheader_type::opcode_type type,
-                                                   const std::string& message,
+                                                   const T& message,
                                                    bool compress,
                                                    const OnProgressCallback& onProgressCallback)
     {
@@ -764,8 +766,8 @@ namespace ix
         size_t wireSize = message.size();
         bool compressionError = false;
 
-        std::string::const_iterator message_begin = message.begin();
-        std::string::const_iterator message_end = message.end();
+        auto message_begin = message.cbegin();
+        auto message_end = message.cend();
 
         if (compress)
         {
@@ -780,8 +782,8 @@ namespace ix
             compressionError = false;
             wireSize = _compressedMessage.size();
 
-            message_begin = _compressedMessage.begin();
-            message_end = _compressedMessage.end();
+            message_begin = _compressedMessage.cbegin();
+            message_end = _compressedMessage.cend();
         }
 
         {
@@ -859,10 +861,11 @@ namespace ix
         return WebSocketSendInfo(success, compressionError, payloadSize, wireSize);
     }
 
+    template<class Iterator>
     bool WebSocketTransport::sendFragment(wsheader_type::opcode_type type,
                                           bool fin,
-                                          std::string::const_iterator message_begin,
-                                          std::string::const_iterator message_end,
+                                          Iterator message_begin,
+                                          Iterator message_end,
                                           bool compress)
     {
         uint64_t message_size = static_cast<uint64_t>(message_end - message_begin);
@@ -1055,7 +1058,7 @@ namespace ix
         else
         {
             // no close code/reason set
-            sendData(wsheader_type::CLOSE, "", compress);
+            sendData(wsheader_type::CLOSE, std::string(""), compress);
         }
     }
 

ixwebsocket/IXWebSocketTransport.h

@@ -239,16 +239,15 @@ namespace ix
         bool sendOnSocket();
         bool receiveFromSocket();
 
+        template<class T>
         WebSocketSendInfo sendData(wsheader_type::opcode_type type,
-                                   const std::string& message,
+                                   const T& message,
                                    bool compress,
                                    const OnProgressCallback& onProgressCallback = nullptr);
 
-        bool sendFragment(wsheader_type::opcode_type type,
-                          bool fin,
-                          std::string::const_iterator begin,
-                          std::string::const_iterator end,
-                          bool compress);
+        template<class Iterator>
+        bool sendFragment(
+            wsheader_type::opcode_type type, bool fin, Iterator begin, Iterator end, bool compress);
 
         void emitMessage(MessageKind messageKind,
                          const std::string& message,
@@ -256,9 +255,11 @@ namespace ix
                          const OnMessageCallback& onMessageCallback);
 
         bool isSendBufferEmpty() const;
+
+        template<class Iterator>
         void appendToSendBuffer(const std::vector<uint8_t>& header,
-                                std::string::const_iterator begin,
-                                std::string::const_iterator end,
+                                Iterator begin,
+                                Iterator end,
                                 uint64_t message_size,
                                 uint8_t masking_key[4]);
 

ixwebsocket/IXWebSocketVersion.h

@@ -6,4 +6,4 @@
 
 #pragma once
 
-#define IX_WEBSOCKET_VERSION "9.5.2"
+#define IX_WEBSOCKET_VERSION "9.9.0"

luarocks/CMakeLists.txt

@@ -1,30 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (luarocks)
-
-# There's -Weverything too for clang
-if (NOT WIN32)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
-endif()
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-include_directories(luarocks .)
-
-add_executable(luarocks main.cpp)
-
-include(FindLua)
-find_package(lua REQUIRED)
-target_link_libraries(luarocks ${LUA_LIBRARIES})
-target_include_directories(luarocks PRIVATE ${LUA_INCLUDE_DIR})
-
-# library with the most dependencies come first
-target_link_libraries(luarocks ixwebsocket)
-
-install(TARGETS luarocks RUNTIME DESTINATION bin)

luarocks/LuaWebSocket.h

@@ -1,163 +0,0 @@
-/*
- *  LuaWebSocket.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <iostream>
-#include <string>
-
-extern "C"
-{
-    #include "lua.h"
-    #include "lauxlib.h"
-}
-
-#include "luawrapper.hpp"
-#include <ixwebsocket/IXWebSocket.h>
-#include <chrono>
-#include <thread>
-#include <queue>
-#include <mutex>
-
-namespace ix
-{
-    class LuaWebSocket
-    {
-        public:
-            LuaWebSocket()
-            {
-                _webSocket.setOnMessageCallback([this](const WebSocketMessagePtr& msg) {
-                    if (msg->type == ix::WebSocketMessageType::Message)
-                    {
-                        std::lock_guard<std::mutex> lock(_queueMutex);
-                        _queue.push(msg->str);
-                    }
-                });
-            }
-
-            void setUrl(const std::string& url) { _webSocket.setUrl(url); }
-            const std::string& getUrl() { return _webSocket.getUrl(); }
-            void start() { _webSocket.start(); }
-            void send(const std::string& msg) { _webSocket.send(msg); }
-
-            const std::string& getMessage()
-            {
-                std::lock_guard<std::mutex> lock(_queueMutex);
-                return _queue.front();
-            }
-
-            bool hasMessage()
-            {
-                std::lock_guard<std::mutex> lock(_queueMutex);
-                return !_queue.empty();
-            }
-
-            void popMessage()
-            {
-                std::lock_guard<std::mutex> lock(_queueMutex);
-                _queue.pop();
-            }
-
-        private:
-            WebSocket _webSocket;
-
-            std::queue<std::string> _queue;
-            std::mutex _queueMutex;
-    };
-
-    LuaWebSocket* WebSocket_new(lua_State* /*L*/)
-    {
-        LuaWebSocket* webSocket = new LuaWebSocket();
-        return webSocket;
-    }
-
-    int WebSocket_getUrl(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        lua_pushstring(L, luaWebSocket->getUrl().c_str());
-        return 1;
-    }
-
-    int WebSocket_setUrl(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        const char* url = luaL_checkstring(L, 2);
-        luaWebSocket->setUrl(url);
-        return 0;
-    }
-
-    int WebSocket_start(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        luaWebSocket->start();
-        return 0;
-    }
-
-    int WebSocket_send(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        const char* msg = luaL_checkstring(L, 2);
-        luaWebSocket->send(msg);
-        return 0;
-    }
-
-    int WebSocket_getMessage(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        lua_pushstring(L, luaWebSocket->getMessage().c_str());
-        return 1;
-    }
-
-    int WebSocket_hasMessage(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        lua_pushboolean(L, luaWebSocket->hasMessage());
-        return 1;
-    }
-
-    int WebSocket_popMessage(lua_State* L)
-    {
-        LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        luaWebSocket->popMessage();
-        return 1;
-    }
-
-    // FIXME: This should be a static method, or be part of a different module
-    int WebSocket_sleep(lua_State* L)
-    {
-        // LuaWebSocket* luaWebSocket = luaW_check<LuaWebSocket>(L, 1);
-        auto duration = luaL_checkinteger(L, 2);
-        std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-        return 0;
-    }
-
-    static luaL_Reg WebSocket_table[] = {
-        { NULL, NULL }
-    };
-
-    static luaL_Reg WebSocket_metatable[] = {
-        { "getUrl", WebSocket_getUrl },
-        { "setUrl", WebSocket_setUrl },
-        { "start", WebSocket_start },
-        { "send", WebSocket_send },
-        { "getMessage", WebSocket_getMessage },
-        { "hasMessage", WebSocket_hasMessage },
-        { "popMessage", WebSocket_popMessage },
-        { "sleep", WebSocket_sleep },
-        { NULL, NULL }
-    };
-
-    int luaopen_WebSocket(lua_State* L)
-    {
-        luaW_register<LuaWebSocket>(L,
-            "WebSocket",
-            WebSocket_table,
-            WebSocket_metatable,
-            WebSocket_new
-            );
-        return 1;
-    }
-}

luarocks/Player.hpp

@@ -1,56 +0,0 @@
-#ifndef PLAYER_HPP
-#define PLAYER_HPP
-
-#include <iostream>
-
-class Player
-{
-public:
-    Player(const char* name, unsigned int health) :
-        m_Name(name),
-        m_Health(health)
-    {
-    }
-
-    void info()
-    {
-        std::cout << m_Name << " have " << m_Health << " HP" << std::endl;
-    }
-
-    void say(const char* text)
-    {
-        std::cout << m_Name << ": " << text << std::endl;
-    }
-
-    void heal(Player* target)
-    {
-        target->setHealth(100);
-    }
-
-    const char* getName()
-    {
-        return m_Name;
-    }
-
-    unsigned int getHealth()
-    {
-        return m_Health;
-    }
-
-    bool setHealth(unsigned int health)
-    {
-        if (health >= 0 && health <= 100)
-        {
-            m_Health = health;
-            return true;
-        }
-        else
-            return false;
-    }
-
-private:
-    const char* m_Name;
-    unsigned int m_Health;
-};
-
-#endif // PLAYER_HPP

luarocks/README.md

@@ -1,7 +0,0 @@
-Wrapper based on https://github.com/LuaxY/cpp-lua
-
-Examples to build C++
-https://github.com/siffiejoe/lua-fltk4lua/blob/master/fltk4lua-scm-0.rockspec
-https://github.com/lua4web/refser/blob/master/rockspecs/refser-0.2-1.rockspec
-
-

luarocks/echo_client.lua

@@ -1,30 +0,0 @@
---
--- make luarocks && (cd luarocks ; ../build/luarocks/luarocks)
---
--- ... git push test with ssh key
---
-local webSocket = WebSocket.new()
-
-webSocket:setUrl("ws://localhost:8008")
-print("Url: " .. webSocket:getUrl())
-
--- Start the background thread
-webSocket:start()
-
-local i = 0
-
-while true
-do
-    print("Sending message...")
-    webSocket:send("msg_" .. tostring(i));
-    i = i + 1
-
-    print("Waiting 1s...")
-    webSocket:sleep(1000)
-
-    if webSocket:hasMessage() then
-        local msg = webSocket:getMessage()
-        print("Received: " .. msg)
-        webSocket:popMessage()
-    end
-end

luarocks/functions.hpp

@@ -1,15 +0,0 @@
-/*
- *  functions.hpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <iostream>
-
-int lua_info(lua_State* /*L*/)
-{
-    std::cout << "C++ Lua v0.1" << std::endl << std::endl;
-    return 0;
-}

luarocks/luawrapper.hpp

@@ -1,709 +0,0 @@
-/*
- * Copyright (c) 2010-2013 Alexander Ames
- * Alexander.Ames@gmail.com
- * See Copyright Notice at the end of this file
- */
-
-// API Summary:
-//
-// LuaWrapper is a library designed to help bridge the gab between Lua and
-// C++. It is designed to be small (a single header file), simple, fast,
-// and typesafe. It has no external dependencies, and does not need to be
-// precompiled; the header can simply be dropped into a project and used
-// immediately. It even supports class inheritance to a certain degree. Objects
-// can be created in either Lua or C++, and passed back and forth.
-//
-// The main functions of interest are the following:
-//  luaW_is<T>
-//  luaW_to<T>
-//  luaW_check<T>
-//  luaW_push<T>
-//  luaW_register<T>
-//  luaW_setfuncs<T>
-//  luaW_extend<T, U>
-//  luaW_hold<T>
-//  luaW_release<T>
-//
-// These functions allow you to manipulate arbitrary classes just like you
-// would the primitive types (e.g. numbers or strings). If you are familiar
-// with the normal Lua API the behavior of these functions should be very
-// intuative.
-//
-// For more information see the README and the comments below
-
-#ifndef LUA_WRAPPER_H_
-#define LUA_WRAPPER_H_
-
-// If you are linking against Lua compiled in C++, define LUAW_NO_EXTERN_C
-#ifndef LUAW_NO_EXTERN_C
-extern "C"
-{
-#endif // LUAW_NO_EXTERN_C
-
-#include "lua.h"
-#include "lauxlib.h"
-    
-#ifndef LUAW_NO_EXTERN_C
-}
-#endif // LUAW_NO_EXTERN_C
-
-#define LUAW_POSTCTOR_KEY "__postctor"
-#define LUAW_EXTENDS_KEY "__extends"
-#define LUAW_STORAGE_KEY "storage"
-#define LUAW_CACHE_KEY "cache"
-#define LUAW_CACHE_METATABLE_KEY "cachemetatable"
-#define LUAW_HOLDS_KEY "holds"
-#define LUAW_WRAPPER_KEY "LuaWrapper"
-
-// A simple utility function to adjust a given index
-// Useful for when a parameter index needs to be adjusted
-// after pushing or popping things off the stack
-inline int luaW_correctindex(lua_State* /*L*/, int index, int correction)
-{
-    return index < 0 ? index - correction : index;
-}
-
-// These are the default allocator and deallocator. If you would prefer an
-// alternative option, you may select a different function when registering
-// your class.
-template <typename T>
-T* luaW_defaultallocator(lua_State*)
-{
-    return new T();
-}
-template <typename T>
-void luaW_defaultdeallocator(lua_State*, T* obj)
-{
-    delete obj;
-}
-
-// The identifier function is responsible for pushing a value unique to each
-// object on to the stack. Most of the time, this can simply be the address
-// of the pointer, but sometimes that is not adaquate. For example, if you
-// are using shared_ptr you would need to push the address of the object the
-// shared_ptr represents, rather than the address of the shared_ptr itself.
-template <typename T>
-void luaW_defaultidentifier(lua_State* L, T* obj)
-{
-    lua_pushlightuserdata(L, obj);
-}
-
-// This class is what is used by LuaWrapper to contain the userdata. data
-// stores a pointer to the object itself, and cast is used to cast toward the
-// base class if there is one and it is necessary. Rather than use RTTI and
-// typid to compare types, I use the clever trick of using the cast to compare
-// types. Because there is at most one cast per type, I can use it to identify
-// when and object is the type I want. This is only used internally.
-struct luaW_Userdata
-{
-    luaW_Userdata(void* vptr = NULL, luaW_Userdata (*udcast)(const luaW_Userdata&) = NULL)
-        : data(vptr), cast(udcast) {}
-    void* data;
-    luaW_Userdata (*cast)(const luaW_Userdata&);
-};
-
-// This class cannot actually to be instantiated. It is used only hold the
-// table name and other information.
-template <typename T>
-class LuaWrapper
-{
-public:
-    static const char* classname;
-    static void (*identifier)(lua_State*, T*);
-    static T* (*allocator)(lua_State*);
-    static void (*deallocator)(lua_State*, T*);
-    static luaW_Userdata (*cast)(const luaW_Userdata&);
-private:
-    LuaWrapper();
-};
-template <typename T> const char* LuaWrapper<T>::classname;
-template <typename T> void (*LuaWrapper<T>::identifier)(lua_State*, T*);
-template <typename T> T* (*LuaWrapper<T>::allocator)(lua_State*);
-template <typename T> void (*LuaWrapper<T>::deallocator)(lua_State*, T*);
-template <typename T> luaW_Userdata (*LuaWrapper<T>::cast)(const luaW_Userdata&);
-
-// Cast from an object of type T to an object of type U. This template
-// function is instantiated by calling luaW_extend<T, U>(L). This is only used
-// internally.
-template <typename T, typename U>
-luaW_Userdata luaW_cast(const luaW_Userdata& obj)
-{
-    return luaW_Userdata(static_cast<U*>(static_cast<T*>(obj.data)), LuaWrapper<U>::cast);
-}
-
-template <typename T, typename U>
-void luaW_identify(lua_State* L, T* obj)
-{
-    LuaWrapper<U>::identifier(L, static_cast<U*>(obj));
-}
-
-template <typename T>
-inline void luaW_wrapperfield(lua_State* L, const char* field)
-{
-    lua_getfield(L, LUA_REGISTRYINDEX, LUAW_WRAPPER_KEY); // ... LuaWrapper
-    lua_getfield(L, -1, field); // ... LuaWrapper LuaWrapper.field
-    lua_getfield(L, -1, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.field LuaWrapper.field.class
-    lua_replace(L, -3); // ... LuaWrapper.field.class LuaWrapper.field
-    lua_pop(L, 1); // ... LuaWrapper.field.class
-}
-
-// Analogous to lua_is(boolean|string|*)
-//
-// Returns 1 if the value at the given acceptable index is of type T (or if
-// strict is false, convertable to type T) and 0 otherwise.
-template <typename T>
-bool luaW_is(lua_State *L, int index, bool strict = false)
-{
-    bool equal = false;// lua_isnil(L, index);
-    if (!equal && lua_isuserdata(L, index) && lua_getmetatable(L, index))
-    {
-        // ... ud ... udmt
-        luaL_getmetatable(L, LuaWrapper<T>::classname); // ... ud ... udmt Tmt
-        equal = lua_rawequal(L, -1, -2) != 0;
-        if (!equal && !strict)
-        {
-            lua_getfield(L, -2, LUAW_EXTENDS_KEY); // ... ud ... udmt Tmt udmt.extends
-            for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1))
-            {
-                // ... ud ... udmt Tmt udmt.extends k v
-                equal = lua_rawequal(L, -1, -4) != 0;
-                if (equal)
-                {
-                    lua_pop(L, 2); // ... ud ... udmt Tmt udmt.extends
-                    break;
-                }
-            }
-            lua_pop(L, 1); // ... ud ... udmt Tmt
-        }
-        lua_pop(L, 2); // ... ud ...
-    }
-    return equal;
-}
-
-// Analogous to lua_to(boolean|string|*)
-//
-// Converts the given acceptable index to a T*. That value must be of (or
-// convertable to) type T; otherwise, returns NULL.
-template <typename T>
-T* luaW_to(lua_State* L, int index, bool strict = false)
-{
-    if (luaW_is<T>(L, index, strict))
-    {
-        luaW_Userdata* pud = static_cast<luaW_Userdata*>(lua_touserdata(L, index));
-        luaW_Userdata ud;
-        while (!strict && LuaWrapper<T>::cast != pud->cast)
-        {
-            ud = pud->cast(*pud);
-            pud = &ud;
-        }
-        return static_cast<T*>(pud->data);
-    }
-    return NULL;
-}
-
-// Analogous to luaL_check(boolean|string|*)
-//
-// Converts the given acceptable index to a T*. That value must be of (or
-// convertable to) type T; otherwise, an error is raised.
-template <typename T>
-T* luaW_check(lua_State* L, int index, bool strict = false)
-{
-    T* obj = NULL;
-    if (luaW_is<T>(L, index, strict))
-    {
-        luaW_Userdata* pud = (luaW_Userdata*)lua_touserdata(L, index);
-        luaW_Userdata ud;
-        while (!strict && LuaWrapper<T>::cast != pud->cast)
-        {
-            ud = pud->cast(*pud);
-            pud = &ud;
-        }
-        obj = (T*)pud->data;
-    }
-    else
-    {
-        const char *msg = lua_pushfstring(L, "%s expected, got %s", LuaWrapper<T>::classname, luaL_typename(L, index));
-        luaL_argerror(L, index, msg);
-    }
-    return obj;
-}
-
-template <typename T>
-T* luaW_opt(lua_State* L, int index, T* fallback = NULL, bool strict = false)
-{
-    if (lua_isnil(L, index))
-        return fallback;
-    else
-        return luaW_check<T>(L, index, strict);
-}
-
-// Analogous to lua_push(boolean|string|*)
-//
-// Pushes a userdata of type T onto the stack. If this object already exists in
-// the Lua environment, it will assign the existing storage table to it.
-// Otherwise, a new storage table will be created for it.
-template <typename T>
-void luaW_push(lua_State* L, T* obj)
-{
-    if (obj)
-    {
-        LuaWrapper<T>::identifier(L, obj); // ... id
-        luaW_wrapperfield<T>(L, LUAW_CACHE_KEY); // ... id cache
-        lua_pushvalue(L, -2); // ... id cache id
-        lua_gettable(L, -2); // ... id cache obj
-        if (lua_isnil(L, -1))
-        {
-            // Create the new luaW_userdata and place it in the cache
-            lua_pop(L, 1); // ... id cache
-            lua_insert(L, -2); // ... cache id
-            luaW_Userdata* ud = static_cast<luaW_Userdata*>(lua_newuserdata(L, sizeof(luaW_Userdata))); // ... cache id obj
-            ud->data = obj;
-            ud->cast = LuaWrapper<T>::cast;
-            lua_pushvalue(L, -1); // ... cache id obj obj
-            lua_insert(L, -4); // ... obj cache id obj
-            lua_settable(L, -3); // ... obj cache
-
-            luaL_getmetatable(L, LuaWrapper<T>::classname); // ... obj cache mt
-            lua_setmetatable(L, -3); // ... obj cache
-
-            lua_pop(L, 1); // ... obj
-        }
-        else
-        {
-            lua_replace(L, -3); // ... obj cache
-            lua_pop(L, 1); // ... obj
-        }
-    }
-    else
-    {
-        lua_pushnil(L);
-    }
-}
-
-// Instructs LuaWrapper that it owns the userdata, and can manage its memory.
-// When all references to the object are removed, Lua is free to garbage
-// collect it and delete the object.
-//
-// Returns true if luaW_hold took hold of the object, and false if it was
-// already held
-template <typename T>
-bool luaW_hold(lua_State* L, T* obj)
-{
-    luaW_wrapperfield<T>(L, LUAW_HOLDS_KEY); // ... holds
-    LuaWrapper<T>::identifier(L, obj); // ... holds id
-    lua_pushvalue(L, -1); // ... holds id id
-    lua_gettable(L, -3); // ... holds id hold
-    // If it's not held, hold it
-    if (!lua_toboolean(L, -1))
-    {
-        // Apply hold boolean
-        lua_pop(L, 1); // ... holds id
-        lua_pushboolean(L, true); // ... holds id true
-        lua_settable(L, -3); // ... holds
-        lua_pop(L, 1); // ...
-        return true;
-    }
-    lua_pop(L, 3); // ...
-    return false;
-}
-
-// Releases LuaWrapper's hold on an object. This allows the user to remove
-// all references to an object in Lua and ensure that Lua will not attempt to
-// garbage collect it.
-//
-// This function takes the index of the identifier for an object rather than
-// the object itself. This is because needs to be able to run after the object
-// has already been deallocated. A wrapper is provided for when it is more
-// convenient to pass in the object directly.
-template <typename T>
-void luaW_release(lua_State* L, int index)
-{
-    luaW_wrapperfield<T>(L, LUAW_HOLDS_KEY); // ... id ... holds
-    lua_pushvalue(L, luaW_correctindex(L, index, 1)); // ... id ... holds id
-    lua_pushnil(L); // ... id ... holds id nil
-    lua_settable(L, -3); // ... id ... holds
-    lua_pop(L, 1); // ... id ...
-}
-
-template <typename T>
-void luaW_release(lua_State* L, T* obj)
-{
-    LuaWrapper<T>::identifier(L, obj); // ... id
-    luaW_release<T>(L, -1); // ... id
-    lua_pop(L, 1); // ...
-}
-
-// This function is called from Lua, not C++
-//
-// Calls the lua post-constructor (LUAW_POSTCTOR_KEY or "__postctor") on a
-// userdata. Assumes the userdata is on top of the stack, and numargs arguments
-// are below it. This runs the LUAW_POSTCTOR_KEY function on T's metatable,
-// using the object as the first argument and whatever else is below it as
-// the rest of the arguments This exists to allow types to adjust values in
-// thier storage table, which can not be created until after the constructor is
-// called.
-template <typename T>
-void luaW_postconstructor(lua_State* L, int numargs)
-{
-    // ... args... ud
-    lua_getfield(L, -1, LUAW_POSTCTOR_KEY); // ... args... ud ud.__postctor
-    if (lua_type(L, -1) == LUA_TFUNCTION)
-    {
-        lua_pushvalue(L, -2); // ... args... ud ud.__postctor ud
-        lua_insert(L, -3 - numargs); // ... ud args... ud ud.__postctor
-        lua_insert(L, -3 - numargs); // ... ud.__postctor ud args... ud
-        lua_insert(L, -3 - numargs); // ... ud ud.__postctor ud args...
-        lua_call(L, numargs + 1, 0); // ... ud
-    }
-    else
-    {
-        lua_pop(L, 1); // ... ud
-    }
-}
-
-// This function is generally called from Lua, not C++
-//
-// Creates an object of type T using the constructor and subsequently calls the
-// post-constructor on it.
-template <typename T>
-inline int luaW_new(lua_State* L, int args)
-{
-    T* obj = LuaWrapper<T>::allocator(L);
-    luaW_push<T>(L, obj);
-    luaW_hold<T>(L, obj);
-    luaW_postconstructor<T>(L, args);
-    return 1;
-}
-
-template <typename T>
-int luaW_new(lua_State* L)
-{
-    return luaW_new<T>(L, lua_gettop(L));
-}
-
-// This function is called from Lua, not C++
-//
-// The default metamethod to call when indexing into lua userdata representing
-// an object of type T. This will first check the userdata's environment table
-// and if it's not found there it will check the metatable. This is done so
-// individual userdata can be treated as a table, and can hold thier own
-// values.
-template <typename T>
-int luaW_index(lua_State* L)
-{
-    // obj key
-    T* obj = luaW_to<T>(L, 1);
-    luaW_wrapperfield<T>(L, LUAW_STORAGE_KEY); // obj key storage
-    LuaWrapper<T>::identifier(L, obj); // obj key storage id
-    lua_gettable(L, -2); // obj key storage store
-
-    // Check if storage table exists
-    if (!lua_isnil(L, -1))
-    {
-        lua_pushvalue(L, -3); // obj key storage store key
-        lua_gettable(L, -2); // obj key storage store store[k]
-    }
-
-    // If either there is no storage table or the key wasn't found
-    // then fall back to the metatable
-    if (lua_isnil(L, -1))
-    {
-        lua_settop(L, 2); // obj key
-        lua_getmetatable(L, -2); // obj key mt
-        lua_pushvalue(L, -2); // obj key mt k
-        lua_gettable(L, -2); // obj key mt mt[k]
-    }
-    return 1;
-}
-
-// This function is called from Lua, not C++
-//
-// The default metamethod to call when creating a new index on lua userdata
-// representing an object of type T. This will index into the the userdata's
-// environment table that it keeps for personal storage. This is done so
-// individual userdata can be treated as a table, and can hold thier own
-// values.
-template <typename T>
-int luaW_newindex(lua_State* L)
-{
-    // obj key value
-    T* obj = luaW_check<T>(L, 1);
-    luaW_wrapperfield<T>(L, LUAW_STORAGE_KEY); // obj key value storage
-    LuaWrapper<T>::identifier(L, obj); // obj key value storage id
-    lua_pushvalue(L, -1); // obj key value storage id id
-    lua_gettable(L, -3); // obj key value storage id store
-
-    // Add the storage table if there isn't one already
-    if (lua_isnil(L, -1))
-    {
-        lua_pop(L, 1); // obj key value storage id
-        lua_newtable(L); // obj key value storage id store
-        lua_pushvalue(L, -1); // obj key value storage id store store
-        lua_insert(L, -3); // obj key value storage store id store
-        lua_settable(L, -4); // obj key value storage store
-    }
-
-    lua_pushvalue(L, 2); // obj key value ... store key
-    lua_pushvalue(L, 3); // obj key value ... store key value
-    lua_settable(L, -3); // obj key value ... store
-
-    return 0;
-}
-
-// This function is called from Lua, not C++
-//
-// The __gc metamethod handles cleaning up userdata. The userdata's reference
-// count is decremented and if this is the final reference to the userdata its
-// environment table is nil'd and pointer deleted with the destructor callback.
-template <typename T>
-int luaW_gc(lua_State* L)
-{
-    // obj
-    T* obj = luaW_to<T>(L, 1);
-    LuaWrapper<T>::identifier(L, obj); // obj key value storage id
-    luaW_wrapperfield<T>(L, LUAW_HOLDS_KEY); // obj id counts count holds
-    lua_pushvalue(L, 2); // obj id counts count holds id
-    lua_gettable(L, -2); // obj id counts count holds hold
-    if (lua_toboolean(L, -1) && LuaWrapper<T>::deallocator)
-    {
-        LuaWrapper<T>::deallocator(L, obj);
-    }
-
-    luaW_wrapperfield<T>(L, LUAW_STORAGE_KEY); // obj id counts count holds hold storage
-    lua_pushvalue(L, 2); // obj id counts count holds hold storage id
-    lua_pushnil(L); // obj id counts count holds hold storage id nil
-    lua_settable(L, -3); // obj id counts count holds hold storage
-
-    luaW_release<T>(L, 2);
-    return 0;
-}
-
-// Thakes two tables and registers them with Lua to the table on the top of the
-// stack. 
-//
-// This function is only called from LuaWrapper internally. 
-inline void luaW_registerfuncs(lua_State* L, const luaL_Reg defaulttable[], const luaL_Reg table[])
-{
-    // ... T
-#if LUA_VERSION_NUM > 501
-    if (defaulttable)
-        luaL_setfuncs(L, defaulttable, 0); // ... T
-    if (table)
-        luaL_setfuncs(L, table, 0); // ... T
-#else
-    if (defaulttable)
-        luaL_register(L, NULL, defaulttable); // ... T
-    if (table)
-        luaL_register(L, NULL, table); // ... T
-#endif
-}
-
-// Initializes the LuaWrapper tables used to track internal state. 
-//
-// This function is only called from LuaWrapper internally. 
-inline void luaW_initialize(lua_State* L)
-{
-    // Ensure that the LuaWrapper table is set up
-    lua_getfield(L, LUA_REGISTRYINDEX, LUAW_WRAPPER_KEY); // ... LuaWrapper
-    if (lua_isnil(L, -1))
-    {
-        lua_newtable(L); // ... nil {}
-        lua_pushvalue(L, -1); // ... nil {} {}
-        lua_setfield(L, LUA_REGISTRYINDEX, LUAW_WRAPPER_KEY); // ... nil LuaWrapper
-        
-        // Create a storage table        
-        lua_newtable(L); // ... LuaWrapper nil {}
-        lua_setfield(L, -2, LUAW_STORAGE_KEY); // ... nil LuaWrapper
-        
-        // Create a holds table
-        lua_newtable(L); // ... LuaWrapper {}
-        lua_setfield(L, -2, LUAW_HOLDS_KEY); // ... nil LuaWrapper
-
-        // Create a cache table, with weak values so that the userdata will not
-        // be ref counted
-        lua_newtable(L); // ... nil LuaWrapper {}
-        lua_setfield(L, -2, LUAW_CACHE_KEY); // ... nil LuaWrapper
-        
-        lua_newtable(L); // ... nil LuaWrapper {}
-        lua_pushstring(L, "v"); // ... nil LuaWrapper {} "v"
-        lua_setfield(L, -2, "__mode"); // ... nil LuaWrapper {}
-        lua_setfield(L, -2, LUAW_CACHE_METATABLE_KEY); // ... nil LuaWrapper
-        
-        lua_pop(L, 1); // ... nil
-    }
-    lua_pop(L, 1); // ...
-}
-
-// Run luaW_register or luaW_setfuncs to create a table and metatable for your
-// class.  These functions create a table with filled with the function from
-// the table argument in addition to the functions new and build (This is
-// generally for things you think of as static methods in C++). The given
-// metatable argument becomes a metatable for each object of your class. These
-// can be thought of as member functions or methods.
-//
-// You may also supply constructors and destructors for classes that do not
-// have a default constructor or that require special set up or tear down. You
-// may specify NULL as the constructor, which means that you will not be able
-// to call the new function on your class table. You will need to manually push
-// objects from C++. By default, the default constructor is used to create
-// objects and a simple call to delete is used to destroy them.
-//
-// By default LuaWrapper uses the address of C++ object to identify unique
-// objects. In some cases this is not desired, such as in the case of
-// shared_ptrs. Two shared_ptrs may themselves have unique locations in memory
-// but still represent the same object. For cases like that, you may specify an
-// identifier function which is responsible for pushing a key representing your
-// object on to the stack.
-//
-// luaW_register will set table as the new value of the global of the given
-// name. luaW_setfuncs is identical to luaW_register, but it does not set the
-// table globally.  As with luaL_register and luaL_setfuncs, both funcstions
-// leave the new table on the top of the stack.
-template <typename T>
-void luaW_setfuncs(lua_State* L, const char* classname, const luaL_Reg* table, const luaL_Reg* metatable, T* (*allocator)(lua_State*) = luaW_defaultallocator<T>, void (*deallocator)(lua_State*, T*) = luaW_defaultdeallocator<T>, void (*identifier)(lua_State*, T*) = luaW_defaultidentifier<T>)
-{
-    luaW_initialize(L);
-
-    LuaWrapper<T>::classname = classname;
-    LuaWrapper<T>::identifier = identifier;
-    LuaWrapper<T>::allocator = allocator;
-    LuaWrapper<T>::deallocator = deallocator;
-
-    const luaL_Reg defaulttable[] =
-    {
-        { "new", luaW_new<T> },
-        { NULL, NULL }
-    };
-    const luaL_Reg defaultmetatable[] = 
-    { 
-        { "__index", luaW_index<T> }, 
-        { "__newindex", luaW_newindex<T> }, 
-        { "__gc", luaW_gc<T> }, 
-        { NULL, NULL } 
-    };
-
-    // Set up per-type tables
-    lua_getfield(L, LUA_REGISTRYINDEX, LUAW_WRAPPER_KEY); // ... LuaWrapper
-    
-    lua_getfield(L, -1, LUAW_STORAGE_KEY); // ... LuaWrapper LuaWrapper.storage
-    lua_newtable(L); // ... LuaWrapper LuaWrapper.storage {}
-    lua_setfield(L, -2, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.storage
-    lua_pop(L, 1); // ... LuaWrapper
-
-    lua_getfield(L, -1, LUAW_HOLDS_KEY); // ... LuaWrapper LuaWrapper.holds
-    lua_newtable(L); // ... LuaWrapper LuaWrapper.holds {}
-    lua_setfield(L, -2, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.holds
-    lua_pop(L, 1); // ... LuaWrapper
-
-    lua_getfield(L, -1, LUAW_CACHE_KEY); // ... LuaWrapper LuaWrapper.cache
-    lua_newtable(L); // ... LuaWrapper LuaWrapper.cache {}
-    luaW_wrapperfield<T>(L, LUAW_CACHE_METATABLE_KEY); // ... LuaWrapper LuaWrapper.cache {} cmt
-    lua_setmetatable(L, -2); // ... LuaWrapper LuaWrapper.cache {}
-    lua_setfield(L, -2, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.cache
-        
-    lua_pop(L, 2); // ...
-    
-    // Open table
-    lua_newtable(L); // ... T
-    luaW_registerfuncs(L, allocator ? defaulttable : NULL, table); // ... T
-
-    // Open metatable, set up extends table
-    luaL_newmetatable(L, classname); // ... T mt
-    lua_newtable(L); // ... T mt {}
-    lua_setfield(L, -2, LUAW_EXTENDS_KEY); // ... T mt
-    luaW_registerfuncs(L, defaultmetatable, metatable); // ... T mt
-    lua_setfield(L, -2, "metatable"); // ... T
-}
-
-template <typename T>
-void luaW_register(lua_State* L, const char* classname, const luaL_Reg* table, const luaL_Reg* metatable, T* (*allocator)(lua_State*) = luaW_defaultallocator<T>, void (*deallocator)(lua_State*, T*) = luaW_defaultdeallocator<T>, void (*identifier)(lua_State*, T*) = luaW_defaultidentifier<T>)
-{
-    luaW_setfuncs(L, classname, table, metatable, allocator, deallocator, identifier); // ... T
-    lua_pushvalue(L, -1); // ... T T
-    lua_setglobal(L, classname); // ... T
-}
-
-// luaW_extend is used to declare that class T inherits from class U. All
-// functions in the base class will be available to the derived class (except
-// when they share a function name, in which case the derived class's function
-// wins). This also allows luaW_to<T> to cast your object apropriately, as
-// casts straight through a void pointer do not work.
-template <typename T, typename U>
-void luaW_extend(lua_State* L)
-{
-    if(!LuaWrapper<T>::classname)
-        luaL_error(L, "attempting to call extend on a type that has not been registered");
-
-    if(!LuaWrapper<U>::classname)
-        luaL_error(L, "attempting to extend %s by a type that has not been registered", LuaWrapper<T>::classname);
-
-    LuaWrapper<T>::cast = luaW_cast<T, U>;
-    LuaWrapper<T>::identifier = luaW_identify<T, U>;
-
-    luaL_getmetatable(L, LuaWrapper<T>::classname); // mt
-    luaL_getmetatable(L, LuaWrapper<U>::classname); // mt emt
-
-    // Point T's metatable __index at U's metatable for inheritance
-    lua_newtable(L); // mt emt {}
-    lua_pushvalue(L, -2); // mt emt {} emt
-    lua_setfield(L, -2, "__index"); // mt emt {}
-    lua_setmetatable(L, -3); // mt emt
-
-    // Set up per-type tables to point at parent type
-    lua_getfield(L, LUA_REGISTRYINDEX, LUAW_WRAPPER_KEY); // ... LuaWrapper
-    
-    lua_getfield(L, -1, LUAW_STORAGE_KEY); // ... LuaWrapper LuaWrapper.storage
-    lua_getfield(L, -1, LuaWrapper<U>::classname); // ... LuaWrapper LuaWrapper.storage U
-    lua_setfield(L, -2, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.storage
-    lua_pop(L, 1); // ... LuaWrapper
-
-    lua_getfield(L, -1, LUAW_HOLDS_KEY); // ... LuaWrapper LuaWrapper.holds
-    lua_getfield(L, -1, LuaWrapper<U>::classname); // ... LuaWrapper LuaWrapper.holds U
-    lua_setfield(L, -2, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.holds
-    lua_pop(L, 1); // ... LuaWrapper
-
-    lua_getfield(L, -1, LUAW_CACHE_KEY); // ... LuaWrapper LuaWrapper.cache
-    lua_getfield(L, -1, LuaWrapper<U>::classname); // ... LuaWrapper LuaWrapper.cache U
-    lua_setfield(L, -2, LuaWrapper<T>::classname); // ... LuaWrapper LuaWrapper.cache
-        
-    lua_pop(L, 2); // ...
-    
-    // Make a list of all types that inherit from U, for type checking
-    lua_getfield(L, -2, LUAW_EXTENDS_KEY); // mt emt mt.extends
-    lua_pushvalue(L, -2); // mt emt mt.extends emt
-    lua_setfield(L, -2, LuaWrapper<U>::classname); // mt emt mt.extends
-    lua_getfield(L, -2, LUAW_EXTENDS_KEY); // mt emt mt.extends emt.extends
-    for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1))
-    {
-        // mt emt mt.extends emt.extends k v
-        lua_pushvalue(L, -2); // mt emt mt.extends emt.extends k v k
-        lua_pushvalue(L, -2); // mt emt mt.extends emt.extends k v k
-        lua_rawset(L, -6); // mt emt mt.extends emt.extends k v
-    }
-
-    lua_pop(L, 4); // mt emt
-}
-
-/*
- * Copyright (c) 2010-2013 Alexander Ames
- *
- * 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.
- */
-
-#endif // LUA_WRAPPER_H_

luarocks/luawrapperutil.hpp

@@ -1,714 +0,0 @@
-/*
- * Copyright (c) 2010-2013 Alexander Ames
- * Alexander.Ames@gmail.com
- * See Copyright Notice at the end of this file
- */
-
-// API Summary:
-//
-// This is a set of utility functions that add to the functionalit of
-// LuaWrapper. Over time I found myself repeating a few patterns, such as
-// writing many trvial getter and setter functions, and wanting pass ownership
-// of one object to another and have the Lua script properly handle that case.
-//
-// This file contains the additional functions that I've added but that do
-// not really belong in the core API.
-
-#ifndef LUAWRAPPERUTILS_HPP_
-#define LUAWRAPPERUTILS_HPP_
-
-#include "luawrapper.hpp"
-
-#ifndef LUAW_NO_CXX11
-#include <type_traits>
-#endif
-
-#ifndef LUAW_STD
-#define LUAW_STD std
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A set of templated luaL_check and lua_push functions for use in the getters
-// and setters below
-//
-// It is often useful to override luaU_check, luaU_to and/or luaU_push to
-// operate on your own simple types rather than register your type with
-// LuaWrapper, especially with small objects.
-//
-
-template<typename U, typename = void>
-struct luaU_Impl
-{
-    static U    luaU_check(lua_State* L, int      index);
-    static U    luaU_to   (lua_State* L, int      index);
-    static void luaU_push (lua_State* L, const U& value);
-    static void luaU_push (lua_State* L,       U& value);
-};
-
-template<typename U> U    luaU_check(lua_State* L, int      index) { return luaU_Impl<U>::luaU_check(L, index); }
-template<typename U> U    luaU_to   (lua_State* L, int      index) { return luaU_Impl<U>::luaU_to   (L, index); }
-template<typename U> void luaU_push (lua_State* L, const U& value) {        luaU_Impl<U>::luaU_push (L, value); }
-template<typename U> void luaU_push (lua_State* L,       U& value) {        luaU_Impl<U>::luaU_push (L, value); }
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// This is slightly different than the previous three functions in that you
-// shouldn't need to write your own version of it, since it uses luaU_check
-// automatically.
-//
-template<typename U>
-U luaU_opt(lua_State* L, int index, const U& fallback = U())
-{
-    if (lua_isnil(L, index))
-        return fallback;
-    else
-        return luaU_Impl<U>::luaU_check(L, index);
-}
-
-template<>
-struct luaU_Impl<bool>
-{
-    static bool luaU_check(lua_State* L, int         index) { return lua_toboolean  (L, index) != 0; }
-    static bool luaU_to   (lua_State* L, int         index) { return lua_toboolean  (L, index) != 0; }
-    static void luaU_push (lua_State* L, const bool& value) {        lua_pushboolean(L, value); }
-};
-
-template<>
-struct luaU_Impl<const char*>
-{
-    static const char* luaU_check(lua_State* L, int                index) { return luaL_checkstring(L, index); }
-    static const char* luaU_to   (lua_State* L, int                index) { return lua_tostring    (L, index); }
-    static void        luaU_push (lua_State* L, const char* const& value) {        lua_pushstring  (L, value); }
-};
-
-template<>
-struct luaU_Impl<unsigned int>
-{
-    static unsigned int luaU_check(lua_State* L, int                 index) { return static_cast<unsigned int>(luaL_checkinteger(L, index)); }
-    static unsigned int luaU_to   (lua_State* L, int                 index) { return static_cast<unsigned int>(lua_tointeger    (L, index)); }
-    static void         luaU_push (lua_State* L, const unsigned int& value) {                                  lua_pushinteger  (L, value); }
-};
-
-template<>
-struct luaU_Impl<int>
-{
-    static int  luaU_check(lua_State* L, int        index) { return static_cast<int>(luaL_checkinteger(L, index)); }
-    static int  luaU_to   (lua_State* L, int        index) { return static_cast<int>(lua_tointeger    (L, index)); }
-    static void luaU_push (lua_State* L, const int& value) {                         lua_pushinteger  (L, value); }
-};
-
-template<>
-struct luaU_Impl<unsigned char>
-{
-    static unsigned char luaU_check(lua_State* L, int                  index) { return static_cast<unsigned char>(luaL_checkinteger(L, index)); }
-    static unsigned char luaU_to   (lua_State* L, int                  index) { return static_cast<unsigned char>(lua_tointeger    (L, index)); }
-    static void          luaU_push (lua_State* L, const unsigned char& value) {                                   lua_pushinteger  (L, value); }
-};
-
-template<>
-struct luaU_Impl<char>
-{
-    static char luaU_check(lua_State* L, int         index) { return static_cast<char>(luaL_checkinteger(L, index)); }
-    static char luaU_to   (lua_State* L, int         index) { return static_cast<char>(lua_tointeger    (L, index)); }
-    static void luaU_push (lua_State* L, const char& value) {                          lua_pushinteger  (L, value); }
-};
-
-template<>
-struct luaU_Impl<float>
-{
-    static float luaU_check(lua_State* L, int          index) { return static_cast<float>(luaL_checknumber(L, index)); }
-    static float luaU_to   (lua_State* L, int          index) { return static_cast<float>(lua_tonumber    (L, index)); }
-    static void  luaU_push (lua_State* L, const float& value) {                           lua_pushnumber  (L, value); }
-};
-
-template<>
-struct luaU_Impl<double>
-{
-    static double luaU_check(lua_State* L, int           index) { return static_cast<double>(luaL_checknumber(L, index)); }
-    static double luaU_to   (lua_State* L, int           index) { return static_cast<double>(lua_tonumber    (L, index)); }
-    static void   luaU_push (lua_State* L, const double& value) {                            lua_pushnumber  (L, value); }
-};
-
-#ifndef LUAW_NO_CXX11
-template<typename T>
-struct luaU_Impl<T, typename LUAW_STD::enable_if<LUAW_STD::is_enum<T>::value>::type>
-{
-    static T    luaU_check(lua_State* L, int      index) { return static_cast<T>(luaL_checkinteger  (L, index)); }
-    static T    luaU_to   (lua_State* L, int      index) { return static_cast<T>(lua_tointeger      (L, index)); }
-    static void luaU_push (lua_State* L, const T& value) {        lua_pushnumber(L, static_cast<int>(value   )); }
-};
-
-template<typename T>
-struct luaU_Impl<T*, typename LUAW_STD::enable_if<LUAW_STD::is_class<T>::value>::type>
-{
-    static T*   luaU_check( lua_State* L, int index) { return luaW_check<T>(L, index); }
-    static T*   luaU_to   ( lua_State* L, int index) { return luaW_to   <T>(L, index); }
-    static void luaU_push ( lua_State* L, T*& value) {        luaW_push <T>(L, value); }
-    static void luaU_push ( lua_State* L, T*  value) {        luaW_push <T>(L, value); }
-};
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// These are just some functions I've always felt should exist
-//
-
-template <typename U>
-inline U luaU_getfield(lua_State* L, int index, const char* field)
-{
-#ifndef LUAW_NO_CXX11
-    static_assert(!std::is_same<U, const char*>::value, 
-        "luaU_getfield is not safe to use on const char*'s. (The string will be popped from the stack.)");
-#endif
-    lua_getfield(L, index, field);
-    U val = luaU_to<U>(L, -1);
-    lua_pop(L, 1);
-    return val;
-}
-
-template <typename U>
-inline U luaU_checkfield(lua_State* L, int index, const char* field)
-{
-#ifndef LUAW_NO_CXX11
-    static_assert(!std::is_same<U, const char*>::value, 
-        "luaU_checkfield is not safe to use on const char*'s. (The string will be popped from the stack.)");
-#endif
-    lua_getfield(L, index, field);
-    U val = luaU_check<U>(L, -1);
-    lua_pop(L, 1);
-    return val;
-}
-
-template <typename U>
-inline void luaU_setfield(lua_State* L, int index, const char* field, U val)
-{
-    luaU_push<U>(L, val);
-    lua_setfield(L, luaW_correctindex(L, index, 1), field);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// A set of trivial getter and setter templates. These templates are designed
-// to call trivial getters or setters.
-//
-// There are four forms:
-//  1. Getting or setting a public member variable that is of a primitive type
-//  2. Getting or setting a public member variable that is a pointer to an
-//     object
-//  3. Getting or setting a private member variable that is of a primitive type
-//     through a getter or setter
-//  3. Getting or setting a private member variable that is is a pointer to an
-//     object through a getter or setter
-//
-// The interface to all of them is the same however. In addition to plain
-// getter and setter functions, there is a getset which does both - if an
-// argument is supplied it attempts to set the value, and in either case it
-// returns the value. In your lua table declaration in C++ rather than write
-// individiual wrappers for each getter and setter you may do the following:
-//
-// static luaL_reg Foo_metatable[] =
-// {
-//     { "GetBar", luaU_get<Foo, bool, &Widget::GetBar> },
-//     { "SetBar", luaU_set<Foo, bool, &Widget::SetBar> },
-//     { "Bar", luaU_getset<Foo, bool, &Widget::GetBar, &Widget::SetBar> },
-//     { NULL, NULL }
-// }
-//
-// Getters and setters must have one of the following signatures:
-//    void T::Setter(U value);
-//    void T::Setter(U* value);
-//    void T::Setter(const U& value);
-//    U Getter() const;
-//    U* Getter() const;
-//
-// In this example, the variable Foo::bar is private and so it is accessed
-// through getter and setter functions. If Foo::bar were public, it could be
-// accessed directly, like so:
-//
-// static luaL_reg Foo_metatable[] =
-// {
-//     { "GetBar", luaU_get<Foo, bool, &Widget::bar> },
-//     { "SetBar", luaU_set<Foo, bool, &Widget::bar> },
-//     { "Bar", luaU_getset<Foo, bool, &Widget::bar> },
-// }
-//
-// In a Lua script, you can now use foo:GetBar(), foo:SetBar() and foo:Bar()
-//
-
-template <typename T, typename U, U T::*Member>
-int luaU_get(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    luaU_push<U>(L, obj->*Member);
-    return 1;
-}
-
-template <typename T, typename U, U* T::*Member>
-int luaU_get(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    luaW_push<U>(L, obj->*Member);
-    return 1;
-}
-
-template <typename T, typename U, U (T::*Getter)() const>
-int luaU_get(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    luaU_push<U>(L, (obj->*Getter)());
-    return 1;
-}
-
-template <typename T, typename U, const U& (T::*Getter)() const>
-int luaU_get(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    luaU_push<U>(L, (obj->*Getter)());
-    return 1;
-}
-
-template <typename T, typename U, U* (T::*Getter)() const>
-int luaU_get(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    luaW_push<U>(L, (obj->*Getter)());
-    return 1;
-}
-
-template <typename T, typename U, U T::*Member>
-int luaU_set(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-        obj->*Member = luaU_check<U>(L, 2);
-    return 0;
-}
-
-template <typename T, typename U, U* T::*Member>
-int luaU_set(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        obj->*Member = member;
-    }
-    return 0;
-}
-
-template <typename T, typename U, const U* T::*Member>
-int luaU_set(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        obj->*Member = member;
-    }
-    return 0;
-}
-
-template <typename T, typename U, const U* T::*Member>
-int luaU_setandrelease(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        obj->*Member = member;
-        if (member)
-            luaW_release<U>(L, member);
-    }
-    return 0;
-}
-
-template <typename T, typename U, void (T::*Setter)(U)>
-int luaU_set(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-        (obj->*Setter)(luaU_check<U>(L, 2));
-    return 0;
-}
-
-template <typename T, typename U, void (T::*Setter)(const U&)>
-int luaU_set(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-        (obj->*Setter)(luaU_check<U>(L, 2));
-    return 0;
-}
-
-template <typename T, typename U, void (T::*Setter)(U*)>
-int luaU_set(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        (obj->*Setter)(member);
-    }
-    return 0;
-}
-
-template <typename T, typename U, void (T::*Setter)(U*)>
-int luaU_setandrelease(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        (obj->*Setter)(member);
-        if (member)
-            luaW_release<U>(L, member);
-    }
-    return 0;
-}
-
-template <typename T, typename U, U T::*Member>
-int luaU_getset(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        obj->*Member = luaU_check<U>(L, 2);
-        return 0;
-    }
-    else
-    {
-        luaU_push<U>(L, obj->*Member);
-        return 1;
-    }
-}
-
-template <typename T, typename U, U* T::*Member>
-int luaU_getset(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        obj->*Member = member;
-        return 0;
-    }
-    else
-    {
-        luaW_push<U>(L, obj->*Member);
-        return 1;
-    }
-}
-
-template <typename T, typename U, U* T::*Member>
-int luaU_getsetandrelease(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        obj->*Member = member;
-        if (member)
-            luaW_release<U>(L, member);
-        return 0;
-    }
-    else
-    {
-        luaW_push<U>(L, obj->*Member);
-        return 1;
-    }
-}
-
-template <typename T, typename U, U (T::*Getter)() const, void (T::*Setter)(U)>
-int luaU_getset(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        (obj->*Setter)(luaU_check<U>(L, 2));
-        return 0;
-    }
-    else
-    {
-        luaU_push<U>(L, (obj->*Getter)());
-        return 1;
-    }
-}
-
-template <typename T, typename U, U (T::*Getter)() const, void (T::*Setter)(const U&)>
-int luaU_getset(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        (obj->*Setter)(luaU_check<U>(L, 2));
-        return 0;
-    }
-    else
-    {
-        luaU_push<U>(L, (obj->*Getter)());
-        return 1;
-    }
-}
-
-template <typename T, typename U, const U& (T::*Getter)() const, void (T::*Setter)(const U&)>
-int luaU_getset(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        (obj->*Setter)(luaU_check<U>(L, 2));
-        return 0;
-    }
-    else
-    {
-        luaU_push<U>(L, (obj->*Getter)());
-        return 1;
-    }
-}
-
-template <typename T, typename U, U* (T::*Getter)() const, void (T::*Setter)(U*)>
-int luaU_getset(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        (obj->*Setter)(member);
-        return 0;
-    }
-    else
-    {
-        luaW_push<U>(L, (obj->*Getter)());
-        return 1;
-    }
-}
-
-template <typename T, typename U, U* (T::*Getter)() const, void (T::*Setter)(U*)>
-int luaU_getsetandrelease(lua_State* L)
-{
-    T* obj = luaW_check<T>(L, 1);
-    if (obj && lua_gettop(L) >= 2)
-    {
-        U* member = luaW_opt<U>(L, 2);
-        (obj->*Setter)(member);
-        if (member)
-            luaW_release<U>(L, member);
-        return 0;
-    }
-    else
-    {
-        luaW_push<U>(L, (obj->*Getter)());
-        return 1;
-    }
-}
-
-#if !defined(_WIN32) && !defined(LUAW_NO_CXX11)
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// luaU_func is a special macro that expands into a simple function wrapper.
-// Unlike the getter setters above, you merely need to name the function you
-// would like to wrap.
-//
-// For example,
-//
-// struct Foo
-// {
-//     int DoSomething(int, const char*);
-// };
-//
-// static luaL_reg Foo_metatable[] =
-// {
-//     { "DoSomething", luaU_func(&Foo::DoSomething) },
-//     { NULL, NULL }
-// }
-//
-// This macro will expand based on the function signature of Foo::DoSomething
-// In this example, it would expand into the following wrapper:
-//
-//     luaU_push(luaW_check<T>(L, 1)->DoSomething(luaU_check<int>(L, 2), luaU_check<const char*>(L, 3)));
-//     return 1;
-//
-// In this example there is only one member function called DoSomething. In some 
-// cases there may be multiple overrides for a function. For those cases, an 
-// additional macro has been provided, luaU_funcsig, which takes the entire
-// function signature. The arguments to the macro reflect the order they would
-// appear in the function signature: return type, type name, function name, and
-// finally a list of all the argument types. For example:
-//
-// struct Foo
-// {
-//     int DoSomething (const char*);
-//     int DoSomething (const char*, int);
-// };
-//
-// const struct luaL_Reg Foo_metatable[] =
-// {
-//     {"DoSomething1", luaU_funcsig(int, Foo, DoSomething, const char*)) },
-//     {"DoSomething1", luaU_funcsig(int, Foo, DoSomething, const char*, int)) },
-//     { NULL, NULL }
-// };
-//
-// These macros and it's underlying templates are somewhat experimental and some
-// refinements are probably needed.  There are cases where it does not
-// currently work and I expect some changes can be made to refine its behavior.
-//
-
-#define luaU_func(memberfunc) &luaU_FuncWrapper<decltype(memberfunc),memberfunc>::call
-#define luaU_funcsig(returntype, type, funcname, ...) luaU_func(static_cast<returntype (type::*)(__VA_ARGS__)>(&type::funcname))
-
-template<int... ints> struct luaU_IntPack { };
-template<int start, int count, int... tail> struct luaU_MakeIntRangeType { typedef typename luaU_MakeIntRangeType<start, count-1, start+count-1, tail...>::type type; };
-template<int start, int... tail> struct luaU_MakeIntRangeType<start, 0, tail...> { typedef luaU_IntPack<tail...> type; };
-template<int start, int count> inline typename luaU_MakeIntRangeType<start, count>::type luaU_makeIntRange() { return typename luaU_MakeIntRangeType<start, count>::type(); }
-template<class MemFunPtrType, MemFunPtrType MemberFunc> struct luaU_FuncWrapper;
-
-template<class T, class ReturnType, class... Args, ReturnType(T::*MemberFunc)(Args...)>
-struct luaU_FuncWrapper<ReturnType (T::*)(Args...), MemberFunc>
-{
-public:
-    static int call(lua_State* L)
-    {
-        return callImpl(L, luaU_makeIntRange<2,sizeof...(Args)>());
-    }
-
-private:
-    template<int... indices>
-    static int callImpl(lua_State* L, luaU_IntPack<indices...>)
-    {
-        luaU_push<ReturnType>(L, (luaW_check<T>(L, 1)->*MemberFunc)(luaU_check<Args>(L, indices)...));
-        return 1;
-    }
-};
-
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Calls the copy constructor for an object of type T.
-// Arguments may be passed in, in case they're needed for the postconstructor
-//
-// e.g.
-//
-// C++:
-// luaL_reg Foo_Metatable[] =
-// {
-//     { "clone", luaU_clone<Foo> },
-//     { NULL, NULL }
-// };
-//
-// Lua:
-// foo = Foo.new()
-// foo2 = foo:clone()
-//
-template <typename T>
-int luaU_clone(lua_State* L)
-{
-    // obj ...
-    T* obj = new T(*luaW_check<T>(L, 1));
-    lua_remove(L, 1); // ...
-    int numargs = lua_gettop(L);
-    luaW_push<T>(L, obj); // ... clone
-    luaW_hold<T>(L, obj);
-    luaW_postconstructor<T>(L, numargs);
-    return 1;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// luaU_build is intended to be used to initialize many values by passing in a
-// table. They keys of the table are used as function names, and values are
-// used as arguments to the function. This is intended to be used on functions
-// that are simple setters.
-//
-// For example, if luaU_build is set as the post constructor, you can
-// initialize an object as so:
-//
-// f = Foo.new
-// {
-//     X = 10;
-//     Y = 20;
-// }
-//
-// After the object is constructed, luaU_build will do the equivalent of
-// calling f:X(10) and f:Y(20).
-//
-template <typename T>
-int luaU_build(lua_State* L)
-{
-    // obj {}
-    lua_insert(L, -2); // {} obj
-    if (lua_type(L, 1) == LUA_TTABLE)
-    {
-        for (lua_pushnil(L); lua_next(L, 1); lua_pop(L, 1))
-        {
-            // {} obj k v
-            lua_pushvalue(L, -2); // {} obj k v k
-            lua_gettable(L, -4); // {} obj k v ud[k]
-            lua_pushvalue(L, -4); // {} obj k v ud[k] ud
-            lua_pushvalue(L, -3); // {} obj k v ud[k] ud v
-            lua_call(L, 2, 0); // {} obj k v
-        }
-        // {} ud
-    }
-    return 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Takes the object of type T at the top of the stack and stores it in on a
-// table with the name storagetable, on the table at the specified index.
-//
-// You may manually call luaW_hold and luaW_release to handle pointer
-// ownership, but it is often easier to simply store a Lua userdata on a table
-// that is owned by its parent. This ensures that your object will not be
-// prematurely freed, and that it can only be destoryed after its parent.
-//
-// e.g.
-//
-// Foo* parent = luaW_check<Foo>(L, 1);
-// Bar* child = luaW_check<Bar>(L, 2);
-// if (parent && child)
-// {
-//     luaU_store<Bar>(L, 1, "Children");
-//     parent->AddChild(child);
-// }
-//
-template <typename T>
-void luaU_store(lua_State* L, int index, const char* storagetable, const char* key = NULL)
-{
-    // ... store ... obj
-    lua_getfield(L, index, storagetable); // ... store ... obj store.storagetable
-    if (key)
-        lua_pushstring(L, key); // ... store ... obj store.storagetable key
-    else
-        LuaWrapper<T>::identifier(L, luaW_to<T>(L, -2)); // ... store ... obj store.storagetable key
-    lua_pushvalue(L, -3); // ... store ... obj store.storagetable key obj
-    lua_settable(L, -3); // ... store ... obj store.storagetable
-    lua_pop(L, 1); // ... store ... obj
-}
-
-/*
- * Copyright (c) 2010-2011 Alexander Ames
- *
- * 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.
- */
-
-#endif // LUAWRAPPERUTILS_HPP_

luarocks/main.cpp

@@ -1,64 +0,0 @@
-/*
- *  main.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-
-extern "C"
-{
-    #include "lua.h"
-    #include "lualib.h"
-    #include "lauxlib.h"
-}
-
-#include "functions.hpp"
-#include "LuaWebSocket.h"
-#include <iostream>
-
-int main()
-{
-    lua_State* L = luaL_newstate();
-    luaL_openlibs(L);
-
-    // Functions
-    lua_register(L, "info", lua_info);
-
-    // Objets
-    ix::luaopen_WebSocket(L);
-
-    //
-    // Simple version does little error handling
-    // luaL_dofile(L, "echo_client.lua");
-    //
-    std::string luaFile("echo_client.lua");
-    int loadStatus = luaL_loadfile(L, luaFile.c_str());
-    if (loadStatus)
-    {
-        std::cerr << "Error loading " << luaFile << std::endl;
-        std::cerr << lua_tostring(L, -1) << std::endl;
-        return 1;
-    }
-    else
-    {
-        std::cout << "loaded " << luaFile << std::endl;
-    }
-
-    //
-    // Capture lua errors
-    //
-    try
-    {
-        lua_call(L, 0, 0);
-        lua_close(L);
-    }
-    catch (const std::runtime_error& ex)
-    {
-        lua_close(L);
-        std::cerr << ex.what() << std::endl;
-        return 1;
-    }
-
-    return 0;
-}

main.cpp

@@ -0,0 +1,62 @@
+/*
+ *  main.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ *
+ *  Super simple standalone example. See ws folder, unittest and doc/usage.md for more.
+ *
+ *  On macOS
+ *  $ mkdir -p build ; cd build ; cmake -DUSE_TLS=1 .. ; make -j ; make install
+ *  $ clang++ --std=c++14 --stdlib=libc++ main.cpp -lixwebsocket -lz -framework Security -framework Foundation
+ *  $ ./a.out
+ */
+
+#include <ixwebsocket/IXNetSystem.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <iostream>
+
+int main()
+{
+    // Required on Windows
+    ix::initNetSystem();
+
+    // Our websocket object
+    ix::WebSocket webSocket;
+
+    std::string url("wss://echo.websocket.org");
+    webSocket.setUrl(url);
+
+    std::cout << "Connecting to " << url << "..." << std::endl;
+
+    // Setup a callback to be fired (in a background thread, watch out for race conditions !)
+    // when a message or an event (open, close, error) is received
+    webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
+        {
+            if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                std::cout << "received message: " << msg->str << std::endl;
+            }
+            else if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                std::cout << "Connection established" << std::endl;
+            }
+        }
+    );
+
+    // Now that our callback is setup, we can start our background thread and receive messages
+    webSocket.start();
+
+    // Send a message to the server (default to TEXT mode)
+    webSocket.send("hello world");
+
+    while (true)
+    {
+        std::string text;
+        std::cout << "> " << std::flush;
+        std::getline(std::cin, text);
+
+        webSocket.send(text);
+    }
+
+    return 0;
+}

makefile

@@ -19,26 +19,28 @@ install: brew
 #
 # Release, Debug, MinSizeRel, RelWithDebInfo are the build types
 #
+# Default rule does not use python as that requires first time users to have Python3 installed
+#
 brew:
-	mkdir -p build && (cd build ; cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4 install)
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; ninja install)
 
-# Docker default target. We've add problem with OpenSSL and TLS 1.3 (on the
+# Docker default target. We've had problems with OpenSSL and TLS 1.3 (on the
 # server side ?) and I can't work-around it easily, so we're using mbedtls on
 # Linux for the SSL backend, which works great.
 ws_mbedtls_install:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4 install)
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; ninja install)
 
 ws:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 .. ; make -j 4)
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && ninja install)
 
 ws_install:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; make -j 4 install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && make -j 4 install)
 
 ws_openssl:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; make -j 4)
+	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_mbedtls:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4)
+	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)
 
 ws_no_ssl:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_WS=1 .. ; make -j 4)
@@ -102,17 +104,23 @@ test_server:
 # env TEST=Websocket_server make test
 # env TEST=Websocket_chat make test
 # env TEST=heartbeat make test
-test:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4)
+build_test:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. ; ninja install)
+
+test: build_test
+	(cd test ; python2.7 run.py -r)
+
+test_make:
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4)
 	(cd test ; python2.7 run.py -r)
 
 test_tsan:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 	(cd test ; python2.7 run.py -r)
 
 test_ubsan:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
 	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 	(cd test ; python2.7 run.py -r)
 
@@ -120,37 +128,37 @@ test_asan: build_test_asan
 	(cd test ; python2.7 run.py -r)
 
 build_test_asan:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableAddressSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableAddressSanitizer YES)
 	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 
 test_tsan_openssl:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 	(cd test ; python2.7 run.py -r)
 
 test_ubsan_openssl:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
 	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 	(cd test ; python2.7 run.py -r)
 
 test_tsan_openssl_release:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Release -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -configuration Release -target ixwebsocket_unittest -enableThreadSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Release -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -configuration Release -target ixwebsocket_unittest -enableThreadSanitizer YES)
 	(cd build/test ; ln -sf Release/ixwebsocket_unittest)
 	(cd test ; python2.7 run.py -r)
 
 test_tsan_mbedtls:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_MBED_TLS=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
+	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_MBED_TLS=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 	(cd test ; python2.7 run.py -r)
 
 build_test_openssl:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; make -j 4)
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; ninja install)
 
 test_openssl: build_test_openssl
 	(cd test ; python2.7 run.py -r)
 
 build_test_mbedtls:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_MBED_TLS=1 -DUSE_TEST=1 .. ; make -j 4)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_MBED_TLS=1 -DUSE_TEST=1 .. ; make -j 4)
 
 test_mbedtls: build_test_mbedtls
 	(cd test ; python2.7 run.py -r)
@@ -159,15 +167,59 @@ test_no_ssl:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TEST=1 .. ; make -j 4)
 	(cd test ; python2.7 run.py -r)
 
-luarocks:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_LUAROCKS=1 .. ; ninja)
-
 ws_test: ws
 	(cd ws ; env DEBUG=1 PATH=../ws/build:$$PATH bash test_ws.sh)
 
 autobahn_report:
 	cp -rvf ~/sandbox/reports/clients/* ../bsergean.github.io/IXWebSocket/autobahn/
 
+httpd:
+	clang++ --std=c++14 --stdlib=libc++ httpd.cpp \
+		ixwebsocket/IXSelectInterruptFactory.cpp \
+		ixwebsocket/IXCancellationRequest.cpp \
+		ixwebsocket/IXSocketTLSOptions.cpp \
+		ixwebsocket/IXUserAgent.cpp \
+		ixwebsocket/IXDNSLookup.cpp \
+		ixwebsocket/IXBench.cpp \
+		ixwebsocket/IXWebSocketHttpHeaders.cpp \
+		ixwebsocket/IXSelectInterruptPipe.cpp \
+		ixwebsocket/IXHttp.cpp \
+		ixwebsocket/IXSocketConnect.cpp \
+		ixwebsocket/IXSocket.cpp \
+		ixwebsocket/IXSocketServer.cpp \
+		ixwebsocket/IXNetSystem.cpp \
+		ixwebsocket/IXHttpServer.cpp \
+		ixwebsocket/IXSocketFactory.cpp \
+		ixwebsocket/IXConnectionState.cpp \
+		ixwebsocket/IXUrlParser.cpp \
+		ixwebsocket/IXSelectInterrupt.cpp \
+		ixwebsocket/apple/IXSetThreadName_apple.cpp \
+		-lz
+
+httpd_linux:
+	g++ --std=c++11 -o ixhttpd httpd.cpp -Iixwebsocket \
+		ixwebsocket/IXSelectInterruptFactory.cpp \
+		ixwebsocket/IXCancellationRequest.cpp \
+		ixwebsocket/IXSocketTLSOptions.cpp \
+		ixwebsocket/IXUserAgent.cpp \
+		ixwebsocket/IXDNSLookup.cpp \
+		ixwebsocket/IXBench.cpp \
+		ixwebsocket/IXWebSocketHttpHeaders.cpp \
+		ixwebsocket/IXSelectInterruptPipe.cpp \
+		ixwebsocket/IXHttp.cpp \
+		ixwebsocket/IXSocketConnect.cpp \
+		ixwebsocket/IXSocket.cpp \
+		ixwebsocket/IXSocketServer.cpp \
+		ixwebsocket/IXNetSystem.cpp \
+		ixwebsocket/IXHttpServer.cpp \
+		ixwebsocket/IXSocketFactory.cpp \
+		ixwebsocket/IXConnectionState.cpp \
+		ixwebsocket/IXUrlParser.cpp \
+		ixwebsocket/IXSelectInterrupt.cpp \
+		ixwebsocket/linux/IXSetThreadName_linux.cpp \
+		-lz -lpthread
+	cp -f ixhttpd /usr/local/bin
+
 # For the fork that is configured with appveyor
 rebase_upstream:
 	git fetch upstream
@@ -175,6 +227,7 @@ rebase_upstream:
 	git reset --hard upstream/master
 	git push origin master --force
 
+# Legacy target
 install_cmake_for_linux:
 	mkdir -p /tmp/cmake
 	(cd /tmp/cmake ; curl -L -O https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz ; tar zxf cmake-3.14.0-Linux-x86_64.tar.gz)
@@ -185,7 +238,9 @@ install_cmake_for_linux:
 doc:
 	mkdocs gh-deploy
 
+change:
+	vim ixwebsocket/IXWebSocketVersion.h docs/CHANGELOG.md
+
 .PHONY: test
 .PHONY: build
 .PHONY: ws
-.PHONY: luarocks

test/CMakeLists.txt

@@ -55,6 +55,7 @@ set (SOURCES
   IXSentryClientTest.cpp
   IXWebSocketChatTest.cpp
   IXWebSocketBroadcastTest.cpp
+  IXWebSocketPerMessageDeflateCompressorTest.cpp
 )
 
 # Some unittest don't work on windows yet
@@ -91,15 +92,30 @@ if (JSONCPP_FOUND)
   target_link_libraries(ixwebsocket_unittest ${JSONCPP_LIBRARIES})
 endif()
 
+if (USE_PYTHON)
+  find_package(Python COMPONENTS Development)
+  if (NOT Python_FOUND)
+    message(FATAL_ERROR "Python3 not found")
+  endif()
+  message("Python_FOUND:${Python_FOUND}")
+  message("Python_VERSION:${Python_VERSION}")
+  message("Python_Development_FOUND:${Python_Development_FOUND}")
+  message("Python_LIBRARIES:${Python_LIBRARIES}")
+endif()
+
 # library with the most dependencies come first
 target_link_libraries(ixwebsocket_unittest ixbots)
 target_link_libraries(ixwebsocket_unittest ixsnake)
 target_link_libraries(ixwebsocket_unittest ixcobra)
 target_link_libraries(ixwebsocket_unittest ixsentry)
+target_link_libraries(ixwebsocket_unittest ixredis)
 target_link_libraries(ixwebsocket_unittest ixwebsocket)
 target_link_libraries(ixwebsocket_unittest ixcrypto)
 target_link_libraries(ixwebsocket_unittest ixcore)
 
 target_link_libraries(ixwebsocket_unittest spdlog)
+if (USE_PYTHON)
+  target_link_libraries(ixwebsocket_unittest ${Python_LIBRARIES})
+endif()
 
 install(TARGETS ixwebsocket_unittest DESTINATION bin)

test/IXCobraChatTest.cpp

@@ -10,7 +10,7 @@
 #include <iostream>
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcrypto/IXUuid.h>
-#include <ixsnake/IXRedisServer.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 
 using namespace ix;
@@ -125,10 +125,12 @@ namespace
     {
         std::string filter;
         std::string position("$");
+        int batchSize = 1;
 
         _conn.subscribe(channel,
                         filter,
                         position,
+                        batchSize,
                         [this](const Json::Value& msg, const std::string& /*position*/) {
                             spdlog::info("receive {}", msg.toStyledString());
 

test/IXCobraMetricsPublisherTest.cpp

@@ -8,7 +8,7 @@
 #include <iostream>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
-#include <ixsnake/IXRedisServer.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <set>
 
@@ -76,10 +76,12 @@ namespace
                 log("Subscriber authenticated");
                 std::string filter;
                 std::string position("$");
+                int batchSize = 1;
 
                 conn.subscribe(channel,
                                filter,
                                position,
+                               batchSize,
                                [](const Json::Value& msg, const std::string& /*position*/) {
                                    log(msg.toStyledString());
 

test/IXCobraToSentryBotTest.cpp

@@ -12,8 +12,8 @@
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
-#include <ixsnake/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <ixwebsocket/IXHttpServer.h>
 #include <ixwebsocket/IXUserAgent.h>
@@ -95,13 +95,15 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")
 
         sentryServer.setOnConnectionCallback(
             [](HttpRequestPtr request,
-               std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr {
+               std::shared_ptr<ConnectionState> /*connectionState*/,
+               std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
                 WebSocketHttpHeaders headers;
                 headers["Server"] = userAgent();
 
                 // Log request
                 std::stringstream ss;
-                ss << request->method << " " << request->headers["User-Agent"] << " "
+                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
+                   << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri;
 
                 if (request->method == "POST")
@@ -138,11 +140,12 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")
 
         std::thread publisherThread(runPublisher, config, channel);
 
-        std::string filter;
-        std::string position("$");
+        ix::CobraBotConfig cobraBotConfig;
+        cobraBotConfig.cobraConfig = config;
+        cobraBotConfig.channel = channel;
+        cobraBotConfig.runtime = 3; // Only run the bot for 3 seconds
+        cobraBotConfig.enableHeartbeat = false;
         bool verbose = true;
-        size_t maxQueueSize = 10;
-        bool enableHeartbeat = false;
 
         // FIXME: try to get this working with https instead of http
         //        to regress the TLS 1.3 OpenSSL bug
@@ -157,18 +160,7 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")
         SentryClient sentryClient(dsn);
         sentryClient.setTLSOptions(tlsOptionsClient);
 
-        // Only run the bot for 3 seconds
-        int runtime = 3;
-
-        int64_t sentCount = cobra_to_sentry_bot(config,
-                                                channel,
-                                                filter,
-                                                position,
-                                                sentryClient,
-                                                verbose,
-                                                maxQueueSize,
-                                                enableHeartbeat,
-                                                runtime);
+        int64_t sentCount = cobra_to_sentry_bot(cobraBotConfig, sentryClient, verbose);
         //
         // We want at least 2 messages to be sent
         //

test/IXCobraToStatsdBotTest.cpp

@@ -12,8 +12,8 @@
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
-#include <ixsnake/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <ixwebsocket/IXHttpServer.h>
 #include <ixwebsocket/IXUserAgent.h>
@@ -87,14 +87,11 @@ TEST_CASE("Cobra_to_statsd_bot", "[cobra_bots]")
 
         std::thread publisherThread(runPublisher, config, channel);
 
-        std::string filter;
-        std::string position("$");
-        bool verbose = true;
-        size_t maxQueueSize = 10;
-        bool enableHeartbeat = false;
-
-        // Only run the bot for 3 seconds
-        int runtime = 3;
+        ix::CobraBotConfig cobraBotConfig;
+        cobraBotConfig.cobraConfig = config;
+        cobraBotConfig.channel = channel;
+        cobraBotConfig.runtime = 3; // Only run the bot for 3 seconds
+        cobraBotConfig.enableHeartbeat = false;
 
         std::string hostname("127.0.0.1");
         // std::string hostname("www.google.com");
@@ -113,19 +110,10 @@ TEST_CASE("Cobra_to_statsd_bot", "[cobra_bots]")
         std::string fields("device.game\ndevice.os_name");
         std::string gauge;
         std::string timer;
+        bool verbose = true;
 
-        int64_t sentCount = ix::cobra_to_statsd_bot(config,
-                                                    channel,
-                                                    filter,
-                                                    position,
-                                                    statsdClient,
-                                                    fields,
-                                                    gauge,
-                                                    timer,
-                                                    verbose,
-                                                    maxQueueSize,
-                                                    enableHeartbeat,
-                                                    runtime);
+        int64_t sentCount =
+            ix::cobra_to_statsd_bot(cobraBotConfig, statsdClient, fields, gauge, timer, verbose);
         //
         // We want at least 2 messages to be sent
         //

test/IXCobraToStdoutBotTest.cpp

@@ -12,8 +12,8 @@
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
-#include <ixsnake/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <ixwebsocket/IXHttpServer.h>
 #include <ixwebsocket/IXUserAgent.h>
@@ -85,29 +85,17 @@ TEST_CASE("Cobra_to_stdout_bot", "[cobra_bots]")
 
         std::thread publisherThread(runPublisher, config, channel);
 
-        std::string filter;
-        std::string position("$");
-        bool verbose = true;
+        ix::CobraBotConfig cobraBotConfig;
+        cobraBotConfig.cobraConfig = config;
+        cobraBotConfig.channel = channel;
+        cobraBotConfig.runtime = 3; // Only run the bot for 3 seconds
+        cobraBotConfig.enableHeartbeat = false;
         bool quiet = false;
-        size_t maxQueueSize = 10;
-        bool enableHeartbeat = false;
-
-        // Only run the bot for 3 seconds
-        int runtime = 3;
 
         // We could try to capture the output ... not sure how.
         bool fluentd = true;
 
-        int64_t sentCount = ix::cobra_to_stdout_bot(config,
-                                                    channel,
-                                                    filter,
-                                                    position,
-                                                    fluentd,
-                                                    quiet,
-                                                    verbose,
-                                                    maxQueueSize,
-                                                    enableHeartbeat,
-                                                    runtime);
+        int64_t sentCount = ix::cobra_to_stdout_bot(cobraBotConfig, fluentd, quiet);
         //
         // We want at least 2 messages to be sent
         //

test/IXGetFreePort.cpp

@@ -4,6 +4,14 @@
  *  Copyright (c) 2019 Machine Zone. All rights reserved.
  */
 
+// Using inet_addr will trigger an error on uwp without this
+// FIXME: use a different api
+#ifdef _WIN32
+#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+#endif
+#endif
+
 #include "IXGetFreePort.h"
 
 #include <ixwebsocket/IXNetSystem.h>

test/IXHttpServerTest.cpp

@@ -67,7 +67,8 @@ TEST_CASE("http server", "[httpd]")
 
 TEST_CASE("http server redirection", "[httpd_redirect]")
 {
-    SECTION("Connect to a local HTTP server, with redirection enabled")
+    SECTION(
+        "Connect to a local HTTP server, with redirection enabled, but we do not follow redirects")
     {
         int port = getFreePort();
         ix::HttpServer server(port, "127.0.0.1");
@@ -117,4 +118,54 @@ TEST_CASE("http server redirection", "[httpd_redirect]")
 
         server.stop();
     }
+
+    SECTION("Connect to a local HTTP server, with redirection enabled, but we do follow redirects")
+    {
+        int port = getFreePort();
+        ix::HttpServer server(port, "127.0.0.1");
+        server.makeRedirectServer("http://www.google.com");
+
+        auto res = server.listen();
+        REQUIRE(res.first);
+        server.start();
+
+        HttpClient httpClient;
+        WebSocketHttpHeaders headers;
+
+        std::string url("http://127.0.0.1:");
+        url += std::to_string(port);
+        url += "/data/foo.txt";
+        auto args = httpClient.createRequest(url);
+
+        args->extraHeaders = headers;
+        args->connectTimeout = 60;
+        args->transferTimeout = 60;
+        args->followRedirects = true;
+        args->maxRedirects = 10;
+        args->verbose = true;
+        args->compress = true;
+        args->logger = [](const std::string& msg) { std::cout << msg; };
+        args->onProgressCallback = [](int current, int total) -> bool {
+            std::cerr << "\r"
+                      << "Downloaded " << current << " bytes out of " << total;
+            return true;
+        };
+
+        auto response = httpClient.get(url, args);
+
+        for (auto it : response->headers)
+        {
+            std::cerr << it.first << ": " << it.second << std::endl;
+        }
+
+        std::cerr << "Upload size: " << response->uploadSize << std::endl;
+        std::cerr << "Download size: " << response->downloadSize << std::endl;
+        std::cerr << "Status: " << response->statusCode << std::endl;
+        std::cerr << "Error message: " << response->errorMsg << std::endl;
+
+        REQUIRE(response->errorCode == HttpErrorCode::Ok);
+        REQUIRE(response->statusCode == 200);
+
+        server.stop();
+    }
 }

test/IXTest.cpp

@@ -85,12 +85,15 @@ namespace ix
     bool startWebSocketEchoServer(ix::WebSocketServer& server)
     {
         server.setOnConnectionCallback([&server](std::shared_ptr<ix::WebSocket> webSocket,
-                                                 std::shared_ptr<ConnectionState> connectionState) {
+                                                 std::shared_ptr<ConnectionState> connectionState,
+                                                 std::unique_ptr<ConnectionInfo> connectionInfo) {
+            auto remoteIp = connectionInfo->remoteIp;
             webSocket->setOnMessageCallback(
-                [webSocket, connectionState, &server](const ix::WebSocketMessagePtr& msg) {
+                [webSocket, connectionState, remoteIp, &server](const ix::WebSocketMessagePtr& msg) {
                     if (msg->type == ix::WebSocketMessageType::Open)
                     {
                         TLogger() << "New connection";
+                        TLogger() << "Remote ip: " << remoteIp;
                         TLogger() << "Uri: " << msg->openInfo.uri;
                         TLogger() << "Headers:";
                         for (auto it : msg->openInfo.headers)

test/IXWebSocketBroadcastTest.cpp

@@ -191,13 +191,16 @@ namespace
 
         server.setOnConnectionCallback([&server, &connectionId](
                                            std::shared_ptr<ix::WebSocket> webSocket,
-                                           std::shared_ptr<ConnectionState> connectionState) {
-            webSocket->setOnMessageCallback([webSocket, connectionState, &connectionId, &server](
+                                           std::shared_ptr<ConnectionState> connectionState,
+                                           std::unique_ptr<ConnectionInfo> connectionInfo) {
+            auto remoteIp = connectionInfo->remoteIp;
+            webSocket->setOnMessageCallback([webSocket, connectionState, remoteIp, &connectionId, &server](
                                                 const ix::WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";
                     connectionState->computeId();
+                    TLogger() << "remote ip: " << remoteIp;
                     TLogger() << "id: " << connectionState->getId();
                     TLogger() << "Uri: " << msg->openInfo.uri;
                     TLogger() << "Headers:";

test/IXWebSocketChatTest.cpp

@@ -194,12 +194,16 @@ namespace
     bool startServer(ix::WebSocketServer& server)
     {
         server.setOnConnectionCallback([&server](std::shared_ptr<ix::WebSocket> webSocket,
-                                                 std::shared_ptr<ConnectionState> connectionState) {
+                                                 std::shared_ptr<ConnectionState> connectionState,
+
+                                                 std::unique_ptr<ConnectionInfo> connectionInfo) {
+            auto remoteIp = connectionInfo->remoteIp;
             webSocket->setOnMessageCallback(
-                [webSocket, connectionState, &server](const ix::WebSocketMessagePtr& msg) {
+                [webSocket, connectionState, remoteIp, &server](const ix::WebSocketMessagePtr& msg) {
                     if (msg->type == ix::WebSocketMessageType::Open)
                     {
                         TLogger() << "New connection";
+                        TLogger() << "remote ip: " << remoteIp;
                         TLogger() << "id: " << connectionState->getId();
                         TLogger() << "Uri: " << msg->openInfo.uri;
                         TLogger() << "Headers:";

test/IXWebSocketCloseTest.cpp

@@ -171,9 +171,12 @@ namespace
         server.setOnConnectionCallback(
             [&receivedCloseCode, &receivedCloseReason, &receivedCloseRemote, &mutexWrite](
                 std::shared_ptr<ix::WebSocket> webSocket,
-                std::shared_ptr<ConnectionState> connectionState) {
+                std::shared_ptr<ConnectionState> connectionState,
+                std::unique_ptr<ConnectionInfo> connectionInfo) {
+                auto remoteIp = connectionInfo->remoteIp;
                 webSocket->setOnMessageCallback([webSocket,
                                                  connectionState,
+                                                 remoteIp,
                                                  &receivedCloseCode,
                                                  &receivedCloseReason,
                                                  &receivedCloseRemote,
@@ -181,6 +184,7 @@ namespace
                     if (msg->type == ix::WebSocketMessageType::Open)
                     {
                         TLogger() << "New server connection";
+                        TLogger() << "remote ip: " << remoteIp;
                         TLogger() << "id: " << connectionState->getId();
                         TLogger() << "Uri: " << msg->openInfo.uri;
                         TLogger() << "Headers:";

test/IXWebSocketPerMessageDeflateCompressorTest.cpp

@@ -0,0 +1,76 @@
+/*
+ *  IXWebSocketPerMessageDeflateCodecTest.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone. All rights reserved.
+ *
+ *  make build_test && build/test/ixwebsocket_unittest per-message-deflate-codec
+ */
+
+#include "IXTest.h"
+#include "catch.hpp"
+#include <iostream>
+#include <ixwebsocket/IXWebSocketPerMessageDeflateCodec.h>
+#include <string.h>
+
+using namespace ix;
+
+namespace ix
+{
+    std::string compressAndDecompress(const std::string& a)
+    {
+        std::string b, c;
+
+        WebSocketPerMessageDeflateCompressor compressor;
+        compressor.init(11, true);
+        compressor.compress(a, b);
+
+        WebSocketPerMessageDeflateDecompressor decompressor;
+        decompressor.init(11, true);
+        decompressor.decompress(b, c);
+
+        return c;
+    }
+
+    std::string compressAndDecompressVector(const std::string& a)
+    {
+        std::string b, c;
+
+        std::vector<uint8_t> vec(a.begin(), a.end());
+
+        WebSocketPerMessageDeflateCompressor compressor;
+        compressor.init(11, true);
+        compressor.compress(vec, b);
+
+        WebSocketPerMessageDeflateDecompressor decompressor;
+        decompressor.init(11, true);
+        decompressor.decompress(b, c);
+
+        return c;
+    }
+
+    TEST_CASE("per-message-deflate-codec", "[zlib]")
+    {
+        SECTION("string api")
+        {
+            REQUIRE(compressAndDecompress("") == "");
+            REQUIRE(compressAndDecompress("foo") == "foo");
+            REQUIRE(compressAndDecompress("bar") == "bar");
+            REQUIRE(compressAndDecompress("asdcaseqw`21897dehqwed") == "asdcaseqw`21897dehqwed");
+            REQUIRE(compressAndDecompress("/usr/local/include/ixwebsocket/IXSocketAppleSSL.h") ==
+                    "/usr/local/include/ixwebsocket/IXSocketAppleSSL.h");
+        }
+
+        SECTION("vector api")
+        {
+            REQUIRE(compressAndDecompressVector("") == "");
+            REQUIRE(compressAndDecompressVector("foo") == "foo");
+            REQUIRE(compressAndDecompressVector("bar") == "bar");
+            REQUIRE(compressAndDecompressVector("asdcaseqw`21897dehqwed") ==
+                    "asdcaseqw`21897dehqwed");
+            REQUIRE(
+                compressAndDecompressVector("/usr/local/include/ixwebsocket/IXSocketAppleSSL.h") ==
+                "/usr/local/include/ixwebsocket/IXSocketAppleSSL.h");
+        }
+    }
+
+} // namespace ix

test/IXWebSocketPingTest.cpp

@@ -19,7 +19,7 @@ namespace
     class WebSocketClient
     {
     public:
-        WebSocketClient(int port, bool useHeartBeatMethod);
+        WebSocketClient(int port);
 
         void start();
         void stop();
@@ -29,12 +29,10 @@ namespace
     private:
         ix::WebSocket _webSocket;
         int _port;
-        bool _useHeartBeatMethod;
     };
 
-    WebSocketClient::WebSocketClient(int port, bool useHeartBeatMethod)
+    WebSocketClient::WebSocketClient(int port)
         : _port(port)
-        , _useHeartBeatMethod(useHeartBeatMethod)
     {
         ;
     }
@@ -63,49 +61,37 @@ namespace
 
         // The important bit for this test.
         // Set a 1 second heartbeat with the setter method to test
-        if (_useHeartBeatMethod)
-        {
-            _webSocket.setPingInterval(1);
-        }
-        else
-        {
-            _webSocket.setPingInterval(1);
-        }
+        _webSocket.setPingInterval(1);
 
         std::stringstream ss;
         log(std::string("Connecting to url: ") + url);
 
-        _webSocket.setOnMessageCallback([](ix::WebSocketMessageType messageType,
-                                           const std::string& str,
-                                           size_t wireSize,
-                                           const ix::WebSocketErrorInfo& error,
-                                           const ix::WebSocketOpenInfo& openInfo,
-                                           const ix::WebSocketCloseInfo& closeInfo) {
+        _webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg) {
             std::stringstream ss;
-            if (messageType == ix::WebSocketMessageType::Open)
+            if (msg->type == ix::WebSocketMessageType::Open)
             {
                 log("client connected");
             }
-            else if (messageType == ix::WebSocketMessageType::Close)
+            else if (msg->type == ix::WebSocketMessageType::Close)
             {
                 log("client disconnected");
             }
-            else if (messageType == ix::WebSocketMessageType::Error)
+            else if (msg->type == ix::WebSocketMessageType::Error)
             {
-                ss << "Error ! " << error.reason;
+                ss << "Error ! " << msg->errorInfo.reason;
                 log(ss.str());
             }
-            else if (messageType == ix::WebSocketMessageType::Pong)
+            else if (msg->type == ix::WebSocketMessageType::Pong)
             {
-                ss << "Received pong message " << str;
+                ss << "Received pong message " << msg->str;
                 log(ss.str());
             }
-            else if (messageType == ix::WebSocketMessageType::Ping)
+            else if (msg->type == ix::WebSocketMessageType::Ping)
             {
-                ss << "Received ping message " << str;
+                ss << "Received ping message " << msg->str;
                 log(ss.str());
             }
-            else if (messageType == ix::WebSocketMessageType::Message)
+            else if (msg->type == ix::WebSocketMessageType::Message)
             {
                 // too many messages to log
             }
@@ -132,33 +118,28 @@ namespace
                                              std::shared_ptr<ConnectionState> connectionState) {
                 webSocket->setOnMessageCallback(
                     [webSocket, connectionState, &server, &receivedPingMessages](
-                        ix::WebSocketMessageType messageType,
-                        const std::string& str,
-                        size_t wireSize,
-                        const ix::WebSocketErrorInfo& error,
-                        const ix::WebSocketOpenInfo& openInfo,
-                        const ix::WebSocketCloseInfo& closeInfo) {
-                        if (messageType == ix::WebSocketMessageType::Open)
+                        const ix::WebSocketMessagePtr& msg) {
+                        if (msg->type == ix::WebSocketMessageType::Open)
                         {
                             TLogger() << "New server connection";
                             TLogger() << "id: " << connectionState->getId();
-                            TLogger() << "Uri: " << openInfo.uri;
+                            TLogger() << "Uri: " << msg->openInfo.uri;
                             TLogger() << "Headers:";
-                            for (auto it : openInfo.headers)
+                            for (auto it : msg->openInfo.headers)
                             {
                                 TLogger() << it.first << ": " << it.second;
                             }
                         }
-                        else if (messageType == ix::WebSocketMessageType::Close)
+                        else if (msg->type == ix::WebSocketMessageType::Close)
                         {
                             log("Server closed connection");
                         }
-                        else if (messageType == ix::WebSocketMessageType::Ping)
+                        else if (msg->type == ix::WebSocketMessageType::Ping)
                         {
                             log("Server received a ping");
                             receivedPingMessages++;
                         }
-                        else if (messageType == ix::WebSocketMessageType::Message)
+                        else if (msg->type == ix::WebSocketMessageType::Message)
                         {
                             // to many messages to log
                             for (auto client : server.getClients())
@@ -193,8 +174,7 @@ TEST_CASE("Websocket_ping_no_data_sent_setPingInterval", "[setPingInterval]")
         REQUIRE(startServer(server, serverReceivedPingMessages));
 
         std::string session = ix::generateSessionId();
-        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
-        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
+        WebSocketClient webSocketClient(port);
 
         webSocketClient.start();
 
@@ -236,8 +216,7 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval", "[setPingInterval]")
         REQUIRE(startServer(server, serverReceivedPingMessages));
 
         std::string session = ix::generateSessionId();
-        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
-        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
+        WebSocketClient webSocketClient(port);
 
         webSocketClient.start();
 
@@ -261,7 +240,7 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval", "[setPingInterval]")
         // Here we test ping interval
         // client has sent data, but ping should have been sent no matter what
         // -> expected ping messages == 3 as 900+900+1300 = 3100 seconds, 1 ping sent every second
-        REQUIRE(serverReceivedPingMessages == 3);
+        REQUIRE(serverReceivedPingMessages >= 2);
 
         // Give us 1000ms for the server to notice that clients went away
         ix::msleep(1000);
@@ -284,8 +263,7 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval_half_full", "[setPingInterva
         REQUIRE(startServer(server, serverReceivedPingMessages));
 
         std::string session = ix::generateSessionId();
-        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
-        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
+        WebSocketClient webSocketClient(port);
 
         webSocketClient.start();
 
@@ -338,8 +316,7 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval_full", "[setPingInterval]")
         REQUIRE(startServer(server, serverReceivedPingMessages));
 
         std::string session = ix::generateSessionId();
-        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
-        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
+        WebSocketClient webSocketClient(port);
 
         webSocketClient.start();
 
@@ -363,8 +340,9 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval_full", "[setPingInterval]")
 
         // Here we test ping interval
         // client has sent data, but ping should have been sent no matter what
-        // -> expected ping messages == 1, 1 ping sent every second
-        REQUIRE(serverReceivedPingMessages == 1);
+        // -> expected ping messages == 2, 1 ping sent every second
+        // The first ping is sent right away on connect
+        REQUIRE(serverReceivedPingMessages == 2);
 
         ix::msleep(100);
 
@@ -392,8 +370,7 @@ TEST_CASE("Websocket_ping_no_data_sent_setHeartBeatPeriod", "[setPingInterval]")
         REQUIRE(startServer(server, serverReceivedPingMessages));
 
         std::string session = ix::generateSessionId();
-        bool useSetHeartBeatPeriodMethod = true;
-        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
+        WebSocketClient webSocketClient(port);
 
         webSocketClient.start();
 
@@ -406,14 +383,13 @@ TEST_CASE("Websocket_ping_no_data_sent_setHeartBeatPeriod", "[setPingInterval]")
 
         REQUIRE(server.getClients().size() == 1);
 
-        ix::msleep(1900);
+        ix::msleep(2100);
 
         webSocketClient.stop();
 
-
         // Here we test ping interval
-        // -> expected ping messages == 1 as 1900 seconds, 1 ping sent every second
-        REQUIRE(serverReceivedPingMessages == 1);
+        // -> expected ping messages == 2 as 2100 seconds, 1 ping sent every second
+        REQUIRE(serverReceivedPingMessages == 2);
 
         // Give us 1000ms for the server to notice that clients went away
         ix::msleep(1000);
@@ -436,8 +412,7 @@ TEST_CASE("Websocket_ping_data_sent_setHeartBeatPeriod", "[setPingInterval]")
         REQUIRE(startServer(server, serverReceivedPingMessages));
 
         std::string session = ix::generateSessionId();
-        bool useSetHeartBeatPeriodMethod = true;
-        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
+        WebSocketClient webSocketClient(port);
 
         webSocketClient.start();
 
@@ -464,7 +439,7 @@ TEST_CASE("Websocket_ping_data_sent_setHeartBeatPeriod", "[setPingInterval]")
         // Here we test ping interval
         // client has sent data, but ping should have been sent no matter what
         // -> expected ping messages == 2 as 900+900+1100 = 2900 seconds, 1 ping sent every second
-        REQUIRE(serverReceivedPingMessages == 2);
+        REQUIRE(serverReceivedPingMessages >= 2);
 
         // Give us 1000ms for the server to notice that clients went away
         ix::msleep(1000);

test/IXWebSocketServerTest.cpp

@@ -35,13 +35,16 @@ namespace ix
 
         server.setOnConnectionCallback([&server, &connectionId](
                                            std::shared_ptr<ix::WebSocket> webSocket,
-                                           std::shared_ptr<ConnectionState> connectionState) {
-            webSocket->setOnMessageCallback([webSocket, connectionState, &connectionId, &server](
+                                           std::shared_ptr<ConnectionState> connectionState,
+                                           std::unique_ptr<ConnectionInfo> connectionInfo) {
+            auto remoteIp = connectionInfo->remoteIp;
+            webSocket->setOnMessageCallback([webSocket, connectionState, remoteIp, &connectionId, &server](
                                                 const ix::WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";
                     connectionState->computeId();
+                    TLogger() << "remote ip: " << remoteIp;
                     TLogger() << "id: " << connectionState->getId();
                     TLogger() << "Uri: " << msg->openInfo.uri;
                     TLogger() << "Headers:";

test/IXWebSocketSubProtocolTest.cpp

@@ -18,12 +18,15 @@ bool startServer(ix::WebSocketServer& server, std::string& subProtocols)
 {
     server.setOnConnectionCallback(
         [&server, &subProtocols](std::shared_ptr<ix::WebSocket> webSocket,
-                                 std::shared_ptr<ConnectionState> connectionState) {
-            webSocket->setOnMessageCallback([webSocket, connectionState, &server, &subProtocols](
+                                 std::shared_ptr<ConnectionState> connectionState,
+                                 std::unique_ptr<ConnectionInfo> connectionInfo) {
+            auto remoteIp = connectionInfo->remoteIp;
+            webSocket->setOnMessageCallback([webSocket, connectionState, remoteIp, &server, &subProtocols](
                                                 const ix::WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";
+                    TLogger() << "remote ip: " << remoteIp;
                     TLogger() << "id: " << connectionState->getId();
                     TLogger() << "Uri: " << msg->openInfo.uri;
                     TLogger() << "Headers:";
@@ -93,10 +96,11 @@ TEST_CASE("subprotocol", "[websocket_subprotocol]")
         webSocket.setUrl(url);
         webSocket.start();
 
+        // Give us 3 seconds to connect
         int attempts = 0;
         while (!connected)
         {
-            REQUIRE(attempts++ < 10);
+            REQUIRE(attempts++ < 300);
             ix::msleep(10);
         }