refine codes.

scheduler/schedule.cpp

@@ -8,6 +8,8 @@
 #include <iomanip>
 #include <json/json.h>
 #include <zlog.h>
+#include "short_addr_cfg.hpp"
+#include "update_cfg.hpp"
 
 extern zlog_category_t *zct;
 extern zlog_category_t *zbt;
@@ -27,13 +29,6 @@ int SensorScheduler::WriteScheduleCfg(long &ts, std::string &world_time) {
     root["available_slice"] = available_slice_;
     root["free_slice"] = free_slice_;
     root["support_modification"] = true;
-//    int total_eigen_value_send_duration = eigen_value_send_duration_ * max_sensor_num_;
-//    int rest_duration = eigen_value_send_interval_ - total_eigen_value_send_duration;
-//    int slice_per_eigen_value_interval = rest_duration / wave_form_send_duration_;
-//    int seconds_per_slice = rest_duration / slice_per_eigen_value_interval;
-
-//    int num = wave_form_send_interval_ / eigen_value_send_interval_;
-//    long current_period_start = ts;
    
     int *slice_allocation = new int[available_slice_];
     int slice_index = 0; // 有时间片的索引
@@ -96,7 +91,6 @@ SensorScheduler::SensorScheduler() {
         free_slice_ = root["free_slice"].asInt();
         support_modification_ = root["support_modification"].asBool(); 
 
-//        size_t id_num = root["id"].size();
         const Json::Value ids = root["id"];
         int sensor_id = 0;        
         int i = 0;
@@ -128,101 +122,13 @@ SensorScheduler::SensorScheduler() {
     }
 
     short_addr_map_.clear();
-    std::ifstream base_relation_file(BASE_RELATION);
+    ShortAddrCfg::ReadCfg(short_addr_map_);    
-    if (base_relation_file.good()) {
-        Json::Reader reader;
-        Json::Value root;
-        if (!reader.parse(base_relation_file, root, false)) {
-            zlog_error(zbt, "invalid format, fail to parse %s", BASE_RELATION);
-            base_relation_file.close();
-            return;
-        }
-        base_relation_file.close();
-        if (!root.isArray()) {
-            zlog_error(zbt, "invalid format, not an array: %s", BASE_RELATION);
-            return;
-        }
-        if (root.size() == 0) {
-            zlog_info(zbt, "no element in %s", BASE_RELATION);
-            return;
-        }
-
-//        size_t sensor_num = root.size();
-        uint16_t short_addr;
-        int index = 0;       
-        
-        for (const auto &item : root) {
-            short_addr = item["short_addr"].asInt();
-            index = item["id"].asInt();
-            zlog_info(zbt, "index:%d, short addr:%d", index, short_addr);
-            short_addr_map_[short_addr] = index;
-        }
-    }
 
     // read upgrade config file: UPGRADE_CONFIG
-    std::ifstream upgrade_file(UPGRADE_CONFIG);
+    UpgradeCfg::ReadCfg(upgrade_);    
-    if (upgrade_file.good()) {
-        Json::Reader reader;
-        Json::Value root;
-        if (!reader.parse(upgrade_file, root, false)) {
-            zlog_error(zbt, "invalid format, fail to parse %s", UPGRADE_CONFIG);
-            upgrade_file.close();
-            return;
-        }
-        upgrade_file.close();
-        if (!root.isArray()) {
-            zlog_error(zbt, "invalid format, not an array: %s", UPGRADE_CONFIG);
-            return;
-        }
-        if (root.size() > 0) {
-            zlog_info(zbt, "element in %s", UPGRADE_CONFIG);
-            UpgradeInfo info;
-            for (const auto &item : root) {
-                info.try_times = item["try_times"].asInt();
-                info.sensor_type = item["type"].asString();
-                info.hw_version = item["hw_version"].asInt();
-                info.current_sw_version = item["current_sw_version"].asString();
-                info.upgrade_sw_version = item["upgrade_sw_version"].asString();
-                info.submit_time = item["submit_time"].asString();
-                for (const auto &time_item : item["try_world_time"]) {
-                    info.try_world_time1.push_back(time_item.asString());
-                }
-                upgrade_[item["id"].asInt()] = info;
-                zlog_info(zbt, "id:%d need to upgrade from:%s to %s", item["id"].asInt(), 
-                        info.current_sw_version.c_str(), info.upgrade_sw_version.c_str());
-            }            
-        }
-    }
 
     // read config update file: CONFIG_UPDATE
-    std::ifstream config_update_file(CONFIG_UPDATE);
+    UpdateCfg::ReadCfg(update_);    
-    if (config_update_file.good()) {
-        Json::Reader reader;
-        Json::Value root;
-        if (!reader.parse(config_update_file, root, false)) {
-            zlog_error(zbt, "invalid format, fail to parse %s", CONFIG_UPDATE);
-            config_update_file.close();
-            return;
-        }
-        config_update_file.close();
-        if (!root.isArray()) {
-            zlog_error(zbt, "invalid format, not an array: %s", CONFIG_UPDATE);
-            return;
-        }
-        if (root.size() > 0) {
-            zlog_info(zbt, "element in %s", CONFIG_UPDATE);
-            for (const auto &item : root) {
-                update_.insert(item.asInt());
-                zlog_info(zbt, "sensor id:%d need to update", item.asInt());
-            }            
-        }
-    }
-}
-
-int SensorScheduler::Init()
-{
-    // 读入schedule.json文件
-    return 0;
 }
 
 int SensorScheduler::GetNextDuration(int short_addr) {
@@ -326,24 +232,9 @@ int SensorScheduler::GetAvailableId(int short_addr) {
             break;
         }
     }
-    zlog_warn(zct, "[GetAvailableId][%d] pan id : %d", available_id, short_addr);
+    zlog_warn(zct, "[GetAvailableId][%d] short addr : %d", available_id, short_addr);
-    Json::Value root;
-    Json::Value item;
-    item["id"] = available_id;
-    item["short_addr"] = short_addr;
-    root.append(item);
-
-    for (auto it = short_addr_map_.begin(); it != short_addr_map_.end(); ++it) {
-        Json::Value item;
-        item["id"] = it->second;
-        item["short_addr"] = it->first;
-        root.append(item);
-    }
-    Json::StyledStreamWriter streamWriter;
-    std::ofstream out_file(BASE_RELATION);
-    streamWriter.write(out_file, root);
-    out_file.close();
     short_addr_map_[short_addr] = available_id;
+    ShortAddrCfg::WriteCfg(short_addr_map_);
     return available_id;
 }
 
@@ -563,7 +454,7 @@ int SensorScheduler::UpdateSensorConfig(int short_addr) {
         return 0;
     }
     update_.insert(id);    
-    UpdateConfigFile();        
+    UpdateCfg::WriteCfg(update_);     
     return 0; 
 }
 
@@ -579,9 +470,9 @@ int SensorScheduler::UpdateConfigResult(int short_addr, int result) {
     if (result != 0) {
         return 0;
     }
-
+    zlog_info(zbt, "[%d] short addr:%d update successfully", id, short_addr);
     update_.erase(id);
-    UpdateConfigFile();
+    UpdateCfg::WriteCfg(update_);
     return 0; 
 }
 
@@ -604,7 +495,8 @@ int SensorScheduler::UpgradeSensor(int short_addr, std::string sensor_type, int
     long ts = GetLocalTs();
     info.submit_time = GetUTCTime(ts);
     upgrade_[id] = info;
-    UpdateUpgradeFile();
+    zlog_info(zbt, "[%d] short addr:%d add upgrade info", id, short_addr);
+    UpgradeCfg::WriteCfg(upgrade_);
     return 0; 
 }
 
@@ -623,13 +515,14 @@ int SensorScheduler::UpgradeResult(int short_addr, int result) {
         result == kZigbeeHWMismatch || 
         result == kUpgradeDoneBefore) {
         upgrade_.erase(id);
-        UpdateUpgradeFile();
+        zlog_info(zbt, "[%d] short addr:%d upgrade successfully", id, short_addr);
+        UpgradeCfg::WriteCfg(upgrade_);
     } else {
         auto upgrade_iter = upgrade_.find(id);
         if (upgrade_iter->second.try_times >= 10) {
             zlog_error(zct, "[%d] short addr:%d upgrade 10 time failure", id, short_addr);
             upgrade_.erase(id);
-            UpdateUpgradeFile();
+            UpgradeCfg::WriteCfg(upgrade_);
             // TODO: call interface to write into database
         }
     }
@@ -667,45 +560,10 @@ std::string SensorScheduler::GetUTCTime(long ts) {
     return world_time;
 }
 
-void SensorScheduler::UpdateConfigFile() {
-    Json::Value root;
-    for (auto item : update_) {
-        root.append(item);
-    }
-    Json::StyledStreamWriter streamWriter;
-    std::ofstream out_file(CONFIG_UPDATE);
-    streamWriter.write(out_file, root);
-    out_file.close();
-}
-
 void SensorScheduler::UpdateUpgradeInfo(int id) {
     auto upgrade_iter = upgrade_.find(id);
     upgrade_iter->second.try_times++;
     long ts = GetLocalTs();
     upgrade_iter->second.try_world_time1.push_back(GetUTCTime(ts));
-    UpdateUpgradeFile();
+    UpgradeCfg::WriteCfg(upgrade_);
-}
-
-void SensorScheduler::UpdateUpgradeFile() {
-    Json::Value root;        
-    for (auto item : upgrade_) {
-        Json::Value upgrade_item;
-        upgrade_item["id"] = item.first;
-        upgrade_item["try_times"] = item.second.try_times;
-        upgrade_item["type"] = item.second.sensor_type;
-        upgrade_item["hw_version"] = item.second.hw_version;
-        upgrade_item["current_sw_version"] = item.second.current_sw_version;
-        upgrade_item["upgrade_sw_version"] = item.second.upgrade_sw_version;
-        upgrade_item["submit_time"] = item.second.submit_time;
-        Json::Value try_world_time;
-        for (auto entry : item.second.try_world_time1) {
-            try_world_time.append(entry);
-        }
-        upgrade_item["try_world_time"] = try_world_time;
-        root.append(upgrade_item);
-    }
-    Json::StyledStreamWriter streamWriter;
-    std::ofstream out_file(UPGRADE_CONFIG);
-    streamWriter.write(out_file, root);
-    out_file.close();
 }

scheduler/schedule.hpp

@@ -7,12 +7,9 @@
 #include <vector>
 #include <stdint.h>
 #include <boost/container/detail/singleton.hpp>
+#include "upgrade_cfg.hpp"
 
-#define SCHEDULE_CONFIG "./schedule.json"
+#define SCHEDULE_CONFIG "/opt/configenv/schedule.json"
-#define BASE_RELATION   "./base_relation.json"
-#define CONFIG_UPDATE   "./config_update.json"
-#define UPGRADE_CONFIG  "./upgrade.json"
-
 
 typedef enum {
     kScheduleResultNone = 0,
@@ -33,20 +30,9 @@ typedef enum {
     kUpgradeDoneBefore = 5 // 当前就是这个版本，不需要升级了
 } FirmFileCheckResult;
 
-typedef struct {
-    int try_times;
-    std::string sensor_type;
-    int hw_version;
-    std::string current_sw_version;
-    std::string upgrade_sw_version;
-    std::string submit_time;
-    std::vector<std::string> try_world_time1;
-} UpgradeInfo;
-
 class SensorScheduler {
 public:
     SensorScheduler();    
-    int Init();
 
     // kScheduleConfigSensor  kScheduleUpgrade 等有结果，调我接口通知结果
     // kScheduleEigenValue kScheduleWaveForm
@@ -110,7 +96,6 @@ public:
 private:
     void UpdateUpgradeInfo(int id);
     void UpdateUpgradeFile();
-    void UpdateConfigFile();
 
     // user config
     int eigen_value_send_interval_;

scheduler/short_addr_cfg.cpp

@@ -0,0 +1,55 @@
+#include "short_addr_cfg.hpp"
+#include <json/json.h>
+#include <zlog.h>
+
+extern zlog_category_t *zct;
+extern zlog_category_t *zbt;
+
+int ShortAddrCfg::ReadCfg(std::map<uint16_t, int>& short_addr_map) {
+    std::ifstream base_relation_file(BASE_RELATION);
+    if (!base_relation_file.good()) {
+        zlog_info(zbt, "[ShortAddrCfg] no file %s", BASE_RELATION);
+        return 0;
+    }
+    Json::Reader reader;
+    Json::Value root;
+    if (!reader.parse(base_relation_file, root, false)) {
+        zlog_error(zbt, "[ShortAddrCfg] invalid format, fail to parse %s", BASE_RELATION);
+        base_relation_file.close();
+        return;
+    }
+    base_relation_file.close();
+    if (!root.isArray()) {
+        zlog_error(zbt, "[ShortAddrCfg] invalid format, not an array: %s", BASE_RELATION);
+        return;
+    }
+    if (root.size() == 0) {
+        zlog_info(zbt, "[ShortAddrCfg] no element in %s", BASE_RELATION);
+        return;
+    }
+
+    uint16_t short_addr;
+    int index = 0;       
+    
+    for (const auto &item : root) {
+        short_addr = item["short_addr"].asInt();
+        index = item["id"].asInt();
+        zlog_info(zbt, "[ShortAddrCfg] index:%d, short addr:%d", index, short_addr);
+        short_addr_map[short_addr] = index;
+    }    
+    return 0; 
+}
+
+int ShortAddrCfg::WriteCfg(std::map<uint16_t, int> &short_addr_map) { 
+    Json::Value root; 
+    for (auto it = short_addr_map.begin(); it != short_addr_map.end(); ++it) {
+        Json::Value item;
+        item["id"] = it->second;
+        item["short_addr"] = it->first;
+        root.append(item);
+    }
+    Json::StyledStreamWriter streamWriter;
+    std::ofstream out_file(BASE_RELATION);
+    streamWriter.write(out_file, root);
+    return 0; 
+}

scheduler/short_addr_cfg.hpp

@@ -0,0 +1,14 @@
+#ifndef SHORT_ADDR_CFG_HPP_
+#define SHORT_ADDR_CFG_HPP_
+#include <stdint.h>
+#include <map>
+
+#define BASE_RELATION   "/opt/configenv/base_relation.json"
+
+class ShortAddrCfg {
+public:
+    static int ReadCfg(std::map<uint16_t, int> &short_addr_map);
+    static int WriteCfg(std::map<uint16_t, int> &short_addr_map);
+};
+
+#endif // SHORT_ADDR_CFG_HPP_

scheduler/update_cfg.cpp

@@ -0,0 +1,47 @@
+#include "update_cfg.hpp"
+#include <json/json.h>
+#include <zlog.h>
+
+extern zlog_category_t *zct;
+extern zlog_category_t *zbt;
+
+int UpdateCfg::ReadCfg(std::unordered_set<int>& update) {
+    std::ifstream config_update_file(CONFIG_UPDATE);
+    if (!config_update_file.good()) {
+        zlog_info(zbt, "[UpdateCfg] no file");
+        return 0;
+    }
+    Json::Reader reader;
+    Json::Value root;
+    if (!reader.parse(config_update_file, root, false)) {
+        zlog_error(zbt, "[UpdateCfg] invalid format, fail to parse %s", CONFIG_UPDATE);
+        config_update_file.close();
+        return 1;
+    }
+    config_update_file.close();
+    if (!root.isArray()) {
+        zlog_error(zbt, "[UpdateCfg] invalid format, not an array: %s", CONFIG_UPDATE);
+        return 2;
+    }
+    if (root.size() > 0) {
+        zlog_info(zbt, "[UpdateCfg] element in %s", CONFIG_UPDATE);
+        for (const auto &item : root) {
+            update.insert(item.asInt());
+            zlog_info(zbt, "[UpdateCfg] sensor id:%d need to update", item.asInt());
+        }            
+    }
+    
+    return 0; 
+}
+
+int UpdateCfg::WriteCfg(std::unordered_set<int> &update) { 
+    Json::Value root;
+    for (auto item : update) {
+        root.append(item);
+    }
+    Json::StyledStreamWriter streamWriter;
+    std::ofstream out_file(CONFIG_UPDATE);
+    streamWriter.write(out_file, root);
+    out_file.close();
+    return 0; 
+}

scheduler/update_cfg.hpp

@@ -0,0 +1,14 @@
+#ifndef UPDATE_CFG_HPP_
+#define UPDATE_CFG_HPP_
+#include <unordered_set>
+
+#define CONFIG_UPDATE   "/opt/configenv/config_update.json"
+
+class UpdateCfg {
+public:
+    static int ReadCfg(std::unordered_set<int> &update);
+    static int WriteCfg(std::unordered_set<int> &update);
+};
+
+
+#endif // UPDATE_CFG_HPP_

scheduler/upgrade_cfg.cpp

@@ -0,0 +1,75 @@
+#include "upgrade_cfg.hpp"
+#include <json/json.h>
+#include <zlog.h>
+
+extern zlog_category_t *zct;
+extern zlog_category_t *zbt;
+
+int UpgradeCfg::ReadCfg(std::map<int, UpgradeInfo> &upgrade) {
+    std::ifstream upgrade_file(UPGRADE_CONFIG);
+    if (!upgrade_file.good()) {
+        zlog_info(zbt, "[UpgradeCfg] no such file");
+        return 0;
+    }
+
+    Json::Reader reader;
+    Json::Value root;
+    if (!reader.parse(upgrade_file, root, false)) {
+        zlog_error(zbt, "[UpgradeCfg] invalid format, fail to parse %s", UPGRADE_CONFIG);
+        upgrade_file.close();
+        return 1;
+    }
+    upgrade_file.close();
+    if (!root.isArray()) {
+        zlog_error(zbt, "[UpgradeCfg] invalid format, not an array: %s", UPGRADE_CONFIG);
+        return 2;
+    }
+
+    if (root.size() == 0) {
+        zlog_info(zbt, "[UpgradeCfg] no element");
+        return 0;
+    }
+    
+    UpgradeInfo info;
+    for (const auto &item : root) {
+        info.try_times = item["try_times"].asInt();
+        info.sensor_type = item["type"].asString();
+        info.hw_version = item["hw_version"].asInt();
+        info.current_sw_version = item["current_sw_version"].asString();
+        info.upgrade_sw_version = item["upgrade_sw_version"].asString();
+        info.submit_time = item["submit_time"].asString();
+        for (const auto &time_item : item["try_world_time"]) {
+            info.try_world_time1.push_back(time_item.asString());
+        }
+        upgrade[item["id"].asInt()] = info;
+        zlog_info(zbt, "[UpgradeCfg] id:%d need to upgrade from:%s to %s", item["id"].asInt(), 
+                info.current_sw_version.c_str(), info.upgrade_sw_version.c_str());
+    }            
+    
+    return 0; 
+}
+
+int UpgradeCfg::WriteCfg(std::map<int, UpgradeInfo> &upgrade) {
+    Json::Value root;        
+    for (auto item : upgrade) {
+        Json::Value upgrade_item;
+        upgrade_item["id"] = item.first;
+        upgrade_item["try_times"] = item.second.try_times;
+        upgrade_item["type"] = item.second.sensor_type;
+        upgrade_item["hw_version"] = item.second.hw_version;
+        upgrade_item["current_sw_version"] = item.second.current_sw_version;
+        upgrade_item["upgrade_sw_version"] = item.second.upgrade_sw_version;
+        upgrade_item["submit_time"] = item.second.submit_time;
+        Json::Value try_world_time;
+        for (auto entry : item.second.try_world_time1) {
+            try_world_time.append(entry);
+        }
+        upgrade_item["try_world_time"] = try_world_time;
+        root.append(upgrade_item);
+    }
+    Json::StyledStreamWriter streamWriter;
+    std::ofstream out_file(UPGRADE_CONFIG);
+    streamWriter.write(out_file, root);
+    out_file.close(); 
+    return 0; 
+}

scheduler/upgrade_cfg.hpp

@@ -0,0 +1,25 @@
+#ifndef UPGRADE_CFG_HPP_
+#define UPGRADE_CFG_HPP_
+#include <string>
+#include <vector>
+#include <map>
+
+#define UPGRADE_CONFIG  "/opt/configenv/upgrade.json"
+
+typedef struct {
+    int try_times;
+    std::string sensor_type;
+    int hw_version;
+    std::string current_sw_version;
+    std::string upgrade_sw_version;
+    std::string submit_time;
+    std::vector<std::string> try_world_time1;
+} UpgradeInfo;
+
+class UpgradeCfg {
+public:
+    static int ReadCfg(std::map<int, UpgradeInfo> &upgrade);
+    static int WriteCfg(std::map<int, UpgradeInfo> &upgrade);
+};
+
+#endif // UPGRADE_CFG_HPP_