ecflow-client-go/ecflow_util.cpp at master · cemc-oper/ecflow-client-go · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include "ecflow_util.h"
#include "json.hpp"

#include <ClientInvoker.hpp>
#include <Defs.hpp>
//#include <DState.hpp>

#include <cstring>

using json = nlohmann::json;

namespace EcflowUtil {

class EcflowClientWrapperPrivate {
public:
    EcflowClientWrapperPrivate(std::string host, std::string port) :
        host_{host}, port_{port} {
        invoker_.set_throw_on_error(false);
    }

    void setConnectTimeout(int time_out) {
        invoker_.set_connect_timeout(time_out);
    }

    int sync() {
        invoker_.set_host_port(host_, port_);
        auto sync_result = invoker_.sync_local();
        if (sync_result != 0) {
            error_message_ = invoker_.errorMsg();
        }
        return sync_result;
    }

    std::vector<NodeStatusRecord> collectStatus() {
        defs_ = invoker_.defs();

        std::vector<node_ptr> nodes;
        defs_->get_all_nodes(nodes);

        std::vector<NodeStatusRecord> records;

        NodeStatusRecord record;
        record.path_ = "/";
        record.status_ = NState::toString(defs_->state());
        records.push_back(record);

        for (auto &node: nodes) {
            NodeStatusRecord record;
            record.path_ = node->absNodePath();
            record.status_ = DState::toString(node->dstate());
            records.push_back(record);
        }

        return records;
    }

private:
    std::string host_;
    std::string port_;
    ClientInvoker invoker_;
    defs_ptr defs_;

    std::string error_message_;

    friend class EcflowClientWrapper;
};

EcflowClientWrapper::EcflowClientWrapper(const std::string &host, const std::string &port) :
    host_{host},
    port_{port},
    p_{new EcflowClientWrapperPrivate{host, port}} {

}

EcflowClientWrapper::~EcflowClientWrapper() {
    delete p_;
}

void EcflowClientWrapper::setConnectTimeout(int time_out) {
    p_->setConnectTimeout(time_out);
}

int EcflowClientWrapper::sync() {
    auto ret = p_->sync();
    if (ret != 0) {
        return ret;
    }
    status_records_ = p_->collectStatus();
    return 0;
}

std::string EcflowClientWrapper::statusRecordsJson() {
    json records_json = json::array();
    for(auto &record: status_records_) {
        json record_json;
        record_json["path"] = record.path_;
        record_json["status"] = record.status_;
        records_json.push_back(record_json);
    }
    return records_json.dump();
}

std::string EcflowClientWrapper::errorMessage() {
    return p_->error_message_;
}


} // namespace EcflowUtil