eis/eqpalg/threads/handler_exec.h

#pragma once
/**
 * @file eqpalg/threads/handler_exec.h
 * @brief 算法执行句柄
 * @author Cat (null.null.null@qq.com)
 * @version 0.1
 * @date 2021-08-18
 *
 * Copyright: Baosight Co. Ltd.
 * DO NOT COPY/USE WITHOUT PERMISSION
 *
 */
#include <boost/utility.hpp>
#include <chrono>
#include <eqpalg/alg_base.h>
#include <eqpalg/define/public.h>
#include <eqpalg/gb_logger.h>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
namespace threads {
using std::string;
using namespace baosight;
using namespace std::chrono;

/**
 * @brief 算法执行句柄
 * A 监控任务，提供报警
 * 1.实时逻辑，不累积样本，只需要进行判断
 * 2. 带有样本的规则，如果没有样本，不进行判断
 * 3.如果样本不合法（样本数据量太小、样本无法还原分布、样本不符合任何分布特征），
 * 使用之前样本的最大值-最小值判断
 *
 * B 单次任务，提供单次执行操作
 *
 * C 定时任务
 */
class HandlerExec {

private:
  static int extractCTaskNumberRegexGeneric(std::string input);

private:
  std::unique_ptr<LOG> logger_;
  std::unique_ptr<std::thread> r_thread_;

public:
  /**
   * @brief Construct a new Handler Exec object
   * @param  alg_name         算法id
   */
  HandlerExec(const string &alg_name);

  /**
   * @brief Destroy the Handler Exec object
   */
  ~HandlerExec();

public:
  /**
   * @brief 程序运行 - 包含执行任务和等待队列管理任务
   */
  std::thread::id run_thread();

  /**
   * @brief 停止运行所有当前任务，并销毁所有算法实例
   */
  int destroy() {
    is_running_ = false;
    return 0;
  }
  /**
   * @brief Get the is running object
   * @return true
   * @return false
   */
  bool get_is_running() { return is_running_; }

  /**
   * @brief 获得内部运行的算法的实例id
   * @return std::vector<std::string>
   */
  std::vector<std::string> get_rule_ids();

  /**
   * @brief 把算法实例载入到程序中
   * @param  alg_pointer      算法实例指针
   * @return int
   */
  int load(std::unique_ptr<AlgBase> &&pointer);

  /**
   * @brief 把算法实例增加到程序中
   * @param  alg_pointer      算法实例指针
   * @return int
   */
  int attach(std::unique_ptr<AlgBase> &&alg_pointer);

  /**
   * @brief 把实例从程序中移除
   * @param  ruleId          算法实例id
   * @return int
   */
  int detach(string ruleId);

  /**
   * @brief 重置统计数据，
   * 主要用于 6-累计时间
   *  7-出现次数
   * @param  ruleId           My Param doc
   * @return int
   */
  int reset(string ruleId);

  /**
   * @brief 设置算法可用性
   * @param  ruleId          算法实例指针id
   * @param  usable          可用性
   * @return int
   */
  int set_usable(string ruleId, bool usable);

  /**
   * @brief 把实例提交到程序实例中
   * @return int
   */
  int submit(std::unique_ptr<AlgBase> &&instance_ptr, TimePoint begin_time,
             TimePoint end_time);
  /**
   * @brief 当前线程的规则数
   * @return int
   */
  int size() { return this->rule_pointers_.size(); }

private:
  /**
   * @brief 程序内部对线程进行处理，一旦条件满足，则把缓存队列中的任务添加到线程
   * @return int
   */
  int event_handler();

public:
  /**
   * @brief
   * @param  ruleid      规则信息
   * @param  lb          下限
   * @param  ub          上限
   * @param  va          当前值
   * @param stime        开始时间
   * @param etime        结束时间
   */
  void update_limit_alarm(std::string ruleid, double lb, double ub, double va,
                          int64_t stime, int64_t etime);

private:
  static int instanceCount;
private:
  int alg_id_;
  bool is_running_;
  string thread_name_;
  std::unordered_map<string, std::unique_ptr<AlgBase>>
      rule_pointers_;
  std::map<string, mix_cc::time_range_t>
      time_ranges_;
  std::mutex mutex_;
  std::queue<std::unique_ptr<AlgBase>> attach_queue_;
  std::queue<std::string> detach_queue_;
  std::queue<std::string> reset_queue_;
  std::queue<std::tuple<std::string, bool>>
      usable_queue_;
  std::queue<std::tuple<std::unique_ptr<AlgBase>, mix_cc::time_range_t>>
      once_exec_queue_;

  TimePoint run_t1;
  TimePoint run_t2;
  int64_t cost_time = 0;
};

}