hikyuu 2.1.0__cp39-none-win_amd64.whl → 2.1.1__cp39-none-win_amd64.whl

hikyuu/include/hikyuu/{global → utilities}/node/NodeClient.h

@@ -7,6 +7,11 @@
 
 #pragma once
 
+#include "hikyuu/utilities/config.h"
+#if !HKU_ENABLE_NODE
+#error "Don't enable node client, please config with --node=y"
+#endif
+
 #include <atomic>
 #include <nng/nng.h>
 #include <nng/protocol/reqrep0/req.h>
@@ -59,13 +64,11 @@ public:
 
             return true;
 
+        } catch (const std::exception& e) {
+            HKU_ERROR_IF(m_show_log, "Failed dail server: {}! {}", m_server_addr, e.what());
         } catch (...) {
+            HKU_ERROR_IF(m_show_log, "Failed dail server: {}! Unknown error!", m_server_addr);
         }
-        // } catch (const std::exception& e) {
-        //     HKU_ERROR("Failed dail server: {}! {}", m_server_addr, e.what());
-        // } catch (...) {
-        //     HKU_ERROR("Failed dail server: {}! Unknown error!", m_server_addr);
-        // }
 
         m_connected = false;
         nng_close(m_socket);
@@ -101,6 +104,10 @@ public:
         return _send(req) && _recv(res);
     }
 
+    void showLog(bool show) {
+        m_show_log = show;
+    }
+
 private:
     bool _send(const json& req) const noexcept {
         bool success = false;
@@ -118,13 +125,11 @@ private:
             NODE_NNG_CHECK(rv, "Failed nng_sendmsg!");
             success = true;
 
+        } catch (const std::exception& e) {
+            HKU_ERROR_IF(m_show_log, "Failed send result! {}", e.what());
         } catch (...) {
+            HKU_ERROR_IF(m_show_log, "Failed send result! Unknown error!");
         }
-        // } catch (const std::exception& e) {
-        //     HKU_ERROR("Failed send result! {}", e.what());
-        // } catch (...) {
-        //     HKU_ERROR("Failed send result! Unknown error!");
-        // }
 
         if (!success) {
             nng_msg_free(msg);
@@ -137,21 +142,22 @@ private:
         bool success = false;
         nng_msg* msg{nullptr};
         int rv = nng_recvmsg(m_socket, &msg, 0);
-        // HKU_ERROR_IF_RETURN(rv != 0, success, "Failed nng_recvmsg! {}", nng_strerror(rv));
-        HKU_IF_RETURN(rv != 0, success);
+        if (rv != 0) {
+            HKU_ERROR_IF(m_show_log, "Failed nng_recvmsg! {}", nng_strerror(rv));
+            return success;
+        }
+
         m_last_ack_time = Datetime::now();
 
         try {
             res = decodeMsg(msg);
             success = true;
 
+        } catch (const std::exception& e) {
+            HKU_ERROR_IF(m_show_log, "Failed recv response! {}", e.what());
         } catch (...) {
+            HKU_ERROR_IF(m_show_log, "Failed recv response! Unknown error!");
         }
-        // } catch (const std::exception& e) {
-        //     HKU_ERROR("Failed recv response! {}", e.what());
-        // } catch (...) {
-        //     HKU_ERROR("Failed recv response! Unknown error!");
-        // }
 
         nng_msg_free(msg);
         return success;
@@ -161,8 +167,9 @@ private:
     std::mutex m_mutex;
     std::string m_server_addr;  // 服务端地址
     nng_socket m_socket;
-    std::atomic_bool m_connected{false};
     Datetime m_last_ack_time{Datetime::now()};  // 最后一次接收服务端响应的时间
+    std::atomic_bool m_connected{false};
+    std::atomic_bool m_show_log{true};
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/{global → utilities}/node/NodeError.h

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "hikyuu/exception.h"
+#include <hikyuu/utilities/exception.h>
 
 namespace hku {
 

hikyuu/include/hikyuu/{global → utilities}/node/NodeMessage.h

@@ -12,6 +12,7 @@
 #include <vector>
 #include <nng/nng.h>
 #include <nlohmann/json.hpp>
+#include <hikyuu/utilities/Log.h>
 #include "NodeError.h"
 
 using json = nlohmann::json;
@@ -26,8 +27,8 @@ namespace hku {
  * req ->
  *  {"cmd": int, ...}
  *
- * req ->
- *  {"cmd": int, "ret": code, "msg": str}
+ * <- res
+ *  {"ret": code, "msg": str} // msg 存在错误时返回错误信息 （可选）
  *
  *
  */

hikyuu/include/hikyuu/utilities/node/NodeServer.h

@@ -0,0 +1,246 @@
+/*
+ *  Copyright (c) 2022 hikyuu.org
+ *
+ *  Created on: 2022-04-15
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/utilities/config.h"
+#if !HKU_ENABLE_NODE
+#error "Don't enable node server, please config with --node=y"
+#endif
+
+#include <string>
+#include <unordered_map>
+#include <nng/nng.h>
+#include <nng/protocol/reqrep0/rep.h>
+
+#include <hikyuu/utilities/osdef.h>
+#if HKU_OS_WINDOWS
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <WS2tcpip.h>
+#include <Ws2ipdef.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#include "hikyuu/utilities/Log.h"
+#include "NodeMessage.h"
+
+namespace hku {
+
+class NodeServer {
+    CLASS_LOGGER_IMP(NodeServer)
+
+public:
+    NodeServer() = default;
+    explicit NodeServer(const std::string& addr) : m_addr(addr) {}
+    virtual ~NodeServer() {
+        stop();
+    }
+
+    void setAddr(const std::string& addr) {
+        m_addr = addr;
+    }
+
+    void regHandle(const std::string& cmd, const std::function<json(json&& req)>& handle) {
+        m_handles[cmd] = handle;
+    }
+
+    void regHandle(const std::string& cmd, std::function<json(json&& req)>&& handle) {
+        m_handles[cmd] = std::move(handle);
+    }
+
+    void start(size_t max_parrel = 128) {
+        CLS_CHECK(!m_addr.empty(), "You must set NodeServer's addr first!");
+
+        // 启动 node server
+        int rv = nng_rep0_open(&m_socket);
+        CLS_CHECK(0 == rv, "Failed open server socket! {}", nng_strerror(rv));
+        rv = nng_listen(m_socket, m_addr.c_str(), &m_listener, 0);
+        CLS_CHECK(0 == rv, "Failed listen node server socket ({})! {}", m_addr, nng_strerror(rv));
+        CLS_TRACE("channel lisenter server: {}", m_addr);
+
+        m_works.resize(max_parrel);
+        for (size_t i = 0, total = m_works.size(); i < total; i++) {
+            Work* w = &m_works[i];
+            rv = nng_aio_alloc(&w->aio, _serverCallback, w);
+            CLS_CHECK(0 == rv, "Failed create work {}! {}", i, nng_strerror(rv));
+            rv = nng_ctx_open(&w->ctx, m_socket);
+            CLS_CHECK(0 == rv, "Failed open ctx {}! {}", i, nng_strerror(rv));
+            w->state = Work::INIT;
+            w->server = this;
+        }
+
+        for (size_t i = 0, total = m_works.size(); i < total; i++) {
+            _serverCallback(&m_works[i]);
+        }
+    }
+
+    void loop() {
+        while (true) {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+    }
+
+    void stop() {
+        HKU_IF_RETURN(m_works.empty(), void());
+        for (size_t i = 0, total = m_works.size(); i < total; i++) {
+            Work* w = &m_works[i];
+            w->server = nullptr;
+            w->state = Work::FINISH;
+            if (w->aio) {
+                nng_aio_stop(w->aio);
+                nng_aio_free(w->aio);
+                nng_ctx_close(w->ctx);
+                w->aio = nullptr;
+            }
+        }
+
+        // 关闭 socket 服务节点
+        nng_listener_close(m_listener);
+        nng_close(m_socket);
+        m_works.clear();
+        CLS_INFO("stopped node server.");
+    }
+
+private:
+    struct Work {
+        enum { INIT, RECV, SEND, FINISH } state = INIT;
+        nng_aio* aio{nullptr};
+        nng_ctx ctx;
+        NodeServer* server{nullptr};
+    };
+
+    static void _serverCallback(void* arg) {
+        Work* work = static_cast<Work*>(arg);
+        int rv = 0;
+        switch (work->state) {
+            case Work::INIT:
+                work->state = Work::RECV;
+                nng_ctx_recv(work->ctx, work->aio);
+                break;
+
+            case Work::RECV:
+                _processRequest(work);
+                break;
+
+            case Work::SEND:
+                if ((rv = nng_aio_result(work->aio)) != 0) {
+                    CLS_FATAL("Failed nng_ctx_send! {}", nng_strerror(rv));
+                    work->state = Work::FINISH;
+                    return;
+                }
+                work->state = Work::RECV;
+                nng_ctx_recv(work->ctx, work->aio);
+                break;
+
+            case Work::FINISH:
+                break;
+
+            default:
+                CLS_FATAL("nng bad state!");
+                break;
+        }
+    }
+
+    static void _processRequest(Work* work) {
+        NodeServer* server = work->server;
+        CLS_IF_RETURN(!server || !work->aio, void());
+        nng_msg* msg = nullptr;
+        json res;
+
+        try {
+            int rv = nng_aio_result(work->aio);
+            HKU_CHECK(rv == 0, "Failed nng_aio_result!");
+
+            msg = nng_aio_get_msg(work->aio);
+            json req = decodeMsg(msg);
+            NODE_CHECK(req.contains("cmd"), NodeErrorCode::MISSING_CMD, "Missing command!");
+
+            // 兼容老版本数字cmd
+            std::string cmd = req["cmd"].is_number() ? fmt::format("{}", req["cmd"].get<int>())
+                                                     : req["cmd"].get<std::string>();
+            auto iter = server->m_handles.find(cmd);
+            NODE_CHECK(iter != server->m_handles.end(), NodeErrorCode::INVALID_CMD,
+                       "The server does not know how to process the message: {}", cmd);
+
+            // tcp 连接尝试获取客户端地址和端口加入 req 中
+            req["remote_host"] = "";
+            req["remote_port"] = 0;
+            nng_pipe p = nng_msg_get_pipe(msg);
+            if (nng_pipe_id(p) > 0) {
+                uint16_t port = 0;
+                nng_sockaddr ra;
+                rv = nng_pipe_get_addr(p, NNG_OPT_REMADDR, &ra);
+                if (rv == 0) {
+                    if (ra.s_family == NNG_AF_INET) {
+                        char ipAddr[INET_ADDRSTRLEN];
+                        inet_ntop(AF_INET, (void*)&ra.s_in.sa_addr, ipAddr, INET_ADDRSTRLEN);
+                        port = ntohs(ra.s_in.sa_port);
+                        req["remote_host"] = ipAddr;
+                        req["remote_port"] = port;
+                    } else if (ra.s_family == NNG_AF_INET6) {
+                        char ipAddr[INET6_ADDRSTRLEN];
+                        inet_ntop(AF_INET6, (void*)&ra.s_in.sa_addr, ipAddr, INET6_ADDRSTRLEN);
+                        port = ntohs(ra.s_in6.sa_port);
+                        req["remote_host"] = ipAddr;
+                        req["remote_port"] = port;
+                    }
+                }
+            }
+
+            res = iter->second(std::move(req));
+            res["ret"] = NodeErrorCode::SUCCESS;
+            encodeMsg(msg, res);
+
+            nng_aio_set_msg(work->aio, msg);
+            work->state = Work::SEND;
+            nng_ctx_send(work->ctx, work->aio);
+
+        } catch (const NodeNngError& e) {
+            CLS_FATAL(e.what());
+            work->state = Work::FINISH;
+
+        } catch (const NodeError& e) {
+            CLS_ERROR(e.what());
+            res["ret"] = e.errcode();
+            res["msg"] = e.what();
+            encodeMsg(msg, res);
+            nng_aio_set_msg(work->aio, msg);
+            work->state = Work::SEND;
+            nng_ctx_send(work->ctx, work->aio);
+
+        } catch (const std::exception& e) {
+            CLS_ERROR(e.what());
+            res["ret"] = NodeErrorCode::UNKNOWN_ERROR;
+            res["msg"] = e.what();
+            encodeMsg(msg, res);
+            nng_aio_set_msg(work->aio, msg);
+            work->state = Work::SEND;
+            nng_ctx_send(work->ctx, work->aio);
+
+        } catch (...) {
+            std::string errmsg = "Unknown error!";
+            CLS_ERROR(errmsg);
+            res["ret"] = NodeErrorCode::UNKNOWN_ERROR;
+            res["msg"] = errmsg;
+            nng_aio_set_msg(work->aio, msg);
+            work->state = Work::SEND;
+            nng_ctx_send(work->ctx, work->aio);
+        }
+    }
+
+private:
+    std::string m_addr;
+    nng_socket m_socket;
+    nng_listener m_listener;
+    std::vector<Work> m_works;
+    std::unordered_map<std::string, std::function<json(json&& req)>> m_handles;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/node/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/utilities/os.h

@@ -17,8 +17,8 @@
 #include "arithmetic.h"
 #include <cstdint>
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -27,27 +27,27 @@ namespace hku {
  * 判断文件或目录是否存在
  * @param filename 文件名或目录名
  */
-bool HKU_API existFile(const std::string& filename) noexcept;
+bool HKU_UTILS_API existFile(const std::string &filename) noexcept;
 
 /**
  * 创建目录
  * @param pathname 路径名
  * @return 如果目录已存在或者创建成功返回 true，否则返回 false
  */
-bool HKU_API createDir(const std::string& pathname) noexcept;
+bool HKU_UTILS_API createDir(const std::string &pathname) noexcept;
 
 /**
  * 删除文件
  * @param filename 文件名
  * @return 删除失败或文件不存在时返回false
  */
-bool HKU_API removeFile(const std::string& filename) noexcept;
+bool HKU_UTILS_API removeFile(const std::string &filename) noexcept;
 
 /**
  * 删除目录及其包含的文件和子目录
  * @param path 待删除目录
  */
-bool HKU_API removeDir(const std::string& path) noexcept;
+bool HKU_UTILS_API removeDir(const std::string &path) noexcept;
 
 /**
  * 拷贝文件
@@ -55,7 +55,8 @@ bool HKU_API removeDir(const std::string& path) noexcept;
  * @param dst 目标文件
  * @param flush 是否立即落盘
  */
-bool HKU_API copyFile(const std::string& src, const std::string& dst, bool flush = false) noexcept;
+bool HKU_UTILS_API copyFile(const std::string &src, const std::string &dst,
+                            bool flush = false) noexcept;
 
 /**
  * 文件、目录改名或移动
@@ -65,23 +66,23 @@ bool HKU_API copyFile(const std::string& src, const std::string& dst, bool flush
  * @return true 成功
  * @return false 失败 旧名文件不存在，或文件被占用等其他原因导致的失败
  */
-bool HKU_API renameFile(const std::string& oldname, const std::string& newname,
-                        bool overlay = false) noexcept;
+bool HKU_UTILS_API renameFile(const std::string &oldname, const std::string &newname,
+                              bool overlay = false) noexcept;
 
 /**
  * 获取用户路径
  */
-std::string HKU_API getUserDir();
+std::string HKU_UTILS_API getUserDir();
 
 /**
  * 获取程序当前所在路径
  */
-std::string HKU_API getCurrentDir();
+std::string HKU_UTILS_API getCurrentDir();
 
 /**
  * 输出终端是否支持彩色控制字符
  */
-bool HKU_API isColorTerminal() noexcept;
+bool HKU_UTILS_API isColorTerminal() noexcept;
 
 /**
  * @brief 获取硬盘剩余存储空间大小
@@ -90,12 +91,12 @@ bool HKU_API isColorTerminal() noexcept;
  * @param path 指定路径名
  * @return uint64_t 获取失败时，返回 Null<uint64_t>()
  */
-uint64_t HKU_API getDiskFreeSpace(const char* path);
+uint64_t HKU_UTILS_API getDiskFreeSpace(const char *path);
 
 /** 获取当前系统名称 */
-std::string HKU_API getPlatform();
+std::string HKU_UTILS_API getPlatform();
 
 /** 获取当前CPU架构名称 */
-std::string HKU_API getCpuArch();
+std::string HKU_UTILS_API getCpuArch();
 
 }  // namespace hku

hikyuu/include/hikyuu/utilities/snowflake.h

@@ -0,0 +1,110 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  The code comes from: https://github.com/sniper00/snowflake-cpp
+ *  Thanks sniper00
+ *
+ *  Create on: 2021-04-13
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <chrono>
+#include <stdexcept>
+#include <mutex>
+
+namespace hku {
+
+class snowflake_nonlock {
+public:
+    void lock() {}
+    void unlock() {}
+};
+
+template <int64_t Twepoch, typename Lock = snowflake_nonlock>
+class snowflake {
+    using lock_type = Lock;
+    static constexpr int64_t TWEPOCH = Twepoch;
+    static constexpr int64_t WORKER_ID_BITS = 5L;
+    static constexpr int64_t DATACENTER_ID_BITS = 5L;
+    static constexpr int64_t MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1;
+    static constexpr int64_t MAX_DATACENTER_ID = (1 << DATACENTER_ID_BITS) - 1;
+    static constexpr int64_t SEQUENCE_BITS = 12L;
+    static constexpr int64_t WORKER_ID_SHIFT = SEQUENCE_BITS;
+    static constexpr int64_t DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
+    static constexpr int64_t TIMESTAMP_LEFT_SHIFT =
+      SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS;
+    static constexpr int64_t SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1;
+
+    using time_point = std::chrono::time_point<std::chrono::steady_clock>;
+
+    time_point start_time_point_ = std::chrono::steady_clock::now();
+    int64_t start_millsecond_ = std::chrono::duration_cast<std::chrono::milliseconds>(
+                                  std::chrono::system_clock::now().time_since_epoch())
+                                  .count();
+
+    int64_t last_timestamp_ = -1;
+    int64_t workerid_ = 0;
+    int64_t datacenterid_ = 0;
+    int64_t sequence_ = 0;
+    lock_type lock_;
+
+public:
+    snowflake() = default;
+
+    snowflake(const snowflake&) = delete;
+
+    snowflake& operator=(const snowflake&) = delete;
+
+    void init(int64_t workerid, int64_t datacenterid) {
+        std::lock_guard<lock_type> lock(lock_);
+        if (workerid > MAX_WORKER_ID || workerid < 0) {
+            throw std::runtime_error("worker Id can't be greater than 31 or less than 0");
+        }
+
+        if (datacenterid > MAX_DATACENTER_ID || datacenterid < 0) {
+            throw std::runtime_error("datacenter Id can't be greater than 31 or less than 0");
+        }
+
+        workerid_ = workerid;
+        datacenterid_ = datacenterid;
+    }
+
+    int64_t nextid() {
+        std::lock_guard<lock_type> lock(lock_);
+        // std::chrono::steady_clock  cannot decrease as physical time moves forward
+        auto timestamp = millsecond();
+        if (last_timestamp_ == timestamp) {
+            sequence_ = (sequence_ + 1) & SEQUENCE_MASK;
+            if (sequence_ == 0) {
+                timestamp = wait_next_millis(last_timestamp_);
+            }
+        } else {
+            sequence_ = 0;
+        }
+
+        last_timestamp_ = timestamp;
+
+        return ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) |
+               (datacenterid_ << DATACENTER_ID_SHIFT) | (workerid_ << WORKER_ID_SHIFT) | sequence_;
+    }
+
+private:
+    int64_t millsecond() const {
+        auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::steady_clock::now() - start_time_point_);
+        return start_millsecond_ + diff.count();
+    }
+
+    int64_t wait_next_millis(int64_t last) const {
+        auto timestamp = millsecond();
+        while (timestamp <= last) {
+            timestamp = millsecond();
+        }
+        return timestamp;
+    }
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/string_view.h

@@ -0,0 +1,70 @@
+/*
+ *  Copyright (c) 2019~2021, hikyuu
+ *
+ *  Created on: 2021/12/16
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "cppdef.h"
+
+#if CPP_STANDARD >= CPP_STANDARD_17
+#include <string>
+#include <string_view>
+namespace hku {
+
+using std::string_view;
+
+}
+
+#else
+
+#include <string>
+#include <cstring>
+#include "Log.h"
+
+namespace hku {
+
+class string_view {
+public:
+    constexpr string_view() noexcept = default;
+
+    string_view(const char *data, std::size_t size) : _data(data), _size(size) {
+        HKU_CHECK_THROW(data, std::invalid_argument, "Input null ptr!");
+    };
+
+    string_view(const char *data) : _data(data) {  // NOSONAR
+        HKU_CHECK_THROW(data, std::invalid_argument, "Input null ptr!");
+        _size = std::strlen(data);
+    }
+
+    string_view(const std::string &str) : _data(str.data()), _size(str.size()) {}  // NOSONAR
+
+    constexpr string_view(const string_view &) noexcept = default;
+
+    string_view &operator=(const string_view &) noexcept = default;
+
+    constexpr const char &operator[](std::size_t pos) const {
+        return _data[pos];
+    }
+
+    constexpr const char *data() const noexcept {
+        return _data;
+    }
+
+    constexpr std::size_t size() const noexcept {
+        return _size;
+    }
+
+private:
+    constexpr string_view(std::nullptr_t) = delete;
+
+private:
+    const char *_data = nullptr;
+    std::size_t _size = 0;
+};
+
+}  // namespace hku
+
+#endif

hikyuu/include/hikyuu/utilities/thread/MQStealThreadPool.h

@@ -22,8 +22,8 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #endif
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -35,7 +35,7 @@ namespace hku {
 #ifdef _MSC_VER
 class MQStealThreadPool {
 #else
-class HKU_API MQStealThreadPool {
+class HKU_UTILS_API MQStealThreadPool {
 #endif
 public:
     /**

hikyuu/include/hikyuu/utilities/thread/MQThreadPool.h

@@ -23,8 +23,8 @@
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #endif
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -38,7 +38,7 @@ namespace hku {
 #ifdef _MSC_VER
 class MQThreadPool {
 #else
-class HKU_API MQThreadPool {
+class HKU_UTILS_API MQThreadPool {
 #endif
 public:
     /**