(cmake) DEFLATE -> Deflate in CMake to stop warnings about casing

* (http client) #ifdefs so we dont try to compress http requests with zlib

* (http client) Remove some #ifdefs for including zlib and removing fields

.clang-format

@@ -0,0 +1,47 @@
+# https://releases.llvm.org/7.0.0/tools/clang/docs/ClangFormatStyleOptions.html
+
+---
+Language: Cpp
+
+BasedOnStyle: WebKit
+
+AlignAfterOpenBracket: Align
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Allman
+BreakConstructorInitializersBeforeComma: true
+ColumnLimit: 100
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+Cpp11BracedListStyle: true
+FixNamespaceComments: true
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^["<](stdafx|pch)\.h[">]$'
+    Priority:        -1
+  - Regex:           '^<Windows\.h>$'
+    Priority:        3
+  - Regex:           '^<(WinIoCtl|winhttp|Shellapi)\.h>$'
+    Priority:        4
+  - Regex:           '.*'
+    Priority:        2
+IndentCaseLabels: true
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+PenaltyReturnTypeOnItsOwnLine: 1000
+PointerAlignment: Left
+SpaceAfterTemplateKeyword: false
+SpaceAfterCStyleCast: true
+Standard: Cpp11
+UseTab: Never

.dockerignore

@@ -0,0 +1,4 @@
+build
+CMakeCache.txt
+ws/CMakeCache.txt
+test/build

.github/workflows/docker.yml

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

.github/workflows/mkdocs.yml

@@ -0,0 +1,25 @@
+name: mkdocs
+on:
+  push:
+    paths:
+    - 'docs/**'
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3.8
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install mkdocs
+        pip install mkdocs-material
+        pip install pygments
+    - name: Build doc
+      run: |
+        git pull
+        mkdocs gh-deploy

.github/workflows/stale.yml

@@ -0,0 +1,19 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: "0 0 * * *"
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/stale@v1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'Stale issue message'
+        stale-pr-message: 'Stale pull request message'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'

.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

@@ -0,0 +1,38 @@
+name: uwp
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  uwp:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: seanmiddleditch/gha-setup-vsdevenv@master
+    - run: |
+        mkdir build
+        cd build
+        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 -DUSE_ZLIB=0 ..
+    - run: cmake --build build
+
+#
+#   Windows with OpenSSL is working but disabled as it takes 13 minutes (10 for openssl) to build with vcpkg
+#
+#   windows_openssl:
+#     runs-on: windows-latest
+#     steps:
+#     - uses: actions/checkout@v1
+#     - uses: seanmiddleditch/gha-setup-vsdevenv@master
+#     - run: |
+#         vcpkg install zlib:x64-windows
+#         vcpkg install openssl:x64-windows
+#     - run: |
+#         mkdir build
+#         cd build
+#         cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_OPEN_SSL=1 -DUSE_TLS=1 -DUSE_WS=1 -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

.github/workflows/unittest_windows.yml

@@ -0,0 +1,20 @@
+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: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_WS=1 -DUSE_TEST=1 -DUSE_ZLIB=0 ..
+    - run: cmake --build build
+
+#- run: ../build/test/ixwebsocket_unittest.exe
+# working-directory: test

.gitignore

@@ -0,0 +1,8 @@
+build
+*.pyc
+venv
+ixsnake/ixsnake/.certs/
+site/
+ws/.certs/
+ws/.srl
+ixhttpd

.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.5.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/pocc/pre-commit-hooks
+    rev: v1.1.1
+    hooks:
+    -    id: clang-format
+         args: [-i, -style=file]

.travis.yml

@@ -1,9 +0,0 @@
-language: cpp
-dist: xenial
-
-compiler:
-  - clang
-#   - gcc
-
-os: osx
-script: make test

CMake/FindDeflate.cmake

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

CMake/FindJsonCpp.cmake

@@ -0,0 +1,19 @@
+# Find package structure taken from libcurl
+
+include(FindPackageHandleStandardArgs)
+
+find_path(JSONCPP_INCLUDE_DIRS json/json.h)
+find_library(JSONCPP_LIBRARY jsoncpp)
+
+find_package_handle_standard_args(JsonCpp
+    FOUND_VAR
+      JSONCPP_FOUND
+    REQUIRED_VARS
+      JSONCPP_LIBRARY
+      JSONCPP_INCLUDE_DIRS
+    FAIL_MESSAGE
+      "Could NOT find jsoncpp"
+)
+
+set(JSONCPP_INCLUDE_DIRS ${JSONCPP_INCLUDE_DIRS})
+set(JSONCPP_LIBRARIES ${JSONCPP_LIBRARY})

CMake/FindMbedTLS.cmake

@@ -0,0 +1,13 @@
+find_path(MBEDTLS_INCLUDE_DIRS mbedtls/ssl.h)
+
+find_library(MBEDTLS_LIBRARY mbedtls)
+find_library(MBEDX509_LIBRARY mbedx509)
+find_library(MBEDCRYPTO_LIBRARY mbedcrypto)
+
+set(MBEDTLS_LIBRARIES "${MBEDTLS_LIBRARY}" "${MBEDX509_LIBRARY}" "${MBEDCRYPTO_LIBRARY}")
+
+include(FindPackageHandleStandardArgs)
+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)

CMake/FindSpdLog.cmake

@@ -0,0 +1,19 @@
+# Find package structure taken from libcurl
+
+include(FindPackageHandleStandardArgs)
+
+find_path(SPDLOG_INCLUDE_DIRS spdlog/spdlog.h)
+find_library(JSONCPP_LIBRARY spdlog)
+
+find_package_handle_standard_args(SPDLOG
+    FOUND_VAR
+    SPDLOG_FOUND
+    REQUIRED_VARS
+      SPDLOG_LIBRARY
+      SPDLOG_INCLUDE_DIRS
+    FAIL_MESSAGE
+      "Could NOT find spdlog"
+)
+
+set(SPDLOG_INCLUDE_DIRS ${SPDLOG_INCLUDE_DIRS})
+set(SPDLOG_LIBRARIES ${SPDLOG_LIBRARY})

CMakeLists.txt

@@ -3,75 +3,140 @@
 # 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)
 
 set (CMAKE_CXX_STANDARD 14)
 set (CXX_STANDARD_REQUIRED ON)
 set (CMAKE_CXX_EXTENSIONS OFF)
 
-if (NOT WIN32)
+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()
 
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshorten-64-to-32")
+endif()
+
 set( IXWEBSOCKET_SOURCES
-    ixwebsocket/IXEventFd.cpp
-    ixwebsocket/IXSocket.cpp
-    ixwebsocket/IXSocketServer.cpp
-    ixwebsocket/IXSocketConnect.cpp
-    ixwebsocket/IXDNSLookup.cpp
+    ixwebsocket/IXBench.cpp
     ixwebsocket/IXCancellationRequest.cpp
+    ixwebsocket/IXConnectionState.cpp
+    ixwebsocket/IXDNSLookup.cpp
+    ixwebsocket/IXExponentialBackoff.cpp
+    ixwebsocket/IXGetFreePort.cpp
+    ixwebsocket/IXGzipCodec.cpp
+    ixwebsocket/IXHttp.cpp
+    ixwebsocket/IXHttpClient.cpp
+    ixwebsocket/IXHttpServer.cpp
+    ixwebsocket/IXNetSystem.cpp
+    ixwebsocket/IXSelectInterrupt.cpp
+    ixwebsocket/IXSelectInterruptFactory.cpp
+    ixwebsocket/IXSelectInterruptPipe.cpp
+    ixwebsocket/IXSetThreadName.cpp
+    ixwebsocket/IXSocket.cpp
+    ixwebsocket/IXSocketConnect.cpp
+    ixwebsocket/IXSocketFactory.cpp
+    ixwebsocket/IXSocketServer.cpp
+    ixwebsocket/IXSocketTLSOptions.cpp
+    ixwebsocket/IXUdpSocket.cpp
+    ixwebsocket/IXUrlParser.cpp
+    ixwebsocket/IXUserAgent.cpp
     ixwebsocket/IXWebSocket.cpp
-    ixwebsocket/IXWebSocketServer.cpp
-    ixwebsocket/IXWebSocketTransport.cpp
+    ixwebsocket/IXWebSocketCloseConstants.cpp
     ixwebsocket/IXWebSocketHandshake.cpp
+    ixwebsocket/IXWebSocketHttpHeaders.cpp
     ixwebsocket/IXWebSocketPerMessageDeflate.cpp
     ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp
     ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp
+    ixwebsocket/IXWebSocketProxyServer.cpp
+    ixwebsocket/IXWebSocketServer.cpp
+    ixwebsocket/IXWebSocketTransport.cpp
 )
 
 set( IXWEBSOCKET_HEADERS
-    ixwebsocket/IXEventFd.h
-    ixwebsocket/IXSocket.h
-    ixwebsocket/IXSocketServer.h
-    ixwebsocket/IXSocketConnect.h
-    ixwebsocket/IXSetThreadName.h
-    ixwebsocket/IXDNSLookup.h
+    ixwebsocket/IXBench.h
     ixwebsocket/IXCancellationRequest.h
+    ixwebsocket/IXConnectionState.h
+    ixwebsocket/IXDNSLookup.h
+    ixwebsocket/IXExponentialBackoff.h
+    ixwebsocket/IXGetFreePort.h
+    ixwebsocket/IXGzipCodec.h
+    ixwebsocket/IXHttp.h
+    ixwebsocket/IXHttpClient.h
+    ixwebsocket/IXHttpServer.h
+    ixwebsocket/IXNetSystem.h
+    ixwebsocket/IXProgressCallback.h
+    ixwebsocket/IXSelectInterrupt.h
+    ixwebsocket/IXSelectInterruptFactory.h
+    ixwebsocket/IXSelectInterruptPipe.h
+    ixwebsocket/IXSetThreadName.h
+    ixwebsocket/IXSocket.h
+    ixwebsocket/IXSocketConnect.h
+    ixwebsocket/IXSocketFactory.h
+    ixwebsocket/IXSocketServer.h
+    ixwebsocket/IXSocketTLSOptions.h
+    ixwebsocket/IXUdpSocket.h
+    ixwebsocket/IXUrlParser.h
+    ixwebsocket/IXUtf8Validator.h
+    ixwebsocket/IXUserAgent.h
     ixwebsocket/IXWebSocket.h
-    ixwebsocket/IXWebSocketServer.h
-    ixwebsocket/IXWebSocketTransport.h
-    ixwebsocket/IXWebSocketHandshake.h
-    ixwebsocket/IXWebSocketSendInfo.h
+    ixwebsocket/IXWebSocketCloseConstants.h
+    ixwebsocket/IXWebSocketCloseInfo.h
     ixwebsocket/IXWebSocketErrorInfo.h
+    ixwebsocket/IXWebSocketHandshake.h
+    ixwebsocket/IXWebSocketHandshakeKeyGen.h
+    ixwebsocket/IXWebSocketHttpHeaders.h
+    ixwebsocket/IXWebSocketInitResult.h
+    ixwebsocket/IXWebSocketMessage.h
+    ixwebsocket/IXWebSocketMessageType.h
+    ixwebsocket/IXWebSocketOpenInfo.h
     ixwebsocket/IXWebSocketPerMessageDeflate.h
     ixwebsocket/IXWebSocketPerMessageDeflateCodec.h
     ixwebsocket/IXWebSocketPerMessageDeflateOptions.h
-    ixwebsocket/IXWebSocketHttpHeaders.h
-    ixwebsocket/libwshandshake.hpp
+    ixwebsocket/IXWebSocketProxyServer.h
+    ixwebsocket/IXWebSocketSendInfo.h
+    ixwebsocket/IXWebSocketServer.h
+    ixwebsocket/IXWebSocketTransport.h
+    ixwebsocket/IXWebSocketVersion.h
 )
 
-# Platform specific code
-if (APPLE)
-    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/apple/IXSetThreadName_apple.cpp)
-elseif (WIN32)
-    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/windows/IXSetThreadName_windows.cpp)
-else()
-    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/linux/IXSetThreadName_linux.cpp)
-endif()
+option(USE_TLS "Enable TLS support" FALSE)
 
 if (USE_TLS)
-    add_definitions(-DIXWEBSOCKET_USE_TLS)
-
+    # default to securetranport on Apple if nothing is configured
     if (APPLE)
+      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)
+      endif()
+    endif()
+
+    if (USE_MBED_TLS)
+        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketMbedTLS.h)
+        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketMbedTLS.cpp)
+    elseif (USE_SECURE_TRANSPORT)
         list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketAppleSSL.h)
         list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketAppleSSL.cpp)
-    elseif (WIN32)
-        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketSChannel.h)
-        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketSChannel.cpp)
-    else()
+    elseif (USE_OPEN_SSL)
         list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketOpenSSL.h)
         list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketOpenSSL.cpp)
+    else()
+        message(FATAL_ERROR "TLS Configuration error: unknown backend")
     endif()
 endif()
 
@@ -80,35 +145,134 @@ add_library( ixwebsocket STATIC
     ${IXWEBSOCKET_HEADERS}
 )
 
-# gcc/Linux needs -pthread
-find_package(Threads)
+if (USE_TLS)
+    target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_TLS)
+    if (USE_MBED_TLS)
+        target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_MBED_TLS)
+    elseif (USE_OPEN_SSL)
+        target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_OPEN_SSL)
+    elseif (USE_SECURE_TRANSPORT)
+        target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_SECURE_TRANSPORT)
+    else()
+        message(FATAL_ERROR "TLS Configuration error: unknown backend")
+    endif()
+endif()
 
-if(UNIX AND NOT APPLE)
-  find_package(OpenSSL REQUIRED)
-  add_definitions(${OPENSSL_DEFINITIONS})
-  message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
-  include_directories(${OPENSSL_INCLUDE_DIR})
+if (USE_TLS)
+  if (USE_OPEN_SSL)
+    message(STATUS "TLS configured to use openssl")
+
+    # Help finding Homebrew's OpenSSL on macOS
+    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()
+
+    # 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})
+    target_include_directories(ixwebsocket PUBLIC ${OPENSSL_INCLUDE_DIR})
+    target_link_libraries(ixwebsocket ${OPENSSL_LIBRARIES})
+  elseif (USE_MBED_TLS)
+    message(STATUS "TLS configured to use mbedtls")
+
+    find_package(MbedTLS REQUIRED)
+    target_include_directories(ixwebsocket PUBLIC ${MBEDTLS_INCLUDE_DIRS})
+    target_link_libraries(ixwebsocket ${MBEDTLS_LIBRARIES})
+  elseif (USE_SECURE_TRANSPORT)
+    message(STATUS "TLS configured to use secure transport")
+    target_link_libraries(ixwebsocket "-framework foundation" "-framework security")
+  endif()
+endif()
+
+option(USE_ZLIB "Enable zlib support" TRUE)
+
+if (USE_ZLIB)
+  # 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})
+
+  target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_ZLIB)
+endif()
+
+# brew install libdeflate
+find_package(Deflate)
+if (DEFLATE_FOUND)
+  include_directories(${DEFLATE_INCLUDE_DIRS})
+  target_link_libraries(ixwebsocket ${DEFLATE_LIBRARIES})
+  target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_DEFLATE)
 endif()
 
 if (WIN32)
-  get_filename_component(libz_path
-    ${PROJECT_SOURCE_DIR}/third_party/ZLIB-Windows/zlib-1.2.11_deploy_v140/release_dynamic/x64/lib/zlib.lib
-    ABSOLUTE)
-  add_library(libz STATIC IMPORTED)
-  set_target_properties(libz PROPERTIES IMPORTED_LOCATION
-    ${libz_path})
-
-  include_directories(${PROJECT_SOURCE_DIR}/third_party/ZLIB-Windows/zlib-1.2.11_deploy_v140/include)
-
-  target_link_libraries(ixwebsocket libz wsock32 ws2_32)
+  target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-  
-else()
-  target_link_libraries(ixwebsocket 
-    z ${OPENSSL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+
+  if (USE_TLS)
+    target_link_libraries(ixwebsocket Crypt32)
+  endif()
 endif()
 
+if (UNIX)
+  find_package(Threads)
+  target_link_libraries(ixwebsocket ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+
 set( IXWEBSOCKET_INCLUDE_DIRS
-    .
-    ../../shared/OpenSSL/include)
-target_include_directories( ixwebsocket PUBLIC ${IXWEBSOCKET_INCLUDE_DIRS} )
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    # Build with Multiple Processes
+    target_compile_options(ixwebsocket PRIVATE /MP)
+endif()
+
+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
+        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)
+
+  include(FetchContent)
+  FetchContent_Declare(spdlog
+      GIT_REPOSITORY "https://github.com/gabime/spdlog"
+      GIT_TAG "v1.8.0"
+      GIT_SHALLOW 1) 
+
+  FetchContent_MakeAvailable(spdlog)
+
+  if (USE_WS)
+      add_subdirectory(ws)
+  endif()
+  if (USE_TEST)
+      add_subdirectory(test)
+  endif()
+endif()

Dockerfile

@@ -1 +1 @@
-docker/Dockerfile.debian
+docker/Dockerfile.alpine

README.md

@@ -1,321 +1,107 @@
-# General
+## Hello world
 
-![Alt text](https://travis-ci.org/machinezone/IXWebSocket.svg?branch=master)
+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.
 
-## Introduction
+It is been used on big mobile video game titles sending and receiving tons of messages since 2017 (iOS and Android). It was tested on macOS, iOS, Linux, Android, Windows and FreeBSD. Note that the MinGW compiler is not supported at this point. Two important design goals are simplicity and correctness.
 
-[*WebSocket*](https://en.wikipedia.org/wiki/WebSocket) is a computer communications protocol, providing full-duplex
-communication channels over a single TCP connection. *IXWebSocket* is a C++ library for client and server Websocket communication. 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.
+```cpp
+/*
+ *  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
+ */
 
-* macOS
-* iOS
-* Linux
-* Android 
-* Windows (no TLS support yet)
+#include <ixwebsocket/IXNetSystem.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <iostream>
 
-## Examples
-
-The examples folder countains a simple chat program, using a node.js broadcast server.
-
-Here is what the client API looks like.
-
-```
-ix::WebSocket webSocket;
-
-std::string url("ws://localhost:8080/");
-webSocket.setUrl(url);
-
-// Optional heart beat, sent every 45 seconds when there isn't any traffic
-// to make sure that load balancers do not kill an idle connection.
-webSocket.setHeartBeatPeriod(45);
-
-// Setup a callback to be fired when a message or an event (open, close, error) is received
-webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketCloseInfo& closeInfo,
-       const ix::WebSocketHttpHeaders& headers)
-    {
-        if (messageType == ix::WebSocket_MessageType_Message)
-        {
-            std::cout << str << 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
-webSocket.send("hello world");
-
-// ... finally ...
-
-// Stop the connection
-webSocket.stop()
-```
-
-Here is what the server API looks like. Note that server support is very recent and subject to changes.
-
-```
-// Run a server on localhost at a given port.
-// Bound host name, max connections and listen backlog can also be passed in as parameters.
-ix::WebSocketServer server(port);
-
-server.setOnConnectionCallback(
-    [&server](std::shared_ptr<ix::WebSocket> webSocket)
-    {
-        webSocket->setOnMessageCallback(
-            [webSocket, &server](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::WebSocket_MessageType_Open)
-                {
-                    std::cerr << "New connection" << std::endl;
-                    std::cerr << "Uri: " << openInfo.uri << std::endl;
-                    std::cerr << "Headers:" << std::endl;
-                    for (auto it : openInfo.headers)
-                    {
-                        std::cerr << it.first << ": " << it.second << std::endl;
-                    }
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    // For an echo server, we just send back to the client whatever was received by the client
-                    // All connected clients are available in an std::set. See the broadcast cpp example.
-                    webSocket->send(str);
-                }
-            }
-        );
-    }
-);
-
-auto res = server.listen();
-if (!res.first)
+int main()
 {
-    // Error handling
-    return 1;
-}
+    // Required on Windows
+    ix::initNetSystem();
 
-// Run the server in the background. Server can be stoped by calling server.stop()
-server.start();
+    // Our websocket object
+    ix::WebSocket webSocket;
 
-// Block until server.stop() is called.
-server.wait();
+    std::string url("wss://echo.websocket.org");
+    webSocket.setUrl(url);
 
-```
+    std::cout << "Connecting to " << url << "..." << std::endl;
 
-## Build
-
-CMakefiles for the library and the examples are available. This library has few dependencies, so it is possible to just add the source files into your project.
-
-There is a Dockerfile for running some code on Linux, and a unittest which can be executed by typing `make test`.
-
-## Implementation details
-
-### Per Message Deflate compression.
-
-The per message deflate compression option is supported. It can lead to very nice bandbwith savings (20x !) if your messages are similar, which is often the case for example for chat applications. All features of the spec should be supported.
-
-### TLS/SSL
-
-Connections can be optionally secured and encrypted with TLS/SSL when using a wss:// endpoint, or using normal un-encrypted socket with ws:// endpoints. AppleSSL is used on iOS and macOS, and OpenSSL is used on Android and Linux.
-
-### Polling and background thread work
-
-No manual polling to fetch data is required. Data is sent and received instantly by using a background thread for receiving data and the select [system](http://man7.org/linux/man-pages/man2/select.2.html) call to be notified by the OS of incoming data. No timeout is used for select so that the background thread is only woken up when data is available, to optimize battery life. This is also the recommended way of using select according to the select tutorial, section [select law](https://linux.die.net/man/2/select_tut). Read and Writes to the socket are non blocking. Data is sent right away and not enqueued by writing directly to the socket, which is [possible](https://stackoverflow.com/questions/1981372/are-parallel-calls-to-send-recv-on-the-same-socket-valid) since system socket implementations allow concurrent read/writes. However concurrent writes need to be protected with mutex.
-
-### Automatic reconnection
-
-If the remote end (server) breaks the connection, the code will try to perpetually reconnect, by using an exponential backoff strategy, capped at one retry every 10 seconds.
-
-## Limitations
-
-* There is no text support for sending data, only the binary protocol is supported. Sending json or text over the binary protocol works well.
-* Automatic reconnection works at the TCP socket level, and will detect remote end disconnects. However, if the device/computer network become unreachable (by turning off wifi), it is quite hard to reliably and timely detect it at the socket level using `recv` and `send` error codes. [Here](https://stackoverflow.com/questions/14782143/linux-socket-how-to-detect-disconnected-network-in-a-client-program) is a good discussion on the subject. This behavior is consistent with other runtimes such as node.js. One way to detect a disconnected device with low level C code is to do a name resolution with DNS but this can be expensive. Mobile devices have good and reliable API to do that.
-* The server code is using select to detect incoming data, and creates one OS thread per connection. This isn't as scalable as strategies using epoll or kqueue.
-
-## Examples
-
-1. Bring up a terminal and jump to the examples folder.
-2. Compile the example C++ code. `sh build.sh`
-3. Install node.js from [here](https://nodejs.org/en/download/).
-4. Type `npm install` to install the node.js dependencies. Then `node broadcast-server.js` to run the server.
-5. Bring up a second terminal. `./cmd_websocket_chat bob`
-6. Bring up a third terminal. `./cmd_websocket_chat bill`
-7. Start typing things in any of those terminals. Hopefully you should see your message being received on the other end.
-
-## C++ code organization
-
-Here's a simplistic diagram which explains how the code is structured in term of class/modules.
-
-```
-+-----------------------+ --- Public
-|                       | Start the receiving Background thread. Auto reconnection. Simple websocket Ping.
-|  IXWebSocket          | Interface used by C++ test clients. No IX dependencies.
-|                       | 
-+-----------------------+
-|                       |
-|  IXWebSocketServer    | Run a server and give each connections its own WebSocket object.
-|                       | Each connection is handled in a new OS thread.
-|                       |
-+-----------------------+ --- Private 
-|                       |
-|  IXWebSocketTransport | Low level websocket code, framing, managing raw socket. Adapted from easywsclient.
-|                       |
-+-----------------------+
-|                       |
-|  IXWebSocketHandshake | Establish the connection between client and server.
-|                       |
-+-----------------------+
-|                       |
-|  IXWebSocket          | ws://  Unencrypted Socket handler
-|  IXWebSocketAppleSSL  | wss:// TLS encrypted Socket AppleSSL handler. Used on iOS and macOS
-|  IXWebSocketOpenSSL   | wss:// TLS encrypted Socket OpenSSL handler.  Used on Android and Linux
-|                       |                                               Can be used on macOS too.
-+-----------------------+
-|                       |
-|  IXSocketConnect      | Connect to the remote host (client).
-|                       |
-+-----------------------+
-|                       |
-|  IXDNSLookup          | Does DNS resolution asynchronously so that it can be interrupted.
-|                       |
-+-----------------------+
-```
-
-## API
-
-### Sending messages
-
-`websocket.send("foo")` will send a message.
-
-If the connection was closed and sending failed, the return value will be set to false.
-
-### ReadyState
-
-`getReadyState()` returns the state of the connection. There are 4 possible states.
-
-1. WebSocket_ReadyState_Connecting - The connection is not yet open.
-2. WebSocket_ReadyState_Open       - The connection is open and ready to communicate.
-3. WebSocket_ReadyState_Closing    - The connection is in the process of closing.
-4. WebSocket_MessageType_Close     - The connection is closed or couldn't be opened.
-
-### Open and Close notifications
-
-The onMessage event will be fired when the connection is opened or closed. This is similar to the [Javascript browser API](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket), which has `open` and `close` events notification that can be registered with the browser `addEventListener`.
-
-```
-webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketCloseInfo& closeInfo,
-       const ix::WebSocketHttpHeaders& headers)
-    {
-        if (messageType == ix::WebSocket_MessageType_Open)
+    // 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 << "send greetings" << std::endl;
-
-            // Headers can be inspected (pairs of string/string)
-            std::cout << "Handshake Headers:" << std::endl;
-            for (auto it : headers)
+            if (msg->type == ix::WebSocketMessageType::Message)
             {
-                std::cout << it.first << ": " << it.second << std::endl;
+                std::cout << "received message: " << msg->str << std::endl;
+            }
+            else if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                std::cout << "Connection established" << std::endl;
             }
         }
-        else if (messageType == ix::WebSocket_MessageType_Close)
-        {
-            std::cout << "disconnected" << std::endl;
+    );
 
-            // The server can send an explicit code and reason for closing.
-            // This data can be accessed through the closeInfo object.
-            std::cout << closeInfo.code << std::endl;
-            std::cout << closeInfo.reason << std::endl;
-        }
-    }
-);
-```
+    // Now that our callback is setup, we can start our background thread and receive messages
+    webSocket.start();
 
-### Error notification
+    // Send a message to the server (default to TEXT mode)
+    webSocket.send("hello world");
 
-A message will be fired when there is an error with the connection. The message type will be `ix::WebSocket_MessageType_Error`. Multiple fields will be available on the event to describe the error.
-
-```
-webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketCloseInfo& closeInfo,
-       const ix::WebSocketHttpHeaders& headers)
+    while (true)
     {
-        if (messageType == ix::WebSocket_MessageType_Error)
-        {
-            std::stringstream ss;
-            ss << "Error: "         << error.reason      << std::endl;
-            ss << "#retries: "      << event.retries     << std::endl;
-            ss << "Wait time(ms): " << event.wait_time   << std::endl;
-            ss << "HTTP Status: "   << event.http_status << std::endl;
-            std::cout << ss.str() << std::endl;
-        }
+        std::string text;
+        std::cout << "> " << std::flush;
+        std::getline(std::cin, text);
+
+        webSocket.send(text);
     }
-);
+
+    return 0;
+}
 ```
 
-### start, stop
+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.
 
-1. `websocket.start()` connect to the remote server and starts the message receiving background thread.
-2. `websocket.stop()` disconnect from the remote server and closes the background thread.
+IXWebSocket is actively being developed, check out the [changelog](https://machinezone.github.io/IXWebSocket/CHANGELOG/) to know what's cooking. If you are looking for a real time messaging service (the chat-like 'server' your websocket code will talk to) with many features such as history, backed by Redis, look at [cobra](https://github.com/machinezone/cobra).
 
-### Configuring the remote url
+IXWebSocket client code is autobahn compliant beginning with the 6.0.0 version. See the current [test results](https://bsergean.github.io/autobahn/reports/clients/index.html). Some tests are still failing in the server code.
 
-The url can be set and queried after a websocket object has been created. You will have to call `stop` and `start` if you want to disconnect and connect to that new url.
+## Users
 
-```
-std::string url("wss://example.com");
-websocket.configure(url);
-```
+If your company or project is using this library, feel free to open an issue or PR to amend this list.
 
-### Ping/Pong support
+- [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
+- [discord.cpp](https://github.com/luccanunes/discord.cpp), a discord library for making bots
 
-Ping/pong messages are used to implement keep-alive. 2 message types exists to identify ping and pong messages. Note that when a ping message is received, a pong is instantly send back as requested by the WebSocket spec.
+## Continuous Integration
 
-```
-webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketCloseInfo& closeInfo,
-       const ix::WebSocketHttpHeaders& headers)
-    {
-        if (messageType == ix::WebSocket_MessageType_Ping ||
-            messageType == ix::WebSocket_MessageType_Pong)
-        {
-            std::cout << "pong data: " << str << std::endl;
-        }
-    }
-);
-```
+| 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] |
 
-A ping message can be sent to the server, with an optional data string.
+[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
 
-```
-websocket.ping("ping data, optional (empty string is ok): limited to 125 bytes long");
-
-### Heartbeat.
-
-You can configure an optional heart beat / keep-alive, sent every 45 seconds
-when there isn't any traffic to make sure that load balancers do not kill an
-idle connection.
-
-```
-webSocket.setHeartBeatPeriod(45);
-```

SECURITY.md

@@ -0,0 +1,11 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 7.x.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Users should send an email to bsergean@gmail.com to report a vulnerability.

appveyor.yml

@@ -1,10 +1,22 @@
 image:
 - Visual Studio 2017
-- Ubuntu
 
 install:
-- ls -al
+- cd C:\Tools\vcpkg
+- git pull
+- .\bootstrap-vcpkg.bat
+- cd %APPVEYOR_BUILD_FOLDER%
 - cmd: call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-- python test/run.py
+- vcpkg install zlib:x64-windows
+- vcpkg install mbedtls:x64-windows
+- mkdir build
+- cd build
+- cmake -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DUSE_WS=1 -DUSE_TEST=1 -DUSE_TLS=1 -G"NMake Makefiles" ..
+- nmake
+- cd ..
+- cd test
+- ..\build\test\ixwebsocket_unittest.exe
+
+cache: c:\tools\vcpkg\installed\
 
 build: off

docker-compose.yml

@@ -0,0 +1,11 @@
+version: "3.3"
+services:
+  push:
+    entrypoint: ws push_server --host 0.0.0.0
+    image: ${DOCKER_REPO}/ws:build
+
+  autoroute:
+    entrypoint: ws autoroute ws://push:8008
+    image: ${DOCKER_REPO}/ws:build
+    depends_on:
+      - push

docker/Dockerfile

@@ -1,16 +0,0 @@
-FROM debian:stretch
-
-# RUN yum install -y gcc-c++ make cmake openssl-devel gdb
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update 
-RUN apt-get -y install g++ 
-RUN apt-get -y install libssl-dev
-RUN apt-get -y install gdb
-RUN apt-get -y install screen
-RUN apt-get -y install procps
-RUN apt-get -y install lsof
-
-COPY . .
-
-WORKDIR examples/ws_connect
-RUN ["sh", "build_linux.sh"]

docker/Dockerfile.alpine

@@ -1,11 +1,39 @@
-FROM alpine:3.8
+FROM alpine:3.12 as build
 
-RUN apk add --no-cache g++ musl-dev make cmake openssl-dev
+RUN apk add --no-cache \
+    gcc g++ musl-dev linux-headers \
+    cmake mbedtls-dev make zlib-dev python3-dev ninja git
 
-COPY . .
+RUN addgroup -S app && \
+    adduser -S -G app app && \
+    chown -R app:app /opt && \
+    chown -R app:app /usr/local
 
-WORKDIR examples/ws_connect
-RUN ["sh", "build_linux.sh"]
+# There is a bug in CMake where we cannot build from the root top folder
+# So we build from /opt
+COPY --chown=app:app . /opt
+WORKDIR /opt
 
-EXPOSE 8765
-CMD ["ws_connect"]
+USER app
+RUN make ws_mbedtls_install && \
+    sh tools/trim_repo_for_docker.sh
+
+FROM alpine:3.12 as runtime
+
+RUN apk add --no-cache libstdc++ mbedtls ca-certificates python3 strace && \
+    addgroup -S app && \
+    adduser -S -G app app
+
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+
+# COPY --chown=app:app --from=build /opt /opt
+
+RUN chmod +x /usr/local/bin/ws && \
+    ldd /usr/local/bin/ws
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+ENTRYPOINT ["ws"]
+EXPOSE 8008

docker/Dockerfile.centos

@@ -1,11 +1,41 @@
-FROM alpine:3.8
+FROM centos:8 as build
 
-RUN apk add --no-cache g++ musl-dev make cmake openssl-dev
+RUN yum install -y gcc-c++ make cmake zlib-devel openssl-devel redhat-rpm-config
 
-COPY . .
+RUN yum install -y epel-release
+RUN yum install -y mbedtls-devel
 
-WORKDIR examples/ws_connect
-RUN ["sh", "build_linux.sh"]
+RUN groupadd app && useradd -g app app
+RUN chown -R app:app /opt
+RUN chown -R app:app /usr/local
 
-EXPOSE 8765
-CMD ["ws_connect"]
+# There is a bug in CMake where we cannot build from the root top folder
+# So we build from /opt
+COPY --chown=app:app . /opt
+WORKDIR /opt
+
+USER app
+RUN [ "make", "ws_mbedtls_install" ]
+RUN [ "rm", "-rf", "build" ]
+
+FROM centos:8 as runtime
+
+RUN yum install -y gdb strace
+
+RUN yum install -y epel-release
+RUN yum install -y mbedtls
+
+RUN groupadd app && useradd -g app app
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+RUN chmod +x /usr/local/bin/ws
+RUN ldd /usr/local/bin/ws
+
+# Copy source code for gcc
+COPY --chown=app:app --from=build /opt /opt
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+ENTRYPOINT ["ws"]
+EXPOSE 8008

docker/Dockerfile.debian

@@ -1,19 +1,52 @@
-FROM debian:stretch
+# Build time
+FROM debian:buster as build
 
 ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update 
-RUN apt-get -y install g++ 
+RUN apt-get update
+RUN apt-get -y install wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++
 RUN apt-get -y install libssl-dev
-RUN apt-get -y install gdb
-RUN apt-get -y install screen
-RUN apt-get -y install procps
-RUN apt-get -y install lsof
 RUN apt-get -y install libz-dev
-RUN apt-get -y install vim
 RUN apt-get -y install make
-RUN apt-get -y install cmake
 
 COPY . .
 
-WORKDIR test
-RUN ["sh", "build_linux.sh"]
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN ["make"]
+
+# Runtime
+FROM debian:buster as runtime
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+# Runtime
+RUN apt-get install -y libssl1.1
+RUN apt-get install -y ca-certificates
+RUN ["update-ca-certificates"]
+
+# Debugging
+RUN apt-get install -y strace
+RUN apt-get install -y procps
+RUN apt-get install -y htop
+
+RUN adduser --disabled-password --gecos '' app
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+RUN chmod +x /usr/local/bin/ws
+RUN ldd /usr/local/bin/ws
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+COPY --chown=app:app ws/snake/appsConfig.json .
+COPY --chown=app:app ws/cobraMetricsSample.json .
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docker/Dockerfile.fedora

@@ -0,0 +1,43 @@
+FROM fedora:30 as build
+
+RUN yum install -y gcc-g++
+RUN yum install -y cmake
+RUN yum install -y make
+RUN yum install -y openssl-devel
+
+RUN yum install -y wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN yum install -y python
+RUN yum install -y libtsan
+RUN yum install -y zlib-devel
+
+COPY . .
+# RUN ["make", "test"]
+RUN ["make"]
+
+# Runtime
+FROM fedora:30 as runtime
+
+RUN yum install -y libtsan
+
+RUN groupadd app && useradd -g app app
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+RUN chmod +x /usr/local/bin/ws
+RUN ldd /usr/local/bin/ws
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+COPY --chown=app:app ws/snake/appsConfig.json .
+COPY --chown=app:app ws/cobraMetricsSample.json .
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docker/Dockerfile.gcc

@@ -1,8 +0,0 @@
-FROM gcc:8
-
-# RUN yum install -y gcc-c++ make cmake openssl-devel gdb
-
-COPY . .
-
-WORKDIR examples/ws_connect
-RUN ["sh", "build_linux.sh"]

docker/Dockerfile.ubuntu_bionic

@@ -0,0 +1,23 @@
+# Build time
+FROM ubuntu:bionic as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get -y install wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install libz-dev
+RUN apt-get -y install make
+RUN apt-get -y install python
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN ["make", "ws"]

docker/Dockerfile.ubuntu_disco

@@ -0,0 +1,24 @@
+# Build time
+FROM ubuntu:disco as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get -y install wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install libz-dev
+RUN apt-get -y install make
+RUN apt-get -y install python
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+# RUN ["make", "test"]
+CMD ["sh"]

docker/Dockerfile.ubuntu_groovy

@@ -0,0 +1,23 @@
+# Build time
+FROM ubuntu:groovy as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+
+RUN apt-get -y install g++ libssl-dev libz-dev make python ninja-build
+RUN apt-get -y install cmake
+RUN apt-get -y install gdb
+
+COPY . /opt
+WORKDIR /opt
+
+#
+# To use the container interactively for debugging/building
+# 1. Build with
+#    CMD ["ls"]
+# 2. Run with
+#    docker run --entrypoint sh -it docker-game-eng-dev.addsrv.com/ws:9.10.6 
+#
+
+RUN ["make", "test"]
+# CMD ["ls"]

docker/Dockerfile.ubuntu_xenial

@@ -0,0 +1,24 @@
+# Build time
+FROM ubuntu:xenial as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get -y install wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install libz-dev
+RUN apt-get -y install make
+RUN apt-get -y install python
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+# RUN ["make"]
+RUN ["make", "test"]

docs/build.md

@@ -0,0 +1,93 @@
+## Build
+
+### CMake
+
+CMakefiles for the library and the examples are available. This library has few dependencies, so it is possible to just add the source files into your project. Otherwise the usual way will suffice.
+
+```
+mkdir build # make a build dir so that you can build out of tree.
+cd build
+cmake -DUSE_TLS=1 ..
+make -j
+make install # will install to /usr/local on Unix, on macOS it is a good idea to sudo chown -R `whoami`:staff /usr/local
+```
+
+Headers and a static library will be installed to the target dir.
+There is a unittest which can be executed by typing `make test`.
+
+Options for building:
+
+* `-DUSE_ZLIB=1` will enable zlib support, required for http client + server + websocket per message deflate extension
+* `-DUSE_TLS=1` will enable TLS support
+* `-DUSE_OPEN_SSL=1` will use [openssl](https://www.openssl.org/) for the TLS support (default on Linux and Windows)
+* `-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/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:
+
+```
+    ExternalProject_Add(
+        IXWebSocket
+        GIT_REPOSITORY https://github.com/machinezone/IXWebSocket.git
+        ...
+    )
+```
+
+### vcpkg
+
+It is possible to get IXWebSocket through Microsoft [vcpkg](https://github.com/microsoft/vcpkg).
+
+```
+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
+
+[ ![Download](https://api.bintray.com/packages/conan/conan-center/ixwebsocket%3A_/images/download.svg) ](https://bintray.com/conan/conan-center/ixwebsocket%3A_/_latestVersion)
+
+Conan is currently supported through a recipe in [Conan Center](https://github.com/conan-io/conan-center-index/tree/master/recipes/ixwebsocket) ([Bintray entry](https://bintray.com/conan/conan-center/ixwebsocket%3A_)).
+
+Package reference
+
+* Conan 1.21.0 and up: `ixwebsocket/7.9.2`
+* Earlier versions: `ixwebsocket/7.9.2@_/_`
+
+Note that the version listed here might not be the latest one. See Bintray or the recipe itself for the latest version. If you're migrating from the previous, custom Bintray remote, note that the package reference _has_ to be lower-case.
+
+### Docker
+
+There is a Dockerfile for running the unittest on Linux, and to run the `ws` tool. It is also available on the docker registry.
+
+```
+docker run docker.pkg.github.com/machinezone/ixwebsocket/ws:latest --help
+```
+
+To use docker-compose you must make a docker container first.
+
+```
+$ make docker
+...
+$ docker compose up &
+...
+$ docker exec -it ixwebsocket_ws_1 bash
+app@ca2340eb9106:~$ ws --help
+ws is a websocket tool
+...
+```

docs/cobra.md

@@ -0,0 +1,81 @@
+## General
+
+[cobra](https://github.com/machinezone/cobra) is a real time messaging server. The `ws` utility can run a cobra server (named snake), and has client to publish and subscribe to a cobra server.
+
+Bring up 3 terminals and run a server, a publisher and a subscriber in each one. As you publish data you should see it being received by the subscriber. You can run `redis-cli MONITOR` too to see how redis is being used.
+
+### Server
+
+You will need to have a redis server running locally. To run the server:
+
+```bash
+$ cd <ixwebsocket-top-level-folder>/ixsnake/ixsnake
+$ ws snake
+{
+  "apps": {
+    "FC2F10139A2BAc53BB72D9db967b024f": {
+      "roles": {
+        "_sub": {
+          "secret": "66B1dA3ED5fA074EB5AE84Dd8CE3b5ba"
+        },
+        "_pub": {
+          "secret": "1c04DB8fFe76A4EeFE3E318C72d771db"
+        }
+      }
+    }
+  }
+}
+
+redis host: 127.0.0.1
+redis password:
+redis port: 6379
+```
+
+### Publisher
+
+```bash
+$ cd <ixwebsocket-top-level-folder>/ws
+$ ws cobra_publish --appkey FC2F10139A2BAc53BB72D9db967b024f --endpoint ws://127.0.0.1:8008 --rolename _pub --rolesecret 1c04DB8fFe76A4EeFE3E318C72d771db test_channel cobraMetricsSample.json
+[2019-11-27 09:06:12.980] [info] Publisher connected
+[2019-11-27 09:06:12.980] [info] Connection: Upgrade
+[2019-11-27 09:06:12.980] [info] Sec-WebSocket-Accept: zTtQKMKbvwjdivURplYXwCVUCWM=
+[2019-11-27 09:06:12.980] [info] Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+[2019-11-27 09:06:12.980] [info] Server: ixwebsocket/7.4.0 macos ssl/DarwinSSL zlib 1.2.11
+[2019-11-27 09:06:12.980] [info] Upgrade: websocket
+[2019-11-27 09:06:12.982] [info] Publisher authenticated
+[2019-11-27 09:06:12.982] [info] Published msg 3
+[2019-11-27 09:06:12.982] [info] Published message id 3 acked
+```
+
+### Subscriber
+
+```bash
+$ ws cobra_subscribe --appkey FC2F10139A2BAc53BB72D9db967b024f --endpoint ws://127.0.0.1:8008 --rolename _pub --rolesecret 1c04DB8fFe76A4EeFE3E318C72d771db test_channel
+#messages 0 msg/s 0
+[2019-11-27 09:07:39.341] [info] Subscriber connected
+[2019-11-27 09:07:39.341] [info] Connection: Upgrade
+[2019-11-27 09:07:39.341] [info] Sec-WebSocket-Accept: 9vkQWofz49qMCUlTSptCCwHWm+Q=
+[2019-11-27 09:07:39.341] [info] Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+[2019-11-27 09:07:39.341] [info] Server: ixwebsocket/7.4.0 macos ssl/DarwinSSL zlib 1.2.11
+[2019-11-27 09:07:39.341] [info] Upgrade: websocket
+[2019-11-27 09:07:39.342] [info] Subscriber authenticated
+[2019-11-27 09:07:39.345] [info] Subscriber: subscribed to channel test_channel
+#messages 0 msg/s 0
+#messages 0 msg/s 0
+#messages 0 msg/s 0
+{"baz":123,"foo":"bar"}
+
+#messages 1 msg/s 1
+#messages 1 msg/s 0
+#messages 1 msg/s 0
+{"baz":123,"foo":"bar"}
+
+{"baz":123,"foo":"bar"}
+
+#messages 3 msg/s 2
+#messages 3 msg/s 0
+{"baz":123,"foo":"bar"}
+
+#messages 4 msg/s 1
+^C
+```

docs/design.md

@@ -0,0 +1,82 @@
+## Implementation details
+
+### Per Message Deflate compression.
+
+The per message deflate compression option is supported. It can lead to very nice bandbwith savings (20x !) if your messages are similar, which is often the case for example for chat applications. All features of the spec should be supported.
+
+### TLS/SSL
+
+Connections can be optionally secured and encrypted with TLS/SSL when using a wss:// endpoint, or using normal un-encrypted socket with ws:// endpoints. AppleSSL is used on iOS and macOS, OpenSSL and mbedTLS can be used on Android, Linux and Windows.
+
+If you are using OpenSSL, try to be on a version higher than 1.1.x as there there are thread safety problems with 1.0.x.
+
+### Polling and background thread work
+
+No manual polling to fetch data is required. Data is sent and received instantly by using a background thread for receiving data and the select [system](http://man7.org/linux/man-pages/man2/select.2.html) call to be notified by the OS of incoming data. No timeout is used for select so that the background thread is only woken up when data is available, to optimize battery life. This is also the recommended way of using select according to the select tutorial, section [select law](https://linux.die.net/man/2/select_tut). Read and Writes to the socket are non blocking. Data is sent right away and not enqueued by writing directly to the socket, which is [possible](https://stackoverflow.com/questions/1981372/are-parallel-calls-to-send-recv-on-the-same-socket-valid) since system socket implementations allow concurrent read/writes. However concurrent writes need to be protected with mutex.
+
+### Automatic reconnection
+
+If the remote end (server) breaks the connection, the code will try to perpetually reconnect, by using an exponential backoff strategy, capped at one retry every 10 seconds. This behavior can be disabled.
+
+### Large messages
+
+Large frames are broken up into smaller chunks or messages to avoid filling up the os tcp buffers, which is permitted thanks to WebSocket [fragmentation](https://tools.ietf.org/html/rfc6455#section-5.4). Messages up to 1G were sent and received succesfully.
+
+### Testing
+
+The library has an interactive tool which is handy for testing compatibility ith other libraries. We have tested our client against Python, Erlang, Node.js, and C++ websocket server libraries.
+
+The unittest tries to be comprehensive, and has been running on multiple platforms, with different sanitizers such as a thread sanitizer to catch data races or the undefined behavior sanitizer.
+
+The regression test is running after each commit on github actions for multiple configurations.
+
+* Linux
+* macOS with thread sanitizer
+* macOS, with OpenSSL, with thread sanitizer
+* macOS, with MbedTLS, with thread sanitizer
+* Windows, with MbedTLS (the unittest is not run yet)
+
+## Limitations
+
+* On some configuration (mostly Android) certificate validation needs to be setup so that SocketTLSOptions.caFile point to a pem file, such as the one distributed by Firefox. Unless that setup is done connecting to a wss endpoint will display an error. With mbedtls the message will contain `error in handshake : X509 - Certificate verification failed, e.g. CRL, CA or signature check failed`.
+* Automatic reconnection works at the TCP socket level, and will detect remote end disconnects. However, if the device/computer network become unreachable (by turning off wifi), it is quite hard to reliably and timely detect it at the socket level using `recv` and `send` error codes. [Here](https://stackoverflow.com/questions/14782143/linux-socket-how-to-detect-disconnected-network-in-a-client-program) is a good discussion on the subject. This behavior is consistent with other runtimes such as node.js. One way to detect a disconnected device with low level C code is to do a name resolution with DNS but this can be expensive. Mobile devices have good and reliable API to do that.
+* The server code is using select to detect incoming data, and creates one OS thread per connection. This is not as scalable as strategies using epoll or kqueue.
+
+## C++ code organization
+
+Here is a simplistic diagram which explains how the code is structured in term of class/modules.
+
+```
++-----------------------+ --- Public
+|                       | Start the receiving Background thread. Auto reconnection. Simple websocket Ping.
+|  IXWebSocket          | Interface used by C++ test clients. No IX dependencies.
+|                       |
++-----------------------+
+|                       |
+|  IXWebSocketServer    | Run a server and give each connections its own WebSocket object.
+|                       | Each connection is handled in a new OS thread.
+|                       |
++-----------------------+ --- Private
+|                       |
+|  IXWebSocketTransport | Low level websocket code, framing, managing raw socket. Adapted from easywsclient.
+|                       |
++-----------------------+
+|                       |
+|  IXWebSocketHandshake | Establish the connection between client and server.
+|                       |
++-----------------------+
+|                       |
+|  IXWebSocket          | ws://  Unencrypted Socket handler
+|  IXWebSocketAppleSSL  | wss:// TLS encrypted Socket AppleSSL handler. Used on iOS and macOS
+|  IXWebSocketOpenSSL   | wss:// TLS encrypted Socket OpenSSL handler.  Used on Android and Linux
+|                       |                                               Can be used on macOS too.
++-----------------------+
+|                       |
+|  IXSocketConnect      | Connect to the remote host (client).
+|                       |
++-----------------------+
+|                       |
+|  IXDNSLookup          | Does DNS resolution asynchronously so that it can be interrupted.
+|                       |
++-----------------------+
+```

docs/index.md

@@ -0,0 +1,64 @@
+## 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.
+
+* macOS
+* iOS
+* Linux
+* Android
+* Windows
+* FreeBSD
+
+## Example code
+
+```c++
+// Required on Windows
+ix::initNetSystem();
+
+// Our websocket object
+ix::WebSocket webSocket;
+
+std::string url("ws://localhost:8080/");
+webSocket.setUrl(url);
+
+// Setup a callback to be fired 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 << msg->str << 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");
+```
+
+## Why another library?
+
+There are 2 main reasons that explain why IXWebSocket got written. First, we needed a C++ cross-platform client library, which should have few dependencies. What looked like the most solid one, [websocketpp](https://github.com/zaphoyd/websocketpp) did depend on boost and this was not an option for us. Secondly, there were other available libraries with fewer dependencies (C ones), but they required calling an explicit poll routine periodically to know if a client had received data from a server, which was not elegant.
+
+We started by solving those 2 problems, then we added server websocket code, then an HTTP client, and finally a very simple HTTP server. IXWebSocket comes with a command line utility named ws which is quite handy, and is now packaged with alpine linux. You can install it with `apk add ws`.
+
+* Few dependencies (only zlib)
+* Simple to use ; uses std::string and std::function callbacks.
+* Complete support of the websocket protocol, and basic http support.
+* Client and Server
+* TLS support
+
+## Alternative libraries
+
+There are plenty of great websocket libraries out there, which might work for you. Here are a couple of serious ones.
+
+* [websocketpp](https://github.com/zaphoyd/websocketpp) - C++
+* [beast](https://github.com/boostorg/beast) - C++
+* [libwebsockets](https://libwebsockets.org/) - C
+* [µWebSockets](https://github.com/uNetworking/uWebSockets) - C
+
+## Contributing
+
+IXWebSocket is developed on [GitHub](https://github.com/machinezone/IXWebSocket). We'd love to hear about how you use it; opening up an issue on GitHub is ok for that. 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.

docs/packages.md

@@ -0,0 +1,94 @@
+Notes on how we can update the different packages for ixwebsocket.
+
+## VCPKG
+
+Visit the [releases](https://github.com/machinezone/IXWebSocket/releases) page on Github. A tag must have been made first.
+
+Download the latest entry.
+
+```
+$ cd /tmp
+/tmp$ curl -s -O -L https://github.com/machinezone/IXWebSocket/archive/v9.1.9.tar.gz
+/tmp$
+/tmp$ openssl sha512 v9.1.9.tar.gz
+SHA512(v9.1.9.tar.gz)= f1fd731b5f6a9ce6d6d10bee22a5d9d9baaa8ea0564d6c4cd7eb91dcb88a45c49b2c7fdb75f8640a3589c1b30cee33ef5df8dcbb55920d013394d1e33ddd3c8e
+```
+
+Now go punch those values in the vcpkg ixwebsocket port config files. Here is what the diff look like.
+
+```
+vcpkg$ git diff
+diff --git a/ports/ixwebsocket/CONTROL b/ports/ixwebsocket/CONTROL
+index db9c2adc9..4acae5c3f 100644
+--- a/ports/ixwebsocket/CONTROL
++++ b/ports/ixwebsocket/CONTROL
+@@ -1,5 +1,5 @@
+ Source: ixwebsocket
+-Version: 8.0.5
++Version: 9.1.9
+ Build-Depends: zlib
+ Homepage: https://github.com/machinezone/IXWebSocket
+ Description: Lightweight WebSocket Client and Server + HTTP Client and Server
+diff --git a/ports/ixwebsocket/portfile.cmake b/ports/ixwebsocket/portfile.cmake
+index de082aece..68e523a05 100644
+--- a/ports/ixwebsocket/portfile.cmake
++++ b/ports/ixwebsocket/portfile.cmake
+@@ -1,8 +1,8 @@
+ vcpkg_from_github(
+     OUT_SOURCE_PATH SOURCE_PATH
+     REPO machinezone/IXWebSocket
+-    REF v8.0.5
+-    SHA512 9dcc20d9a0629b92c62a68a8bd7c8206f18dbd9e93289b0b687ec13c478ce9ad1f3563b38c399c8277b0d3812cc78ca725786ba1dedbc3445b9bdb9b689e8add
++    REF v9.1.9
++    SHA512 f1fd731b5f6a9ce6d6d10bee22a5d9d9baaa8ea0564d6c4cd7eb91dcb88a45c49b2c7fdb75f8640a3589c1b30cee33ef5df8dcbb55920d013394d1e33ddd3c8e
+ )
+```
+
+You will need a fork of the vcpkg repo to make a pull request.
+
+```
+git fetch upstream
+git co master
+git reset --hard upstream/master
+git push origin master --force
+```
+
+Make the pull request (I use a new branch to do that).
+
+```
+vcpkg$ git co -b feature/ixwebsocket_9.1.9
+M	ports/ixwebsocket/CONTROL
+M	ports/ixwebsocket/portfile.cmake
+Switched to a new branch 'feature/ixwebsocket_9.1.9'
+vcpkg$
+vcpkg$
+vcpkg$ git commit -am 'ixwebsocket: update to 9.1.9'
+[feature/ixwebsocket_9.1.9 8587a4881] ixwebsocket: update to 9.1.9
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+vcpkg$
+vcpkg$ git push
+fatal: The current branch feature/ixwebsocket_9.1.9 has no upstream branch.
+To push the current branch and set the remote as upstream, use
+
+    git push --set-upstream origin feature/ixwebsocket_9.1.9
+
+vcpkg$ git push --set-upstream origin feature/ixwebsocket_9.1.9
+
+Enumerating objects: 11, done.
+Counting objects: 100% (11/11), done.
+Delta compression using up to 8 threads
+Compressing objects: 100% (6/6), done.
+Writing objects: 100% (6/6), 621 bytes | 621.00 KiB/s, done.
+Total 6 (delta 4), reused 0 (delta 0)
+remote: Resolving deltas: 100% (4/4), completed with 4 local objects.
+remote:
+remote: Create a pull request for 'feature/ixwebsocket_9.1.9' on GitHub by visiting:
+remote:      https://github.com/bsergean/vcpkg/pull/new/feature/ixwebsocket_9.1.9
+remote:
+To https://github.com/bsergean/vcpkg.git
+ * [new branch]          feature/ixwebsocket_9.1.9 -> feature/ixwebsocket_9.1.9
+Branch 'feature/ixwebsocket_9.1.9' set up to track remote branch 'feature/ixwebsocket_9.1.9' from 'origin' by rebasing.
+vcpkg$
+```
+
+Just visit this url, https://github.com/bsergean/vcpkg/pull/new/feature/ixwebsocket_9.1.9, printed on the console, to make the pull request.

docs/performance.md

@@ -0,0 +1,37 @@
+
+## WebSocket Client performance
+
+We will run a client and a server on the same machine, connecting to localhost. This bench is run on a MacBook Pro from 2015. We can receive over 200,000 (small) messages per second, another way to put it is that it takes 5 micro-second to receive and process one message. This is an indication about the minimal latency to receive messages.
+
+### Receiving messages
+
+By using the push_server ws sub-command, the server will send the same message in a loop to any connected client.
+
+```
+ws push_server -q --send_msg 'yo'
+```
+
+By using the echo_client ws sub-command, with the -m (mute or no_send), we will display statistics on how many messages we can receive per second.
+
+```
+$ ws echo_client -m ws://localhost:8008
+[2020-08-02 12:31:17.284] [info] ws_echo_client: connected
+[2020-08-02 12:31:17.284] [info] Uri: /
+[2020-08-02 12:31:17.284] [info] Headers:
+[2020-08-02 12:31:17.284] [info] Connection: Upgrade
+[2020-08-02 12:31:17.284] [info] Sec-WebSocket-Accept: byy/pMK2d0PtRwExaaiOnXJTQHo=
+[2020-08-02 12:31:17.284] [info] Server: ixwebsocket/10.1.4 macos ssl/SecureTransport zlib 1.2.11
+[2020-08-02 12:31:17.284] [info] Upgrade: websocket
+[2020-08-02 12:31:17.663] [info] messages received: 0 per second 2595307 total
+[2020-08-02 12:31:18.668] [info] messages received: 79679 per second 2674986 total
+[2020-08-02 12:31:19.668] [info] messages received: 207438 per second 2882424 total
+[2020-08-02 12:31:20.673] [info] messages received: 209207 per second 3091631 total
+[2020-08-02 12:31:21.676] [info] messages received: 216056 per second 3307687 total
+[2020-08-02 12:31:22.680] [info] messages received: 214927 per second 3522614 total
+[2020-08-02 12:31:23.684] [info] messages received: 216960 per second 3739574 total
+[2020-08-02 12:31:24.688] [info] messages received: 215232 per second 3954806 total
+[2020-08-02 12:31:25.691] [info] messages received: 212300 per second 4167106 total
+[2020-08-02 12:31:26.694] [info] messages received: 212501 per second 4379607 total
+[2020-08-02 12:31:27.699] [info] messages received: 212330 per second 4591937 total
+[2020-08-02 12:31:28.702] [info] messages received: 216511 per second 4808448 total
+```

docs/usage.md

@@ -0,0 +1,581 @@
+# Examples
+
+The [*ws*](https://github.com/machinezone/IXWebSocket/tree/master/ws) folder countains many interactive programs for chat, [file transfers](https://github.com/machinezone/IXWebSocket/blob/master/ws/ws_send.cpp), [curl like](https://github.com/machinezone/IXWebSocket/blob/master/ws/ws_http_client.cpp) http clients, demonstrating client and server usage.
+
+## Windows note
+
+To use the network system on Windows, you need to initialize it once with *WSAStartup()* and clean it up with *WSACleanup()*. We have helpers for that which you can use, see below. This init would typically take place in your main function.
+
+```cpp
+#include <ixwebsocket/IXNetSystem.h>
+
+int main()
+{
+    ix::initNetSystem();
+
+    ...
+
+    ix::uninitNetSystem();
+    return 0;
+}
+```
+
+## WebSocket client API
+
+```cpp
+#include <ixwebsocket/IXWebSocket.h>
+
+...
+
+// Our websocket object
+ix::WebSocket webSocket;
+
+std::string url("ws://localhost:8080/");
+webSocket.setUrl(url);
+
+// Optional heart beat, sent every 45 seconds when there is not any traffic
+// to make sure that load balancers do not kill an idle connection.
+webSocket.setPingInterval(45);
+
+// Per message deflate connection is enabled by default. You can tweak its parameters or disable it
+webSocket.disablePerMessageDeflate();
+
+// Setup a callback to be fired 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 << msg->str << 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");
+
+// The message can be sent in BINARY mode (useful if you send MsgPack data for example)
+webSocket.sendBinary("some serialized binary data");
+
+// ... finally ...
+
+// Stop the connection
+webSocket.stop()
+```
+
+### Sending messages
+
+`WebSocketSendInfo result = websocket.send("foo")` will send a message.
+
+If the connection was closed, sending will fail, and the success field of the result object  will be set to false. There could also be a compression error in which case the compressError field will be set to true. The payloadSize field and wireSize fields will tell you respectively how much bytes the message weight, and how many bytes were sent on the wire (potentially compressed + counting the message header (a few bytes).
+
+There is an optional progress callback that can be passed in as the second argument. If a message is large it will be fragmented into chunks which will be sent independantly. Everytime the we can write a fragment into the OS network cache, the callback will be invoked. If a user wants to cancel a slow send, false should be returned from within the callback.
+
+Here is an example code snippet copied from the ws send sub-command. Each fragment weights 32K, so the total integer is the wireSize divided by 32K. As an example if you are sending 32M of data, uncompressed, total will be 1000. current will be set to 0 for the first fragment, then 1, 2 etc...
+
+```
+auto result =
+    _webSocket.sendBinary(serializedMsg, [this, throttle](int current, int total) -> bool {
+        spdlog::info("ws_send: Step {} out of {}", current + 1, total);
+
+        if (throttle)
+        {
+            std::chrono::duration<double, std::milli> duration(10);
+            std::this_thread::sleep_for(duration);
+        }
+
+        return _connected;
+    });
+```
+
+### ReadyState
+
+`getReadyState()` returns the state of the connection. There are 4 possible states.
+
+1. ReadyState::Connecting - The connection is not yet open.
+2. ReadyState::Open       - The connection is open and ready to communicate.
+3. ReadyState::Closing    - The connection is in the process of closing.
+4. ReadyState::Closed     - The connection is closed or could not be opened.
+
+### Open and Close notifications
+
+The onMessage event will be fired when the connection is opened or closed. This is similar to the [JavaScript browser API](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket), which has `open` and `close` events notification that can be registered with the browser `addEventListener`.
+
+```cpp
+webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
+    {
+        if (msg->type == ix::WebSocketMessageType::Open)
+        {
+            std::cout << "send greetings" << std::endl;
+
+            // Headers can be inspected (pairs of string/string)
+            std::cout << "Handshake Headers:" << std::endl;
+            for (auto it : msg->headers)
+            {
+                std::cout << it.first << ": " << it.second << std::endl;
+            }
+        }
+        else if (msg->type == ix::WebSocketMessageType::Close)
+        {
+            std::cout << "disconnected" << std::endl;
+
+            // The server can send an explicit code and reason for closing.
+            // This data can be accessed through the closeInfo object.
+            std::cout << msg->closeInfo.code << std::endl;
+            std::cout << msg->closeInfo.reason << std::endl;
+        }
+    }
+);
+```
+
+### Error notification
+
+A message will be fired when there is an error with the connection. The message type will be `ix::WebSocketMessageType::Error`. Multiple fields will be available on the event to describe the error.
+
+```cpp
+webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
+    {
+        if (msg->type == ix::WebSocketMessageType::Error)
+        {
+            std::stringstream ss;
+            ss << "Error: "         << msg->errorInfo.reason      << std::endl;
+            ss << "#retries: "      << msg->eventInfo.retries     << std::endl;
+            ss << "Wait time(ms): " << msg->eventInfo.wait_time   << std::endl;
+            ss << "HTTP Status: "   << msg->eventInfo.http_status << std::endl;
+            std::cout << ss.str() << std::endl;
+        }
+    }
+);
+```
+
+### start, stop
+
+1. `websocket.start()` connect to the remote server and starts the message receiving background thread.
+2. `websocket.stop()` disconnect from the remote server and closes the background thread.
+
+### Configuring the remote url
+
+The url can be set and queried after a websocket object has been created. You will have to call `stop` and `start` if you want to disconnect and connect to that new url.
+
+```cpp
+std::string url("wss://example.com");
+websocket.configure(url);
+```
+
+### Ping/Pong support
+
+Ping/pong messages are used to implement keep-alive. 2 message types exists to identify ping and pong messages. Note that when a ping message is received, a pong is instantly send back as requested by the WebSocket spec.
+
+```cpp
+webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
+    {
+        if (msg->type == ix::WebSocketMessageType::Ping ||
+            msg->type == ix::WebSocketMessageType::Pong)
+        {
+            std::cout << "pong data: " << msg->str << std::endl;
+        }
+    }
+);
+```
+
+A ping message can be sent to the server, with an optional data string.
+
+```cpp
+websocket.ping("ping data, optional (empty string is ok): limited to 125 bytes long");
+```
+
+### Heartbeat.
+
+You can configure an optional heart beat / keep-alive, sent every 45 seconds
+when there is no any traffic to make sure that load balancers do not kill an
+idle connection.
+
+```cpp
+webSocket.setPingInterval(45);
+```
+
+### Supply extra HTTP headers.
+
+You can set extra HTTP headers to be sent during the WebSocket handshake.
+
+```cpp
+WebSocketHttpHeaders headers;
+headers["foo"] = "bar";
+webSocket.setExtraHeaders(headers);
+```
+
+### Subprotocols
+
+You can specify subprotocols to be set during the WebSocket handshake. For more info you can refer to [this doc](https://hpbn.co/websocket/#subprotocol-negotiation).
+
+```cpp
+webSocket.addSubprotocol("appProtocol-v1");
+webSocket.addSubprotocol("appProtocol-v2");
+```
+
+The protocol that the server did accept is available in the open info `protocol` field.
+
+```cpp
+std::cout << "protocol: " << msg->openInfo.protocol << std::endl;
+```
+
+### Automatic reconnection
+
+Automatic reconnection kicks in when the connection is disconnected without the user consent. This feature is on by default and can be turned off.
+
+```cpp
+webSocket.enableAutomaticReconnection();  // turn on
+webSocket.disableAutomaticReconnection(); // turn off
+bool enabled = webSocket.isAutomaticReconnectionEnabled(); // query state
+```
+
+The technique to calculate wait time is called [exponential
+backoff](https://docs.aws.amazon.com/general/latest/gr/api-retries.html). Here
+are the default waiting times between attempts (from connecting with `ws connect ws://foo.com`)
+
+```
+> Connection error: Got bad status connecting to foo.com, status: 301, HTTP Status line: HTTP/1.1 301 Moved Permanently
+
+#retries: 1
+Wait time(ms): 100
+#retries: 2
+Wait time(ms): 200
+#retries: 3
+Wait time(ms): 400
+#retries: 4
+Wait time(ms): 800
+#retries: 5
+Wait time(ms): 1600
+#retries: 6
+Wait time(ms): 3200
+#retries: 7
+Wait time(ms): 6400
+#retries: 8
+Wait time(ms): 10000
+```
+
+The waiting time is capped by default at 10s between 2 attempts, but that value can be changed and queried.
+
+```cpp
+webSocket.setMaxWaitBetweenReconnectionRetries(5 * 1000); // 5000ms = 5s
+uint32_t m = webSocket.getMaxWaitBetweenReconnectionRetries();
+```
+
+## WebSocket server API
+
+### Legacy api
+
+This api was actually changed to take a weak_ptr<WebSocket> as the first argument to setOnConnectionCallback ; previously it would take a shared_ptr<WebSocket> which was creating cycles and then memory leaks problems.
+
+```cpp
+#include <ixwebsocket/IXWebSocketServer.h>
+
+...
+
+// Run a server on localhost at a given port.
+// Bound host name, max connections and listen backlog can also be passed in as parameters.
+ix::WebSocketServer server(port);
+
+server.setOnConnectionCallback(
+    [&server](std::weak_ptr<WebSocket> webSocket,
+              std::shared_ptr<ConnectionState> connectionState)
+    {
+        std::cout << "Remote ip: " << connectionState->remoteIp << std::endl;
+
+        auto ws = webSocket.lock();
+        if (ws)
+        {
+            ws->setOnMessageCallback(
+                [webSocket, connectionState, &server](const ix::WebSocketMessagePtr msg)
+                {
+                    if (msg->type == ix::WebSocketMessageType::Open)
+                    {
+                        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::cout << "id: " << connectionState->getId() << std::endl;
+
+                        // The uri the client did connect to.
+                        std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+
+                        std::cout << "Headers:" << std::endl;
+                        for (auto it : msg->openInfo.headers)
+                        {
+                            std::cout << it.first << ": " << it.second << std::endl;
+                        }
+                    }
+                    else if (msg->type == ix::WebSocketMessageType::Message)
+                    {
+                        // For an echo server, we just send back to the client whatever was received by the server
+                        // All connected clients are available in an std::set. See the broadcast cpp example.
+                        // Second parameter tells whether we are sending the message in binary or text mode.
+                        // Here we send it in the same mode as it was received.
+                        auto ws = webSocket.lock();
+                        if (ws)
+                        {
+                            ws->send(msg->str, msg->binary);
+                        }
+                    }
+                }
+            }
+        );
+    }
+);
+
+auto res = server.listen();
+if (!res.first)
+{
+    // Error handling
+    return 1;
+}
+
+// Run the server in the background. Server can be stoped by calling server.stop()
+server.start();
+
+// Block until server.stop() is called.
+server.wait();
+
+```
+
+### New api
+
+The new API does not require to use 2 nested callbacks, which is a bit annoying. The real fix is that there was a memory leak due to a shared_ptr cycle, due to passing down a shared_ptr<WebSocket> down to the callbacks.
+
+The webSocket reference is guaranteed to be always valid ; by design the callback will never be invoked with a null webSocket object.
+
+```cpp
+#include <ixwebsocket/IXWebSocketServer.h>
+
+...
+
+// Run a server on localhost at a given port.
+// Bound host name, max connections and listen backlog can also be passed in as parameters.
+ix::WebSocketServer server(port);
+
+server.setOnClientMessageCallback(std::shared_ptr<ConnectionState> connectionState,
+                                  WebSocket& webSocket,
+                                  const WebSocketMessagePtr& msg)
+{
+    // The ConnectionState object contains information about the connection,
+    // at this point only the client ip address and the port.
+    std::cout << "Remote ip: " << connectionState->getRemoteIp();
+
+    if (msg->type == ix::WebSocketMessageType::Open)
+    {
+        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::cout << "id: " << connectionState->getId() << std::endl;
+
+        // The uri the client did connect to.
+        std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+
+        std::cout << "Headers:" << std::endl;
+        for (auto it : msg->openInfo.headers)
+        {
+            std::cout << it.first << ": " << it.second << std::endl;
+        }
+    }
+    else if (msg->type == ix::WebSocketMessageType::Message)
+    {
+        // For an echo server, we just send back to the client whatever was received by the server
+        // All connected clients are available in an std::set. See the broadcast cpp example.
+        // Second parameter tells whether we are sending the message in binary or text mode.
+        // Here we send it in the same mode as it was received.
+        webSocket.send(msg->str, msg->binary);
+    }
+);
+
+auto res = server.listen();
+if (!res.first)
+{
+    // Error handling
+    return 1;
+}
+
+// Run the server in the background. Server can be stoped by calling server.stop()
+server.start();
+
+// Block until server.stop() is called.
+server.wait();
+
+```
+
+## HTTP client API
+
+```cpp
+#include <ixwebsocket/IXHttpClient.h>
+
+...
+
+//
+// Preparation
+//
+HttpClient httpClient;
+HttpRequestArgsPtr args = httpClient.createRequest();
+
+// Custom headers can be set
+WebSocketHttpHeaders headers;
+headers["Foo"] = "bar";
+args->extraHeaders = headers;
+
+// Timeout options
+args->connectTimeout = connectTimeout;
+args->transferTimeout = transferTimeout;
+
+// Redirect options
+args->followRedirects = followRedirects;
+args->maxRedirects = maxRedirects;
+
+// Misc
+args->compress = compress; // Enable gzip compression
+args->verbose = verbose;
+args->logger = [](const std::string& msg)
+{
+    std::cout << msg;
+};
+
+//
+// Synchronous Request
+//
+HttpResponsePtr out;
+std::string url = "https://www.google.com";
+
+// HEAD request
+out = httpClient.head(url, args);
+
+// GET request
+out = httpClient.get(url, args);
+
+// POST request with parameters
+HttpParameters httpParameters;
+httpParameters["foo"] = "bar";
+
+// HTTP form data can be passed in as well, for multi-part upload of files
+HttpFormDataParameters httpFormDataParameters;
+httpParameters["baz"] = "booz";
+
+out = httpClient.post(url, httpParameters, httpFormDataParameters, args);
+
+// POST request with a body
+out = httpClient.post(url, std::string("foo=bar"), args);
+
+// PUT and PATCH are available too.
+
+//
+// Result
+//
+auto statusCode = response->statusCode; // Can be HttpErrorCode::Ok, HttpErrorCode::UrlMalformed, etc...
+auto errorCode = response->errorCode; // 200, 404, etc...
+auto responseHeaders = response->headers; // All the headers in a special case-insensitive unordered_map of (string, string)
+auto body = response->body; // All the bytes from the response as an std::string
+auto errorMsg = response->errorMsg; // Descriptive error message in case of failure
+auto uploadSize = response->uploadSize; // Byte count of uploaded data
+auto downloadSize = response->downloadSize; // Byte count of downloaded data
+
+//
+// Asynchronous Request
+//
+bool async = true;
+HttpClient httpClient(async);
+auto args = httpClient.createRequest(url, HttpClient::kGet);
+
+// Push the request to a queue,
+bool ok = httpClient.performRequest(args, [](const HttpResponsePtr& response)
+    {
+        // This callback execute in a background thread. Make sure you uses appropriate protection such as mutex
+        auto statusCode = response->statusCode; // acess results
+    }
+);
+
+// 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
+#include <ixwebsocket/IXHttpServer.h>
+
+ix::HttpServer server(port, hostname);
+
+auto res = server.listen();
+if (!res.first)
+{
+    std::cerr << res.second << std::endl;
+    return 1;
+}
+
+server.start();
+server.wait();
+```
+
+If you want to handle how requests are processed, implement the setOnConnectionCallback callback, which takes an HttpRequestPtr as input, and returns an HttpResponsePtr. You can look at HttpServer::setDefaultConnectionCallback for a slightly more advanced callback example.
+
+```cpp
+setOnConnectionCallback(
+    [this](HttpRequestPtr request,
+           std::shared_ptr<ConnectionState> connectionState) -> HttpResponsePtr
+    {
+        // Build a string for the response
+        std::stringstream ss;
+        ss << connectionState->getRemoteIp();
+           << " "
+           << request->method
+           << " "
+           << request->uri;
+
+        std::string content = ss.str();
+
+        return std::make_shared<HttpResponse>(200, "OK",
+                                              HttpErrorCode::Ok,
+                                              WebSocketHttpHeaders(),
+                                              content);
+}
+```
+
+## TLS support and configuration
+
+To leverage TLS features, the library must be compiled with the option `USE_TLS=1`.
+
+If you are using OpenSSL, try to be on a version higher than 1.1.x as there there are thread safety problems with 1.0.x.
+
+Then, secure sockets are automatically used when connecting to a `wss://*` url.
+
+Additional TLS options can be configured by passing a `ix::SocketTLSOptions` instance to the
+`setTLSOptions` on `ix::WebSocket` (or `ix::WebSocketServer` or `ix::HttpServer`)
+
+```cpp
+webSocket.setTLSOptions({
+    .certFile = "path/to/cert/file.pem",
+    .keyFile = "path/to/key/file.pem",
+    .caFile = "path/to/trust/bundle/file.pem", // as a file, or in memory buffer in PEM format
+    .tls = true // required in server mode
+});
+```
+
+Specifying `certFile` and `keyFile` configures the certificate that will be used to communicate with TLS peers.
+
+On a client, this is only necessary for connecting to servers that require a client certificate.
+
+On a server, this is necessary for TLS support.
+
+Specifying `caFile` configures the trusted roots bundle file (in PEM format) that will be used to verify peer certificates.
+ - The special value of `SYSTEM` (the default) indicates that the system-configured trust bundle should be used; this is generally what you want when connecting to any publicly exposed API/server.
+ - The special value of `NONE` can be used to disable peer verification; this is only recommended to rule out certificate verification when testing connectivity.
+ - If the value contain the special value `-----BEGIN CERTIFICATE-----`, the value will be read from memory, and not from a file. This is convenient on platforms like Android where reading / writing to the file system can be challenging without proper permissions, or without knowing the location of a temp directory.
+
+For a client, specifying `caFile` can be used if connecting to a server that uses a self-signed cert, or when using a custom CA in an internal environment.
+
+For a server, specifying `caFile` implies that:
+1. You require clients to present a certificate
+1. It must be signed by one of the trusted roots in the file

docs/ws.md

@@ -0,0 +1,387 @@
+## General
+
+ws is a command line tool that should exercise most of the IXWebSocket code, and provide example code.
+
+```
+ws is a websocket tool
+Usage: ws [OPTIONS] SUBCOMMAND
+
+Options:
+  -h,--help                   Print this help message and exit
+
+Subcommands:
+  send                        Send a file
+  receive                     Receive a file
+  transfer                    Broadcasting server
+  connect                     Connect to a remote server
+  chat                        Group chat
+  echo_server                 Echo server
+  broadcast_server            Broadcasting server
+  ping                        Ping pong
+  curl                        HTTP Client
+  redis_publish               Redis publisher
+  redis_subscribe             Redis subscriber
+  cobra_subscribe             Cobra subscriber
+  cobra_publish               Cobra publisher
+  cobra_to_statsd             Cobra to statsd
+  cobra_to_sentry             Cobra to sentry
+  snake                       Snake server
+  httpd                       HTTP server
+```
+
+## curl
+
+The curl subcommand try to be compatible with the curl syntax, to fetch http pages.
+
+Making a HEAD request with the -I parameter.
+
+```
+$ ws curl -I https://www.google.com/
+
+Accept-Ranges: none
+Alt-Svc: quic=":443"; ma=2592000; v="46,43",h3-Q048=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000
+Cache-Control: private, max-age=0
+Content-Type: text/html; charset=ISO-8859-1
+Date: Tue, 08 Oct 2019 21:36:57 GMT
+Expires: -1
+P3P: CP="This is not a P3P policy! See g.co/p3phelp for more info."
+Server: gws
+Set-Cookie: NID=188=ASwfz8GrXQrHCLqAz-AndLOMLcz0rC9yecnf3h0yXZxRL3rTufTU_GDDwERp7qQL7LZ_EB8gCRyPXGERyOSAgaqgnrkoTmvWrwFemRLMaOZ896GrHobi5fV7VLklnSG2w48Gj8xMlwxfP7Z-bX-xR9UZxep1tHM6UmFQdD_GkBE; expires=Wed, 08-Apr-2020 21:36:57 GMT; path=/; domain=.google.com; HttpOnly
+Transfer-Encoding: chunked
+Vary: Accept-Encoding
+X-Frame-Options: SAMEORIGIN
+X-XSS-Protection: 0
+Upload size: 143
+Download size: 0
+Status: 200
+```
+
+Making a POST request with the -F parameter.
+
+```
+$ ws curl -F foo=bar https://httpbin.org/post
+foo: bar
+Downloaded 438 bytes out of 438
+Access-Control-Allow-Credentials: true
+Access-Control-Allow-Origin: *
+Connection: keep-alive
+Content-Encoding:
+Content-Length: 438
+Content-Type: application/json
+Date: Tue, 08 Oct 2019 21:47:54 GMT
+Referrer-Policy: no-referrer-when-downgrade
+Server: nginx
+X-Content-Type-Options: nosniff
+X-Frame-Options: DENY
+X-XSS-Protection: 1; mode=block
+Upload size: 219
+Download size: 438
+Status: 200
+payload: {
+  "args": {},
+  "data": "",
+  "files": {},
+  "form": {
+    "foo": "bar"
+  },
+  "headers": {
+    "Accept": "*/*",
+    "Content-Length": "7",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "Host": "httpbin.org",
+    "User-Agent": "ixwebsocket/7.0.0 macos ssl/OpenSSL OpenSSL 1.0.2q  20 Nov 2018 zlib 1.2.11"
+  },
+  "json": null,
+  "origin": "155.94.127.118, 155.94.127.118",
+  "url": "https://httpbin.org/post"
+}
+```
+
+Passing in a custom header with -H.
+
+```
+$ ws curl -F foo=bar -H 'my_custom_header: baz' https://httpbin.org/post
+my_custom_header:  baz
+foo: bar
+Downloaded 470 bytes out of 470
+Access-Control-Allow-Credentials: true
+Access-Control-Allow-Origin: *
+Connection: keep-alive
+Content-Encoding:
+Content-Length: 470
+Content-Type: application/json
+Date: Tue, 08 Oct 2019 21:50:25 GMT
+Referrer-Policy: no-referrer-when-downgrade
+Server: nginx
+X-Content-Type-Options: nosniff
+X-Frame-Options: DENY
+X-XSS-Protection: 1; mode=block
+Upload size: 243
+Download size: 470
+Status: 200
+payload: {
+  "args": {},
+  "data": "",
+  "files": {},
+  "form": {
+    "foo": "bar"
+  },
+  "headers": {
+    "Accept": "*/*",
+    "Content-Length": "7",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "Host": "httpbin.org",
+    "My-Custom-Header": "baz",
+    "User-Agent": "ixwebsocket/7.0.0 macos ssl/OpenSSL OpenSSL 1.0.2q  20 Nov 2018 zlib 1.2.11"
+  },
+  "json": null,
+  "origin": "155.94.127.118, 155.94.127.118",
+  "url": "https://httpbin.org/post"
+}
+```
+
+## connect
+
+The connect command connects to a websocket endpoint, and starts an interactive prompt. Line editing, such as using the direction keys to fetch the last thing you tried to type) is provided. That command is pretty useful to try to send random data to an endpoint and verify that the service handles it with grace (such as sending invalid json).
+
+```
+ws connect wss://echo.websocket.org
+Type Ctrl-D to exit prompt...
+Connecting to url: wss://echo.websocket.org
+> ws_connect: connected
+Uri: /
+Handshake Headers:
+Connection: Upgrade
+Date: Tue, 08 Oct 2019 21:38:44 GMT
+Sec-WebSocket-Accept: 2j6LBScZveqrMx1W/GJkCWvZo3M=
+sec-websocket-extensions:
+Server: Kaazing Gateway
+Upgrade: websocket
+Received ping
+Received ping
+Received ping
+Hello world !
+> Received 13 bytes
+ws_connect: received message: Hello world !
+> Hello world !
+> Received 13 bytes
+ws_connect: received message: Hello world !
+```
+
+```
+ws connect 'ws://jeanserge.com/v2?appkey=_pubsub'
+Type Ctrl-D to exit prompt...
+Connecting to url: ws://jeanserge.com/v2?appkey=_pubsub
+> ws_connect: connected
+Uri: /v2?appkey=_pubsub
+Handshake Headers:
+Connection: Upgrade
+Date: Tue, 08 Oct 2019 21:45:28 GMT
+Sec-WebSocket-Accept: LYHmjh9Gsu/Yw7aumQqyPObOEV4=
+Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+Server: Python/3.7 websockets/8.0.2
+Upgrade: websocket
+bababababababab
+> ws_connect: connection closed: code 1000 reason
+
+ws_connect: connected
+Uri: /v2?appkey=_pubsub
+Handshake Headers:
+Connection: Upgrade
+Date: Tue, 08 Oct 2019 21:45:44 GMT
+Sec-WebSocket-Accept: I1rqxdLgTU+opPi5/zKPBTuXdLw=
+Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+Server: Python/3.7 websockets/8.0.2
+Upgrade: websocket
+```
+
+## Websocket proxy
+
+```
+ws proxy_server --remote_host ws://127.0.0.1:9000 -v
+Listening on 127.0.0.1:8008
+```
+
+If you connect to ws://127.0.0.1:8008, the proxy will connect to ws://127.0.0.1:9000 and pass all traffic to this server.
+
+You can also use a more complex setup if you want to redirect to different websocket servers based on the hostname your client is trying to connect to. If you have multiple CNAME aliases that point to the same server.
+
+A JSON config file is used to express that mapping ; here connecting to echo.jeanserge.com will proxy the client to ws://localhost:8008 on the local machine (which actually runs ws echo_server), while connecting to bavarde.jeanserge.com will proxy the client to ws://localhost:5678 where a cobra python server is running. As a side note you will need a wildcard SSL certificate if you want to have SSL enabled on that machine.
+
+```json
+{
+        "remote_urls": {
+                "echo.jeanserge.com": "ws://localhost:8008",
+                "bavarde.jeanserge.com": "ws://localhost:5678"
+        }
+}
+```
+The --config_path option is required to instruct ws proxy_server to read that file.
+
+```
+ws proxy_server --config_path proxyConfig.json --port 8765
+```
+
+## File transfer
+
+```
+# Start transfer server, which is just a broadcast server at this point
+ws transfer # running on port 8080.
+
+# Start receiver first
+ws receive ws://localhost:8080
+
+# Then send a file. File will be received and written to disk by the receiver process
+ws send ws://localhost:8080 /file/to/path
+```
+
+## HTTP Client
+
+```
+$ ws curl --help
+HTTP Client
+Usage: ws curl [OPTIONS] url
+
+Positionals:
+  url TEXT REQUIRED           Connection url
+
+Options:
+  -h,--help                   Print this help message and exit
+  -d TEXT                     Form data
+  -F TEXT                     Form data
+  -H TEXT                     Header
+  --output TEXT               Output file
+  -I                          Send a HEAD request
+  -L                          Follow redirects
+  --max-redirects INT         Max Redirects
+  -v                          Verbose
+  -O                          Save output to disk
+  --compress                  Enable gzip compression
+  --connect-timeout INT       Connection timeout
+  --transfer-timeout INT      Transfer timeout
+```
+
+## Cobra client and server
+
+[cobra](https://github.com/machinezone/cobra) is a real time messenging server. ws has several sub-command to interact with cobra. There is also a minimal cobra compatible server named snake available.
+
+Below are examples on running a snake server and clients with TLS enabled (the server only works with the OpenSSL and the Mbed TLS backend for now).
+
+First, generate certificates.
+
+```
+$ cd /path/to/IXWebSocket
+$ cd ixsnake/ixsnake
+$ bash ../../ws/generate_certs.sh
+Generating RSA private key, 2048 bit long modulus
+.....+++
+.................+++
+e is 65537 (0x10001)
+generated ./.certs/trusted-ca-key.pem
+generated ./.certs/trusted-ca-crt.pem
+Generating RSA private key, 2048 bit long modulus
+..+++
+.......................................+++
+e is 65537 (0x10001)
+generated ./.certs/trusted-server-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=trusted-server
+Getting CA Private Key
+generated ./.certs/trusted-server-crt.pem
+Generating RSA private key, 2048 bit long modulus
+...................................+++
+..................................................+++
+e is 65537 (0x10001)
+generated ./.certs/trusted-client-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=trusted-client
+Getting CA Private Key
+generated ./.certs/trusted-client-crt.pem
+Generating RSA private key, 2048 bit long modulus
+..............+++
+.......................................+++
+e is 65537 (0x10001)
+generated ./.certs/untrusted-ca-key.pem
+generated ./.certs/untrusted-ca-crt.pem
+Generating RSA private key, 2048 bit long modulus
+..........+++
+................................................+++
+e is 65537 (0x10001)
+generated ./.certs/untrusted-client-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=untrusted-client
+Getting CA Private Key
+generated ./.certs/untrusted-client-crt.pem
+Generating RSA private key, 2048 bit long modulus
+.....................................................................................+++
+...........+++
+e is 65537 (0x10001)
+generated ./.certs/selfsigned-client-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=selfsigned-client
+Getting Private key
+generated ./.certs/selfsigned-client-crt.pem
+```
+
+Now run the snake server.
+
+```
+$ export certs=.certs
+$ ws snake --tls --port 8765 --cert-file ${certs}/trusted-server-crt.pem --key-file ${certs}/trusted-server-key.pem --ca-file ${certs}/trusted-ca-crt.pem
+{
+  "apps": {
+    "FC2F10139A2BAc53BB72D9db967b024f": {
+      "roles": {
+        "_sub": {
+          "secret": "66B1dA3ED5fA074EB5AE84Dd8CE3b5ba"
+        },
+        "_pub": {
+          "secret": "1c04DB8fFe76A4EeFE3E318C72d771db"
+        }
+      }
+    }
+  }
+}
+
+redis host: 127.0.0.1
+redis password:
+redis port: 6379
+```
+
+As a new connection comes in, such output should be printed
+
+```
+[2019-12-19 20:27:19.724] [info] New connection
+id: 0
+Uri: /v2?appkey=_health
+Headers:
+Connection: Upgrade
+Host: 127.0.0.1:8765
+Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+Sec-WebSocket-Key: d747B0fE61Db73f7Eh47c0==
+Sec-WebSocket-Protocol: json
+Sec-WebSocket-Version: 13
+Upgrade: websocket
+User-Agent: ixwebsocket/7.5.8 macos ssl/OpenSSL OpenSSL 1.0.2q  20 Nov 2018 zlib 1.2.11
+```
+
+To connect and publish a message, do:
+
+```
+$ export certs=.certs
+$ cd /path/to/ws/folder
+$ ls cobraMetricsSample.json
+cobraMetricsSample.json
+$ ws cobra_publish --endpoint wss://127.0.0.1:8765 --appkey FC2F10139A2BAc53BB72D9db967b024f --rolename _pub --rolesecret 1c04DB8fFe76A4EeFE3E318C72d771db --channel foo --cert-file ${certs}/trusted-client-crt.pem --key-file ${certs}/trusted-client-key.pem --ca-file ${certs}/trusted-ca-crt.pem cobraMetricsSample.json
+[2019-12-19 20:46:42.656] [info] Publisher connected
+[2019-12-19 20:46:42.657] [info] Connection: Upgrade
+[2019-12-19 20:46:42.657] [info] Sec-WebSocket-Accept: rs99IFThoBrhSg+k8G4ixH9yaq4=
+[2019-12-19 20:46:42.657] [info] Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+[2019-12-19 20:46:42.657] [info] Server: ixwebsocket/7.5.8 macos ssl/OpenSSL OpenSSL 1.0.2q  20 Nov 2018 zlib 1.2.11
+[2019-12-19 20:46:42.657] [info] Upgrade: websocket
+[2019-12-19 20:46:42.658] [info] Publisher authenticated
+[2019-12-19 20:46:42.658] [info] Published msg 3
+[2019-12-19 20:46:42.659] [info] Published message id 3 acked
+```
+
+To use OpenSSL on macOS, compile with `make ws_openssl`. First you will have to install OpenSSL libraries, which can be done with Homebrew. Use `make ws_mbedtls` accordingly to use MbedTLS.

examples/broadcast_server/.gitignore

@@ -1,9 +0,0 @@
-CMakeCache.txt
-package-lock.json
-CMakeFiles		
-ixwebsocket_unittest	
-cmake_install.cmake	
-node_modules
-ixwebsocket
-Makefile
-build

examples/broadcast_server/CMakeLists.txt

@@ -1,30 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (broadcast_server)
-
-# There's -Weverything too for clang
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
-
-set (OPENSSL_PREFIX /usr/local/opt/openssl) # Homebrew openssl
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-include_directories(broadcast_server .)
-
-add_executable(broadcast_server 
-  broadcast_server.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(broadcast_server "-framework foundation" "-framework security")
-endif()
-
-target_link_libraries(broadcast_server ixwebsocket)
-install(TARGETS broadcast_server DESTINATION bin)

examples/broadcast_server/broadcast_server.cpp

@@ -1,74 +0,0 @@
-/*
- *  broadcast_server.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <ixwebsocket/IXWebSocketServer.h>
-
-int main(int argc, char** argv)
-{
-    int port = 8080;
-    if (argc == 2)
-    {
-        std::stringstream ss;
-        ss << argv[1];
-        ss >> port;
-    }
-
-    ix::WebSocketServer server(port);
-
-    server.setOnConnectionCallback(
-        [&server](std::shared_ptr<ix::WebSocket> webSocket)
-        {
-            webSocket->setOnMessageCallback(
-                [webSocket, &server](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::WebSocket_MessageType_Open)
-                    {
-                        std::cerr << "New connection" << std::endl;
-                        std::cerr << "Uri: " << openInfo.uri << std::endl;
-                        std::cerr << "Headers:" << std::endl;
-                        for (auto it : openInfo.headers)
-                        {
-                            std::cerr << it.first << ": " << it.second << std::endl;
-                        }
-                    }
-                    else if (messageType == ix::WebSocket_MessageType_Close)
-                    {
-                        std::cerr << "Closed connection" << std::endl;
-                    }
-                    else if (messageType == ix::WebSocket_MessageType_Message)
-                    {
-                        for (auto&& client : server.getClients())
-                        {
-                            if (client != webSocket)
-                            {
-                                client->send(str);
-                            }
-                        }
-                    }
-                }
-            );
-        }
-    );
-
-    auto res = server.listen();
-    if (!res.first)
-    {
-        std::cerr << res.second << std::endl;
-        return 1;
-    }
-
-    server.start();
-    server.wait();
-
-    return 0;
-}

examples/chat/CMakeLists.txt

@@ -1,23 +0,0 @@
-#
-# cmd_websocket_chat.cpp
-# Author: Benjamin Sergeant
-# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (cmd_websocket_chat)
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-add_executable(cmd_websocket_chat cmd_websocket_chat.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(cmd_websocket_chat "-framework foundation" "-framework security")
-endif()
-
-target_link_libraries(cmd_websocket_chat ixwebsocket)
-install(TARGETS cmd_websocket_chat DESTINATION bin)

examples/chat/README.md

@@ -1,39 +0,0 @@
-# Building
-
-1. cmake -G .
-2. make
-
-## Disable TLS
-
-chat$ cmake -DUSE_TLS=OFF .
--- Configuring done
--- Generating done
--- Build files have been written to: /Users/bsergeant/src/foss/ixwebsocket/examples/chat
-chat$ make
-Scanning dependencies of target ixwebsocket
-[ 16%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXSocket.cpp.o
-[ 33%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocket.cpp.o
-[ 50%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocketTransport.cpp.o
-[ 66%] Linking CXX static library libixwebsocket.a
-[ 66%] Built target ixwebsocket
-[ 83%] Linking CXX executable cmd_websocket_chat
-[100%] Built target cmd_websocket_chat
-
-## Enable TLS (default)
-
-```
-chat$ cmake -DUSE_TLS=ON .
--- Configuring done
--- Generating done
--- Build files have been written to: /Users/bsergeant/src/foss/ixwebsocket/examples/chat
-(venv) chat$ make
-Scanning dependencies of target ixwebsocket
-[ 14%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXSocket.cpp.o
-[ 28%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocket.cpp.o
-[ 42%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocketTransport.cpp.o
-[ 57%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXSocketAppleSSL.cpp.o
-[ 71%] Linking CXX static library libixwebsocket.a
-[ 71%] Built target ixwebsocket
-[ 85%] Linking CXX executable cmd_websocket_chat
-[100%] Built target cmd_websocket_chat
-```

examples/chat/build_linux.sh

@@ -1,15 +0,0 @@
-#!/bin/sh
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
-#
-
-# 'manual' way of building. You can also use cmake.
-
-g++ --std=c++11 \
-    ../../ixwebsocket/IXSocket.cpp	\
-    ../../ixwebsocket/IXWebSocketTransport.cpp \
-    ../../ixwebsocket/IXWebSocket.cpp \
-    -I ../.. \
-    cmd_websocket_chat.cpp \
-    -o cmd_websocket_chat

examples/chat/build_macos.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
-#
-
-# 'manual' way of building. You can also use cmake.
-
-clang++ --std=c++11 --stdlib=libc++ \
-    ../../ixwebsocket/IXSocket.cpp	\
-    ../../ixwebsocket/IXWebSocketTransport.cpp \
-    ../../ixwebsocket/IXSocketAppleSSL.cpp	\
-    ../../ixwebsocket/IXWebSocket.cpp \
-    cmd_websocket_chat.cpp \
-    -o cmd_websocket_chat \
-    -framework Security \
-    -framework Foundation

examples/chat/cmd_websocket_chat.cpp

@@ -1,203 +0,0 @@
-/*
- *  cmd_websocket_chat.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
- */
-
-//
-// Simple chat program that talks to the node.js server at
-// websocket_chat_server/broacast-server.js
-//
-
-#include <iostream>
-#include <sstream>
-#include <queue>
-#include <ixwebsocket/IXWebSocket.h>
-#include <ixwebsocket/IXSocket.h>
-
-#include "nlohmann/json.hpp"
-
-// for convenience
-using json = nlohmann::json;
-
-using namespace ix;
-
-namespace
-{
-    void log(const std::string& msg)
-    {
-        std::cout << msg << std::endl;
-    }
-
-    class WebSocketChat
-    {
-        public:
-            WebSocketChat(const std::string& user);
-
-            void subscribe(const std::string& channel);
-            void start();
-            void stop();
-            bool isReady() const;
-
-            void sendMessage(const std::string& text);
-            size_t getReceivedMessagesCount() const;
-
-            std::string encodeMessage(const std::string& text);
-            std::pair<std::string, std::string> decodeMessage(const std::string& str);
-
-        private:
-            std::string _user;
-
-            ix::WebSocket _webSocket;
-
-            std::queue<std::string> _receivedQueue;
-    };
-
-    WebSocketChat::WebSocketChat(const std::string& user) :
-        _user(user)
-    {
-        ;
-    }
-
-    size_t WebSocketChat::getReceivedMessagesCount() const
-    {
-        return _receivedQueue.size();
-    }
-
-    bool WebSocketChat::isReady() const
-    {
-        return _webSocket.getReadyState() == ix::WebSocket_ReadyState_Open;
-    }
-
-    void WebSocketChat::stop()
-    {
-        _webSocket.stop();
-    }
-
-    void WebSocketChat::start()
-    {
-        std::string url("ws://localhost:8080/");
-        _webSocket.setUrl(url);
-
-        std::stringstream ss;
-        log(std::string("Connecting to url: ") + url);
-
-        _webSocket.setOnMessageCallback(
-            [this](ix::WebSocketMessageType messageType,
-               const std::string& str,
-               size_t wireSize,
-               const ix::WebSocketErrorInfo& error,
-               const ix::WebSocketOpenInfo& openInfo,
-               const ix::WebSocketCloseInfo& closeInfo)
-            {
-                std::stringstream ss;
-                if (messageType == ix::WebSocket_MessageType_Open)
-                {
-                    ss << "cmd_websocket_chat: user "
-                       << _user
-                       << " Connected !";
-                       log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Close)
-                {
-                    ss << "cmd_websocket_chat: user "
-                       << _user
-                       << " disconnected !";
-                       log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    auto result = decodeMessage(str);
-
-                    // Our "chat" / "broacast" node.js server does not send us
-                    // the messages we send, so we don't have to filter it out.
-
-                    // store text
-                    _receivedQueue.push(result.second);
-
-                    ss << std::endl 
-                       << result.first << " > " << result.second
-                       << std::endl
-                       << _user << " > ";
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Error)
-                {
-                    ss << "Connection error: " << error.reason      << std::endl;
-                    ss << "#retries: "         << error.retries     << std::endl;
-                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
-                    ss << "HTTP Status: "      << error.http_status << std::endl;
-                    log(ss.str());
-                }
-                else
-                {
-                    ss << "Invalid ix::WebSocketMessageType";
-                    log(ss.str());
-                }
-            });
-
-        _webSocket.start();
-    }
-
-    std::pair<std::string, std::string> WebSocketChat::decodeMessage(const std::string& str)
-    {
-        auto j = json::parse(str);
-
-        std::string msg_user = j["user"];
-        std::string msg_text = j["text"];
-
-        return std::pair<std::string, std::string>(msg_user, msg_text);
-    }
-
-    std::string WebSocketChat::encodeMessage(const std::string& text)
-    {
-        json j;
-        j["user"] = _user;
-        j["text"] = text;
-
-        std::string output = j.dump();
-        return output;
-    }
-
-    void WebSocketChat::sendMessage(const std::string& text)
-    {
-        _webSocket.send(encodeMessage(text));
-    }
-
-    void interactiveMain(const std::string& user)
-    {
-        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
-        WebSocketChat webSocketChat(user);
-        webSocketChat.start();
-
-        while (true)
-        {
-            std::string text;
-            std::cout << user << " > " << std::flush;
-            std::getline(std::cin, text);
-
-            if (!std::cin)
-            {
-                break;
-            }
-
-            webSocketChat.sendMessage(text);
-        }
-
-        std::cout << std::endl;
-        webSocketChat.stop();
-    }
-}
-
-int main(int argc, char** argv)
-{
-    std::string user("user");
-    if (argc == 2)
-    {
-        user = argv[1];
-    }
-
-    Socket::init();
-    interactiveMain(user);
-    return 0;
-}

examples/chat/package-lock.json

@@ -1,31 +0,0 @@
-{
-  "requires": true,
-  "lockfileVersion": 1,
-  "dependencies": {
-    "async-limiter": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz",
-      "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg=="
-    },
-    "safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
-    },
-    "ultron": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz",
-      "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og=="
-    },
-    "ws": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz",
-      "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==",
-      "requires": {
-        "async-limiter": "1.0.0",
-        "safe-buffer": "5.1.2",
-        "ultron": "1.1.1"
-      }
-    }
-  }
-}

examples/chat/package.json

@@ -1,6 +0,0 @@
-{
-  "dependencies": {
-    "msgpack-js": "^0.3.0",
-    "ws": "^3.3.3"
-  }
-}

examples/cobra_publisher/.gitignore

@@ -1,3 +0,0 @@
-venv
-build
-node_modules

examples/cobra_publisher/CMakeLists.txt

@@ -1,40 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (cobra_publisher)
-
-# There's -Weverything too for clang
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
-
-set (OPENSSL_PREFIX /usr/local/opt/openssl) # Homebrew openssl
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-include_directories(cobra_publisher ${OPENSSL_PREFIX}/include)
-include_directories(cobra_publisher .)
-
-add_executable(cobra_publisher 
-  jsoncpp/jsoncpp.cpp
-  ixcrypto/IXHMac.cpp
-  ixcrypto/IXBase64.cpp
-  IXCobraConnection.cpp
-  cobra_publisher.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(cobra_publisher "-framework foundation" "-framework security")
-endif()
-
-get_filename_component(crypto_lib_path ${OPENSSL_PREFIX}/lib/libcrypto.a ABSOLUTE)
-add_library(lib_crypto STATIC IMPORTED)
-set_target_properties(lib_crypto PROPERTIES IMPORTED_LOCATION ${crypto_lib_path})
-
-link_directories(/usr/local/opt/openssl/lib)
-target_link_libraries(cobra_publisher ixwebsocket lib_crypto)
-install(TARGETS cobra_publisher DESTINATION bin)

examples/cobra_publisher/IXCobraConnection.cpp

@@ -1,475 +0,0 @@
-/*
- *  IXCobraConnection.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone. All rights reserved.
- */
-
-#include "IXCobraConnection.h"
-#include <ixcrypto/IXHMac.h>
-
-#include <algorithm>
-#include <stdexcept>
-#include <cmath>
-#include <cassert>
-#include <cstring>
-
-
-namespace ix
-{
-    TrafficTrackerCallback CobraConnection::_trafficTrackerCallback = nullptr;
-    constexpr size_t CobraConnection::kQueueMaxSize;
-
-    CobraConnection::CobraConnection() :
-        _authenticated(false),
-        _eventCallback(nullptr),
-        _publishMode(CobraConnection_PublishMode_Immediate)
-    {
-        _pdu["action"] = "rtm/publish";
-
-        initWebSocketOnMessageCallback();
-    }
-
-    CobraConnection::~CobraConnection()
-    {
-        disconnect();
-    }
-
-    void CobraConnection::setTrafficTrackerCallback(const TrafficTrackerCallback& callback)
-    {
-        _trafficTrackerCallback = callback;
-    }
-
-    void CobraConnection::resetTrafficTrackerCallback()
-    {
-        setTrafficTrackerCallback(nullptr);
-    }
-
-    void CobraConnection::invokeTrafficTrackerCallback(size_t size, bool incoming)
-    {
-        if (_trafficTrackerCallback)
-        {
-            _trafficTrackerCallback(size, incoming);
-        }
-    }
-
-    void CobraConnection::setEventCallback(const EventCallback& eventCallback)
-    {
-        std::lock_guard<std::mutex> lock(_eventCallbackMutex);
-        _eventCallback = eventCallback;
-    }
-
-    void CobraConnection::invokeEventCallback(ix::CobraConnectionEventType eventType,
-                                               const std::string& errorMsg,
-                                               const WebSocketHttpHeaders& headers)
-    {
-        std::lock_guard<std::mutex> lock(_eventCallbackMutex);
-        if (_eventCallback)
-        {
-            _eventCallback(eventType, errorMsg, headers);
-        }
-    }
-
-    void CobraConnection::invokeErrorCallback(const std::string& errorMsg)
-    {
-        invokeEventCallback(ix::CobraConnection_EventType_Error, errorMsg);
-    }
-
-    void CobraConnection::disconnect()
-    {
-        _authenticated = false;
-        _webSocket.stop();
-    }
-
-    void CobraConnection::initWebSocketOnMessageCallback()
-    {
-        _webSocket.setOnMessageCallback(
-            [this](ix::WebSocketMessageType messageType,
-                   const std::string& str,
-                   size_t wireSize,
-                   const ix::WebSocketErrorInfo& error,
-                   const ix::WebSocketCloseInfo& closeInfo,
-                   const ix::WebSocketHttpHeaders& headers)
-            {
-                CobraConnection::invokeTrafficTrackerCallback(wireSize, true);
-
-                std::stringstream ss;
-                if (messageType == ix::WebSocket_MessageType_Open)
-                {
-                    invokeEventCallback(ix::CobraConnection_EventType_Open,
-                                        std::string(),
-                                        headers);
-                    sendHandshakeMessage();
-                }
-                else if (messageType == ix::WebSocket_MessageType_Close)
-                {
-                    _authenticated = false;
-
-                    std::stringstream ss;
-                    ss << "Close code " << closeInfo.code;
-                    ss << " reason " << closeInfo.reason;
-                    invokeEventCallback(ix::CobraConnection_EventType_Closed,
-                                        ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    Json::Value data;
-                    Json::Reader reader;
-                    if (!reader.parse(str, data))
-                    {
-                        invokeErrorCallback(std::string("Invalid json: ") + str);
-                        return;
-                    }
-
-                    if (!data.isMember("action"))
-                    {
-                        invokeErrorCallback("Missing action");
-                        return;
-                    }
-
-                    auto action = data["action"].asString();
-
-                    if (action == "auth/handshake/ok")
-                    {
-                        if (!handleHandshakeResponse(data))
-                        {
-                            invokeErrorCallback("Error extracting nonce from handshake response");
-                        }
-                    }
-                    else if (action == "auth/handshake/error")
-                    {
-                        invokeErrorCallback("Handshake error."); // print full message ?
-                    }
-                    else if (action == "auth/authenticate/ok")
-                    {
-                        _authenticated = true;
-                        invokeEventCallback(ix::CobraConnection_EventType_Authenticated);
-                        flushQueue();
-                    }
-                    else if (action == "auth/authenticate/error")
-                    {
-                        invokeErrorCallback("Authentication error."); // print full message ?
-                    }
-                    else if (action == "rtm/subscription/data")
-                    {
-                        handleSubscriptionData(data);
-                    }
-                    else
-                    {
-                        invokeErrorCallback(std::string("Un-handled message type: ") + action);
-                    }
-                }
-                else if (messageType == ix::WebSocket_MessageType_Error)
-                {
-                    std::stringstream ss;
-                    ss << "Connection error: " << error.reason      << std::endl;
-                    ss << "#retries: "         << error.retries     << std::endl;
-                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
-                    ss << "HTTP Status: "      << error.http_status << std::endl;
-                    invokeErrorCallback(ss.str());
-                }
-        });
-    }
-
-    void CobraConnection::setPublishMode(CobraConnectionPublishMode publishMode)
-    {
-        _publishMode = publishMode;
-    }
-
-    void CobraConnection::configure(const std::string& appkey,
-                                     const std::string& endpoint,
-                                     const std::string& rolename,
-                                     const std::string& rolesecret,
-                                     WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions)
-    {
-        _appkey = appkey;
-        _endpoint = endpoint;
-        _role_name = rolename;
-        _role_secret = rolesecret;
-
-        std::stringstream ss;
-        ss << _endpoint;
-        ss << "/v2?appkey=";
-        ss << _appkey;
-
-        std::string url = ss.str();
-        _webSocket.setUrl(url);
-        _webSocket.setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
-    }
-
-    //
-    // Handshake message schema.
-    //
-    // handshake = {
-    //     "action": "auth/handshake",
-    //     "body": {
-    //         "data": {
-    //             "role": role
-    //         },
-    //         "method": "role_secret"
-    //     },
-    // }
-    //
-    //
-    bool CobraConnection::sendHandshakeMessage()
-    {
-        Json::Value data;
-        data["role"] = _role_name;
-
-        Json::Value body;
-        body["data"] = data;
-        body["method"] = "role_secret";
-
-        Json::Value pdu;
-        pdu["action"] = "auth/handshake";
-        pdu["body"] = body;
-
-        std::string serializedJson = serializeJson(pdu);
-        CobraConnection::invokeTrafficTrackerCallback(serializedJson.size(), false);
-
-        return _webSocket.send(serializedJson).success;
-    }
-
-    // 
-    // Extract the nonce from the handshake response
-    // use it to compute a hash during authentication
-    //
-    // {
-    //     "action": "auth/handshake/ok",
-    //     "body": {
-    //         "data": {
-    //             "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
-    //             "version": "0.0.24"
-    //         }
-    //     }
-    // }
-    //
-    bool CobraConnection::handleHandshakeResponse(const Json::Value& pdu)
-    {
-        if (!pdu.isMember("body")) return false;
-        Json::Value body = pdu["body"];
-
-        if (!body.isMember("data")) return false;
-        Json::Value data = body["data"];
-
-        if (!data.isMember("nonce")) return false;
-        Json::Value nonce = data["nonce"];
-
-        if (!nonce.isString()) return false;
-
-        return sendAuthMessage(nonce.asString());
-    }
-
-    //
-    // Authenticate message schema.
-    //
-    // challenge = {
-    //     "action": "auth/authenticate",
-    //     "body": {
-    //         "method": "role_secret",
-    //         "credentials": {
-    //             "hash": computeHash(secret, nonce)
-    //         }
-    //     },
-    // }
-    //
-    bool CobraConnection::sendAuthMessage(const std::string& nonce)
-    {
-        Json::Value credentials;
-        credentials["hash"] = hmac(nonce, _role_secret);
-
-        Json::Value body;
-        body["credentials"] = credentials;
-        body["method"] = "role_secret";
-
-        Json::Value pdu;
-        pdu["action"] = "auth/authenticate";
-        pdu["body"] = body;
-
-        std::string serializedJson = serializeJson(pdu);
-        CobraConnection::invokeTrafficTrackerCallback(serializedJson.size(), false);
-
-        return _webSocket.send(serializedJson).success;
-    }
-
-
-    bool CobraConnection::handleSubscriptionData(const Json::Value& pdu)
-    {
-        if (!pdu.isMember("body")) return false;
-        Json::Value body = pdu["body"];
-
-        // Identify subscription_id, so that we can find 
-        // which callback to execute
-        if (!body.isMember("subscription_id")) return false;
-        Json::Value subscriptionId = body["subscription_id"];
-
-        std::lock_guard<std::mutex> lock(_cbsMutex);
-        auto cb = _cbs.find(subscriptionId.asString());
-        if (cb == _cbs.end()) return false; // cannot find callback
-
-        // Extract messages now
-        if (!body.isMember("messages")) return false;
-        Json::Value messages = body["messages"];
-
-        for (auto&& msg : messages)
-        {
-            cb->second(msg);
-        }
-
-        return true;
-    }
-
-    bool CobraConnection::connect()
-    {
-        _webSocket.start();
-        return true;
-    }
-
-    bool CobraConnection::isConnected() const
-    {
-        return _webSocket.getReadyState() == ix::WebSocket_ReadyState_Open;
-    }
-
-    std::string CobraConnection::serializeJson(const Json::Value& value)
-    {
-        std::lock_guard<std::mutex> lock(_jsonWriterMutex);
-        return _jsonWriter.write(value);
-    }
-
-    //
-    // publish is not thread safe as we are trying to reuse some Json objects.
-    //
-    bool CobraConnection::publish(const Json::Value& channels,
-                                   const Json::Value& msg)
-    {
-        _body["channels"] = channels;
-        _body["message"] = msg;
-        _pdu["body"] = _body;
-
-        std::string serializedJson = serializeJson(_pdu);
-
-        if (_publishMode == CobraConnection_PublishMode_Batch)
-        {
-            enqueue(serializedJson);
-            return true;
-        }
-
-        //
-        // Fast path. We are authenticated and the publishing succeed
-        //            This should happen for 99% of the cases.
-        //
-        if (_authenticated && publishMessage(serializedJson))
-        {
-            return true;
-        }
-        else // Or else we enqueue
-             // Slow code path is when we haven't connected yet (startup),
-             // or when the connection drops for some reason.
-        {
-            enqueue(serializedJson);
-            return false;
-        }
-    }
-
-    void CobraConnection::subscribe(const std::string& channel,
-                                     SubscriptionCallback cb)
-    {
-        // Create and send a subscribe pdu
-        Json::Value body;
-        body["channel"] = channel;
-
-        Json::Value pdu;
-        pdu["action"] = "rtm/subscribe";
-        pdu["body"] = body;
-
-        _webSocket.send(pdu.toStyledString());
-
-        // Set the callback
-        std::lock_guard<std::mutex> lock(_cbsMutex);
-        _cbs[channel] = cb;
-    }
-
-    void CobraConnection::unsubscribe(const std::string& channel)
-    {
-        {
-            std::lock_guard<std::mutex> lock(_cbsMutex);
-            auto cb = _cbs.find(channel);
-            if (cb == _cbs.end()) return;
-
-            _cbs.erase(cb);
-        }
-
-        // Create and send an unsubscribe pdu
-        Json::Value body;
-        body["channel"] = channel;
-
-        Json::Value pdu;
-        pdu["action"] = "rtm/unsubscribe";
-        pdu["body"] = body;
-
-        _webSocket.send(pdu.toStyledString());
-    }
-
-    //
-    // Enqueue strategy drops old messages when we are at full capacity
-    //
-    // If we want to keep only 3 items max in the queue:
-    //
-    // enqueue(A) -> [A]
-    // enqueue(B) -> [B, A]
-    // enqueue(C) -> [C, B, A]
-    // enqueue(D) -> [D, C, B] -- now we drop A, the oldest message,
-    //                         -- and keep the 'fresh ones'
-    //
-    void CobraConnection::enqueue(const std::string& msg)
-    {
-        std::lock_guard<std::mutex> lock(_queueMutex);
-
-        if (_messageQueue.size() == CobraConnection::kQueueMaxSize)
-        {
-            _messageQueue.pop_back();
-        }
-        _messageQueue.push_front(msg);
-    }
-
-    //
-    // We process messages back (oldest) to front (newest) to respect ordering
-    // when sending them. If we fail to send something, we put it back in the queue
-    // at the end we picked it up originally (at the end).
-    //
-    bool CobraConnection::flushQueue()
-    {
-        std::lock_guard<std::mutex> lock(_queueMutex);
-
-        while (!_messageQueue.empty())
-        {
-            auto&& msg = _messageQueue.back();
-            if (!publishMessage(msg))
-            {
-                _messageQueue.push_back(msg);
-                return false;
-            }
-            _messageQueue.pop_back();
-        }
-
-        return true;
-    }
-
-    bool CobraConnection::publishMessage(const std::string& serializedJson)
-    {
-        auto webSocketSendInfo = _webSocket.send(serializedJson);
-        CobraConnection::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize,
-                                                       false);
-        return webSocketSendInfo.success;
-    }
-
-    void CobraConnection::suspend()
-    {
-        disconnect();
-    }
-
-    void CobraConnection::resume()
-    {
-        connect();
-    }
-    
-} // namespace ix

examples/cobra_publisher/README.md

@@ -1,6 +0,0 @@
-```
-mkdir build
-cd build
-cmake ..
-make && (cd .. ; sh cobra_publisher.sh)
-```

examples/cobra_publisher/cobra_publisher.cpp

@@ -1,123 +0,0 @@
-/*
- *  cobra_publisher.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <fstream>
-#include <atomic>
-#include <ixwebsocket/IXWebSocket.h>
-#include "IXCobraConnection.h"
-#include "jsoncpp/json/json.h"
-
-void msleep(int ms)
-{
-    std::chrono::duration<double, std::milli> duration(ms);
-    std::this_thread::sleep_for(duration);
-}
-
-int main(int argc, char* argv[])
-{
-    if (argc != 7)
-    {
-        std::cerr << "Usage error: need 6 arguments." << std::endl;
-    }
-
-    std::string endpoint = argv[1];
-    std::string appkey = argv[2];
-    std::string channel = argv[3];
-    std::string rolename = argv[4];
-    std::string rolesecret = argv[5];
-    std::string path = argv[6];
-
-    std::atomic<size_t> incomingBytes(0);
-    std::atomic<size_t> outgoingBytes(0);
-    ix::CobraConnection::setTrafficTrackerCallback(
-        [&incomingBytes, &outgoingBytes](size_t size, bool incoming)
-        {
-            if (incoming)
-            {
-                incomingBytes += size;
-            }
-            else
-            {
-                outgoingBytes += size;
-            }
-        }
-    );
-
-    bool done = false;
-    ix::CobraConnection cobraConnection;
-    ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
-        true, false, false, 15, 15);
-    cobraConnection.configure(appkey, endpoint, rolename, rolesecret,
-                               webSocketPerMessageDeflateOptions);
-    cobraConnection.connect();
-    cobraConnection.setEventCallback(
-        [&cobraConnection, channel, path, &done]
-        (ix::CobraConnectionEventType eventType,
-         const std::string& errMsg,
-         const ix::WebSocketHttpHeaders& headers)
-        {
-            if (eventType == ix::CobraConnection_EventType_Open)
-            {
-                std::cout << "Handshake Headers:" << std::endl;
-                for (auto it : headers)
-                {
-                    std::cout << it.first << ": " << it.second << std::endl;
-                }
-            }
-            else if (eventType == ix::CobraConnection_EventType_Authenticated)
-            {
-                std::cout << "Authenticated" << std::endl;
-
-                std::string line;
-                std::ifstream f(path);
-                if (!f.is_open())
-                {
-                    std::cerr << "Error while opening file: " << path << std::endl;
-                }
-
-                int n = 0;
-                while (getline(f, line))
-                {
-                    Json::Value value;
-                    Json::Reader reader;
-                    reader.parse(line, value);
-
-                    cobraConnection.publish(channel, value);
-                    n++;
-                }
-                std::cerr << "#published messages: " << n << std::endl;
-
-                if (f.bad())
-                {
-                    std::cerr << "Error while opening file: " << path << std::endl;
-                }
-
-                done = true;
-            }
-            else if (eventType == ix::CobraConnection_EventType_Error)
-            {
-                std::cerr << "Cobra Error received: " << errMsg << std::endl;
-                done = true;
-            }
-            else if (eventType == ix::CobraConnection_EventType_Closed)
-            {
-                std::cerr << "Cobra connection closed" << std::endl;
-            }
-        }
-    );
-
-    while (!done)
-    {
-        msleep(1);
-    }
-
-    std::cout << "Incoming bytes: " << incomingBytes << std::endl;
-    std::cout << "Outgoing bytes: " << outgoingBytes << std::endl;
-
-    return 0;
-}

examples/cobra_publisher/cobra_publisher.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-
-endpoint="ws://127.0.0.1:8765"
-endpoint="ws://127.0.0.1:5678"
-appkey="appkey"
-channel="foo"
-rolename="a_role"
-rolesecret="a_secret"
-filename=${FILENAME:=events.jsonl}
-
-build/cobra_publisher $endpoint $appkey $channel $rolename $rolesecret $filename

examples/cobra_publisher/devnull_server.js

@@ -1,45 +0,0 @@
-/*
- *  devnull_server.js
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- */
-const WebSocket = require('ws');
-
-let wss = new WebSocket.Server({ port: 5678, perMessageDeflate: true })
-
-wss.on('connection', (ws) => {
-
-  let handshake = false
-  let authenticated = false
-
-  ws.on('message', (data) => {
-
-    console.log(data.toString('utf-8'))
-
-    if (!handshake) {
-      let response = {
-          "action": "auth/handshake/ok",
-          "body": {
-              "data": {
-                  "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
-                  "version": "0.0.24"
-              }
-          },
-          "id": 1
-      }
-      ws.send(JSON.stringify(response))
-      handshake = true
-    } else if (!authenticated) {
-      let response = {
-        "action": "auth/authenticate/ok",
-        "body": {},
-        "id": 2
-      }
-      
-      ws.send(JSON.stringify(response))
-      authenticated = true
-    } else {
-      console.log(data)
-    }
-  });
-})

examples/cobra_publisher/devnull_server.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import json
-import asyncio
-import websockets
-
-
-async def echo(websocket, path):
-    handshake = False
-    authenticated = False
-
-    async for message in websocket:
-        print(message)
-
-        if not handshake:
-            response = {
-                "action": "auth/handshake/ok",
-                "body": {
-                    "data": {
-                        "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
-                        "version": "0.0.24"
-                    }
-                },
-                "id": 1
-            }
-            await websocket.send(json.dumps(response))
-            handshake = True
-
-        elif not authenticated:
-            response = {
-                "action": "auth/authenticate/ok",
-                "body": {},
-                "id": 2
-            }
-          
-            await websocket.send(json.dumps(response))
-            authenticated = True
-
-
-asyncio.get_event_loop().run_until_complete(
-    websockets.serve(echo, 'localhost', 5678))
-asyncio.get_event_loop().run_forever()

examples/cobra_publisher/events.jsonl

@@ -1,3 +0,0 @@
-{"array":[1,2,3],"boolean":true,"color":"#82b92c","null":null,"number":123,"object":{"a":"b","c":"d","e":"f"},"string":"Foo"}
-{"array":[1,2,3],"boolean":true,"color":"#82b92c","null":null,"number":123,"object":{"a":"b","c":"d","e":"f"},"string":"Bar"}
-{"array":[1,2,3],"boolean":true,"color":"#82b92c","null":null,"number":123,"object":{"a":"b","c":"d","e":"f"},"string":"Baz"}

examples/cobra_publisher/ixcrypto/IXBase64.cpp

@@ -1,84 +0,0 @@
-/*
- base64.cpp and base64.h
- 
- Copyright (C) 2004-2008 René Nyffenegger
- 
- This source code is provided 'as-is', without any express or implied
- warranty. In no event will the author be held liable for any damages
- arising from the use of this software.
- 
- Permission is granted to anyone to use this software for any purpose,
- including commercial applications, and to alter it and redistribute it
- freely, subject to the following restrictions:
- 
- 1. The origin of this source code must not be misrepresented; you must not
- claim that you wrote the original source code. If you use this source code
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
- 
- 2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original source code.
- 
- 3. This notice may not be removed or altered from any source distribution.
- 
- René Nyffenegger rene.nyffenegger@adp-gmbh.ch
- 
- */
-
-#include "IXBase64.h"
-    
-namespace ix
-{
-    static const std::string base64_chars =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    "abcdefghijklmnopqrstuvwxyz"
-    "0123456789+/";
-    
-    std::string base64_encode(const std::string& data, size_t len)
-    {
-        std::string ret;
-        int i = 0;
-        int j = 0;
-        unsigned char char_array_3[3];
-        unsigned char char_array_4[4];
-        
-        const char* bytes_to_encode = data.c_str();
-        
-        while(len--)
-        {
-            char_array_3[i++] = *(bytes_to_encode++);
-            if(i == 3)
-            {
-                char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-                char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-                char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-                char_array_4[3] = char_array_3[2] & 0x3f;
-                
-                for(i = 0; (i <4) ; i++)
-                    ret += base64_chars[char_array_4[i]];
-                
-                i = 0;
-            }
-        }
-        
-        if(i)
-        {
-            for(j = i; j < 3; j++)
-                char_array_3[j] = '\0';
-            
-            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-            char_array_4[3] = char_array_3[2] & 0x3f;
-            
-            for(j = 0; (j < i + 1); j++)
-                ret += base64_chars[char_array_4[j]];
-            
-            while((i++ < 3))
-                ret += '=';
-            
-        }
-        
-        return ret;
-    }
-}

examples/cobra_publisher/ixcrypto/IXHMac.cpp

@@ -1,27 +0,0 @@
-/*
- *  IXHMac.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone. All rights reserved.
- */
-#include "IXHMac.h"
-#include "IXBase64.h"
-
-#include <openssl/hmac.h>
-
-namespace ix
-{
-    std::string hmac(const std::string& data, const std::string& key)
-    {
-        constexpr size_t hashSize = 16;
-        unsigned char hash[hashSize];
-
-        HMAC(EVP_md5(),
-             key.c_str(), (int) key.size(),
-             (unsigned char *) data.c_str(), (int) data.size(),
-             (unsigned char *) hash, nullptr);
-
-        std::string hashString(reinterpret_cast<char*>(hash), hashSize);
-
-        return base64_encode(hashString, (uint32_t) hashString.size());
-    }
-}

examples/echo_server/CMakeLists.txt

@@ -1,30 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (echo_server)
-
-# There's -Weverything too for clang
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
-
-set (OPENSSL_PREFIX /usr/local/opt/openssl) # Homebrew openssl
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-include_directories(echo_server .)
-
-add_executable(echo_server 
-  echo_server.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(echo_server "-framework foundation" "-framework security")
-endif()
-
-target_link_libraries(echo_server ixwebsocket)
-install(TARGETS echo_server DESTINATION bin)

examples/echo_server/echo_server.cpp

@@ -1,68 +0,0 @@
-/*
- *  echo_server.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <ixwebsocket/IXWebSocketServer.h>
-
-int main(int argc, char** argv)
-{
-    int port = 8080;
-    if (argc == 2)
-    {
-        std::stringstream ss;
-        ss << argv[1];
-        ss >> port;
-    }
-
-    ix::WebSocketServer server(port);
-
-    server.setOnConnectionCallback(
-        [&server](std::shared_ptr<ix::WebSocket> webSocket)
-        {
-            webSocket->setOnMessageCallback(
-                [webSocket, &server](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::WebSocket_MessageType_Open)
-                    {
-                        std::cerr << "New connection" << std::endl;
-                        std::cerr << "Uri: " << openInfo.uri << std::endl;
-                        std::cerr << "Headers:" << std::endl;
-                        for (auto it : openInfo.headers)
-                        {
-                            std::cerr << it.first << ": " << it.second << std::endl;
-                        }
-                    }
-                    else if (messageType == ix::WebSocket_MessageType_Close)
-                    {
-                        std::cerr << "Closed connection" << std::endl;
-                    }
-                    else if (messageType == ix::WebSocket_MessageType_Message)
-                    {
-                        webSocket->send(str);
-                    }
-                }
-            );
-        }
-    );
-
-    auto res = server.listen();
-    if (!res.first)
-    {
-        std::cerr << res.second << std::endl;
-        return 1;
-    }
-
-    server.start();
-    server.wait();
-
-    return 0;
-}

examples/ping_pong/.gitignore

@@ -1,2 +0,0 @@
-venv
-build

examples/ping_pong/CMakeLists.txt

@@ -1,27 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (ping_pong)
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-add_executable(ping_pong ping_pong.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(ping_pong "-framework foundation" "-framework security")
-endif()
-
-if (WIN32)
-    target_link_libraries(ping_pong wsock32 ws2_32)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-endif()
-
-target_link_libraries(ping_pong ixwebsocket)
-install(TARGETS ping_pong DESTINATION bin)

examples/ping_pong/build_linux.sh

@@ -1,15 +0,0 @@
-#!/bin/sh
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
-#
-
-# 'manual' way of building. You can also use cmake.
-
-g++ --std=c++11 \
-    ../../ixwebsocket/IXSocket.cpp	\
-    ../../ixwebsocket/IXWebSocketTransport.cpp \
-    ../../ixwebsocket/IXWebSocket.cpp \
-    -I ../.. \
-    cmd_websocket_chat.cpp \
-    -o cmd_websocket_chat

examples/ping_pong/client.py

@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-
-import asyncio
-import websockets
-
-async def hello(uri):
-    async with websockets.connect(uri) as websocket:
-        await websocket.send("Hello world!")
-        response = await websocket.recv()
-        print(response)
-
-        pong_waiter = await websocket.ping('coucou')
-        ret = await pong_waiter   # only if you want to wait for the pong
-        print(ret)
-
-asyncio.get_event_loop().run_until_complete(
-    hello('ws://localhost:5678'))

examples/ping_pong/ping_pong.cpp

@@ -1,171 +0,0 @@
-/*
- *  ping_pong.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <ixwebsocket/IXWebSocket.h>
-#include <ixwebsocket/IXSocket.h>
-
-using namespace ix;
-
-namespace
-{
-    void log(const std::string& msg)
-    {
-        std::cout << msg << std::endl;
-    }
-
-    class WebSocketPingPong
-    {
-        public:
-            WebSocketPingPong(const std::string& _url);
-
-            void subscribe(const std::string& channel);
-            void start();
-            void stop();
-
-            void ping(const std::string& text);
-            void send(const std::string& text);
-
-        private:
-            std::string _url;
-            ix::WebSocket _webSocket;
-    };
-
-    WebSocketPingPong::WebSocketPingPong(const std::string& url) :
-        _url(url)
-    {
-        ;
-    }
-
-    void WebSocketPingPong::stop()
-    {
-        _webSocket.stop();
-    }
-
-    void WebSocketPingPong::start()
-    {
-        _webSocket.setUrl(_url);
-
-        std::stringstream ss;
-        log(std::string("Connecting to url: ") + _url);
-
-        _webSocket.setOnMessageCallback(
-            [this](ix::WebSocketMessageType messageType,
-               const std::string& str,
-               size_t wireSize,
-               const ix::WebSocketErrorInfo& error,
-               const ix::WebSocketOpenInfo& openInfo,
-               const ix::WebSocketCloseInfo& closeInfo)
-            {
-                std::stringstream ss;
-                if (messageType == ix::WebSocket_MessageType_Open)
-                {
-                    log("ping_pong: connected");
-                }
-                else if (messageType == ix::WebSocket_MessageType_Close)
-                {
-                    ss << "ping_pong: disconnected:"
-                       << " code " << closeInfo.code
-                       << " reason " << closeInfo.reason
-                       << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    ss << "ping_pong: received message: "
-                       << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Ping)
-                {
-                    ss << "ping_pong: received ping message: "
-                       << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Pong)
-                {
-                    ss << "ping_pong: received pong message: "
-                       << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Error)
-                {
-                    ss << "Connection error: " << error.reason      << std::endl;
-                    ss << "#retries: "         << error.retries     << std::endl;
-                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
-                    ss << "HTTP Status: "      << error.http_status << std::endl;
-                    log(ss.str());
-                }
-                else
-                {
-                    ss << "Invalid ix::WebSocketMessageType";
-                    log(ss.str());
-                }
-            });
-
-        _webSocket.start();
-    }
-
-    void WebSocketPingPong::ping(const std::string& text)
-    {
-        if (!_webSocket.ping(text).success)
-        {
-            std::cerr << "Failed to send ping message. Message too long (> 125 bytes) or endpoint is disconnected"
-                      << std::endl;
-        }
-    }
-
-    void WebSocketPingPong::send(const std::string& text)
-    {
-        _webSocket.send(text);
-    }
-
-    void interactiveMain(const std::string& url)
-    {
-        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
-        WebSocketPingPong webSocketPingPong(url);
-        webSocketPingPong.start();
-
-        while (true)
-        {
-            std::string text;
-            std::cout << "> " << std::flush;
-            std::getline(std::cin, text);
-
-            if (!std::cin)
-            {
-                break;
-            }
-
-            if (text == "/close")
-            {
-                webSocketPingPong.send(text);
-            }
-            else
-            {
-                webSocketPingPong.ping(text);
-            }
-        }
-
-        std::cout << std::endl;
-        webSocketPingPong.stop();
-    }
-}
-
-int main(int argc, char** argv)
-{
-    if (argc != 2)
-    {
-        std::cerr << "Usage: ping_pong <url>" << std::endl;
-        return 1;
-    }
-    std::string url = argv[1];
-
-    Socket::init();
-    interactiveMain(url);
-    return 0;
-}

examples/ping_pong/server.py

@@ -1,21 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import asyncio
-import websockets
-
-async def echo(websocket, path):
-    async for message in websocket:
-        print(message)
-        await websocket.send(message)
-
-        if os.getenv('TEST_CLOSE'):
-            print('Closing')
-            # breakpoint()
-            await websocket.close(1001, 'close message')
-            # await websocket.close()
-            break
-
-asyncio.get_event_loop().run_until_complete(
-    websockets.serve(echo, 'localhost', 5678))
-asyncio.get_event_loop().run_forever()

examples/ping_pong/test.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-
-test -d build || {
-    mkdir -p build
-    cd build
-    cmake ..
-}
-(cd build ; make)
-./build/ping_pong ws://localhost:5678

examples/ws_connect/.gitignore

@@ -1,3 +0,0 @@
-build
-venv
-node_modules

examples/ws_connect/CMakeLists.txt

@@ -1,22 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (ws_connect)
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-add_executable(ws_connect ws_connect.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(ws_connect "-framework foundation" "-framework security")
-endif()
-
-target_link_libraries(ws_connect ixwebsocket)
-install(TARGETS ws_connect DESTINATION bin)

examples/ws_connect/README.md

@@ -1,11 +0,0 @@
-# Building
-
-1. mkdir build
-2. cd build
-3. cmake ..
-4. make
-
-## Disable TLS
-
-* Enable: `cmake -DUSE_TLS=OFF ..`
-* Disable: `cmake -DUSE_TLS=ON ..`

examples/ws_connect/build_linux.sh

@@ -1,25 +0,0 @@
-#!/bin/sh
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
-#
-
-# 'manual' way of building. You can also use cmake.
-
-g++ --std=c++11 \
-    -DIXWEBSOCKET_USE_TLS \
-    -g \
-    ../../ixwebsocket/IXEventFd.cpp	\
-    ../../ixwebsocket/IXSocket.cpp	\
-    ../../ixwebsocket/IXSetThreadName.cpp	\
-    ../../ixwebsocket/IXWebSocketTransport.cpp \
-    ../../ixwebsocket/IXWebSocket.cpp \
-    ../../ixwebsocket/IXDNSLookup.cpp \
-    ../../ixwebsocket/IXSocketConnect.cpp \
-    ../../ixwebsocket/IXSocketOpenSSL.cpp \
-    ../../ixwebsocket/IXWebSocketPerMessageDeflate.cpp \
-    ../../ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp \
-    -I ../.. \
-    ws_connect.cpp \
-    -o ws_connect \
-    -lcrypto -lssl -lz -lpthread

examples/ws_connect/ws_connect.cpp

@@ -1,165 +0,0 @@
-/*
- *  ws_connect.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <ixwebsocket/IXWebSocket.h>
-#include <ixwebsocket/IXSocket.h>
-
-using namespace ix;
-
-namespace
-{
-    void log(const std::string& msg)
-    {
-        std::cout << msg << std::endl;
-    }
-
-    class WebSocketConnect
-    {
-        public:
-            WebSocketConnect(const std::string& _url);
-
-            void subscribe(const std::string& channel);
-            void start();
-            void stop();
-
-            void sendMessage(const std::string& text);
-
-        private:
-            std::string _url;
-            ix::WebSocket _webSocket;
-    };
-
-    WebSocketConnect::WebSocketConnect(const std::string& url) :
-        _url(url)
-    {
-        ;
-    }
-
-    void WebSocketConnect::stop()
-    {
-        _webSocket.stop();
-    }
-
-    void WebSocketConnect::start()
-    {
-        _webSocket.setUrl(_url);
-
-        ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
-            true, false, false, 15, 15);
-        _webSocket.setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
-
-        std::stringstream ss;
-        log(std::string("Connecting to url: ") + _url);
-
-        _webSocket.setOnMessageCallback(
-            [this](ix::WebSocketMessageType messageType,
-               const std::string& str,
-               size_t wireSize,
-               const ix::WebSocketErrorInfo& error,
-               const ix::WebSocketOpenInfo& openInfo,
-               const ix::WebSocketCloseInfo& closeInfo)
-            {
-                std::stringstream ss;
-                if (messageType == ix::WebSocket_MessageType_Open)
-                {
-                    log("ws_connect: connected");
-                    std::cout << "Uri: " << openInfo.uri << std::endl;
-                    std::cout << "Handshake Headers:" << std::endl;
-                    for (auto it : openInfo.headers)
-                    {
-                        std::cout << it.first << ": " << it.second << std::endl;
-                    }
-                }
-                else if (messageType == ix::WebSocket_MessageType_Close)
-                {
-                    ss << "ws_connect: connection closed:";
-                    ss << " code " << closeInfo.code;
-                    ss << " reason " << closeInfo.reason << std::endl;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    ss << "ws_connect: received message: "
-                       << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Error)
-                {
-                    ss << "Connection error: " << error.reason      << std::endl;
-                    ss << "#retries: "         << error.retries     << std::endl;
-                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
-                    ss << "HTTP Status: "      << error.http_status << std::endl;
-                    log(ss.str());
-                }
-                else
-                {
-                    ss << "Invalid ix::WebSocketMessageType";
-                    log(ss.str());
-                }
-            });
-
-        _webSocket.start();
-    }
-
-    void WebSocketConnect::sendMessage(const std::string& text)
-    {
-        _webSocket.send(text);
-    }
-
-    void interactiveMain(const std::string& url)
-    {
-        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
-        WebSocketConnect webSocketChat(url);
-        webSocketChat.start();
-
-        while (true)
-        {
-            std::string text;
-            std::cout << "> " << std::flush;
-            std::getline(std::cin, text);
-
-            if (text == "/stop")
-            {
-                std::cout << "Stopping connection..." << std::endl;
-                webSocketChat.stop();
-                continue;
-            }
-
-            if (text == "/start")
-            {
-                std::cout << "Starting connection..." << std::endl;
-                webSocketChat.start();
-                continue;
-            }
-
-            if (!std::cin)
-            {
-                break;
-            }
-
-            webSocketChat.sendMessage(text);
-        }
-
-        std::cout << std::endl;
-        webSocketChat.stop();
-    }
-}
-
-int main(int argc, char** argv)
-{
-    if (argc != 2)
-    {
-        std::cerr << "Usage: ws_connect <url>" << std::endl;
-        return 1;
-    }
-    std::string url = argv[1];
-
-    Socket::init();
-    interactiveMain(url);
-    return 0;
-}

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

@@ -0,0 +1,59 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+#
+
+set (IXBOTS_SOURCES
+    ixbots/IXCobraBot.cpp
+    ixbots/IXCobraToCobraBot.cpp
+    ixbots/IXCobraToSentryBot.cpp
+    ixbots/IXCobraToStatsdBot.cpp
+    ixbots/IXCobraToStdoutBot.cpp
+    ixbots/IXCobraMetricsToRedisBot.cpp
+    ixbots/IXCobraToPythonBot.cpp
+    ixbots/IXStatsdClient.cpp
+)
+
+set (IXBOTS_HEADERS
+    ixbots/IXCobraBot.h
+    ixbots/IXCobraBotConfig.h
+    ixbots/IXCobraToCobraBot.h
+    ixbots/IXCobraToSentryBot.h
+    ixbots/IXCobraToStatsdBot.h
+    ixbots/IXCobraToStdoutBot.h
+    ixbots/IXCobraMetricsToRedisBot.h
+    ixbots/IXCobraToPythonBot.h
+    ixbots/IXStatsdClient.h
+)
+
+add_library(ixbots STATIC
+    ${IXBOTS_SOURCES}
+    ${IXBOTS_HEADERS}
+)
+
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
+endif()
+
+if (USE_PYTHON)
+  target_compile_definitions(ixbots PUBLIC IXBOTS_USE_PYTHON)
+  find_package(Python COMPONENTS Development)
+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

@@ -0,0 +1,326 @@
+/*
+ *  IXCobraBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraBot.h"
+
+#include <ixcobra/IXCobraConnection.h>
+#include <ixcore/utils/IXCoreLogger.h>
+#include <ixwebsocket/IXSetThreadName.h>
+
+#include <algorithm>
+#include <chrono>
+#include <sstream>
+#include <thread>
+#include <vector>
+
+namespace ix
+{
+    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;
+
+        config.headers["X-Cobra-Channel"] = channel;
+
+        ix::CobraConnection conn;
+        conn.configure(config);
+        conn.connect();
+
+        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);
+        std::atomic<bool> stalledConnection(false);
+        int minuteCounter = 0;
+
+        auto timer = [&sentCount,
+                      &receivedCount,
+                      &sentCountTotal,
+                      &receivedCountTotal,
+                      &sentCountPerSecs,
+                      &receivedCountPerSecs,
+                      &receivedCountPerMinutes,
+                      &minuteCounter,
+                      &conn,
+                      &stop] {
+            setThreadName("Bot progress");
+            while (!stop)
+            {
+                //
+                // We cannot write to sentCount and receivedCount
+                // as those are used externally, so we need to introduce
+                // our own counters
+                //
+                std::stringstream ss;
+                ss << "messages received "
+                   << receivedCountPerSecs
+                   << " "
+                   << receivedCountTotal
+                   << " sent " 
+                   << sentCountPerSecs
+                   << " "
+                   << sentCountTotal;
+
+                if (conn.isAuthenticated())
+                {
+                    CoreLogger::info(ss.str());
+                }
+
+                receivedCountPerSecs = receivedCount - 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");
+        };
+
+        std::thread t1(timer);
+
+        auto heartbeat = [&sentCount,
+                          &receivedCount,
+                          &stop,
+                          &enableHeartbeat,
+                          &heartBeatTimeout,
+                          &stalledConnection]
+        {
+            setThreadName("Bot heartbeat");
+            std::string state("na");
+
+            if (!enableHeartbeat) return;
+
+            while (!stop)
+            {
+                std::stringstream ss;
+                ss << "messages received " << receivedCount;
+                ss << "messages sent " << sentCount;
+
+                std::string currentState = ss.str();
+
+                if (currentState == state)
+                {
+                    ss.str("");
+                    ss << "no messages received or sent for "
+                       << heartBeatTimeout << " seconds, reconnecting";
+
+                    CoreLogger::warn(ss.str());
+                    stalledConnection = true;
+                }
+                state = currentState;
+
+                auto duration = std::chrono::seconds(heartBeatTimeout);
+                std::this_thread::sleep_for(duration);
+            }
+
+            CoreLogger::info("heartbeat thread done");
+        };
+
+        std::thread t2(heartbeat);
+
+        std::string subscriptionPosition(position);
+
+        conn.setEventCallback([this,
+                               &conn,
+                               &channel,
+                               &filter,
+                               &subscriptionPosition,
+                               &throttled,
+                               &receivedCount,
+                               &receivedCountPerMinutes,
+                               maxEventsPerMinute,
+                               limitReceivedEvents,
+                               batchSize,
+                               &fatalCobraError,
+                               &sentCount](const CobraEventPtr& event) {
+            if (event->type == ix::CobraEventType::Open)
+            {
+                CoreLogger::info("Subscriber connected");
+
+                for (auto&& it : event->headers)
+                {
+                    CoreLogger::info(it.first + ": " + it.second);
+                }
+            }
+            else if (event->type == ix::CobraEventType::Closed)
+            {
+                CoreLogger::info("Subscriber closed: " + event->errMsg);
+            }
+            else if (event->type == ix::CobraEventType::Handshake)
+            {
+                CoreLogger::info("Subscriber: Cobra handshake connection id: " + event->connectionId);
+            }
+            else if (event->type == ix::CobraEventType::Authenticated)
+            {
+                CoreLogger::info("Subscriber authenticated");
+                CoreLogger::info("Subscribing to " + channel);
+                CoreLogger::info("Subscribing at position " + subscriptionPosition);
+                CoreLogger::info("Subscribing with filter " + filter);
+                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;
+
+                        ++receivedCountPerMinutes;
+                        if (limitReceivedEvents)
+                        {
+                            if (receivedCountPerMinutes > maxEventsPerMinute)
+                            {
+                                return;
+                            }
+                        }
+
+                        // If we cannot send to sentry fast enough, drop the message
+                        if (throttled)
+                        {
+                            return;
+                        }
+
+                        _onBotMessageCallback(
+                            msg, position, throttled,
+                            fatalCobraError, sentCount);
+                    });
+            }
+            else if (event->type == ix::CobraEventType::Subscribed)
+            {
+                CoreLogger::info("Subscriber: subscribed to channel " + event->subscriptionId);
+            }
+            else if (event->type == ix::CobraEventType::UnSubscribed)
+            {
+                CoreLogger::info("Subscriber: unsubscribed from channel " + event->subscriptionId);
+            }
+            else if (event->type == ix::CobraEventType::Error)
+            {
+                CoreLogger::error("Subscriber: error " + event->errMsg);
+            }
+            else if (event->type == ix::CobraEventType::Published)
+            {
+                CoreLogger::error("Published message hacked: " + std::to_string(event->msgId));
+            }
+            else if (event->type == ix::CobraEventType::Pong)
+            {
+                CoreLogger::info("Received websocket pong: " + event->errMsg);
+            }
+            else if (event->type == ix::CobraEventType::HandshakeError)
+            {
+                CoreLogger::error("Subscriber: Handshake error: " + event->errMsg);
+                fatalCobraError = true;
+            }
+            else if (event->type == ix::CobraEventType::AuthenticationError)
+            {
+                CoreLogger::error("Subscriber: Authentication error: " + event->errMsg);
+                fatalCobraError = true;
+            }
+            else if (event->type == ix::CobraEventType::SubscriptionError)
+            {
+                CoreLogger::error("Subscriber: Subscription error: " + event->errMsg);
+                fatalCobraError = true;
+            }
+        });
+
+        // Run forever
+        if (runtime == -1)
+        {
+            while (true)
+            {
+                auto duration = std::chrono::seconds(1);
+                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
+        else
+        {
+            for (int i = 0; i < runtime; ++i)
+            {
+                auto duration = std::chrono::seconds(1);
+                std::this_thread::sleep_for(duration);
+
+                if (fatalCobraError) break;
+
+                if (stalledConnection)
+                {
+                    conn.disconnect();
+                    conn.connect();
+                    stalledConnection = false;
+                }
+            }
+        }
+
+        //
+        // Cleanup.
+        // join all the bg threads and stop them.
+        //
+        conn.disconnect();
+        stop = true;
+
+        // progress thread
+        t1.join();
+
+        // heartbeat thread
+        if (t2.joinable()) t2.join();
+
+        return fatalCobraError ? -1 : (int64_t) sentCount;
+    }
+
+    void CobraBot::setOnBotMessageCallback(const OnBotMessageCallback& callback)
+    {
+        _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

@@ -0,0 +1,36 @@
+/*
+ *  IXCobraBot.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include "IXCobraBotConfig.h"
+#include <json/json.h>
+#include <stddef.h>
+
+namespace ix
+{
+    using OnBotMessageCallback = std::function<void(const Json::Value&,
+                                                    const std::string&,
+                                                    std::atomic<bool>&,
+                                                    std::atomic<bool>&,
+                                                    std::atomic<uint64_t>&)>;
+
+    class CobraBot
+    {
+    public:
+        CobraBot() = default;
+
+        int64_t run(const CobraBotConfig& botConfig);
+        void setOnBotMessageCallback(const OnBotMessageCallback& callback);
+
+        std::string getDeviceIdentifier(const Json::Value& msg);
+
+    private:
+        OnBotMessageCallback _onBotMessageCallback;
+    };
+} // namespace ix

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/IXCobraToCobraBot.cpp

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

ixbots/ixbots/IXCobraToCobraBot.h

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

ixbots/ixbots/IXCobraToPythonBot.cpp

@@ -0,0 +1,329 @@
+/*
+ *  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& moduleName)
+    {
+#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
+
+        PyObject* pyModuleName = PyUnicode_DecodeFSDefault(moduleName.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& moduleName);
+} // namespace ix

ixbots/ixbots/IXCobraToSentryBot.cpp

@@ -0,0 +1,76 @@
+/*
+ *  IXCobraToSentryBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraToSentryBot.h"
+
+#include "IXCobraBot.h"
+#include <ixcobra/IXCobraConnection.h>
+#include <ixcore/utils/IXCoreLogger.h>
+
+#include <chrono>
+#include <sstream>
+#include <vector>
+
+namespace ix
+{
+    int64_t cobra_to_sentry_bot(const CobraBotConfig& config,
+                                SentryClient& sentryClient,
+                                bool verbose)
+    {
+        CobraBot bot;
+        bot.setOnBotMessageCallback([&sentryClient, &verbose](const Json::Value& msg,
+                                                    const std::string& /*position*/,
+                                                    std::atomic<bool>& throttled,
+                                                    std::atomic<bool>& /*fatalCobraError*/,
+                                                    std::atomic<uint64_t>& sentCount) -> void {
+            sentryClient.send(msg, verbose,
+                [&sentCount, &throttled](const HttpResponsePtr& response) {
+                if (!response)
+                {
+                    CoreLogger::warn("Null HTTP Response");
+                    return;
+                }
+
+                if (response->statusCode == 200)
+                {
+                    sentCount++;
+                }
+                else
+                {
+                    CoreLogger::error("Error sending data to sentry: " + std::to_string(response->statusCode));
+                    CoreLogger::error("Response: " + response->body);
+
+                    // 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())
+                        {
+                            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;
+                    }
+                }
+            });
+        });
+
+        return bot.run(config);
+    }
+} // namespace ix

ixbots/ixbots/IXCobraToSentryBot.h

@@ -0,0 +1,18 @@
+/*
+ *  IXCobraToSentryBot.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
+ */
+#pragma once
+
+#include <cstdint>
+#include "IXCobraBotConfig.h"
+#include <ixsentry/IXSentryClient.h>
+#include <string>
+
+namespace ix
+{
+    int64_t cobra_to_sentry_bot(const CobraBotConfig& config,
+                                SentryClient& sentryClient,
+                                bool verbose);
+} // namespace ix

ixbots/ixbots/IXCobraToStatsdBot.cpp

@@ -0,0 +1,143 @@
+/*
+ *  IXCobraToStatsdBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraToStatsdBot.h"
+
+#include "IXCobraBot.h"
+#include "IXStatsdClient.h"
+#include <chrono>
+#include <ixcobra/IXCobraConnection.h>
+#include <ixcore/utils/IXCoreLogger.h>
+#include <sstream>
+#include <vector>
+
+namespace ix
+{
+    // fields are command line argument that can be specified multiple times
+    std::vector<std::string> parseFields(const std::string& fields)
+    {
+        std::vector<std::string> tokens;
+
+        // Split by \n
+        std::string token;
+        std::stringstream tokenStream(fields);
+
+        while (std::getline(tokenStream, token))
+        {
+            tokens.push_back(token);
+        }
+
+        return tokens;
+    }
+
+    //
+    // Extract an attribute from a Json Value.
+    // extractAttr("foo.bar", {"foo": {"bar": "baz"}}) => baz
+    //
+    Json::Value extractAttr(const std::string& attr, const Json::Value& jsonValue)
+    {
+        // Split by .
+        std::string token;
+        std::stringstream tokenStream(attr);
+
+        Json::Value val(jsonValue);
+
+        while (std::getline(tokenStream, token, '.'))
+        {
+            val = val[token];
+        }
+
+        return val;
+    }
+
+    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)
+    {
+        auto tokens = parseFields(fields);
+
+        CobraBot bot;
+        bot.setOnBotMessageCallback(
+            [&statsdClient, &tokens, &gauge, &timer, &verbose](const Json::Value& msg,
+                                                     const std::string& /*position*/,
+                                                     std::atomic<bool>& /*throttled*/,
+                                                     std::atomic<bool>& fatalCobraError,
+                                                     std::atomic<uint64_t>& sentCount) -> void {
+                std::string id;
+                size_t idx = 0;
+                for (auto&& attr : tokens)
+                {
+                    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())
+                {
+                    statsdClient.count(id, 1);
+                }
+                else
+                {
+                    std::string attrName = (!gauge.empty()) ? gauge : timer;
+                    auto val = extractAttr(attrName, msg);
+                    size_t x;
+
+                    if (val.isInt())
+                    {
+                        x = (size_t) val.asInt();
+                    }
+                    else if (val.isInt64())
+                    {
+                        x = (size_t) val.asInt64();
+                    }
+                    else if (val.isUInt())
+                    {
+                        x = (size_t) val.asUInt();
+                    }
+                    else if (val.isUInt64())
+                    {
+                        x = (size_t) val.asUInt64();
+                    }
+                    else if (val.isDouble())
+                    {
+                        x = (size_t) val.asUInt64();
+                    }
+                    else
+                    {
+                        CoreLogger::error("Gauge " + gauge + " is not a numeric type");
+                        fatalCobraError = true;
+                        return;
+                    }
+
+                    if (verbose)
+                    {
+                        CoreLogger::info(id + " - " + attrName + " -> " + std::to_string(x));
+                    }
+
+                    if (!gauge.empty())
+                    {
+                        statsdClient.gauge(id, x);
+                    }
+                    else
+                    {
+                        statsdClient.timing(id, x);
+                    }
+                }
+
+                sentCount++;
+            });
+
+        return bot.run(config);
+    }
+} // namespace ix

ixbots/ixbots/IXCobraToStatsdBot.h

@@ -0,0 +1,22 @@
+/*
+ *  IXCobraToStatsdBot.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019-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_statsd_bot(const ix::CobraBotConfig& config,
+                                StatsdClient& statsdClient,
+                                const std::string& fields,
+                                const std::string& gauge,
+                                const std::string& timer,
+                                bool verbose);
+} // namespace ix

ixbots/ixbots/IXCobraToStdoutBot.cpp

@@ -0,0 +1,88 @@
+/*
+ *  IXCobraToStdoutBot.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCobraToStdoutBot.h"
+
+#include "IXCobraBot.h"
+#include <chrono>
+#include <iostream>
+#include <sstream>
+
+namespace ix
+{
+    using StreamWriterPtr = std::unique_ptr<Json::StreamWriter>;
+
+    StreamWriterPtr makeStreamWriter()
+    {
+        Json::StreamWriterBuilder builder;
+        builder["commentStyle"] = "None";
+        builder["indentation"] = ""; // will make the JSON object compact
+        std::unique_ptr<Json::StreamWriter> jsonWriter(builder.newStreamWriter());
+        return jsonWriter;
+    }
+
+    std::string timeSinceEpoch()
+    {
+        std::chrono::system_clock::time_point tp = std::chrono::system_clock::now();
+        std::chrono::system_clock::duration dtn = tp.time_since_epoch();
+
+        std::stringstream ss;
+        ss << dtn.count() * std::chrono::system_clock::period::num /
+                  std::chrono::system_clock::period::den;
+        return ss.str();
+    }
+
+    void writeToStdout(bool fluentd,
+                       const StreamWriterPtr& jsonWriter,
+                       const Json::Value& msg,
+                       const std::string& position)
+    {
+        Json::Value enveloppe;
+        if (fluentd)
+        {
+            enveloppe["producer"] = "cobra";
+            enveloppe["consumer"] = "fluentd";
+
+            Json::Value nestedMessage(msg);
+            nestedMessage["position"] = position;
+            nestedMessage["created_at"] = timeSinceEpoch();
+            enveloppe["message"] = nestedMessage;
+
+            jsonWriter->write(enveloppe, &std::cout);
+            std::cout << std::endl; // add lf and flush
+        }
+        else
+        {
+            enveloppe = msg;
+            std::cout << position << " ";
+            jsonWriter->write(enveloppe, &std::cout);
+            std::cout << std::endl;
+        }
+    }
+
+    int64_t cobra_to_stdout_bot(const ix::CobraBotConfig& config,
+                                bool fluentd,
+                                bool quiet)
+    {
+        CobraBot bot;
+        auto jsonWriter = makeStreamWriter();
+
+        bot.setOnBotMessageCallback(
+            [&fluentd, &quiet, &jsonWriter](const Json::Value& msg,
+                                            const std::string& position,
+                                            std::atomic<bool>& /*throttled*/,
+                                            std::atomic<bool>& /*fatalCobraError*/,
+                                            std::atomic<uint64_t>& sentCount) -> void {
+                if (!quiet)
+                {
+                    writeToStdout(fluentd, jsonWriter, msg, position);
+                }
+                sentCount++;
+            });
+
+        return bot.run(config);
+    }
+} // namespace ix

ixbots/ixbots/IXCobraToStdoutBot.h

@@ -0,0 +1,18 @@
+/*
+ *  IXCobraToStdoutBot.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
+ */
+#pragma once
+
+#include <cstdint>
+#include "IXCobraBotConfig.h"
+#include <stddef.h>
+#include <string>
+
+namespace ix
+{
+    int64_t cobra_to_stdout_bot(const ix::CobraBotConfig& config,
+                                bool fluentd,
+                                bool quiet);
+} // namespace ix

ixbots/ixbots/IXStatsdClient.cpp

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2014, Rex
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the {organization} nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  IXStatsdClient.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+// Adapted from statsd-client-cpp
+// test with netcat as a server: `nc -ul 8125`
+
+#include "IXStatsdClient.h"
+
+#include <ixwebsocket/IXNetSystem.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,
+                               bool verbose)
+        : _host(host)
+        , _port(port)
+        , _prefix(prefix)
+        , _stop(false)
+        , _verbose(verbose)
+    {
+        _thread = std::thread([this] {
+            setThreadName("Statsd");
+
+            while (!_stop)
+            {
+                flushQueue();
+                std::this_thread::sleep_for(std::chrono::seconds(1));
+            }
+        });
+    }
+
+    StatsdClient::~StatsdClient()
+    {
+        _stop = true;
+        if (_thread.joinable()) _thread.join();
+
+        _socket.close();
+    }
+
+    bool StatsdClient::init(std::string& errMsg)
+    {
+        return _socket.init(_host, _port, errMsg);
+    }
+
+    /* will change the original string */
+    void StatsdClient::cleanup(std::string& key)
+    {
+        size_t pos = key.find_first_of(":|@");
+        while (pos != std::string::npos)
+        {
+            key[pos] = '_';
+            pos = key.find_first_of(":|@");
+        }
+    }
+
+    int StatsdClient::dec(const std::string& key)
+    {
+        return count(key, -1);
+    }
+
+    int StatsdClient::inc(const std::string& key)
+    {
+        return count(key, 1);
+    }
+
+    int StatsdClient::count(const std::string& key, size_t value)
+    {
+        return send(key, value, "c");
+    }
+
+    int StatsdClient::gauge(const std::string& key, size_t value)
+    {
+        return send(key, value, "g");
+    }
+
+    int StatsdClient::timing(const std::string& key, size_t ms)
+    {
+        return send(key, ms, "ms");
+    }
+
+    int StatsdClient::send(std::string key, size_t value, const std::string& type)
+    {
+        cleanup(key);
+
+        std::stringstream ss;
+        ss << _prefix << "." << key << ":" << value << "|" << type;
+
+        if (_verbose)
+        {
+            CoreLogger::info(ss.str());
+        }
+
+        enqueue(ss.str() + "\n");
+        return 0;
+    }
+
+    void StatsdClient::enqueue(const std::string& message)
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        _queue.push_back(message);
+    }
+
+    void StatsdClient::flushQueue()
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+
+        while (!_queue.empty())
+        {
+            auto message = _queue.front();
+            auto ret = _socket.sendto(message);
+            if (ret == -1)
+            {
+                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();
+        }
+    }
+} // end namespace ix

ixbots/ixbots/IXStatsdClient.h

@@ -0,0 +1,59 @@
+/*
+ *  IXStatsdClient.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <deque>
+#include <ixwebsocket/IXUdpSocket.h>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace ix
+{
+    class StatsdClient
+    {
+    public:
+        StatsdClient(const std::string& host = "127.0.0.1",
+                     int port = 8125,
+                     const std::string& prefix = "",
+                     bool verbose = false);
+        ~StatsdClient();
+
+        bool init(std::string& errMsg);
+        int inc(const std::string& key);
+        int dec(const std::string& key);
+        int count(const std::string& key, size_t value);
+        int gauge(const std::string& key, size_t value);
+        int timing(const std::string& key, size_t ms);
+
+    private:
+        void enqueue(const std::string& message);
+
+        /* (Low Level Api) manually send a message
+         * type = "c", "g" or "ms"
+         */
+        int send(std::string key, size_t value, const std::string& type);
+
+        void cleanup(std::string& key);
+        void flushQueue();
+
+        UdpSocket _socket;
+
+        std::string _host;
+        int _port;
+        std::string _prefix;
+
+        std::atomic<bool> _stop;
+        std::thread _thread;
+        std::mutex _mutex; // for the queue
+
+        std::deque<std::string> _queue;
+        bool _verbose;
+    };
+
+} // end namespace ix

ixcobra/CMakeLists.txt

@@ -0,0 +1,37 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+#
+
+set (IXCOBRA_SOURCES
+    ixcobra/IXCobraConnection.cpp
+    ixcobra/IXCobraMetricsThreadedPublisher.cpp
+    ixcobra/IXCobraMetricsPublisher.cpp
+)
+
+set (IXCOBRA_HEADERS
+    ixcobra/IXCobraConnection.h
+    ixcobra/IXCobraMetricsThreadedPublisher.h
+    ixcobra/IXCobraMetricsPublisher.h
+    ixcobra/IXCobraConfig.h
+    ixcobra/IXCobraEventType.h
+)
+
+add_library(ixcobra STATIC
+    ${IXCOBRA_SOURCES}
+    ${IXCOBRA_HEADERS}
+)
+
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
+endif()
+
+set(IXCOBRA_INCLUDE_DIRS
+    .
+    ..
+    ../ixcore
+    ../ixcrypto
+    ${JSONCPP_INCLUDE_DIRS})
+
+target_include_directories( ixcobra PUBLIC ${IXCOBRA_INCLUDE_DIRS} )

ixcobra/ixcobra/IXCobraConfig.h

@@ -0,0 +1,37 @@
+/*
+ *  IXCobraConfig.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <ixwebsocket/IXSocketTLSOptions.h>
+#include <ixwebsocket/IXWebSocketPerMessageDeflateOptions.h>
+#include <ixwebsocket/IXWebSocketHttpHeaders.h>
+
+namespace ix
+{
+    struct CobraConfig
+    {
+        std::string appkey;
+        std::string endpoint;
+        std::string rolename;
+        std::string rolesecret;
+        WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions;
+        SocketTLSOptions socketTLSOptions;
+        WebSocketHttpHeaders headers;
+
+        CobraConfig(const std::string& a = std::string(),
+                    const std::string& e = std::string(),
+                    const std::string& r = std::string(),
+                    const std::string& s = std::string())
+            : appkey(a)
+            , endpoint(e)
+            , rolename(r)
+            , rolesecret(s)
+        {
+            ;
+        }
+    };
+} // namespace ix

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -0,0 +1,712 @@
+/*
+ *  IXCobraConnection.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone. All rights reserved.
+ */
+
+#include "IXCobraConnection.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <iostream>
+#include <ixcrypto/IXHMac.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <sstream>
+#include <stdexcept>
+
+
+namespace ix
+{
+    TrafficTrackerCallback CobraConnection::_trafficTrackerCallback = nullptr;
+    PublishTrackerCallback CobraConnection::_publishTrackerCallback = nullptr;
+    constexpr size_t CobraConnection::kQueueMaxSize;
+    constexpr CobraConnection::MsgId CobraConnection::kInvalidMsgId;
+    constexpr int CobraConnection::kPingIntervalSecs;
+
+    CobraConnection::CobraConnection()
+        : _webSocket(new WebSocket())
+        , _publishMode(CobraConnection_PublishMode_Immediate)
+        , _authenticated(false)
+        , _eventCallback(nullptr)
+        , _id(1)
+    {
+        _pdu["action"] = "rtm/publish";
+
+        _webSocket->addSubProtocol("json");
+        initWebSocketOnMessageCallback();
+    }
+
+    CobraConnection::~CobraConnection()
+    {
+        disconnect();
+        setEventCallback(nullptr);
+    }
+
+    void CobraConnection::setTrafficTrackerCallback(const TrafficTrackerCallback& callback)
+    {
+        _trafficTrackerCallback = callback;
+    }
+
+    void CobraConnection::resetTrafficTrackerCallback()
+    {
+        setTrafficTrackerCallback(nullptr);
+    }
+
+    void CobraConnection::invokeTrafficTrackerCallback(size_t size, bool incoming)
+    {
+        if (_trafficTrackerCallback)
+        {
+            _trafficTrackerCallback(size, incoming);
+        }
+    }
+
+    void CobraConnection::setPublishTrackerCallback(const PublishTrackerCallback& callback)
+    {
+        _publishTrackerCallback = callback;
+    }
+
+    void CobraConnection::resetPublishTrackerCallback()
+    {
+        setPublishTrackerCallback(nullptr);
+    }
+
+    void CobraConnection::invokePublishTrackerCallback(bool sent, bool acked)
+    {
+        if (_publishTrackerCallback)
+        {
+            _publishTrackerCallback(sent, acked);
+        }
+    }
+
+    void CobraConnection::setEventCallback(const EventCallback& eventCallback)
+    {
+        std::lock_guard<std::mutex> lock(_eventCallbackMutex);
+        _eventCallback = eventCallback;
+    }
+
+    void CobraConnection::invokeEventCallback(ix::CobraEventType eventType,
+                                              const std::string& errorMsg,
+                                              const WebSocketHttpHeaders& headers,
+                                              const std::string& subscriptionId,
+                                              CobraConnection::MsgId msgId,
+                                              const std::string& connectionId)
+    {
+        std::lock_guard<std::mutex> lock(_eventCallbackMutex);
+        if (_eventCallback)
+        {
+            _eventCallback(
+                std::make_unique<CobraEvent>(eventType, errorMsg, headers, subscriptionId, msgId, connectionId));
+        }
+    }
+
+    void CobraConnection::invokeErrorCallback(const std::string& errorMsg,
+                                              const std::string& serializedPdu)
+    {
+        std::stringstream ss;
+        ss << errorMsg << " : received pdu => " << serializedPdu;
+        invokeEventCallback(ix::CobraEventType::Error, ss.str());
+    }
+
+    void CobraConnection::disconnect()
+    {
+        auto subscriptionIds = getSubscriptionsIds();
+        for (auto&& subscriptionId : subscriptionIds)
+        {
+            unsubscribe(subscriptionId);
+        }
+
+        _authenticated = false;
+        _webSocket->stop();
+    }
+
+    void CobraConnection::initWebSocketOnMessageCallback()
+    {
+        _webSocket->setOnMessageCallback([this](const ix::WebSocketMessagePtr& msg) {
+            CobraConnection::invokeTrafficTrackerCallback(msg->wireSize, true);
+
+            std::stringstream ss;
+            if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                invokeEventCallback(ix::CobraEventType::Open, std::string(), msg->openInfo.headers);
+                sendHandshakeMessage();
+            }
+            else if (msg->type == ix::WebSocketMessageType::Close)
+            {
+                _authenticated = false;
+
+                std::stringstream ss;
+                ss << "Close code " << msg->closeInfo.code;
+                ss << " reason " << msg->closeInfo.reason;
+                invokeEventCallback(ix::CobraEventType::Closed, ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                Json::Value data;
+                Json::Reader reader;
+                if (!reader.parse(msg->str, data))
+                {
+                    invokeErrorCallback("Invalid json", msg->str);
+                    return;
+                }
+
+                if (!data.isMember("action"))
+                {
+                    invokeErrorCallback("Missing action", msg->str);
+                    return;
+                }
+
+                auto action = data["action"].asString();
+
+                if (action == "auth/handshake/ok")
+                {
+                    if (!handleHandshakeResponse(data))
+                    {
+                        invokeErrorCallback("Error extracting nonce from handshake response",
+                                            msg->str);
+                    }
+                }
+                else if (action == "auth/handshake/error")
+                {
+                    invokeEventCallback(ix::CobraEventType::HandshakeError, msg->str);
+                }
+                else if (action == "auth/authenticate/ok")
+                {
+                    _authenticated = true;
+                    invokeEventCallback(ix::CobraEventType::Authenticated);
+                    flushQueue();
+                }
+                else if (action == "auth/authenticate/error")
+                {
+                    invokeEventCallback(ix::CobraEventType::AuthenticationError, msg->str);
+                }
+                else if (action == "rtm/subscription/data")
+                {
+                    handleSubscriptionData(data);
+                }
+                else if (action == "rtm/subscribe/ok")
+                {
+                    if (!handleSubscriptionResponse(data))
+                    {
+                        invokeErrorCallback("Error processing subscribe response", msg->str);
+                    }
+                }
+                else if (action == "rtm/subscribe/error")
+                {
+                    invokeEventCallback(ix::CobraEventType::SubscriptionError, msg->str);
+                }
+                else if (action == "rtm/unsubscribe/ok")
+                {
+                    if (!handleUnsubscriptionResponse(data))
+                    {
+                        invokeErrorCallback("Error processing unsubscribe response", msg->str);
+                    }
+                }
+                else if (action == "rtm/unsubscribe/error")
+                {
+                    invokeErrorCallback("Unsubscription error", msg->str);
+                }
+                else if (action == "rtm/publish/ok")
+                {
+                    if (!handlePublishResponse(data))
+                    {
+                        invokeErrorCallback("Error processing publish response", msg->str);
+                    }
+                }
+                else if (action == "rtm/publish/error")
+                {
+                    invokeErrorCallback("Publish error", msg->str);
+                }
+                else
+                {
+                    invokeErrorCallback("Un-handled message type", msg->str);
+                }
+            }
+            else if (msg->type == ix::WebSocketMessageType::Error)
+            {
+                std::stringstream ss;
+                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                invokeErrorCallback(ss.str(), std::string());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Pong)
+            {
+                invokeEventCallback(ix::CobraEventType::Pong, msg->str);
+            }
+        });
+    }
+
+    void CobraConnection::setPublishMode(CobraConnectionPublishMode publishMode)
+    {
+        _publishMode = publishMode;
+    }
+
+    CobraConnectionPublishMode CobraConnection::getPublishMode()
+    {
+        return _publishMode;
+    }
+
+    void CobraConnection::configure(
+        const std::string& appkey,
+        const std::string& endpoint,
+        const std::string& rolename,
+        const std::string& rolesecret,
+        const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
+        const SocketTLSOptions& socketTLSOptions,
+        const WebSocketHttpHeaders& headers)
+    {
+        _roleName = rolename;
+        _roleSecret = rolesecret;
+
+        std::stringstream ss;
+        ss << endpoint;
+        ss << "/v2?appkey=";
+        ss << appkey;
+
+        std::string url = ss.str();
+        _webSocket->setUrl(url);
+        _webSocket->setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
+        _webSocket->setTLSOptions(socketTLSOptions);
+        _webSocket->setExtraHeaders(headers);
+
+        // Send a websocket ping every N seconds (N = 30) now
+        // This should keep the connection open and prevent some load balancers such as
+        // the Amazon one from shutting it down
+        _webSocket->setPingInterval(kPingIntervalSecs);
+    }
+
+    void CobraConnection::configure(const ix::CobraConfig& config)
+    {
+        configure(config.appkey,
+                  config.endpoint,
+                  config.rolename,
+                  config.rolesecret,
+                  config.webSocketPerMessageDeflateOptions,
+                  config.socketTLSOptions,
+                  config.headers);
+    }
+
+    //
+    // Handshake message schema.
+    //
+    // handshake = {
+    //     "action": "auth/handshake",
+    //     "body": {
+    //         "data": {
+    //             "role": role
+    //         },
+    //         "method": "role_secret"
+    //     },
+    // }
+    //
+    //
+    bool CobraConnection::sendHandshakeMessage()
+    {
+        Json::Value data;
+        data["role"] = _roleName;
+
+        Json::Value body;
+        body["data"] = data;
+        body["method"] = "role_secret";
+
+        Json::Value pdu;
+        pdu["action"] = "auth/handshake";
+        pdu["body"] = body;
+        pdu["id"] = Json::UInt64(_id++);
+
+        std::string serializedJson = serializeJson(pdu);
+        CobraConnection::invokeTrafficTrackerCallback(serializedJson.size(), false);
+
+        return _webSocket->send(serializedJson).success;
+    }
+
+    //
+    // Extract the nonce from the handshake response
+    // use it to compute a hash during authentication
+    //
+    // {
+    //     "action": "auth/handshake/ok",
+    //     "body": {
+    //         "data": {
+    //             "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
+    //             "version": "0.0.24"
+    //         }
+    //     }
+    // }
+    //
+    bool CobraConnection::handleHandshakeResponse(const Json::Value& pdu)
+    {
+        if (!pdu.isObject()) return false;
+
+        if (!pdu.isMember("body")) return false;
+        Json::Value body = pdu["body"];
+
+        if (!body.isMember("data")) return false;
+        Json::Value data = body["data"];
+
+        if (!data.isMember("nonce")) return false;
+        Json::Value nonce = data["nonce"];
+
+        if (!nonce.isString()) return false;
+
+        if (!data.isMember("connection_id")) return false;
+        Json::Value connectionId = data["connection_id"];
+
+        if (!connectionId.isString()) return false;
+
+        invokeEventCallback(ix::CobraEventType::Handshake,
+                            std::string(),
+                            WebSocketHttpHeaders(),
+                            std::string(),
+                            0,
+                            connectionId.asString());
+
+        return sendAuthMessage(nonce.asString());
+    }
+
+    //
+    // Authenticate message schema.
+    //
+    // challenge = {
+    //     "action": "auth/authenticate",
+    //     "body": {
+    //         "method": "role_secret",
+    //         "credentials": {
+    //             "hash": computeHash(secret, nonce)
+    //         }
+    //     },
+    // }
+    //
+    bool CobraConnection::sendAuthMessage(const std::string& nonce)
+    {
+        Json::Value credentials;
+        credentials["hash"] = hmac(nonce, _roleSecret);
+
+        Json::Value body;
+        body["credentials"] = credentials;
+        body["method"] = "role_secret";
+
+        Json::Value pdu;
+        pdu["action"] = "auth/authenticate";
+        pdu["body"] = body;
+        pdu["id"] = Json::UInt64(_id++);
+
+        std::string serializedJson = serializeJson(pdu);
+        CobraConnection::invokeTrafficTrackerCallback(serializedJson.size(), false);
+
+        return _webSocket->send(serializedJson).success;
+    }
+
+    bool CobraConnection::handleSubscriptionResponse(const Json::Value& pdu)
+    {
+        if (!pdu.isObject()) return false;
+
+        if (!pdu.isMember("body")) return false;
+        Json::Value body = pdu["body"];
+
+        if (!body.isMember("subscription_id")) return false;
+        Json::Value subscriptionId = body["subscription_id"];
+
+        if (!subscriptionId.isString()) return false;
+
+        invokeEventCallback(ix::CobraEventType::Subscribed,
+                            std::string(),
+                            WebSocketHttpHeaders(),
+                            subscriptionId.asString());
+        return true;
+    }
+
+    bool CobraConnection::handleUnsubscriptionResponse(const Json::Value& pdu)
+    {
+        if (!pdu.isObject()) return false;
+
+        if (!pdu.isMember("body")) return false;
+        Json::Value body = pdu["body"];
+
+        if (!body.isMember("subscription_id")) return false;
+        Json::Value subscriptionId = body["subscription_id"];
+
+        if (!subscriptionId.isString()) return false;
+
+        invokeEventCallback(ix::CobraEventType::UnSubscribed,
+                            std::string(),
+                            WebSocketHttpHeaders(),
+                            subscriptionId.asString());
+        return true;
+    }
+
+    bool CobraConnection::handleSubscriptionData(const Json::Value& pdu)
+    {
+        if (!pdu.isObject()) return false;
+
+        if (!pdu.isMember("body")) return false;
+        Json::Value body = pdu["body"];
+
+        // Identify subscription_id, so that we can find
+        // which callback to execute
+        if (!body.isMember("subscription_id")) return false;
+        Json::Value subscriptionId = body["subscription_id"];
+
+        std::lock_guard<std::mutex> lock(_cbsMutex);
+        auto cb = _cbs.find(subscriptionId.asString());
+        if (cb == _cbs.end()) return false; // cannot find callback
+
+        // Extract messages now
+        if (!body.isMember("messages")) return false;
+        Json::Value messages = body["messages"];
+
+        if (!body.isMember("position")) return false;
+        std::string position = body["position"].asString();
+
+        for (auto&& msg : messages)
+        {
+            cb->second(msg, position);
+        }
+
+        return true;
+    }
+
+    bool CobraConnection::handlePublishResponse(const Json::Value& pdu)
+    {
+        if (!pdu.isObject()) return false;
+
+        if (!pdu.isMember("id")) return false;
+        Json::Value id = pdu["id"];
+
+        if (!id.isUInt64()) return false;
+
+        uint64_t msgId = id.asUInt64();
+
+        invokeEventCallback(ix::CobraEventType::Published,
+                            std::string(),
+                            WebSocketHttpHeaders(),
+                            std::string(),
+                            msgId);
+
+        invokePublishTrackerCallback(false, true);
+
+        return true;
+    }
+
+    bool CobraConnection::connect()
+    {
+        _webSocket->start();
+        return true;
+    }
+
+    bool CobraConnection::isConnected() const
+    {
+        return _webSocket->getReadyState() == ix::ReadyState::Open;
+    }
+
+    bool CobraConnection::isAuthenticated() const
+    {
+        return isConnected() && _authenticated;
+    }
+
+    std::string CobraConnection::serializeJson(const Json::Value& value)
+    {
+        std::lock_guard<std::mutex> lock(_jsonWriterMutex);
+        return _jsonWriter.write(value);
+    }
+
+    std::pair<CobraConnection::MsgId, std::string> CobraConnection::prePublish(
+        const Json::Value& channels, const Json::Value& msg, bool addToQueue)
+    {
+        std::lock_guard<std::mutex> lock(_prePublishMutex);
+
+        invokePublishTrackerCallback(true, false);
+
+        CobraConnection::MsgId msgId = _id;
+
+        _body["channels"] = channels;
+        _body["message"] = msg;
+        _pdu["body"] = _body;
+        _pdu["id"] = Json::UInt64(_id++);
+
+        std::string serializedJson = serializeJson(_pdu);
+
+        if (addToQueue)
+        {
+            enqueue(serializedJson);
+        }
+
+        return std::make_pair(msgId, serializedJson);
+    }
+
+    bool CobraConnection::publishNext()
+    {
+        std::lock_guard<std::mutex> lock(_queueMutex);
+
+        if (_messageQueue.empty()) return true;
+
+        auto&& msg = _messageQueue.back();
+        if (!_authenticated || !publishMessage(msg))
+        {
+            return false;
+        }
+        _messageQueue.pop_back();
+        return true;
+    }
+
+    //
+    // publish is not thread safe as we are trying to reuse some Json objects.
+    //
+    CobraConnection::MsgId CobraConnection::publish(const Json::Value& channels,
+                                                    const Json::Value& msg)
+    {
+        auto p = prePublish(channels, msg, false);
+        auto msgId = p.first;
+        auto serializedJson = p.second;
+
+        //
+        // 1. When we use batch mode, we just enqueue and will do the flush explicitely
+        // 2. When we aren't authenticated yet to the cobra server, we need to enqueue
+        //    and retry later
+        // 3. If the network connection was droped (WebSocket::send will return false),
+        //    it means the message won't be sent so we need to enqueue as well.
+        //
+        // The order of the conditionals is important.
+        //
+        if (_publishMode == CobraConnection_PublishMode_Batch || !_authenticated ||
+            !publishMessage(serializedJson))
+        {
+            enqueue(serializedJson);
+        }
+
+        return msgId;
+    }
+
+    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())
+        {
+            body["filter"] = filter;
+        }
+
+        if (!position.empty())
+        {
+            body["position"] = position;
+        }
+
+        Json::Value pdu;
+        pdu["action"] = "rtm/subscribe";
+        pdu["body"] = body;
+        pdu["id"] = Json::UInt64(_id++);
+
+        _webSocket->send(pdu.toStyledString());
+
+        // Set the callback
+        std::lock_guard<std::mutex> lock(_cbsMutex);
+        _cbs[channel] = cb;
+    }
+
+    void CobraConnection::unsubscribe(const std::string& channel)
+    {
+        {
+            std::lock_guard<std::mutex> lock(_cbsMutex);
+            auto cb = _cbs.find(channel);
+            if (cb == _cbs.end()) return;
+
+            _cbs.erase(cb);
+        }
+
+        // Create and send an unsubscribe pdu
+        Json::Value body;
+        body["subscription_id"] = channel;
+
+        Json::Value pdu;
+        pdu["action"] = "rtm/unsubscribe";
+        pdu["body"] = body;
+        pdu["id"] = Json::UInt64(_id++);
+
+        _webSocket->send(pdu.toStyledString());
+    }
+
+    std::vector<std::string> CobraConnection::getSubscriptionsIds()
+    {
+        std::vector<std::string> subscriptionIds;
+        std::lock_guard<std::mutex> lock(_cbsMutex);
+
+        for (auto&& it : _cbs)
+        {
+            subscriptionIds.push_back(it.first);
+        }
+        return subscriptionIds;
+    }
+
+    //
+    // Enqueue strategy drops old messages when we are at full capacity
+    //
+    // If we want to keep only 3 items max in the queue:
+    //
+    // enqueue(A) -> [A]
+    // enqueue(B) -> [B, A]
+    // enqueue(C) -> [C, B, A]
+    // enqueue(D) -> [D, C, B] -- now we drop A, the oldest message,
+    //                         -- and keep the 'fresh ones'
+    //
+    void CobraConnection::enqueue(const std::string& msg)
+    {
+        std::lock_guard<std::mutex> lock(_queueMutex);
+
+        if (_messageQueue.size() == CobraConnection::kQueueMaxSize)
+        {
+            _messageQueue.pop_back();
+        }
+        _messageQueue.push_front(msg);
+    }
+
+    //
+    // We process messages back (oldest) to front (newest) to respect ordering
+    // when sending them. If we fail to send something, we put it back in the queue
+    // at the end we picked it up originally (at the end).
+    //
+    bool CobraConnection::flushQueue()
+    {
+        while (!isQueueEmpty())
+        {
+            bool ok = publishNext();
+            if (!ok) return false;
+        }
+
+        return true;
+    }
+
+    bool CobraConnection::isQueueEmpty()
+    {
+        std::lock_guard<std::mutex> lock(_queueMutex);
+        return _messageQueue.empty();
+    }
+
+    bool CobraConnection::publishMessage(const std::string& serializedJson)
+    {
+        auto webSocketSendInfo = _webSocket->send(serializedJson);
+        CobraConnection::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize, false);
+        return webSocketSendInfo.success;
+    }
+
+    void CobraConnection::suspend()
+    {
+        disconnect();
+    }
+
+    void CobraConnection::resume()
+    {
+        connect();
+    }
+
+} // namespace ix