move snake code to its own subfolder like ixcobra, ixcrypto, etc...

ixsnake/CMakeLists.txt

@@ -0,0 +1,33 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+#
+
+set (IXSNAKE_SOURCES
+    ixsnake/IXSnakeServer.cpp
+    ixsnake/IXSnakeProtocol.cpp
+    ixsnake/IXAppConfig.cpp
+    ixsnake/IXRedisClient.cpp
+)
+
+set (IXSNAKE_HEADERS
+    ixsnake/IXSnakeServer.h
+    ixsnake/IXSnakeProtocol.h
+    ixsnake/IXAppConfig.h
+    ixsnake/IXRedisClient.h
+)
+
+add_library(ixsnake STATIC
+    ${IXSNAKE_SOURCES}
+    ${IXSNAKE_HEADERS}
+)
+
+set(IXSNAKE_INCLUDE_DIRS
+    .
+    ..
+    ../ixcore
+    ../ixcrypto
+    ../ixwebsocket
+    ../third_party)
+
+target_include_directories( ixsnake PUBLIC ${IXSNAKE_INCLUDE_DIRS} )

ixsnake/ixsnake/IXAppConfig.cpp

@@ -0,0 +1,48 @@
+/*
+ *  IXSnakeProtocol.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXAppConfig.h"
+
+#include "IXSnakeProtocol.h"
+#include <iostream>
+#include <ixcrypto/IXUuid.h>
+
+namespace snake
+{
+    bool isAppKeyValid(const AppConfig& appConfig, std::string appkey)
+    {
+        return appConfig.apps.count(appkey) != 0;
+    }
+
+    std::string getRoleSecret(const AppConfig& appConfig, std::string appkey, std::string role)
+    {
+        if (!isAppKeyValid(appConfig, appkey))
+        {
+            std::cerr << "Missing appkey " << appkey << std::endl;
+            return std::string();
+        }
+
+        auto roles = appConfig.apps[appkey]["roles"];
+        auto channel = roles[role]["secret"];
+        return channel;
+    }
+
+    std::string generateNonce()
+    {
+        return ix::uuid4();
+    }
+
+    void dumpConfig(const AppConfig& appConfig)
+    {
+        for (auto&& host : appConfig.redisHosts)
+        {
+            std::cout << "redis host: " << host << std::endl;
+        }
+
+        std::cout << "redis password: " << appConfig.redisPassword << std::endl;
+        std::cout << "redis port: " << appConfig.redisPort << std::endl;
+    }
+} // namespace snake

ixsnake/ixsnake/IXAppConfig.h

@@ -0,0 +1,40 @@
+/*
+ *  IXAppConfig.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+namespace snake
+{
+    struct AppConfig
+    {
+        // Server
+        std::string hostname;
+        int port;
+
+        // Redis
+        std::vector<std::string> redisHosts;
+        int redisPort;
+        std::string redisPassword;
+
+        // AppKeys
+        nlohmann::json apps;
+
+        // Misc
+        bool verbose;
+    };
+
+    bool isAppKeyValid(const AppConfig& appConfig, std::string appkey);
+
+    std::string getRoleSecret(const AppConfig& appConfig, std::string appkey, std::string role);
+
+    std::string generateNonce();
+
+    void dumpConfig(const AppConfig& appConfig);
+} // namespace snake

ixsnake/ixsnake/IXRedisClient.cpp

@@ -0,0 +1,248 @@
+/*
+ *  IXRedisClient.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXRedisClient.h"
+
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <ixwebsocket/IXSocket.h>
+#include <ixwebsocket/IXSocketFactory.h>
+#include <sstream>
+#include <vector>
+
+namespace ix
+{
+    bool RedisClient::connect(const std::string& hostname, int port)
+    {
+        bool tls = false;
+        std::string errorMsg;
+        _socket = createSocket(tls, errorMsg);
+
+        if (!_socket)
+        {
+            return false;
+        }
+
+        std::string errMsg;
+        return _socket->connect(hostname, port, errMsg, nullptr);
+    }
+
+    bool RedisClient::auth(const std::string& password, std::string& response)
+    {
+        response.clear();
+
+        if (!_socket) return false;
+
+        std::stringstream ss;
+        ss << "AUTH ";
+        ss << password;
+        ss << "\r\n";
+
+        bool sent = _socket->writeBytes(ss.str(), nullptr);
+        if (!sent)
+        {
+            return false;
+        }
+
+        auto pollResult = _socket->isReadyToRead(-1);
+        if (pollResult == PollResultType::Error)
+        {
+            return false;
+        }
+
+        auto lineResult = _socket->readLine(nullptr);
+        auto lineValid = lineResult.first;
+        auto line = lineResult.second;
+
+        response = line;
+        return lineValid;
+    }
+
+    std::string RedisClient::writeString(const std::string& str)
+    {
+        std::stringstream ss;
+        ss << "$";
+        ss << str.size();
+        ss << "\r\n";
+        ss << str;
+        ss << "\r\n";
+
+        return ss.str();
+    }
+
+    bool RedisClient::publish(const std::string& channel,
+                              const std::string& message,
+                              std::string& errMsg)
+    {
+        errMsg.clear();
+
+        if (!_socket)
+        {
+            errMsg = "socket is not initialized";
+            return false;
+        }
+
+        std::stringstream ss;
+        ss << "*3\r\n";
+        ss << writeString("PUBLISH");
+        ss << writeString(channel);
+        ss << writeString(message);
+
+        bool sent = _socket->writeBytes(ss.str(), nullptr);
+        if (!sent)
+        {
+            errMsg = "Cannot write bytes to socket";
+            return false;
+        }
+
+        auto pollResult = _socket->isReadyToRead(-1);
+        if (pollResult == PollResultType::Error)
+        {
+            errMsg = "Error while polling for result";
+            return false;
+        }
+
+        auto lineResult = _socket->readLine(nullptr);
+        auto lineValid = lineResult.first;
+        auto line = lineResult.second;
+
+        // A successful response starts with a :
+        if (line.empty() || line[0] != ':')
+        {
+            errMsg = line;
+            return false;
+        }
+
+        return lineValid;
+    }
+
+    //
+    // FIXME: we assume that redis never return errors...
+    //
+    bool RedisClient::subscribe(const std::string& channel,
+                                const OnRedisSubscribeResponseCallback& responseCallback,
+                                const OnRedisSubscribeCallback& callback)
+    {
+        _stop = false;
+
+        if (!_socket) return false;
+
+        std::stringstream ss;
+        ss << "SUBSCRIBE ";
+        ss << channel;
+        ss << "\r\n";
+
+        bool sent = _socket->writeBytes(ss.str(), nullptr);
+        if (!sent)
+        {
+            return false;
+        }
+
+        // Wait 1s for the response
+        auto pollResult = _socket->isReadyToRead(-1);
+        if (pollResult == PollResultType::Error)
+        {
+            return false;
+        }
+
+        // build the response as a single string
+        std::stringstream oss;
+
+        // Read the first line of the response
+        auto lineResult = _socket->readLine(nullptr);
+        auto lineValid = lineResult.first;
+        auto line = lineResult.second;
+        oss << line;
+
+        if (!lineValid) return false;
+
+        // There are 5 items for the subscribe reply
+        for (int i = 0; i < 5; ++i)
+        {
+            auto lineResult = _socket->readLine(nullptr);
+            auto lineValid = lineResult.first;
+            auto line = lineResult.second;
+            oss << line;
+
+            if (!lineValid) return false;
+        }
+
+        responseCallback(oss.str());
+
+        // Wait indefinitely for new messages
+        while (true)
+        {
+            if (_stop) break;
+
+            // Wait until something is ready to read
+            int timeoutMs = 10;
+            auto pollResult = _socket->isReadyToRead(timeoutMs);
+            if (pollResult == PollResultType::Error)
+            {
+                return false;
+            }
+
+            if (pollResult == PollResultType::Timeout)
+            {
+                continue;
+            }
+
+            // The first line of the response describe the return type,
+            // => *3 (an array of 3 elements)
+            auto lineResult = _socket->readLine(nullptr);
+            auto lineValid = lineResult.first;
+            auto line = lineResult.second;
+
+            if (!lineValid) return false;
+
+            int arraySize;
+            {
+                std::stringstream ss;
+                ss << line.substr(1, line.size() - 1);
+                ss >> arraySize;
+            }
+
+            // There are 6 items for each received message
+            for (int i = 0; i < arraySize; ++i)
+            {
+                auto lineResult = _socket->readLine(nullptr);
+                auto lineValid = lineResult.first;
+                auto line = lineResult.second;
+
+                if (!lineValid) return false;
+
+                // Messages are string, which start with a string size
+                // => $7 (7 bytes)
+                int stringSize;
+                std::stringstream ss;
+                ss << line.substr(1, line.size() - 1);
+                ss >> stringSize;
+
+                auto readResult = _socket->readBytes(stringSize, nullptr, nullptr);
+                if (!readResult.first) return false;
+
+                if (i == 2)
+                {
+                    // The message is the 3rd element.
+                    callback(readResult.second);
+                }
+
+                // read last 2 bytes (\r\n)
+                char c;
+                _socket->readByte(&c, nullptr);
+                _socket->readByte(&c, nullptr);
+            }
+        }
+
+        return true;
+    }
+
+    void RedisClient::stop()
+    {
+        _stop = true;
+    }
+} // namespace ix

ixsnake/ixsnake/IXRedisClient.h

@@ -0,0 +1,47 @@
+/*
+ *  IXRedisClient.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <memory>
+
+namespace ix
+{
+    class Socket;
+
+    class RedisClient
+    {
+    public:
+        using OnRedisSubscribeResponseCallback = std::function<void(const std::string&)>;
+        using OnRedisSubscribeCallback = std::function<void(const std::string&)>;
+
+        RedisClient()
+            : _stop(false)
+        {
+        }
+        ~RedisClient() = default;
+
+        bool connect(const std::string& hostname, int port);
+
+        bool auth(const std::string& password, std::string& response);
+
+        bool publish(const std::string& channel, const std::string& message, std::string& errMsg);
+
+        bool subscribe(const std::string& channel,
+                       const OnRedisSubscribeResponseCallback& responseCallback,
+                       const OnRedisSubscribeCallback& callback);
+
+        void stop();
+
+    private:
+        std::string writeString(const std::string& str);
+
+        std::shared_ptr<Socket> _socket;
+        std::atomic<bool> _stop;
+    };
+} // namespace ix

ixsnake/ixsnake/IXSnakeConnectionState.h

@@ -0,0 +1,60 @@
+/*
+ *  IXSnakeConnectionState.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXRedisClient.h"
+#include <future>
+#include <ixwebsocket/IXConnectionState.h>
+#include <string>
+
+namespace snake
+{
+    class SnakeConnectionState : public ix::ConnectionState
+    {
+    public:
+        std::string getNonce()
+        {
+            return _nonce;
+        }
+        void setNonce(const std::string& nonce)
+        {
+            _nonce = nonce;
+        }
+
+        std::string appkey()
+        {
+            return _appkey;
+        }
+        void setAppkey(const std::string& appkey)
+        {
+            _appkey = appkey;
+        }
+
+        std::string role()
+        {
+            return _role;
+        }
+        void setRole(const std::string& role)
+        {
+            _role = role;
+        }
+
+        ix::RedisClient& redisClient()
+        {
+            return _redisClient;
+        }
+
+        std::future<void> fut;
+
+    private:
+        std::string _nonce;
+        std::string _role;
+        std::string _appkey;
+
+        ix::RedisClient _redisClient;
+    };
+} // namespace snake

ixsnake/ixsnake/IXSnakeProtocol.cpp

@@ -0,0 +1,288 @@
+/*
+ *  IXSnakeProtocol.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXSnakeProtocol.h"
+
+#include "IXAppConfig.h"
+#include "IXSnakeConnectionState.h"
+#include "nlohmann/json.hpp"
+#include <iostream>
+#include <ixcrypto/IXHMac.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <sstream>
+
+namespace snake
+{
+    void handleError(const std::string& action,
+                     std::shared_ptr<ix::WebSocket> ws,
+                     nlohmann::json pdu,
+                     const std::string& errMsg)
+    {
+        std::string actionError(action);
+        actionError += "/error";
+
+        nlohmann::json response = {
+            {"action", actionError}, {"id", pdu.value("id", 1)}, {"body", {{"reason", errMsg}}}};
+        ws->sendText(response.dump());
+    }
+
+    void handleHandshake(std::shared_ptr<SnakeConnectionState> state,
+                         std::shared_ptr<ix::WebSocket> ws,
+                         const nlohmann::json& pdu)
+    {
+        std::string role = pdu["body"]["data"]["role"];
+
+        state->setNonce(generateNonce());
+        state->setRole(role);
+
+        nlohmann::json response = {
+            {"action", "auth/handshake/ok"},
+            {"id", pdu.value("id", 1)},
+            {"body",
+             {
+                 {"data", {{"nonce", state->getNonce()}, {"connection_id", state->getId()}}},
+             }}};
+
+        auto serializedResponse = response.dump();
+        std::cout << "response = " << serializedResponse << std::endl;
+
+        ws->sendText(serializedResponse);
+    }
+
+    void handleAuth(std::shared_ptr<SnakeConnectionState> state,
+                    std::shared_ptr<ix::WebSocket> ws,
+                    const AppConfig& appConfig,
+                    const nlohmann::json& pdu)
+    {
+        auto secret = getRoleSecret(appConfig, state->appkey(), state->role());
+        std::cout << "secret = " << secret << std::endl;
+
+        if (secret.empty())
+        {
+            nlohmann::json response = {
+                {"action", "auth/authenticate/error"},
+                {"id", pdu.value("id", 1)},
+                {"body", {{"error", "authentication_failed"}, {"reason", "invalid secret"}}}};
+            ws->sendText(response.dump());
+            return;
+        }
+
+        auto nonce = state->getNonce();
+        auto serverHash = ix::hmac(nonce, secret);
+        std::string clientHash = pdu["body"]["credentials"]["hash"];
+
+        if (appConfig.verbose)
+        {
+            std::cout << serverHash << std::endl;
+            std::cout << clientHash << std::endl;
+        }
+
+        if (serverHash != clientHash)
+        {
+            nlohmann::json response = {
+                {"action", "auth/authenticate/error"},
+                {"id", pdu.value("id", 1)},
+                {"body", {{"error", "authentication_failed"}, {"reason", "invalid hash"}}}};
+            ws->sendText(response.dump());
+            return;
+        }
+
+        nlohmann::json response = {
+            {"action", "auth/authenticate/ok"}, {"id", pdu.value("id", 1)}, {"body", {}}};
+
+        ws->sendText(response.dump());
+    }
+
+    void handlePublish(std::shared_ptr<SnakeConnectionState> state,
+                       std::shared_ptr<ix::WebSocket> ws,
+                       const nlohmann::json& pdu)
+    {
+        std::vector<std::string> channels;
+
+        auto body = pdu["body"];
+        if (body.find("channels") != body.end())
+        {
+            for (auto&& channel : body["channels"])
+            {
+                channels.push_back(channel);
+            }
+        }
+        else if (body.find("channel") != body.end())
+        {
+            channels.push_back(body["channel"]);
+        }
+        else
+        {
+            std::stringstream ss;
+            ss << "Missing channels or channel field in publish data";
+            handleError("rtm/publish", ws, pdu, ss.str());
+            return;
+        }
+
+        for (auto&& channel : channels)
+        {
+            std::stringstream ss;
+            ss << state->appkey() << "::" << channel;
+
+            std::string errMsg;
+            if (!state->redisClient().publish(ss.str(), pdu.dump(), errMsg))
+            {
+                std::stringstream ss;
+                ss << "Cannot publish to redis host " << errMsg;
+                handleError("rtm/publish", ws, pdu, ss.str());
+                return;
+            }
+        }
+
+        nlohmann::json response = {
+            {"action", "rtm/publish/ok"}, {"id", pdu.value("id", 1)}, {"body", {}}};
+
+        ws->sendText(response.dump());
+    }
+
+    //
+    // FIXME: this is not cancellable. We should be able to cancel the redis subscription
+    //
+    void handleRedisSubscription(std::shared_ptr<SnakeConnectionState> state,
+                                 std::shared_ptr<ix::WebSocket> ws,
+                                 const AppConfig& appConfig,
+                                 const nlohmann::json& pdu)
+    {
+        std::string channel = pdu["body"]["channel"];
+        std::string subscriptionId = channel;
+
+        std::stringstream ss;
+        ss << state->appkey() << "::" << channel;
+
+        std::string appChannel(ss.str());
+
+        ix::RedisClient redisClient;
+        int port = appConfig.redisPort;
+
+        auto urls = appConfig.redisHosts;
+        std::string hostname(urls[0]);
+
+        // Connect to redis first
+        if (!redisClient.connect(hostname, port))
+        {
+            std::stringstream ss;
+            ss << "Cannot connect to redis host " << hostname << ":" << port;
+            handleError("rtm/subscribe", ws, pdu, ss.str());
+            return;
+        }
+
+        std::cout << "Connected to redis host " << hostname << ":" << port << std::endl;
+
+        // Now authenticate, if needed
+        if (!appConfig.redisPassword.empty())
+        {
+            std::string authResponse;
+            if (!redisClient.auth(appConfig.redisPassword, authResponse))
+            {
+                std::stringstream ss;
+                ss << "Cannot authenticated to redis";
+                handleError("rtm/subscribe", ws, pdu, ss.str());
+                return;
+            }
+            std::cout << "Auth response: " << authResponse << ":" << port << std::endl;
+        }
+
+        int id = 0;
+        auto callback = [ws, &id, &subscriptionId](const std::string& messageStr) {
+            auto msg = nlohmann::json::parse(messageStr);
+
+            msg = msg["body"]["message"];
+
+            nlohmann::json response = {
+                {"action", "rtm/subscription/data"},
+                {"id", id++},
+                {"body", {{"subscription_id", subscriptionId}, {"messages", {msg}}}}};
+
+            ws->sendText(response.dump());
+        };
+
+        auto responseCallback = [ws, pdu, &subscriptionId](const std::string& redisResponse) {
+            std::cout << "Redis subscribe response: " << redisResponse << std::endl;
+
+            // Success
+            nlohmann::json response = {{"action", "rtm/subscribe/ok"},
+                                       {"id", pdu.value("id", 1)},
+                                       {"body", {{"subscription_id", subscriptionId}}}};
+            ws->sendText(response.dump());
+        };
+
+        std::cerr << "Subscribing to " << appChannel << "..." << std::endl;
+        if (!redisClient.subscribe(appChannel, responseCallback, callback))
+        {
+            std::stringstream ss;
+            ss << "Error subscribing to channel " << appChannel;
+            handleError("rtm/subscribe", ws, pdu, ss.str());
+            return;
+        }
+    }
+
+    void handleSubscribe(std::shared_ptr<SnakeConnectionState> state,
+                         std::shared_ptr<ix::WebSocket> ws,
+                         const AppConfig& appConfig,
+                         const nlohmann::json& pdu)
+    {
+        state->fut =
+            std::async(std::launch::async, handleRedisSubscription, state, ws, appConfig, pdu);
+    }
+
+    void handleUnSubscribe(std::shared_ptr<SnakeConnectionState> state,
+                           std::shared_ptr<ix::WebSocket> ws,
+                           const nlohmann::json& pdu)
+    {
+        // extract subscription_id
+        auto body = pdu["body"];
+        auto subscriptionId = body["subscription_id"];
+
+        state->redisClient().stop();
+
+        nlohmann::json response = {{"action", "rtm/unsubscribe/ok"},
+                                   {"id", pdu.value("id", 1)},
+                                   {"body", {{"subscription_id", subscriptionId}}}};
+        ws->sendText(response.dump());
+    }
+
+    void processCobraMessage(std::shared_ptr<SnakeConnectionState> state,
+                             std::shared_ptr<ix::WebSocket> ws,
+                             const AppConfig& appConfig,
+                             const std::string& str)
+    {
+        auto pdu = nlohmann::json::parse(str);
+        std::cout << "Got " << str << std::endl;
+
+        auto action = pdu["action"];
+        std::cout << "action = " << action << std::endl;
+
+        if (action == "auth/handshake")
+        {
+            handleHandshake(state, ws, pdu);
+        }
+        else if (action == "auth/authenticate")
+        {
+            handleAuth(state, ws, appConfig, pdu);
+        }
+        else if (action == "rtm/publish")
+        {
+            handlePublish(state, ws, pdu);
+        }
+        else if (action == "rtm/subscribe")
+        {
+            handleSubscribe(state, ws, appConfig, pdu);
+        }
+        else if (action == "rtm/unsubscribe")
+        {
+            handleUnSubscribe(state, ws, pdu);
+        }
+        else
+        {
+            std::cerr << "Unhandled action: " << action << std::endl;
+        }
+    }
+} // namespace snake

ixsnake/ixsnake/IXSnakeProtocol.h

@@ -0,0 +1,26 @@
+/*
+ *  IXSnakeProtocol.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+namespace ix
+{
+    class WebSocket;
+}
+
+namespace snake
+{
+    class SnakeConnectionState;
+    struct AppConfig;
+
+    void processCobraMessage(std::shared_ptr<SnakeConnectionState> state,
+                             std::shared_ptr<ix::WebSocket> ws,
+                             const AppConfig& appConfig,
+                             const std::string& str);
+} // namespace snake

ixsnake/ixsnake/IXSnakeServer.cpp

@@ -0,0 +1,131 @@
+/*
+ *  IXSnakeServer.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXSnakeServer.h"
+
+#include "IXAppConfig.h"
+#include "IXSnakeConnectionState.h"
+#include "IXSnakeProtocol.h"
+#include <iostream>
+#include <sstream>
+
+namespace snake
+{
+    SnakeServer::SnakeServer(const AppConfig& appConfig)
+        : _appConfig(appConfig)
+        , _server(appConfig.port, appConfig.hostname)
+    {
+        ;
+    }
+
+    //
+    // Parse appkey from this uri. Won't work if multiple args are present in the uri
+    // Uri: /v2?appkey=FC2F10139A2BAc53BB72D9db967b024f
+    //
+    std::string SnakeServer::parseAppKey(const std::string& path)
+    {
+        std::string::size_type idx;
+
+        idx = path.rfind('=');
+        if (idx != std::string::npos)
+        {
+            std::string appkey = path.substr(idx + 1);
+            return appkey;
+        }
+        else
+        {
+            return std::string();
+        }
+    }
+
+    bool SnakeServer::run()
+    {
+        std::cout << "Listening on " << _appConfig.hostname << ":" << _appConfig.port << std::endl;
+
+        auto factory = []() -> std::shared_ptr<ix::ConnectionState> {
+            return std::make_shared<SnakeConnectionState>();
+        };
+        _server.setConnectionStateFactory(factory);
+
+        _server.setOnConnectionCallback(
+            [this](std::shared_ptr<ix::WebSocket> webSocket,
+                   std::shared_ptr<ix::ConnectionState> connectionState) {
+                auto state = std::dynamic_pointer_cast<SnakeConnectionState>(connectionState);
+
+                webSocket->setOnMessageCallback(
+                    [this, webSocket, state](const ix::WebSocketMessagePtr& msg) {
+                        if (msg->type == ix::WebSocketMessageType::Open)
+                        {
+                            std::cerr << "New connection" << std::endl;
+                            std::cerr << "id: " << state->getId() << std::endl;
+                            std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                            std::cerr << "Headers:" << std::endl;
+                            for (auto it : msg->openInfo.headers)
+                            {
+                                std::cerr << it.first << ": " << it.second << std::endl;
+                            }
+
+                            std::string appkey = parseAppKey(msg->openInfo.uri);
+                            state->setAppkey(appkey);
+
+                            // Connect to redis first
+                            if (!state->redisClient().connect(_appConfig.redisHosts[0],
+                                                              _appConfig.redisPort))
+                            {
+                                std::cerr << "Cannot connect to redis host" << std::endl;
+                            }
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Close)
+                        {
+                            std::cerr << "Closed connection"
+                                      << " code " << msg->closeInfo.code << " reason "
+                                      << msg->closeInfo.reason << std::endl;
+                        }
+                        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;
+                            std::cerr << ss.str();
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Fragment)
+                        {
+                            std::cerr << "Received message fragment" << std::endl;
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Message)
+                        {
+                            std::cerr << "Received " << msg->wireSize << " bytes" << std::endl;
+                            processCobraMessage(state, webSocket, _appConfig, msg->str);
+                        }
+                    });
+            });
+
+        auto res = _server.listen();
+        if (!res.first)
+        {
+            std::cerr << res.second << std::endl;
+            return false;
+        }
+
+        _server.start();
+        return true;
+    }
+
+    void SnakeServer::runForever()
+    {
+        if (run())
+        {
+            _server.wait();
+        }
+    }
+
+    void SnakeServer::stop()
+    {
+        _server.stop();
+    }
+} // namespace snake

ixsnake/ixsnake/IXSnakeServer.h

@@ -0,0 +1,31 @@
+/*
+ *  IXSnakeServer.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXAppConfig.h"
+#include <ixwebsocket/IXWebSocketServer.h>
+#include <string>
+
+namespace snake
+{
+    class SnakeServer
+    {
+    public:
+        SnakeServer(const AppConfig& appConfig);
+        ~SnakeServer() = default;
+
+        bool run();
+        void runForever();
+        void stop();
+
+    private:
+        std::string parseAppKey(const std::string& path);
+
+        AppConfig _appConfig;
+        ix::WebSocketServer _server;
+    };
+} // namespace snake

ixsnake/ixsnake/appsConfig.json

@@ -0,0 +1,14 @@
+{
+  "apps": {
+    "FC2F10139A2BAc53BB72D9db967b024f": {
+      "roles": {
+        "_sub": {
+          "secret": "66B1dA3ED5fA074EB5AE84Dd8CE3b5ba"
+        },
+        "_pub": {
+          "secret": "1c04DB8fFe76A4EeFE3E318C72d771db"
+        }
+      }
+    }
+  }
+}