hikyuu 2.5.6__py3-none-macosx_11_0_arm64.whl

hikyuu/include/hikyuu/utilities/node/NodeClient.h

@@ -0,0 +1,175 @@
+/*
+ *  Copyright (c) 2022 hikyuu.org
+ *
+ *  Created on: 2022-04-25
+ *      Author: fasiondog
+ */
+
+#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>
+#include "hikyuu/utilities/datetime/Datetime.h"
+#include "NodeMessage.h"
+
+namespace hku {
+
+class NodeClient {
+public:
+    NodeClient() = default;
+
+    explicit NodeClient(const std::string& serverAddr) : m_server_addr(serverAddr) {}
+
+    virtual ~NodeClient() {
+        close();
+    }
+
+    /** 设置服务端地址 */
+    void setServerAddr(const std::string& serverAddr) {
+        m_server_addr = serverAddr;
+    }
+
+    /** 连接服务器 */
+    bool dial() noexcept {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        close();
+        // HKU_TRACE("dial: {}", m_server_addr);
+        int rv = nng_req0_open(&m_socket);
+        // HKU_ERROR_IF_RETURN(rv != 0, false, "Failed open req socket! {}", nng_strerror(rv));
+        HKU_IF_RETURN(rv != 0, false);
+        m_connected = true;
+
+        try {
+            // 设置发送结果 socket 连接参数
+            rv = nng_socket_set_ms(m_socket, NNG_OPT_RECONNMINT, 10);
+            NODE_NNG_CHECK(rv, "Failed nng_socket_set_ms!");
+
+            rv = nng_socket_set_ms(m_socket, NNG_OPT_RECONNMAXT, 15000);
+            NODE_NNG_CHECK(rv, "Failed nng_socket_set_ms!");
+
+            rv = nng_socket_set_ms(m_socket, NNG_OPT_SENDTIMEO, 10000);
+            NODE_NNG_CHECK(rv, "Failed nng_socket_set_ms!");
+
+            rv = nng_socket_set_ms(m_socket, NNG_OPT_RECVTIMEO, 10000);
+            NODE_NNG_CHECK(rv, "Failed nng_socket_set_ms!");
+
+            rv = nng_dial(m_socket, m_server_addr.c_str(), NULL, 0);
+            NODE_NNG_CHECK(rv, "Failed dial server: {}!", m_server_addr);
+
+            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);
+        }
+
+        m_connected = false;
+        nng_close(m_socket);
+        return false;
+    }
+
+    /** 关闭连接 */
+    void close() noexcept {
+        if (m_connected) {
+            nng_close(m_socket);
+            m_connected = false;
+        }
+    }
+
+    /** 当前连接状态 */
+    bool connected() const {
+        return m_connected;
+    }
+
+    /** 获取最后一次接收到服务端响应的时间 */
+    Datetime getLastAckTime() const {
+        return m_last_ack_time;
+    }
+
+    /**
+     * 发送消息
+     * @param req 发送请求消息
+     * @param res 返回响应
+     */
+    bool post(const json& req, json& res) noexcept {
+        // 保证和服务器的通信必须是 req/res 模式
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return _send(req) && _recv(res);
+    }
+
+    void showLog(bool show) {
+        m_show_log = show;
+    }
+
+private:
+    bool _send(const json& req) const noexcept {
+        bool success = false;
+        // HKU_ERROR_IF_RETURN(!m_connected, success, "Not connected!");
+        HKU_IF_RETURN(!m_connected, success);
+
+        nng_msg* msg = nullptr;
+        int rv = nng_msg_alloc(&msg, 0);
+        // HKU_ERROR_IF_RETURN(rv != 0, success, "Failed nng_msg_alloc! {}", nng_strerror(rv));
+        HKU_IF_RETURN(rv != 0, success);
+
+        try {
+            encodeMsg(msg, req);
+            rv = nng_sendmsg(m_socket, msg, 0);
+            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!");
+        }
+
+        if (!success) {
+            nng_msg_free(msg);
+        }
+
+        return success;
+    }
+
+    bool _recv(json& res) noexcept {
+        bool success = false;
+        nng_msg* msg{nullptr};
+        int rv = nng_recvmsg(m_socket, &msg, 0);
+        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!");
+        }
+
+        nng_msg_free(msg);
+        return success;
+    }
+
+private:
+    std::mutex m_mutex;
+    std::string m_server_addr;  // 服务端地址
+    nng_socket m_socket;
+    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/utilities/node/NodeError.h

@@ -0,0 +1,66 @@
+/*
+ *  Copyright (c) 2022 hikyuu.org
+ *
+ *  Created on: 2022-04-16
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <hikyuu/utilities/exception.h>
+
+namespace hku {
+
+/**
+ * 节点返回码
+ */
+enum NodeErrorCode {
+    SUCCESS = 0,
+    UNKNOWN_ERROR = 1,  ///< 未知错误
+    NNG_ERROR,          ///< nng内部错误
+    MISSING_CMD,        ///< 缺失命令
+    INVALID_CMD,        ///< 无效命令，没有相应的处理服务
+};
+
+class NodeError : public hku::exception {
+public:
+    NodeError() : NodeError(NodeErrorCode::UNKNOWN_ERROR, "Unknow error!") {}
+    NodeError(NodeErrorCode errcode, const char* errmsg)
+    : hku::exception(fmt::format("{} errcode: {}", errmsg, int(errcode))), m_errcode(errcode) {}
+    NodeError(NodeErrorCode errcode, const std::string& errmsg)
+    : hku::exception(errmsg), m_errcode(errcode) {}
+
+    NodeErrorCode errcode() const {
+        return m_errcode;
+    }
+
+private:
+    NodeErrorCode m_errcode = NodeErrorCode::UNKNOWN_ERROR;
+};
+
+class NodeNngError : public NodeError {
+public:
+    NodeNngError() = delete;
+    NodeNngError(int rv, const char* msg)
+    : NodeError(NodeErrorCode::NNG_ERROR,
+                fmt::format("{} nng error: {} (errcode: {})", msg, nng_strerror(rv), rv)) {}
+    NodeNngError(int rv, const std::string& msg)
+    : NodeError(NodeErrorCode::NNG_ERROR,
+                fmt::format("{} nng error: {} (errcode: {})", msg, nng_strerror(rv), rv)) {}
+};
+
+#define NODE_CHECK(expr, errcode, ...)                          \
+    {                                                           \
+        if (!(expr)) {                                          \
+            throw NodeError(errcode, fmt::format(__VA_ARGS__)); \
+        }                                                       \
+    }
+
+#define NODE_NNG_CHECK(rv, ...)                               \
+    {                                                         \
+        if (rv != 0) {                                        \
+            throw NodeNngError(rv, fmt::format(__VA_ARGS__)); \
+        }                                                     \
+    }
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/node/NodeMessage.h

@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2022-03-27
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <nng/nng.h>
+#include <nlohmann/json.hpp>
+#include <hikyuu/utilities/Log.h>
+#include "NodeError.h"
+
+using json = nlohmann::json;
+
+namespace hku {
+
+#define NODE_STATUS_TIMEOUT 150  ///< 节点状态超时时长（秒），超时认为连接中断
+#define NODE_STATUS_INTERVAL 60  ///< 发送状态的间隔时间（秒）（心跳）
+
+/*
+ * 消息格式
+ * req ->
+ *  {"cmd": int, ...}
+ *
+ * <- res
+ *  {"ret": code, "msg": str} // msg 存在错误时返回错误信息 （可选）
+ *
+ *
+ */
+
+/**
+ * 对消息进行解码，消息类型和消息体必须匹配
+ * @tparam T 消息体类型
+ * @param msg 消息
+ * @exception NodeErrorCode 消息类型不匹配
+ */
+inline json decodeMsg(nng_msg *msg) {
+    HKU_ASSERT(msg != nullptr);
+    size_t len = nng_msg_len(msg);
+    uint8_t *data = (uint8_t *)nng_msg_body(msg);
+    json result = json::from_msgpack(data, data + len);
+    return result;
+}
+
+/**
+ * @brief 消息编码
+ * @tparam T 消息体类型
+ * @param msg 消息
+ * @param in 编码输入
+ * @exception NodeNngError nng 操作失败
+ * @exception yas::io_exception yas 序列化异常
+ */
+inline void encodeMsg(nng_msg *msg, const json &in) {
+    HKU_ASSERT(msg != nullptr);
+    nng_msg_clear(msg);
+
+    std::vector<std::uint8_t> v = json::to_msgpack(in);
+    int rv = nng_msg_append(msg, v.data(), v.size());
+    NODE_NNG_CHECK(rv, "Failed nng_msg_append!");
+}
+
+/**
+ * 构造错误消息响应
+ * @param msg [out] 消息
+ * @param errcode 错误码
+ * @param errmsg 错误消息
+ */
+inline void errorMsg(nng_msg *msg, NodeErrorCode errcode, const std::string &errmsg) {
+    json res;
+    res["ret"] = errcode;
+    res["msg"] = errmsg;
+    encodeMsg(msg, res);
+}
+
+}  // namespace hku

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

@@ -0,0 +1,102 @@
+/*
+ * os.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-12-19
+ *      Author: fasiondog
+ *
+ *  用途：跨系统函数封装
+ *  注意：如无特殊说明，输入和输出的字符串均为 UTF8 编码
+ */
+
+#pragma once
+
+#include <string>
+#include "Null.h"
+#include "arithmetic.h"
+#include <cstdint>
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+/**
+ * 判断文件或目录是否存在
+ * @param filename 文件名或目录名
+ */
+bool HKU_UTILS_API existFile(const std::string &filename) noexcept;
+
+/**
+ * 创建目录
+ * @param pathname 路径名
+ * @return 如果目录已存在或者创建成功返回 true，否则返回 false
+ */
+bool HKU_UTILS_API createDir(const std::string &pathname) noexcept;
+
+/**
+ * 删除文件
+ * @param filename 文件名
+ * @return 删除失败或文件不存在时返回false
+ */
+bool HKU_UTILS_API removeFile(const std::string &filename) noexcept;
+
+/**
+ * 删除目录及其包含的文件和子目录
+ * @param path 待删除目录
+ */
+bool HKU_UTILS_API removeDir(const std::string &path) noexcept;
+
+/**
+ * 拷贝文件
+ * @param src 原文件
+ * @param dst 目标文件
+ * @param flush 是否立即落盘
+ */
+bool HKU_UTILS_API copyFile(const std::string &src, const std::string &dst,
+                            bool flush = false) noexcept;
+
+/**
+ * 文件、目录改名或移动
+ * @param oldname 旧名
+ * @param newname 新名
+ * @param overlay 新名文件已存在时，强制覆盖
+ * @return true 成功
+ * @return false 失败 旧名文件不存在，或文件被占用等其他原因导致的失败
+ */
+bool HKU_UTILS_API renameFile(const std::string &oldname, const std::string &newname,
+                              bool overlay = false) noexcept;
+
+/**
+ * 获取用户路径
+ */
+std::string HKU_UTILS_API getUserDir();
+
+/**
+ * 获取程序当前所在路径
+ */
+std::string HKU_UTILS_API getCurrentDir();
+
+/**
+ * 输出终端是否支持彩色控制字符
+ */
+bool HKU_UTILS_API isColorTerminal() noexcept;
+
+/**
+ * @brief 获取硬盘剩余存储空间大小
+ * @note windows下如果指定路径无效时，返回的是当前磁盘剩余空间。
+ *       某些 64 位linux下 size_t 位 32位无符号整数，这里返回值需使用 uint64_t
+ * @param path 指定路径名
+ * @return uint64_t 获取失败时，返回 Null<uint64_t>()
+ */
+uint64_t HKU_UTILS_API getDiskFreeSpace(const char *path);
+
+/** 获取当前系统名称 */
+std::string HKU_UTILS_API getPlatform();
+
+/** 获取当前CPU架构名称 */
+std::string HKU_UTILS_API getCpuArch();
+
+}  // namespace hku