SaaS Automation Engine - Personal or Commercial

1#include "handler_registry.h"
2 
3#include <algorithm>
4 
5namespace wre {
6 
7void HandlerRegistry::register_factory(const std::string& category, CommandFactory factory) {
8  const std::lock_guard<std::mutex> lock(mutex_);
9  factories_[category] = std::move(factory);
10}
11 
12bool HandlerRegistry::load_config(const std::string& path, std::string& error) {
13  auto parsed = bs9::Json::parse_file(path, error);
14  if (!parsed) {
15    error = "cannot read " + path + ": " + error;
16    return false;
17  }
18  return load(*parsed, error);
19}
20 
21bool HandlerRegistry::load(const bs9::Json& config, std::string& error) {
22  const std::lock_guard<std::mutex> lock(mutex_);
23 
24  if (!config.is_object()) {
25    error = "config root must be an object";
26    return false;
27  }
28 
29  const bs9::Json& retry = config["retry_policy"];
30  if (retry.is_object()) {
31    const double attempts = retry["max_attempts"].as_number(8.0);
32    if (attempts >= 1.0) default_max_attempts_ = static_cast<int>(attempts);
33  }
34 
35  const bs9::Json& enabled = config["enabled_categories"];
36  if (!enabled.is_array()) {
37    error = "enabled_categories must be an array of category names";
38    return false;
39  }
40 
41  const bs9::Json& secrets = config["webhook_secrets"];
42  const bs9::Json& downstream = config["downstream_urls"];
43  const bs9::Json& per_category = config["handlers"];
44 
45  configs_.clear();
46  instances_.clear();
47 
48  std::vector<std::string> missing;
49 
50  for (const bs9::Json& entry : enabled.as_array()) {
51    const std::string category = entry.as_string();
52    if (category.empty()) continue;
53 
54    // A category cannot be enabled without an implementation. Refusing here is
55    // the difference between a bot that does nothing and a bot that does not
56    // exist - and the second one is the honest answer.
57    if (factories_.find(category) == factories_.end()) {
58      missing.push_back(category);
59      continue;
60    }
61 
62    HandlerConfig handler;
63    handler.category = category;
64    handler.enabled = true;
65    handler.secret = secrets[category].as_string();
66    handler.downstream_url = downstream[category].as_string();
67 
68    // A per-handler block may override the secret, the downstream and the
69    // retry ceiling for one category without touching the others.
70    const bs9::Json& own = per_category[category];
71    if (own.is_object()) {
72      if (own["secret"].is_string()) handler.secret = own["secret"].as_string();
73      if (own["downstream_url"].is_string()) {
74        handler.downstream_url = own["downstream_url"].as_string();
75      }
76      const double attempts = own["max_attempts"].as_number(0.0);
77      if (attempts >= 1.0) handler.max_attempts = static_cast<int>(attempts);
78      // An explicit "enabled": false wins over the enabled_categories list.
79      if (own["enabled"].is_bool() && !own["enabled"].as_bool()) continue;
80    }
81 
82    configs_[category] = std::move(handler);
83  }
84 
85  if (!missing.empty()) {
86    error = "enabled but no handler compiled in: ";
87    for (std::size_t i = 0; i < missing.size(); ++i) {
88      if (i > 0) error += ", ";
89      error += missing[i];
90    }
91    error += ". Add a file under src/commands/ and register it, or remove it "
92             "from enabled_categories.";
93    return false;
94  }
95 
96  if (configs_.empty()) {
97    error = "no categories enabled - the engine would accept nothing";
98    return false;
99  }
100