tracker.h

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
 *
 * Copyright (c) 2022, 郑昱笙，濮雯旭，张典典（牛校牛子队）
 * All rights reserved.
 */
 
#ifndef TRAKER_H
#define TRAKER_H
 
#include <iostream>
#include <mutex>
#include <thread>
#include <memory>
#include <vector>
 
#include "tracker_config.h"
#include "spdlog/spdlog.h"
 
 
class tracker_base
{
  std::jthread thread;
  std::mutex mutex;
  friend class tracker_manager;
 
 public:
  volatile bool exiting;
  virtual ~tracker_base()
  {
    stop_tracker();
    spdlog::debug("tracker_base::~tracker_base()");
  }
  virtual void start_tracker(void) = 0;
  void stop_tracker(void)
  {
    exiting = true;
    if (thread.joinable())
    {
      thread.join();
    }
  }
};
 
class prometheus_server;
 
 
template<typename ENV, typename EVENT>
class tracker_with_config : public tracker_base
{
public:
  using event = EVENT;
  using config_data = tracker_config<ENV, EVENT>;
  using tracker_event_handler = std::shared_ptr<event_handler<EVENT>>;
 
  struct prometheus_event_handler final : public event_handler<EVENT>
  {
    prometheus_event_handler(prometheus_server &server)
    {
    }
    void handle(tracker_event<EVENT> &e)
    {
    }
  };
  struct plain_text_event_printer final : public event_handler<EVENT>
  {
    void handle(tracker_event<EVENT> &e)
    {
    }
  };
  struct json_event_printer final : public event_handler<EVENT>
  {
    void handle(tracker_event<EVENT> &e)
    {
    }
  };
  struct csv_event_printer final : public event_handler<EVENT>
  {
    void handle(tracker_event<EVENT> &e)
    {
    }
  };
  tracker_config<ENV, EVENT> current_config;
  tracker_with_config(tracker_config<ENV, EVENT> config) : current_config(config)
  {
  }
 
  virtual ~tracker_with_config(){
    stop_tracker();
  }
};
 
 
template<typename TRACKER>
concept tracker_concept = requires
{
  typename TRACKER::event;
  typename TRACKER::config_data;
  typename TRACKER::tracker_event_handler;
  typename TRACKER::prometheus_event_handler;
  typename TRACKER::json_event_printer;
  typename TRACKER::plain_text_event_printer;
  typename TRACKER::csv_event_printer;
};
 
 
template<tracker_concept TRACKER, typename EVENT>
static int handle_tracker_event(void *ctx, void *data, size_t data_sz)
{
  if (!data || !ctx)
  {
    std::cout << "warn: no data or no ctx" << std::endl;
    return 0;
  }
  const EVENT &e = *(const EVENT *)data;
  TRACKER &pt = *(TRACKER *)ctx;
  auto event = tracker_event<EVENT>{ e };
  if (pt.current_config.handler)
  {
    pt.current_config.handler->do_handle_event(event);
  }
  else
  {
    std::cout << "warn: no handler for tracker event" << std::endl;
  }
  return 0;
}
 
#endif