474 lines
13 KiB
C++
474 lines
13 KiB
C++
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <mutex>
|
|
#include <condition_variable>
|
|
#include <map>
|
|
#include <thread>
|
|
#include <algorithm>
|
|
|
|
#include "exception.hpp"
|
|
#include "services/builder.hpp"
|
|
#include "services/inotify.hpp"
|
|
#include "services/logger.hpp"
|
|
#include "utils/config.hpp"
|
|
#include "utils/string.hpp"
|
|
#include "utils/concurrency.hpp"
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
#define Concat(one, two) one ## two
|
|
|
|
#define _Stringify(expr) #expr
|
|
#define Stringify(expr) _Stringify(expr)
|
|
|
|
#define DefineModule(ModuleName, ModuleType) struct ModuleName : public ModuleType<ModuleName>
|
|
#define CastModule(ModuleName) static_cast<ModuleName *>(this)
|
|
#define ConstCastModule(ModuleName) static_cast<ModuleName const &>(*this)
|
|
|
|
#define DEFAULT_FORMAT "format"
|
|
|
|
DefineBaseException(ModuleError);
|
|
DefineChildException(UndefinedFormat, ModuleError);
|
|
DefineChildException(UndefinedFormatTag, ModuleError);
|
|
|
|
class ModuleFormatter
|
|
{
|
|
public:
|
|
struct Format
|
|
{
|
|
std::string value;
|
|
std::vector<std::string> tags;
|
|
|
|
std::string fg, bg, ul, ol;
|
|
int spacing, padding, margin, offset;
|
|
|
|
std::string decorate(Builder *builder, const std::string& output)
|
|
{
|
|
if (this->offset != 0) builder->offset(this->offset);
|
|
|
|
if (this->margin > 0) builder->space(this->margin);
|
|
|
|
if (!this->bg.empty()) builder->background(this->bg);
|
|
if (!this->fg.empty()) builder->color(this->fg);
|
|
if (!this->ul.empty()) builder->underline(this->ul);
|
|
if (!this->ol.empty()) builder->overline(this->ol);
|
|
|
|
if (this->padding > 0) builder->space(this->padding);
|
|
|
|
builder->append(output);
|
|
|
|
if (this->padding > 0) builder->space(this->padding);
|
|
|
|
if (!this->ol.empty()) builder->overline_close();
|
|
if (!this->ul.empty()) builder->underline_close();
|
|
if (!this->fg.empty()) builder->color_close();
|
|
if (!this->bg.empty()) builder->background_close();
|
|
|
|
if (this->margin > 0) builder->space(this->margin);
|
|
|
|
return builder->flush();
|
|
}
|
|
};
|
|
|
|
std::string module_name;
|
|
std::map<std::string, std::unique_ptr<Format>> formats;
|
|
|
|
public:
|
|
explicit ModuleFormatter(const std::string& module_name)
|
|
: module_name(module_name) {}
|
|
|
|
void add(const std::string& name, const std::string& fallback, std::vector<std::string> &&tags, std::vector<std::string> &&whitelist = {})
|
|
{
|
|
auto format = std::make_unique<Format>();
|
|
|
|
format->value = config::get<std::string>(this->module_name, name, fallback);
|
|
format->fg = config::get<std::string>(this->module_name, name +"-foreground", "");
|
|
format->bg = config::get<std::string>(this->module_name, name +"-background", "");
|
|
format->ul = config::get<std::string>(this->module_name, name +"-underline", "");
|
|
format->ol = config::get<std::string>(this->module_name, name +"-overline", "");
|
|
format->spacing = config::get<int>(this->module_name, name +"-spacing", DEFAULT_SPACING);
|
|
format->padding = config::get<int>(this->module_name, name +"-padding", 0);
|
|
format->margin = config::get<int>(this->module_name, name +"-margin", 0);
|
|
format->offset = config::get<int>(this->module_name, name +"-offset", 0);
|
|
format->tags.swap(tags);
|
|
|
|
for (auto &&tag : string::split(format->value, ' ')) {
|
|
if (tag[0] != '<' || tag[tag.length()-1] != '>')
|
|
continue;
|
|
if (std::find(format->tags.begin(), format->tags.end(), tag) != format->tags.end())
|
|
continue;
|
|
if (std::find(whitelist.begin(), whitelist.end(), tag) != whitelist.end())
|
|
continue;
|
|
throw UndefinedFormatTag("["+ this->module_name +"] Undefined \""+ name +"\" tag: "+ tag);
|
|
}
|
|
|
|
this->formats.insert(std::make_pair(name, std::move(format)));
|
|
}
|
|
|
|
std::unique_ptr<Format>& get(const std::string& format_name)
|
|
{
|
|
auto format = this->formats.find(format_name);
|
|
if (format == this->formats.end())
|
|
throw UndefinedFormat("Format \""+ format_name +"\" has not been added");
|
|
return format->second;
|
|
}
|
|
|
|
bool has(const std::string& tag, const std::string& format_name)
|
|
{
|
|
auto format = this->formats.find(format_name);
|
|
if (format == this->formats.end())
|
|
throw UndefinedFormat(format_name);
|
|
return format->second->value.find(tag) != std::string::npos;
|
|
}
|
|
|
|
bool has(const std::string& tag)
|
|
{
|
|
for (auto &&format : this->formats)
|
|
if (format.second->value.find(tag) != std::string::npos)
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
namespace modules
|
|
{
|
|
void broadcast_module_update(const std::string& module_name);
|
|
std::string get_tag_name(const std::string& tag);
|
|
|
|
struct ModuleInterface
|
|
{
|
|
public:
|
|
virtual ~ModuleInterface(){}
|
|
|
|
virtual std::string name() const = 0;
|
|
|
|
virtual void start() = 0;
|
|
virtual void stop() = 0;
|
|
virtual void refresh() = 0;
|
|
|
|
virtual std::string operator()() = 0;
|
|
|
|
virtual bool handle_command(const std::string& cmd) = 0;
|
|
};
|
|
|
|
template<typename ModuleImpl>
|
|
class Module : public ModuleInterface
|
|
{
|
|
concurrency::Atomic<bool> enabled_flag;
|
|
concurrency::Value<std::string> cache;
|
|
|
|
protected:
|
|
concurrency::SpinLock output_lock;
|
|
concurrency::SpinLock broadcast_lock;
|
|
|
|
std::mutex sleep_lock;
|
|
std::condition_variable sleep_handler;
|
|
|
|
std::string name_;
|
|
std::unique_ptr<Builder> builder;
|
|
std::unique_ptr<ModuleFormatter> formatter;
|
|
std::vector<std::thread> threads;
|
|
|
|
public:
|
|
Module(const std::string& name, bool lazy_builder = true)
|
|
: name_("module/"+ name), builder(std::make_unique<Builder>(lazy_builder))
|
|
{
|
|
this->enable(false);
|
|
this->cache = "";
|
|
this->formatter = std::make_unique<ModuleFormatter>(ConstCastModule(ModuleImpl).name());
|
|
}
|
|
|
|
~Module()
|
|
{
|
|
if (this->enabled())
|
|
this->stop();
|
|
|
|
std::lock_guard<concurrency::SpinLock> lck(this->broadcast_lock);
|
|
|
|
for (auto &&t : this->threads) {
|
|
if (t.joinable())
|
|
t.join();
|
|
else
|
|
log_warning("["+ ConstCastModule(ModuleImpl).name() +"] Runner thread not joinable");
|
|
}
|
|
|
|
log_trace(name());
|
|
}
|
|
|
|
std::string name() const {
|
|
return name_;
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
log_trace(name());
|
|
this->wakeup();
|
|
std::lock_guard<concurrency::SpinLock> lck(this->broadcast_lock);
|
|
this->enable(false);
|
|
}
|
|
|
|
void refresh() {
|
|
this->cache = CastModule(ModuleImpl)->get_output();
|
|
}
|
|
|
|
std::string operator()() {
|
|
return this->cache();
|
|
}
|
|
|
|
bool handle_command(const std::string& cmd) {
|
|
return CastModule(ModuleImpl)->handle_command(cmd);
|
|
}
|
|
|
|
protected:
|
|
bool enabled() {
|
|
return this->enabled_flag();
|
|
}
|
|
|
|
void enable(bool state) {
|
|
this->enabled_flag = state;
|
|
}
|
|
|
|
void broadcast()
|
|
{
|
|
std::lock_guard<concurrency::SpinLock> lck(this->broadcast_lock);
|
|
broadcast_module_update(ConstCastModule(ModuleImpl).name());
|
|
}
|
|
|
|
void sleep(std::chrono::duration<double> sleep_duration)
|
|
{
|
|
std::unique_lock<std::mutex> lck(this->sleep_lock);
|
|
std::thread sleep_thread([&]{
|
|
auto start = std::chrono::system_clock::now();
|
|
while ((std::chrono::system_clock::now() - start) < sleep_duration) {
|
|
std::this_thread::sleep_for(50ms);
|
|
}
|
|
this->wakeup();
|
|
});
|
|
sleep_thread.detach();
|
|
this->sleep_handler.wait(lck);
|
|
}
|
|
|
|
void wakeup()
|
|
{
|
|
log_trace("Releasing sleep lock for "+ this->name_);
|
|
this->sleep_handler.notify_one();
|
|
}
|
|
|
|
std::string get_format() {
|
|
return DEFAULT_FORMAT;
|
|
}
|
|
|
|
std::string get_output()
|
|
{
|
|
std::lock_guard<concurrency::SpinLock> lck(this->output_lock);
|
|
|
|
log_trace(ConstCastModule(ModuleImpl).name());
|
|
|
|
if (!this->enabled()) {
|
|
log_trace(ConstCastModule(ModuleImpl).name() +" is disabled");
|
|
return "";
|
|
}
|
|
|
|
auto format_name = CastModule(ModuleImpl)->get_format();
|
|
auto &&format = this->formatter->get(format_name);
|
|
|
|
int i = 0;
|
|
for (auto tag : string::split(format->value, ' ')) {
|
|
if ((i > 0 && !tag.empty()) || tag.empty()) {
|
|
this->builder->space(format->spacing);
|
|
}
|
|
|
|
if (tag[0] == '<' && tag[tag.length()-1] == '>') {
|
|
if (!CastModule(ModuleImpl)->build(this->builder.get(), tag)) {
|
|
this->builder->remove_trailing_space(format->spacing);
|
|
}
|
|
} else {
|
|
this->builder->node(tag);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return format->decorate(this->builder.get(), this->builder->flush());
|
|
}
|
|
};
|
|
|
|
template<typename ModuleImpl>
|
|
class StaticModule : public Module<ModuleImpl>
|
|
{
|
|
using Module<ModuleImpl>::Module;
|
|
|
|
public:
|
|
void start()
|
|
{
|
|
this->enable(true);
|
|
this->threads.emplace_back(std::thread(&StaticModule::broadcast, this));
|
|
}
|
|
|
|
bool build(Builder *builder, const std::string& tag)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template<typename ModuleImpl>
|
|
class TimerModule : public Module<ModuleImpl>
|
|
{
|
|
protected:
|
|
std::chrono::duration<double> interval = 1s;
|
|
|
|
concurrency::SpinLock update_lock;
|
|
|
|
void runner()
|
|
{
|
|
while (this->enabled()) {
|
|
{ std::lock_guard<concurrency::SpinLock> lck(this->update_lock);
|
|
if (CastModule(ModuleImpl)->update())
|
|
CastModule(ModuleImpl)->broadcast();
|
|
}
|
|
this->sleep(this->interval);
|
|
}
|
|
}
|
|
|
|
public:
|
|
template<typename I>
|
|
TimerModule(const std::string& name, I const &interval)
|
|
: Module<ModuleImpl>(name), interval(interval) {}
|
|
|
|
void start()
|
|
{
|
|
this->enable(true);
|
|
this->threads.emplace_back(std::thread(&TimerModule::runner, this));
|
|
}
|
|
};
|
|
|
|
template<typename ModuleImpl>
|
|
class EventModule : public Module<ModuleImpl>
|
|
{
|
|
using Module<ModuleImpl>::Module;
|
|
|
|
protected:
|
|
concurrency::SpinLock update_lock;
|
|
|
|
void runner()
|
|
{
|
|
// warmup
|
|
CastModule(ModuleImpl)->update();
|
|
CastModule(ModuleImpl)->broadcast();
|
|
|
|
while (this->enabled()) {
|
|
std::lock_guard<concurrency::SpinLock> lck(this->update_lock);
|
|
|
|
if (!CastModule(ModuleImpl)->has_event())
|
|
continue;
|
|
|
|
if (!CastModule(ModuleImpl)->update())
|
|
continue;
|
|
|
|
CastModule(ModuleImpl)->broadcast();
|
|
}
|
|
}
|
|
|
|
public:
|
|
void start()
|
|
{
|
|
this->enable(true);
|
|
this->threads.emplace_back(std::thread(&EventModule::runner, this));
|
|
}
|
|
};
|
|
|
|
template<typename ModuleImpl>
|
|
class InotifyModule : public Module<ModuleImpl>
|
|
{
|
|
using Module<ModuleImpl>::Module;
|
|
|
|
protected:
|
|
std::map<std::string, int> watch_list;
|
|
|
|
concurrency::SpinLock update_lock;
|
|
|
|
void runner()
|
|
{
|
|
// warmup
|
|
if (CastModule(ModuleImpl)->on_event(nullptr))
|
|
CastModule(ModuleImpl)->broadcast();
|
|
|
|
while (this->enabled()) {
|
|
try {
|
|
this->poll_events();
|
|
} catch (InotifyException &e) {
|
|
get_logger()->fatal(e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
void idle() const
|
|
{
|
|
// std::this_thread::sleep_for(1s);
|
|
}
|
|
|
|
void poll_events()
|
|
{
|
|
std::lock_guard<concurrency::SpinLock> lck(this->update_lock);
|
|
std::vector<std::unique_ptr<InotifyWatch>> watches;
|
|
|
|
try {
|
|
for (auto &&w : this->watch_list)
|
|
watches.emplace_back(std::make_unique<InotifyWatch>(w.first, w.second));
|
|
} catch (InotifyException &e) {
|
|
watches.clear();
|
|
get_logger()->error(e.what());
|
|
std::this_thread::sleep_for(100ms);
|
|
return;
|
|
}
|
|
|
|
while (this->enabled()) {
|
|
ConstCastModule(ModuleImpl).idle();
|
|
|
|
for (auto &&w : watches) {
|
|
log_trace("Polling inotify event for watch at "+ (*w)());
|
|
|
|
if (w->has_event(500 / watches.size())) {
|
|
std::unique_ptr<InotifyEvent> event = w->get_event();
|
|
|
|
watches.clear();
|
|
|
|
if (CastModule(ModuleImpl)->on_event(event.get()))
|
|
CastModule(ModuleImpl)->broadcast();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void watch(const std::string& path, int mask = InotifyEvent::ALL)
|
|
{
|
|
log_trace(path);
|
|
this->watch_list.insert(std::make_pair(path, mask));
|
|
}
|
|
|
|
public:
|
|
InotifyModule(const std::string& name, const std::string& path, int mask = InotifyEvent::ALL) : Module<ModuleImpl>(name)
|
|
{
|
|
this->watch(path, mask);
|
|
}
|
|
|
|
InotifyModule(const std::string& name, std::vector<std::string> paths, int mask = InotifyEvent::ALL) : Module<ModuleImpl>(name)
|
|
{
|
|
for (auto &&path : paths)
|
|
this->watch(path, mask);
|
|
}
|
|
|
|
void start()
|
|
{
|
|
this->enable(true);
|
|
this->threads.emplace_back(std::thread(&InotifyModule::runner, this));
|
|
}
|
|
};
|
|
}
|