ws.hpp

/*
 *  Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 *  SPDX-License-Identifier: MIT
 *
 *  Copyright (c) 2020-2021 Bhumit Attarde
 *
 *  Permission is hereby  granted, free of charge, to any  person obtaining a
 * copy of this software and associated  documentation files (the "Software"),
 * to deal in the Software  without restriction, including without  limitation
 * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
 * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom the
 * Software  is furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
 * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
 * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
 * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
 * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
#pragma once
 
#include <algorithm> //reverse
#include <atomic>
#include <chrono>
#include <cstdint>
#include <cstring> //memcpy
#include <functional>
#include <ios>
#include <iostream>
#include <limits>
#include <string>
#include <thread>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "../exceptions.hpp"
#include "../responses/responses.hpp"
#include "../userconstants.hpp" //modes
#include "../utils.hpp"
 
#include "rapidjson/include/rapidjson/document.h"
#include "rapidjson/include/rapidjson/rapidjson.h"
#include "rapidjson/include/rapidjson/writer.h"
#include <uWS/uWS.h>
 
namespace kiteconnect {
 
// To make sure doubles are parsed correctly
static_assert(std::numeric_limits<double>::is_iec559,
    "Requires IEEE 754 floating point!");
 
using std::string;
namespace kc = kiteconnect;
 
class ticker {
 
  public:
    // callbacks
    std::function<void(ticker* ws)> onConnect;
 
    std::function<void(ticker* ws, const std::vector<kc::tick>& ticks)> onTicks;
 
    std::function<void(ticker* ws, const kc::postback& postback)> onOrderUpdate;
 
    std::function<void(ticker* ws, const string& message)> onMessage;
 
    std::function<void(ticker* ws, int code, const string& message)> onError;
 
    std::function<void(ticker* ws)> onConnectError;
 
    std::function<void(ticker* ws, unsigned int attemptCount)> onTryReconnect;
 
    std::function<void(ticker* ws)> onReconnectFail;
 
    std::function<void(ticker* ws, int code, const string& message)> onClose;
 
    explicit ticker(string Key,
        unsigned int ConnectTimeout = DEFAULT_CONNECT_TIMEOUT,
        bool EnableReconnect = false,
        unsigned int MaxReconnectDelay = DEFAULT_MAX_RECONNECT_DELAY,
        unsigned int MaxReconnectTries = DEFAULT_MAX_RECONNECT_TRIES);
 
    void setApiKey(const string& key);
 
    string getApiKey() const;
 
    void setAccessToken(const string& token);
 
    string getAccessToken() const;
 
    void connect();
 
    bool isConnected() const;
 
    std::chrono::time_point<std::chrono::system_clock> getLastBeatTime() const;
 
    void run();
 
    void stop();
 
    void subscribe(const std::vector<int>& instrumentTokens);
 
    void unsubscribe(const std::vector<int>& instrumentTokens);
 
    void setMode(const string& mode, const std::vector<int>& instrumentTokens);
 
  private:
    friend class tickerTest_binaryParsingTest_Test;
    const string connectUrlFmt =
        "wss://ws.kite.trade/?api_key={0}&access_token={1}";
    string key;
    string token;
    enum class SEGMENTS : int
    {
        NSE = 1,
        NFO,
        CDS,
        BSE,
        BFO,
        BSECDS,
        MCX,
        MCXSX,
        INDICES
    };
    enum class MODES
    {
        LTP,
        QUOTE,
        FULL
    };
    const MODES DEFAULT_MODE = MODES::QUOTE;
    std::unordered_map<int, MODES> subbedInstruments;
    uWS::Hub hub;
    // NOLINTNEXTLINE(readability-implicit-bool-conversion)
    uWS::Group<uWS::CLIENT>* group;
    // NOLINTNEXTLINE(readability-implicit-bool-conversion)
    uWS::WebSocket<uWS::CLIENT>* ws = nullptr;
    static constexpr unsigned int DEFAULT_CONNECT_TIMEOUT = 5;      // s
    static constexpr unsigned int DEFAULT_MAX_RECONNECT_DELAY = 60; // s
    static constexpr unsigned int DEFAULT_MAX_RECONNECT_TRIES = 30;
    const unsigned int connectTimeout = DEFAULT_CONNECT_TIMEOUT; // ms
    const string pingMessage;
    const unsigned int pingInterval = 3000; // ms
    const bool enableReconnect = false;
    const unsigned int initReconnectDelay = 2; // s
    unsigned int reconnectDelay = initReconnectDelay;
    const unsigned int maxReconnectDelay = DEFAULT_MAX_RECONNECT_DELAY; // s
    unsigned int reconnectTries = 0;
    const unsigned int maxReconnectTries = DEFAULT_MAX_RECONNECT_TRIES;
    std::atomic<bool> isReconnecting { false };
    std::chrono::time_point<std::chrono::system_clock> lastPongTime;
    std::chrono::time_point<std::chrono::system_clock> lastBeatTime;
 
    void connectInternal();
 
    void reconnect();
 
    void processTextMessage(const string& message);
 
    template <typename T>
    T unpack(const std::vector<char>& bytes, size_t start, size_t end);
 
    std::vector<std::vector<char>> splitPackets(const std::vector<char>& bytes);
 
    std::vector<kc::tick> parseBinaryMessage(char* bytes, size_t size);
 
    void resubInstruments();
 
    void assignCallbacks();
};
} // namespace kiteconnect