eis/eqpalg/algs/exp_base.cpp

#include <eqpalg/algs/exp_base.h>
#include <eqpalg/exp_macro/get_macro_replaced_exp.h>
#include <eqpalg/table_struct/t_sample_mag.h>
#include <eqpalg/utility/build_alarm_info.h>
#include <float.h>
#include <memory>
#include <mix_cc/ihyper_db/utility.h>
#include <mix_cc/sql.h>
#include <mix_cc/sql/database/db2_t.h>
#include <mix_cc/type/mix_time.h>
#include <shm/TaskData.h>
#include <unordered_map>
#include <vector>
extern ProcessType glob_process_type;
ExpBase::ExpBase(const string &name, const mix_cc::json &rule_json,
                 const string &ruleId, size_t exp_type)
    : AlgBase(name, rule_json, ruleId), exp_type_(exp_type) {
  logger_.reset(
      new LOG("ExpBase-" + std::to_string(exp_type) + ":" + rule_name_,
              AUTO_CATCH_PID));
}
ExpBase::~ExpBase() {
}

int ExpBase::init() {

  int ret = 0;
  try {
    ret += AlgBase::init(); /*1.tag点；2.执行周期*/
    this->con_monitor_.setThreshold(100);
    // 重新载入数据源配置信息
    ret += this->reload_config_data_source(); /*3.数据源*/
    // 在载入数据源信息完成后，载入表达式配置之前，必须刷新变量，把变量信息初始化到mm_vars内
    if (glob_process_type == ProcessType::kMon ||
        glob_process_type == ProcessType::kTask) {
      ret += expr_engine_->firstFill(data_source_, now_time_, query_time_range_); /*4.数据项*/
    }

    // 必须在刷新变量后，才可以初始化表达式
    ret += this->reload_config_exp_act(); /*5.动作表达式*/
    if (feedback_mode_) {
      ret += this->reload_config_exp_feedback(); /*6.反馈表达式*/
    }

    if (exp_type_ == ExpType::Bound || exp_type_ == ExpType::CondBound ||
        exp_type_ == ExpType::BoundHoldTime) {
      ret += this->reload_config_up_down(); /*7.上下限*/
      this->reload_ci_dist();
      this->last_load_time_ = chrono::system_clock::now();
    }
    if (exp_type_ == ExpType::BoundHoldTime) {
      ret += this->reload_config_up_down_hold_time(); /*8.上下限-保持时间*/
    }
  } catch (const std::exception &e) {
    logger_->Debug() << e.what() << ".location:" << BOOST_CURRENT_LOCATION
                     << endl;
  }
  if (ret == 0) {
    this->exp_is_wrong_ = false;
  }
  return ret;
}

AlarmInfo ExpBase::exec_mon() {
  AlarmInfo out_alarm{};
  /*----规则配置参数检查----start*/
  if (this->exp_is_wrong_) {
    if (!exp_wrong_is_alarmed_) {
      std::string msg = rule_name_ + "配置参数加载异常，请检规则配置！";
      mix_cc::time_range_t time_range(chrono::system_clock::now() - 20s,
                                      chrono::system_clock::now());
      if (!this->error_code_list_.empty()) {
        for (auto item : this->error_code_list_) {
          msg +=
              ErrorCode::ErrorLocationDescription.at(int(item.error_location));
          msg += ErrorCode::ErrorTypeDescription.at(int(item.error_type));
          msg += "。";
        }
      }
      msg += this->error_message_str_;

      auto alarm_task = utility::build_alarm_info(
          MsgLevel::ERROR, rule_id_, rule_name_, "EXPACT", msg, time_range);

      if (alarm_task.alarmed) {
        last_alarm_time_ -= minutes(5);
        alarm_poster_.alarm(alarm_task, &last_alarm_time_);
      }
      exp_wrong_is_alarmed_ = true;
    }
    return out_alarm;
  }
  /*----规则配置参数检查----end*/

  /*----定时载入置信区间---错峰调用--start*/
  if (now_time_ - last_load_time_ >
      (minutes(30) + save_interval_ms_ + rule_state_update_interval_ms_)) {
    this->reload_ci_dist();
  }
  /*----定时载入置信区间-----end*/

  try {
    this->refresh_now_time();
    // 根据数据来源种类，决定最后的执行过程
    switch (data_source_) {
    // 如果是共享内存，只需要执行当前周期的数据和表达式
    // 并判断是否报警
    case DataSource::MEMORY: {
      try {
        expr_engine_->refreshFromMemory(now_time_, query_time_range_);
      } catch (const std::exception &e) {
        logger_->Error() << rule_id_ << ":refreshFromMemory()异常！"
                         << e.what() << ",location:" << BOOST_CURRENT_LOCATION
                         << endl;
        return out_alarm;
      }
      if (this->refresh_counts_ < 11) {
        /*首次载入，刷mm_vars 11次 刷新mm_vars[pv1_10]*/
        this->refresh_counts_++;
      } else {
        out_alarm = mon_proc();
      }
    } break;
    // 如果是ihyperDB
    case DataSource::IHDB:
      // 需要先重新载入ihyperDB的缓存数据
      refresh_ihd_cache();
      // 然后刷以此把缓存中的数据取出
      for (auto i = 0; i < queried_data_.rows(); i++) {
        expr_engine_->refreshFromIhdRow(i, queried_data_, queried_time_, now_time_, query_time_range_);
        if (!out_alarm.alarmed) {
          auto tmp = mon_proc();
          if (tmp.alarmed) {
            out_alarm = (tmp);
          }
        }
      }
      break;
    default:
      break;
    }
  } catch (const std::exception &e) {
    gb_logger_->log_exception(e);
  }
  return out_alarm;
}

std::vector<AlarmInfo> ExpBase::exec_task(mix_cc::time_range_t time_range) {

  std::vector<AlarmInfo> out_alarms;
  /*统计类，需要单独处理数据*/
  if (this->exp_type_ == ExpType::Bound ||
      this->exp_type_ == ExpType::CondBound ||
      this->exp_type_ == ExpType::BoundHoldTime) {
    this->refresh_counts_ = 0;
    try {
      /**
       * 1.获取样本id，数据查询时间范围，查数据
       * 2.计算参数
       * 3.存数据至 db2 T_SAMPLE_STAT表
       * 4.存样本管理 db2 T_SAMPLE_MAG
       */
      logger_->Debug()
          << "stime:"
          << mix_cc::mix_time_t(time_range.get_left()).to_formatted_time()
          << ",endtime:"
          << mix_cc::mix_time_t(time_range.get_right()).to_formatted_time()
          << endl;
      std::string sample_id = this->get_id(time_range);
      if (sta_ptr_ == nullptr) {
        logger_->Debug() << rule_name_ << " sta_ptr_ == nullptr" << endl;
        sta_ptr_ = std::make_unique<DAA::STA>(rule_id_, rule_name_);
      }

      logger_->Debug() << "reset_data()------1" << endl;
      if ((time_range.get_right() - time_range.get_left()) <
          this->query_interval_time_) {
        this->query_time_range_ = time_range;
        task_mon_pro(); /*累计数据*/
      } else {
        for (auto t = time_range.get_left(); t < time_range.get_right();
             t += query_interval_time_) {
          this->query_time_range_.set_left(t);
          if (time_range.get_right() - t > query_interval_time_) {
            this->query_time_range_.set_right(t + query_interval_time_);
          } else {
            this->query_time_range_.set_right(time_range.get_right());
          }
          task_mon_pro(); /*累计数据*/
        }
      }
      logger_->Debug() << "reset_data()------1" << endl;
      this->sta_ptr_->reset_data(); /*参数重置*/
      logger_->Debug() << "reset_data()------2" << endl;
      logger_->Debug() << "task_seq:" << task_seq << std::endl;
      auto &data_record = TaskShm::TaskRecordPtr.get()
                              ->
                              operator[](exp_type_ * 1000 + task_seq)
                              .data_record;
      logger_->Debug() << "dataSize:" << data_record.size() << std::endl;
      for (size_t j = 0; j < data_record.size(); j++) {
        double dataJ = data_record[j];
        this->sta_ptr_->dist_add(dataJ);
      }
      logger_->Debug() << "reset_data()------3" << endl;
      auto store_res = this->sta_ptr_->task_store_db2(sample_id);
      logger_->Debug() << "reset_data()------4" << endl;
      this->sample_result_ = this->sta_ptr_->get_sample_stat_str();
      this->update_t_sample_mag(store_res);
      this->alarm_poster_.zmqp_send(912, this->sample_result_);
      TaskShm::TaskRecordPtr.get()->erase(exp_type_ * 1000 + task_seq);
      logger_->Debug() << "|" << rule_id_ << "|" << rule_name_ << "|"
                       << "统计完成！info:" << sample_result_ << std::endl;
    } catch (const std::exception &e) {
      logger_->Error() << "ExpBase::exec_task:" << e.what()
                       << ",location:" << BOOST_CURRENT_LOCATION << endl;
      return out_alarms;
    }
    return out_alarms;
  }

  /*其他算法*/
  try {
    // 刷一遍 mmvar 防止p1_3数据错误带来的问题
    now_time_ = time_range.get_left() - query_interval_time_;
    if (this->delay_time_ > this->ihd_min_time_particles_ &&
        (this->delay_time_.count() % this->ihd_min_time_particles_.count() ==
         0)) {
      refresh_ihd_cache(this->delay_time_);
    } else {
      refresh_ihd_cache();
    }
    for (auto i = 0; i < queried_data_.rows(); i++) {
      expr_engine_->refreshFromIhdRow(i, queried_data_, queried_time_, now_time_, query_time_range_);
    }
    // 对每个ihdb 查询周期的数据，进行处理
    for (auto now_time = time_range.get_left();
         now_time <= time_range.get_right(); now_time += query_interval_time_) {
      this->now_time_ = now_time;
      if (this->delay_time_ > this->ihd_min_time_particles_ &&
          (this->delay_time_.count() % this->ihd_min_time_particles_.count() ==
           0)) {
        refresh_ihd_cache(this->delay_time_);
      } else {
        refresh_ihd_cache();
      }
      for (auto i = 0; i < queried_data_.rows(); i++) {
        expr_engine_->refreshFromIhdRow(i, queried_data_, queried_time_, now_time_, query_time_range_);
        auto tmp = mon_proc();
        if (tmp.alarmed) {
          out_alarms.push_back(tmp);
        }
      }
    }
    gb_logger_->log_info("本次测试报警数量：" +
                         std::to_string(out_alarms.size()));
    auto msg =
        rule_name_ + "本次测试报警数量：" + std::to_string(out_alarms.size());
    auto alarm_task = utility::build_alarm_info(
        MsgLevel::INFO, rule_id_, rule_name_, "EXPACT", msg, time_range);
    out_alarms.clear();
    out_alarms.push_back(alarm_task);
  } catch (const std::exception &e) {
    gb_logger_->log_exception(e);
  }

  return out_alarms;
}

AlarmInfo ExpBase::mon_proc() {
  // 监控基本过程
  double result_value;
  filter_flag_ = false;
  expr_engine_->autoResetFunVars();
  try {
    // 获得是否满足前提条件表达式
    result_value = expr_engine_->evaluate("act");
    if (exp_type_ == ExpType::Bound || exp_type_ == ExpType::BoundHoldTime) {
      try {
        /*有数据筛选*/
        filter_flag_ = expr_engine_->evaluateBool("feedback");
      } catch (...) {
        /*无数据筛选*/
        logger_->Debug() << "ruleid:" << rule_id_ << ",feedback evaluate ERROR!"
                         << endl;
        filter_flag_ = true;
      }
      if (is_learning_ && filter_flag_ == true) {
        rule_stat_.current_value = result_value;
        SingletonTemp<EqpStat>::GetInstance().add_stat_values(this->rule_id_,
                                                              result_value);
      }
    }

    act_triggered_ = static_cast<bool>(result_value);
    // 如果是反馈模式
    if (feedback_mode_) {
      feedback_done_ = false;
      if (act_start_done()) {
        if (rule_id_ == string(CMemVar::Const()->printRuleid)) {
          logger_->Debug() << "act_start_done!" << std::endl;
          expr_engine_->printVars();
        }
        return AlarmInfo{};
      }

      if (act_not_hold()) {
        if (rule_id_ == string(CMemVar::Const()->printRuleid)) {
          logger_->Debug()
              << "act_not_hold!---fun_vars_.refresh_fun_vars---start"
              << std::endl;
          expr_engine_->printVars();
        }
        expr_engine_->markFunVarsNeedReset();
        return AlarmInfo{};
      }
      if (act_done()) {
        feedback_done_ = true;
        this->query_time_range_.set_left(
            query_time_range_.get_right() -
            milliseconds(int(mm_vars["time"])));
        result_value = expr_engine_->evaluate("result");
        expr_engine_->markFunVarsNeedReset();
        this->rule_stat_.limit_down = limit_down_;
        this->rule_stat_.limit_up = limit_up_;
        rule_stat_.current_value = result_value;
        expr_engine_->printVars();
        logger_->Debug() << " action end:"
                         << mix_cc::mix_time_t(query_time_range_.get_right())
                                .to_formatted_time()
                         << " timediff:" << mm_vars["time"]
                         << " exp:" << exp_str_ << "=" << result_value << endl;
        if (exp_type_ == ExpType::CondBound) {
          if (this->is_learning_) {
            SingletonTemp<EqpStat>::GetInstance().add_stat_values(
                this->rule_id_, result_value);
          }
          if (this->detect_up_down(result_value)) {
            rule_stat_.alarm_value = result_value;
            std::string msg = "";
            if (m_timemode) {
              /*动作时间类*/
              msg = error_str_ + ":" + DAA::double2str(result_value) +
                    "ms,时间范围:[0," + DAA::double2str(limit_up_) + "] ms";
            } else {
              msg = error_str_ + ":" + DAA::double2str(result_value) + unit_ +
                    ",合理区间:[" + DAA::double2strLimit(limit_down_) + "," +
                    DAA::double2strLimit(limit_up_) + "]" + unit_;
            }
            logger_->Debug()
                << "报警！！！！" << msg << ",last_alarm_time_："
                << mix_cc::mix_time_t(last_alarm_time_).to_formatted_time()
                << endl;
            return utility::build_alarm_info(
                utility::get_msg_level(limit_down_, limit_up_, result_value),
                rule_id_, rule_name_, "EXP4", msg, this->get_alarm_time());
          }
        }
        else {
          if (result_value) {
            rule_stat_.alarm_value = result_value;
            std::string msg_tag = "";
            auto msg = rule_name_ + " " + error_str_ + msg_tag;
            logger_->Debug()
                << "报警！！！！" << msg << ",last_alarm_time_："
                << mix_cc::mix_time_t(last_alarm_time_).to_formatted_time()
                << endl;
            return utility::build_alarm_info(MsgLevel::ERROR, rule_id_,
                                             rule_name_, "EXP3", msg,
                                             this->get_alarm_time());
          }
        }

      } else if (act_timeout()) {
        expr_engine_->markFunVarsNeedReset();
        return this->get_timeout_alarm();
        return AlarmInfo{};
      }
    }
    //  不是动作反馈
    else {
      if (exp_type_ == ExpType::Bound) {
        if (filter_flag_ == true && this->detect_up_down(result_value)) {
          rule_stat_.alarm_value = result_value;
          auto msg = error_str_ + ":" + DAA::double2str(result_value) + unit_ +
                     ",合理区间:[" + DAA::double2strLimit(limit_down_) + "," +
                     DAA::double2strLimit(limit_up_) + "]" + unit_;
          logger_->Debug() << msg << endl;
          this->query_time_range_.set_left(query_time_range_.get_right() -
                                           delay_time_);
          expr_engine_->markFunVarsNeedReset();
          return utility::build_alarm_info(MsgLevel::ERROR, rule_id_,
                                           rule_name_, "EXP2", msg,
                                           this->get_alarm_time());
        }
      }
      else if (exp_type_ == ExpType::BoundHoldTime) {

        bool is_over_up_down =
            this->detect_up_down(result_value);
        if (!filter_flag_) {
          /*前提条件不满足*/
          act_start_time_ = this->now_time_;
          act_started_ = false;
        } else {
          /*前提条件满足*/
          /*检查范围*/
          if (is_over_up_down) {
            /*超范围*/
            if (!act_started_) {
              // 首次检测到异常，记录开始时间
              act_started_ = true;
              act_start_time_ = this->now_time_;
            }
            /*检查时间*/
            if ((hold_time_ <= delay_time_) ||
                (now_time_ - act_start_time_ > hold_time_)) {
              rule_stat_.alarm_value = result_value;
              auto msg = error_str_ + ":" + DAA::double2str(result_value) +
                         unit_ + ",合理区间:[" +
                         DAA::double2strLimit(limit_down_) + "," +
                         DAA::double2strLimit(limit_up_) + "]" + unit_;
              expr_engine_->printVars();
              this->query_time_range_.set_left(query_time_range_.get_right() -
                                               delay_time_);
              expr_engine_->markFunVarsNeedReset();
              act_start_time_ =
                  this->now_time_;
              act_started_ = false;
              return utility::build_alarm_info(
                  utility::get_msg_level(limit_down_, limit_up_, result_value),
                  rule_id_, rule_name_, "EXP5", msg, this->get_alarm_time());
            }
          } else {
            act_start_time_ = this->now_time_;
            act_started_ = false;
          }
        }
      }
      else {
        if (act_triggered_) {
          rule_stat_.alarm_value = act_triggered_;
          expr_engine_->printVars();
          auto msg = rule_name_ + " " + error_str_;
          logger_->Debug() << msg << endl;
          this->query_time_range_.set_left(query_time_range_.get_right() -
                                           delay_time_);
          expr_engine_->markFunVarsNeedReset();
          return utility::build_alarm_info(MsgLevel::ERROR, rule_id_,
                                           rule_name_, "EXP1", msg,
                                           this->get_alarm_time());
        }
      }
    }
  } catch (const std::exception &e) {
    gb_logger_->log_error("rule_name:" + rule_name_ + ",error:" + e.what());
    return AlarmInfo{};
  }
  return AlarmInfo{};
}
bool ExpBase::get_cycled_cron() {
  auto now = system_clock::now();
  if ((now - last_run_start_time_) > std::chrono::minutes(1)) {
    last_run_start_time_ = now;
  } else {
    return false;
  }
  return true;
}

mix_cc::json ExpBase::exec_cron() {
  if (this->get_cycled_cron()) {
    if (this->exp_type_ == ExpType::Bound ||
        this->exp_type_ == ExpType::CondBound ||
        this->exp_type_ == ExpType::BoundHoldTime) {
      int stat_size = this->cron_proc();
      logger_->Debug() << this->rule_name_ << ",cron 统计数据量：" << stat_size
                       << std::endl;
    }
  }
  return {};
}

bool ExpBase::act_start_done() {
  // 如果动作未开始且前提条件满足
  if (!act_started_ && act_triggered_) {
    // 则认为动作开始，并置动作开始时间为当前时间
    act_started_ = true;
    act_start_time_ = this->now_time_;
    mm_vars["stime"] =
        duration_cast<milliseconds>(now_time_.time_since_epoch()).count();
    mm_vars["time"] = 0;
    for (unsigned int i = 0; i < m_tags.size(); i++) {
      // s[n] 表示tag[n]在动作开始时刻的起始值
      mm_vars["s" + std::to_string(i + 1)] =
          mm_vars["tag" + std::to_string(i + 1)];

      // mv2 变量
      mm_vars["mx_tag" + std::to_string(i + 1)] =
          mm_vars["tag" + std::to_string(i + 1)];
      mm_vars["mi_tag" + std::to_string(i + 1)] =
          mm_vars["tag" + std::to_string(i + 1)];
      mm_vars["up_tag" + std::to_string(i + 1)] = 0;
      mm_vars["dw_tag" + std::to_string(i + 1)] = 0;
      mm_vars["mv2_tag" + std::to_string(i + 1)] = 0;
      mm_vars["mv2_p" + std::to_string(i + 1)] = 0;
      mm_vars["up_tag" + std::to_string(i + 1)] =
          0 + (int)(mm_vars["p" + std::to_string(i + 1)] == 0 &&
                    mm_vars["tag" + std::to_string(i + 1)] == 1);
      mm_vars["dw_tag" + std::to_string(i + 1)] =
          0 + (int)(mm_vars["p" + std::to_string(i + 1)] == 1 &&
                    mm_vars["tag" + std::to_string(i + 1)] == 0);
      if (mm_vars["tag" + std::to_string(i + 1)] == 1) {
        mm_vars["mv2_tag" + std::to_string(i + 1)] = 1;
      }
      if (mm_vars["p" + std::to_string(i + 1)] == 1) {
        mm_vars["mv2_p" + std::to_string(i + 1)] = 1;
      }
    }
    // 重设query time range 的 left，使得时间下限为报警的时间开始
    this->query_time_range_.set_left(now_time_);

    // 检查动作开时间条件是否错误
    logger_->Debug() << " action start:"
                     << mix_cc::mix_time_t(act_start_time_).to_formatted_time()
                     << endl;
    return true;
  } else if (!act_started_ && !act_triggered_) {
    expr_engine_->markFunVarsNeedReset();
  }
  return false;
}
int ExpBase::cron_proc() {
  int size_data = 0;
  this->refresh_now_time();
  if (exp_type_ == ExpType::Bound || exp_type_ == ExpType::CondBound ||
      exp_type_ == ExpType::BoundHoldTime) {
    /*只保存有上下限的,2-监控变量-上下限；4-动作反馈-上下限；5-监控变量-上下限-持续*/
    if (sta_ptr_ == nullptr) {
      logger_->Debug() << rule_name_ << " sta_ptr_ == nullptr" << endl;
      sta_ptr_ = std::make_unique<DAA::STA>(rule_id_, rule_name_);
      this->sta_ptr_->update_ci_dist();
      last_load_time_ = chrono::system_clock::now();
    }

    if (now_time_ - last_load_time_ > hours(CronUpdateDelay)) {
      this->sta_ptr_->update_ci_dist();
      last_load_time_ = now_time_;
    }
    this->rule_stat_.stat_values.clear();
    SingletonTemp<EqpStat>::GetInstance().get_stat_values(this->rule_id_,
                                                          this->rule_stat_);
    if (!this->rule_stat_.stat_values.empty()) {
      size_data = this->rule_stat_.stat_values.size();
      logger_->Debug() << rule_name_ << ",this->rule_stat_ size:" << size_data
                       << endl;
      if (sta_ptr_->is_init()) {
        for (int i = 0; i < size_data; i++) {
          sta_ptr_->dist_add(this->rule_stat_.stat_values[i]);
        }
      } else {
        double max_data =
            *(std::max_element(this->rule_stat_.stat_values.begin(),
                               this->rule_stat_.stat_values.end()));
        double min_data =
            *(std::min_element(this->rule_stat_.stat_values.begin(),
                               this->rule_stat_.stat_values.end()));
        double range = (max_data - min_data) / double(DAA::STA_SIZE_MIN);
        logger_->Debug() << "max:" << max_data << ",min:" << min_data
                         << ",range:" << range << endl;
        if (range < 0.1) {
          range = 0.1;
        }
        if (sta_ptr_->init(range, min_data)) {
          for (int i = 0; i < size_data; i++) {
            sta_ptr_->dist_add(this->rule_stat_.stat_values[i]);
          }
        }
      }
      logger_->Debug() << rule_name_ << ",sta_ptr_ size:" << sta_ptr_->size()
                       << endl;
      sta_ptr_->store_db2();
    }
    this->rule_stat_.stat_values.clear();
    this->rule_stat_.stat_values.shrink_to_fit();
  }
  return size_data;
}

bool ExpBase::act_not_hold() {
  // 如果动作开始，且需要保持，且动作开始没有被触发，
  if (act_started_ && keep_mode_ && !act_triggered_) {
    // 开始条件act_started置为假，即动作停止
    act_started_ = false;
    logger_->Debug() << " action signal is not holding " << endl;
    return true;
  }
  return false;
}

bool ExpBase::act_done() {
  // 如果动作已开始 刷新 mv2_tag[n]
  if (act_started_) {
    /*time ：动作开始-当前时刻 的时间*/
    mm_vars["time"] = mm_vars["now"] - mm_vars["stime"];
    for (unsigned int i = 0; i < m_tags.size(); i++) {
      mm_vars["mx_tag" + std::to_string(i + 1)] =
          std::max(mm_vars["tag" + std::to_string(i + 1)],
                   mm_vars["mx_tag" + std::to_string(i + 1)]);
      mm_vars["mi_tag" + std::to_string(i + 1)] =
          std::min(mm_vars["tag" + std::to_string(i + 1)],
                   mm_vars["mi_tag" + std::to_string(i + 1)]);
      if (mm_vars["tag" + std::to_string(i + 1)] == 1) {
        mm_vars["mv2_tag" + std::to_string(i + 1)] += 1;
      }
      if (mm_vars["p" + std::to_string(i + 1)] == 1) {
        mm_vars["mv2_p" + std::to_string(i + 1)] += 1;
      }
      mm_vars["up_tag" + std::to_string(i + 1)] +=
          (int)(mm_vars["p" + std::to_string(i + 1)] == 0 &&
                mm_vars["tag" + std::to_string(i + 1)] == 1);
      mm_vars["dw_tag" + std::to_string(i + 1)] +=
          (int)(mm_vars["p" + std::to_string(i + 1)] == 1 &&
                mm_vars["tag" + std::to_string(i + 1)] == 0);
    }
  }
  /*-----------根据最新变量，计算feedback结果-----------*/
  feedback_triggered_ = expr_engine_->evaluateBool("feedback");
  /*-----------根据最新变量，计算feedback结果-----------*/

  // 如果动作处于开始状态，且反馈模式触发
  if (act_started_ && feedback_triggered_) {
    // 则记录下结束时间
    mm_vars["etime"] = mm_vars["now"];
    act_started_ = false;
    return true;
  }
  return false;
}

// 表达式系统触发-反馈动作超时
bool ExpBase::act_timeout() {
  //-32768 无限制
  if (time_out_ == milliseconds(-32768)) {
    // 重置mv_tag 防止崩溃
    for (unsigned int i = 0; i < m_tags.size(); i++) {
      if (abs(mm_vars["mv2_tag" + std::to_string(i + 1)] - DBL_MAX) < 2.0) {
        mm_vars["mv2_tag" + std::to_string(i + 1)] = 0;
        mm_vars["mv2_p" + std::to_string(i + 1)] = 0;

        mm_vars["up_tag" + std::to_string(i + 1)] = 0;
        mm_vars["dw_tag" + std::to_string(i + 1)] = 0;

        this->logger_->Debug()
            << "mv2_tag" + std::to_string(i + 1)
            << ",up_tag" + std::to_string(i + 1)
            << ",dw_tag" + std::to_string(i + 1) << "已达上限，被清空" << endl;
        act_started_ = false;
        return true; //不再继续
      }
    }
    return false;
  }
  // 如果当动作处于开始状态 当前时间减去开始时间大于超时时间，则认为超时
  if (act_started_ && (now_time_ - act_start_time_) > time_out_) {
    act_started_ = false;
    // 超时 重置 防止崩溃
    logger_->Debug() << "动作反馈超时，mv2_tag将被重置" << endl;
    for (unsigned int i = 0; i < m_tags.size(); i++) {
      logger_->Debug() << "当前mv2_tag" << i + 1 << "="
                       << mm_vars["mv2_tag" + std::to_string(i + 1)] << endl;
      mm_vars["mv2_tag" + std::to_string(i + 1)] = 0;
      mm_vars["mv2_p" + std::to_string(i + 1)] = 0;
      mm_vars["up_tag" + std::to_string(i + 1)] = 0;
      mm_vars["dw_tag" + std::to_string(i + 1)] = 0;
    }
    return true;
  }
  return false;
}

// 得到报警超时信息
AlarmInfo ExpBase::get_timeout_alarm() {
  if (!m_timemode) {
    return AlarmInfo{};
  }
  string msg =
      rule_name_ + " 反馈超时：" + std::to_string(time_out_.count()) + " ms";
  logger_->Debug() << msg << endl;
  return utility::build_alarm_info(MsgLevel::ERROR, rule_id_, rule_name_,
                                   "EXPACT", msg, query_time_range_);
}

int ExpBase::reload_config_exp_feedback() {
  int res = 0;
  //  获取feedback信息
  if (rule_json_.at("function").at("action_start").contains("param")) {
    //是否保持
    keep_mode_ = std::stoi(rule_json_.at("function")
                               .at("action_start")
                               .at("param")
                               .at("hold")
                               .at("value")
                               .get<std::string>());
    logger_->Debug() << "keep:" << keep_mode_ << endl;
    //超时时间
    time_out_ = milliseconds(std::stoi(rule_json_.at("function")
                                           .at("action_end")
                                           .at("param")
                                           .at("timeout")
                                           .at("value")
                                           .get<std::string>()));
    logger_->Debug() << "init timeout:" << time_out_.count() << endl;
    // 如果超时时间小于3分钟，则默认为超时时间为3分钟
    if (time_out_ < minutes(3) && time_out_ != milliseconds(-32768)) {
      time_out_ = minutes(3);
    }
    logger_->Debug() << "timeout:" << time_out_.count() << endl;

    auto tmp_exp = string(rule_json_.at("function")
                              .at("action_end")
                              .at("value")
                              .get<std::string>());
    exp_str_ = get_macro_replaced_exp(tmp_exp);

    if (exp_str_ != "") {
      int reg_ret = expr_engine_->registerExpression("feedback", exp_str_);
      if (reg_ret != 0) {
        this->error_code_list_.push_back(
            {ErrorType::CalError, ErrorLocation::FBExp});
        return -1;
      }
    }

  } else {
    time_out_ = milliseconds(600000);
  }
  // 获取监控变量信息
  auto tmp_exp =
      rule_json_.at("function").at("result").at("value").get<std::string>();
  exp_str_ = get_macro_replaced_exp(tmp_exp);

  if (exp_str_ != "") {
    int reg_ret = expr_engine_->registerExpression("result", exp_str_);
    if (reg_ret != 0) {
      this->error_code_list_.push_back(
          {ErrorType::CalError, ErrorLocation::ResultExp});
      res += reg_ret;
    }
  }

  if (exp_str_.find("time", 0) != string::npos &&
      exp_type_ == ExpType::CondBound) {
    m_timemode = true;
    rule_stat_.unit = "ms";
  } else {
    m_timemode = false;
  }
  return res;
}

// 重新载入数据源配置
int ExpBase::reload_config_data_source() {
  int res = 0;
  if (!rule_json_.contains("datasource")) {
    data_source_ = 0;
    logger_->Debug()
        << "默认数据源为iHyerDB！ data source[0:iHyerDB，1:memory]："
        << data_source_ << endl;
    return 0;
  }
  try {
    data_source_ =
        std::stoi(rule_json_.at("datasource").at("value").get<std::string>());
    logger_->Debug() << "data source[0:iHyerDB，1:memory]:" << data_source_
                     << endl;
  } catch (const std::exception &e) {
    gb_logger_->log_error(std::string("ExpBase::reload_config_data_source()") +
                          e.what());
    this->error_code_list_.push_back(
        {ErrorType::Empty, ErrorLocation::DataSource});
    return -1;
  }

  return res;
}

int ExpBase::reload_config_exp_act() {
  // 根据key，对不同版本的算法都进行取值
  int res = 0;
  if (rule_json_.at("function").contains("action_start")) {
    auto tmp_exp = rule_json_.at("function")
                       .at("action_start")
                       .at("value")
                       .get<std::string>();
    exp_str_ = get_macro_replaced_exp(tmp_exp);
    feedback_mode_ = true;

  } else if (rule_json_.at("function").contains("result")) {
    if (rule_json_.at("function").contains("filter_exp")) {
      auto tmp_exp = rule_json_.at("function")
                         .at("filter_exp")
                         .at("value")
                         .get<std::string>();
      exp_str_ = get_macro_replaced_exp(tmp_exp);
      feedback_mode_ = false;
      if (exp_str_ != "") {
        int reg_ret = expr_engine_->registerExpression("feedback", exp_str_);
        if (reg_ret != 0) {
          this->error_code_list_.push_back(
              {ErrorType::CalError, ErrorLocation::FBExp});
          return -1;
        }
      } else {
        logger_->Error() << "filter_exp exp_feedback_:"
                         << "为空"
                         << ",location:" << BOOST_CURRENT_LOCATION << endl;
        this->error_code_list_.push_back(
            {ErrorType::CalError, ErrorLocation::FBExp});
        return -1;
      }
    }
    auto tmp_exp =
        rule_json_.at("function").at("result").at("value").get<std::string>();
    exp_str_ = get_macro_replaced_exp(tmp_exp);

    feedback_mode_ = false;
  }

  if (exp_str_ != "") {
    int reg_ret = expr_engine_->registerExpression("act", exp_str_);
    if (reg_ret != 0) {
      this->error_code_list_.push_back(
          {ErrorType::CalError, ErrorLocation::ActExp});
      return -1;
    }
  }
  if (rule_json_.at("output").contains("error")) {
    try {
      error_str_ =
          rule_json_.at("output").at("error").at("value").get<std::string>();
    } catch (const std::exception &e) {
      logger_->Error() << "output,error出错：" << e.what()
                       << ",location:" << BOOST_CURRENT_LOCATION << endl;
      error_message_str_ += "报警内容格式异常！";
      return -1;
    }
  }
  return 0;
}

int ExpBase::reload_config_up_down() {
  try {
    if (rule_json_.at("function").at("result").contains("param")) {
      if (rule_json_.at("function").at("result").at("param").contains("unit")) {
        unit_ = rule_json_.at("function")
                    .at("result")
                    .at("param")
                    .at("unit")
                    .at("value")
                    .get<std::string>();
      }
      rule_stat_.unit = unit_;
      limit_down_ = std::stod(rule_json_.at("function")
                                  .at("result")
                                  .at("param")
                                  .at("limit_down")
                                  .at("value")
                                  .get<std::string>());
      limit_up_ = std::stod(rule_json_.at("function")
                                .at("result")
                                .at("param")
                                .at("limit_up")
                                .at("value")
                                .get<std::string>());
      this->rule_stat_.current_value = (limit_down_ + limit_up_) / 2;
      if (-32768 == (int)limit_down_ && (int)limit_up_ != (int)limit_down_) {
        this->rule_stat_.current_value = 0;
        this->detect_mode_ = DetectMode::OnlyRight;
      } else if ((-32768 == (int)limit_up_ || 32768 == (int)limit_up_ ||
                  32767 == (int)limit_up_) &&
                 (int)limit_up_ != (int)limit_down_) {
        this->detect_mode_ = DetectMode::OnlyLeft;
        this->rule_stat_.current_value = limit_down_ + 1;
      } else if (-32768 == (int)limit_up_ &&
                 (int)limit_up_ == (int)limit_down_) {
        this->detect_mode_ = DetectMode::ErrorMode;
      }
      ///共享内存参数
      logger_->Info() << rule_name_
                      << ",detect_mode_[0-双侧，1-仅left；2-仅right；3-错误]:"
                      << detect_mode_ << ",limit_down:" << limit_down_ << ","
                      << "limit_up:" << limit_up_ << std::endl;
      this->rule_stat_.limit_down = limit_down_;
      this->rule_stat_.limit_up = limit_up_;
    }
    if (rule_json_.contains("self_learning")) {
      this->dist_mode_ = rule_json_.at("self_learning").at("mode").get<int>();
      this->is_learning_ =
          rule_json_.at("self_learning").at("is_learning").get<bool>();
      logger_->Debug() << "is_learning_:" << is_learning_ << std::endl;
    }
  } catch (const std::exception &e) {
    logger_->Error() << e.what() << ",location:" << BOOST_CURRENT_LOCATION
                     << endl;
    return -1;
  }

  return 0;
}
int ExpBase::reload_config_up_down_hold_time() {
  try {
    if (rule_json_.at("function")
            .at("result")
            .at("param")
            .contains("hold_time")) {
      hold_time_ = milliseconds(std::stoi(rule_json_.at("function")
                                              .at("result")
                                              .at("param")
                                              .at("hold_time")
                                              .at("value")
                                              .get<std::string>()));
      logger_->Info() << rule_name_ << "hold_time:" << hold_time_.count()
                      << std::endl;
    }
  } catch (const std::exception &e) {
    logger_->Error() << e.what() << ",location:" << BOOST_CURRENT_LOCATION
                     << endl;
    return -1;
  }
  return 0;
}

void ExpBase::set_last_alarm_time(TimePoint time_point) {
  this->refresh_counts_ = 0;
  if (this->is_usable_) {
    expr_engine_->firstFill(data_source_, now_time_, query_time_range_);
  }
  AlgBase::set_last_alarm_time(time_point);
}

void ExpBase::set_usable(bool usable) {
  this->refresh_counts_ = 0;
  if (this->is_usable_) {
    expr_engine_->firstFill(data_source_, now_time_, query_time_range_);
  }
  AlgBase::set_usable(usable);
}

int ExpBase::reload_ci_dist() {
  if (this->exp_type_ != ExpType::Bound &&
      this->exp_type_ != ExpType::CondBound &&
      this->exp_type_ != ExpType::BoundHoldTime) {
    return 0;
  }
  last_load_time_ = now_time_;
  if (this->dist_mode_ != 0) {
    mix_cc::float_range_t dist_range;
    if (this->dist_mode_ == DistMode::Online) {
      dist_range = DAA::STA::select_from_t_rule_feature(this->rule_id_);
    } else if (this->dist_mode_ == DistMode::Offline) {
      dist_range = DAA::STA::select_from_t_sample_mag(this->rule_id_);
    }

    if (dist_range.get_distance() == 0 ||
        dist_range.get_left() > dist_range.get_right()) {
      logger_->Error() << "区间不合法![" << dist_range.get_left() << ","
                       << dist_range.get_right() << "]" << endl;
      return -1;
    }
    this->limit_down_ = dist_range.get_left();
    this->limit_up_ = dist_range.get_right();
    this->rule_stat_.limit_down = limit_down_;
    this->rule_stat_.limit_up = limit_up_;
    this->rule_stat_.current_value =
        (this->limit_down_ + this->limit_up_) / 2;
    logger_->Info()
        << "更新置信区间，[" << dist_range.get_left() << ","
        << dist_range.get_right() << "]"
        << ",type[0-手动设置的区间;1-在线更新的区间；2-离线分析的区间]:"
        << this->dist_mode_ << endl;
  }
  return 0;
}

void ExpBase::query_ihd_data() {
  vector<string> ihd_tags = m_tags;
  auto queried_batch_maybe = mix_cc::ihd::make_query_batch_maybe(
      ihd_tags, query_time_range_, this->ihd_min_time_particles_);
  if (queried_batch_maybe.is_nothing()) {
    queried_time_.clear();
    queried_data_ = typename decltype(queried_batch_maybe)::type::Mat2d{};
    gb_logger_->log_error("Tag点没有查到相应的信息");
    return;
  }
  auto queried_bath = queried_batch_maybe.unsafe_get_just();
  auto result_maybe = mix_cc::ihd::read_data_with_time_maybe(&queried_bath);
  if (result_maybe.is_nothing()) {
    queried_time_.clear();
    queried_data_ = typename decltype(queried_batch_maybe)::type::Mat2d{};
    gb_logger_->log_error("Tag点没有查到相应的数据");
    return;
  }
  std::tie(queried_time_, queried_data_) = result_maybe.unsafe_get_just();
}

void ExpBase::task_mon_pro() {
  /*1.查数据
   *2.执行
   */
  query_ihd_data(); /*查询m_tags+运行前提条件(如果有，放置在最后一列)*/
  logger_->Debug() << rule_name_ << ",ihd size:" << queried_data_.size()
                   << endl;
  for (auto i = 0; i < queried_data_.rows(); i++) {
    expr_engine_->refreshFromIhdRow(i, queried_data_, queried_time_, now_time_, query_time_range_);
    if (this->refresh_counts_ < 3) {
      this->refresh_counts_++;
    } else {
      auto res = task_base_proc();
      if (res.is_valid && this->task_prr(i)) {
        TaskShm::TaskRecordPtr.get()
            ->
            operator[](exp_type_ * 1000 + task_seq)
            .data_record.push_back(res.value);
        this->sta_ptr_->running_stat_add(res.value);
      }
    }
  }
}
string ExpBase::get_id(mix_cc::time_range_t time_range) {
  this->sample_id_ =
      this->rule_id_.substr(3, 21) + "_" +
      std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
                         time_range.get_left().time_since_epoch())
                         .count()) +
      "_" +
      std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
                         time_range.get_right().time_since_epoch())
                         .count());
  return this->sample_id_;
}

TaskReturnType ExpBase::task_base_proc() {
  TaskReturnType task_return_data;
  double result_value = 0;
  try {
    // 获得是否满足前提条件表达式
    result_value = expr_engine_->evaluate("act");
    act_triggered_ = static_cast<bool>(result_value);
    // 检测是否是表达式-反馈模式
    if (feedback_mode_) {
      // 如果是表达式反馈-模式，检测是否满足反馈条件
      if (act_start_done() || act_not_hold()) {
        return task_return_data;
      }
      if (act_done()) {
        result_value = expr_engine_->evaluate("result");
        expr_engine_->printVars();
        // 并且数据合法
        if (!std::isnan(result_value)) {
          task_return_data.is_valid = true;
          task_return_data.value = result_value;
          return task_return_data;
        }
      } else if (act_timeout()) {
        return task_return_data;
      }
    }
    // 表达式-样本，无需反馈
    else if (!std::isnan(result_value)) {
      try {
        if (expr_engine_->evaluateBool("feedback")) {
          task_return_data.is_valid = true;
          task_return_data.value = result_value;
          logger_->Debug() << "实时值：" << result_value << endl;
          expr_engine_->printVars();
        }
      } catch (...) {
        task_return_data.is_valid = true;
        task_return_data.value = result_value;
      }

      return task_return_data;
    }

  } catch (const std::exception &e) {
    this->logger_->Error() << "ExpBase::task_base_proc():" << e.what()
                           << ",location:" << BOOST_CURRENT_LOCATION << endl;
    return task_return_data;
  }
  return task_return_data;
}

int ExpBase::update_t_sample_mag(bool vlid) {
  T_SAMPLE_MAG tsm;
  auto update_ret = exec<db2_t, size_t>(
      update(tsm)
          .set(tsm.result() = this->sample_result_,
               tsm.type() = this->sample_type_, tsm.usable() = 0,
               tsm.starttime() =
                   mix_cc::mix_time_t(this->task_time_range_.get_left()),
               tsm.endtime() =
                   mix_cc::mix_time_t(this->task_time_range_.get_right()),
               tsm.verify() = (vlid ? 1 : 3))
          .where(tsm.sampleid() = this->sample_id_,
                 tsm.ruleId() = this->rule_id_));
  if (!update_ret.is_nothing()) {
    auto res = update_ret.unsafe_get_just();
    if (res == 0) {
      auto inset_ret = exec<db2_t, size_t>(insert_into(tsm).set(
          tsm.ruleId() = this->rule_id_, tsm.result() = this->sample_result_,
          tsm.type() = this->sample_type_, tsm.sampleid() = this->sample_id_,
          tsm.usable() = 0,
          tsm.starttime() =
              mix_cc::mix_time_t(this->task_time_range_.get_left()),
          tsm.endtime() =
              mix_cc::mix_time_t(this->task_time_range_.get_right()),
          tsm.verify() = (vlid ? 1 : 3)));
      if (inset_ret.is_nothing()) {
        logger_->Error() << "T_SAMPLE_MAG,插入数据失败" << std::endl;
        return -2;
      }
    }
  } else {
    gb_logger_->log_error("T_SAMPLE_MAG 表更新失败:" + rule_name_);
    return -1;
  }

  gb_logger_->log_info(
      "T_SAMPLE_MAG更新:" + rule_name_ +
      ",vlid[true-计算成功；false-计算失败]:" + std::to_string(vlid)) +
      ",结果:" + this->sample_result_;
  return 0;
}

bool ExpBase::detect_up_down(const double &value) {
  switch (this->detect_mode_) {
  case DetectMode::Default:
    return value < this->limit_down_ || value > limit_up_;
    break;
  case DetectMode::OnlyLeft:
    return value < limit_down_;
    break;
  case DetectMode::OnlyRight:
    return value > limit_up_;
    break;
  default:
    return false;
    break;
  }
  return false;
}

bool ExpBase::task_prr(int row) {
  if (this->prr_ == 1) {
    expr_engine_->refreshFromIhdRow(row, queried_data_, queried_time_, now_time_, query_time_range_);
    bool prr_result = expr_engine_->evaluateBool("pre_result");
    return prr_result;
  }
  return true;
}

void ExpBase::reset_dev_data() {
  if (glob_process_type == ProcessType::kMon) {
    if (exp_type_ == ExpType::Bound || exp_type_ == ExpType::CondBound ||
        exp_type_ == ExpType::BoundHoldTime) {
      int res = DAA::STA::delete_statistics_data(this->rule_id_);
      if (res != 0) {
        logger_->Debug() << "DAA::STA::delete_statistics_data(this->rule_id_) "
                            "存在删除失败的表！"
                         << endl;
      }
      this->reload_config_up_down(); /*7.上下限*/
      this->reload_ci_dist();
      this->last_load_time_ = chrono::system_clock::now();
      SingletonTemp<EqpStat>::GetInstance().update_static(this->rule_id_,
                                                          false);
    }
  }
}

void ExpBase::save_rule_norm_data() {
  if (feedback_mode_ && feedback_done_ ||
      ((exp_type_ == ExpType::Bound || exp_type_ == ExpType::BoundHoldTime) &&
       filter_flag_ == true)) {
    int64_t default_lt =
        mix_cc::mix_time_t(now_time_).to_milliseconds() - 1000 * 5;
    int64_t stime = mm_vars["stime"];
    int64_t lt = std::min(default_lt, stime);
    data_info_.update(lt, mix_cc::mix_time_t(now_time_).to_milliseconds());
  } else {
    if (con_monitor_.getCurrentState()) {
      AlgBase::save_rule_norm_data();
    } else {
      /*查不到数据，无法保存*/
      data_info_.update(mix_cc::mix_time_t(now_time_).to_milliseconds(),
                        mix_cc::mix_time_t(now_time_).to_milliseconds());
    }
  }
}

bool ExpBase::get_prr() {
  if (this->prr_ == 1) {
    // 变量刷新已由 exec_mon() 中的 refreshFromMemory 完成，此处只需求值
    bool prr_result = expr_engine_->evaluateBool("pre_result");
    this->now_prr_ = prr_result;

    if (!this->now_prr_) {
      /*-------动作反馈标记-重置------*/
      this->act_started_ = false;
      this->act_triggered_ = false;
      this->feedback_triggered_ = false;
    }
    return prr_result;
  }
  now_prr_ = true;
  return true;
}