TEST_F(RemoteEnrollmentTests, test_enroll) {
// Set the enrollment URI to the server we created.
FLAGS_enrollment_uri = "http://127.0.0.1:" + port_;
FLAGS_enrollment_app_id = "just_a_test_id";
// Call enroll
PluginRequest request = {
{"enroll", "1"},
// 0 enroll if needed, 1 force re-enroll
};
PluginResponse resp;
Status stat = Registry::call("enrollment", "get_key", request, resp);
// The enrollment server test mostly stresses workflow and code coverage.
// Occasionally, like with the transports testing, the non-mocked netlib
// server failed to bind.
if (stat.ok()) {
// Verify get key contains the string
if (resp.size() == 1) {
EXPECT_EQ(resp[0]["key"], "potatoes");
} else {
EXPECT_EQ(resp.size(), 1);
}
}
}
Status Config::genPack(const std::string& name,
const std::string& source,
const std::string& target) {
// If the pack value is a string (and not a JSON object) then it is a
// resource to be handled by the config plugin.
PluginResponse response;
PluginRequest request = {
{"action", "genPack"}, {"name", name}, {"value", target}};
Registry::call("config", request, response);
if (response.size() == 0 || response[0].count(name) == 0) {
return Status(1, "Invalid plugin response");
}
try {
pt::ptree pack_tree;
std::stringstream pack_stream;
pack_stream << response[0][name];
pt::read_json(pack_stream, pack_tree);
addPack(name, source, pack_tree);
} catch (const pt::json_parser::json_parser_error& /* e */) {
LOG(WARNING) << "Error parsing the pack JSON: " << name;
}
return Status(0);
}
Status Config::load() {
valid_ = false;
auto& config_plugin = Registry::getActive("config");
if (!Registry::exists("config", config_plugin)) {
return Status(1, "Missing config plugin " + config_plugin);
}
PluginResponse response;
auto status = Registry::call("config", {{"action", "genConfig"}}, response);
if (!status.ok()) {
loaded_ = true;
return status;
}
// if there was a response, parse it and update internal state
valid_ = true;
if (response.size() > 0) {
if (FLAGS_config_dump) {
// If config checking is enabled, debug-write the raw config data.
for (const auto& content : response[0]) {
fprintf(stdout,
"{\"%s\": %s}\n",
content.first.c_str(),
content.second.c_str());
}
// Instead of forcing the shutdown, request one since the config plugin
// may have started services.
Initializer::requestShutdown();
}
status = update(response[0]);
}
loaded_ = true;
return status;
}
TEST_F(TLSConfigTests, test_retrieve_config) {
TLSServerRunner::start();
TLSServerRunner::setClientConfig();
// Trigger the enroll.
auto endpoint = Flag::getValue("config_tls_endpoint");
Flag::updateValue("config_tls_endpoint", "/config");
Registry::setActive("config", "tls");
// Expect a POST to the /config endpoint.
// A GET will return different results.
Config c;
c.load();
const auto& hashes = c.hash_;
EXPECT_EQ("c109cd4fc0a928dba787384a89f9d03d", hashes.at("tls_plugin"));
// Configure the plugin to use the node API.
Flag::updateValue("tls_node_api", "1");
Registry::setActive("config", "tls");
PluginResponse response;
auto status = Registry::call("config", {{"action", "genConfig"}}, response);
ASSERT_TRUE(status.ok());
ASSERT_EQ(1U, response.size());
// The GET and POST results are slightly different.
EXPECT_EQ("baz", response[0]["tls_plugin"]);
// Clean up.
Flag::updateValue("tls_node_api", "0");
Flag::updateValue("config_tls_endpoint", endpoint);
TLSServerRunner::unsetClientConfig();
TLSServerRunner::stop();
}
Status getDatabaseValue(const std::string& domain,
const std::string& key,
std::string& value) {
if (domain.empty()) {
return Status(1, "Missing domain");
}
if (RegistryFactory::get().external()) {
// External registries (extensions) do not have databases active.
// It is not possible to use an extension-based database.
PluginRequest request = {
{"action", "get"}, {"domain", domain}, {"key", key}};
PluginResponse response;
auto status = Registry::call("database", request, response);
if (status.ok()) {
// Set value from the internally-known "v" key.
if (response.size() > 0 && response[0].count("v") > 0) {
value = response[0].at("v");
}
}
return status;
}
ReadLock lock(kDatabaseReset);
if (!DatabasePlugin::kDBInitialized) {
throw std::runtime_error("Cannot get database value: " + key);
} else {
auto plugin = getDatabasePlugin();
return plugin->get(domain, key, value);
}
}
int xCreate(sqlite3 *db,
void *pAux,
int argc,
const char *const *argv,
sqlite3_vtab **ppVtab,
char **pzErr) {
auto *pVtab = new VirtualTable;
if (!pVtab || argc == 0 || argv[0] == nullptr) {
delete pVtab;
return SQLITE_NOMEM;
}
memset(pVtab, 0, sizeof(VirtualTable));
pVtab->content = new VirtualTableContent;
pVtab->instance = (SQLiteDBInstance *)pAux;
// Create a TablePlugin Registry call, expect column details as the response.
PluginResponse response;
pVtab->content->name = std::string(argv[0]);
// Get the table column information.
auto status = Registry::call(
"table", pVtab->content->name, {{"action", "columns"}}, response);
if (!status.ok() || response.size() == 0) {
delete pVtab->content;
delete pVtab;
return SQLITE_ERROR;
}
// Generate an SQL create table statement from the retrieved column details.
auto statement =
"CREATE TABLE " + pVtab->content->name + columnDefinition(response);
int rc = sqlite3_declare_vtab(db, statement.c_str());
if (rc != SQLITE_OK || !status.ok() || response.size() == 0) {
delete pVtab->content;
delete pVtab;
return (rc != SQLITE_OK) ? rc : SQLITE_ERROR;
}
// Keep a local copy of the column details in the VirtualTableContent struct.
// This allows introspection into the column type without additional calls.
for (const auto &column : response) {
pVtab->content->columns.push_back(
std::make_pair(column.at("name"), columnTypeName(column.at("type"))));
}
*ppVtab = (sqlite3_vtab *)pVtab;
return rc;
}
Status TablePlugin::addExternal(const std::string& name,
const PluginResponse& response) {
// Attach the table.
if (response.size() == 0) {
// Invalid table route info.
return Status(1, "Invalid route info");
}
// Use the SQL registry to attach the name/definition.
return Registry::call("sql", "sql", {{"action", "attach"}, {"table", name}});
}
Status Config::genConfig() {
PluginResponse response;
auto status = Registry::call("config", {{"action", "genConfig"}}, response);
if (!status.ok()) {
return status;
}
if (response.size() > 0) {
return update(response[0]);
}
return Status(0, "OK");
}
Status runEnrollment(bool force = false) {
PluginResponse response;
PluginRequest request = {{"enroll", (force) ? "1" : "0"}};
auto status = Registry::call("enrollment", "get_key", request, response);
if (!status.ok()) {
return status;
}
if (response.size() > 0 && response[0]["key"].size() == 0) {
return Status(1, "Enrollment Error: No Key");
}
return Status(0, "OK");
}
Status getDatabaseValue(const std::string& domain,
const std::string& key,
std::string& value) {
PluginRequest request = {{"action", "get"}, {"domain", domain}, {"key", key}};
PluginResponse response;
auto status = Registry::call("database", "rocks", request, response);
if (!status.ok()) {
return status;
}
// Set value from the internally-known "v" key.
if (response.size() > 0 && response[0].count("v") > 0) {
value = response[0].at("v");
}
return status;
}
Status getDatabaseValue(const std::string& domain,
const std::string& key,
std::string& value) {
if (RegistryFactory::get().external()) {
// External registries (extensions) do not have databases active.
// It is not possible to use an extension-based database.
PluginRequest request = {
{"action", "get"}, {"domain", domain}, {"key", key}};
PluginResponse response;
auto status = Registry::call("database", request, response);
if (status.ok()) {
// Set value from the internally-known "v" key.
if (response.size() > 0 && response[0].count("v") > 0) {
value = response[0].at("v");
}
}
return status;
} else {
auto plugin = getDatabasePlugin();
return plugin->get(domain, key, value);
}
}
TEST_F(ExtensionsTest, test_extension_broadcast) {
auto status = startExtensionManager(socket_path);
EXPECT_TRUE(status.ok());
EXPECT_TRUE(socketExists(socket_path));
// This time we're going to add a plugin to the extension_test registry.
Registry::add<TestExtensionPlugin>("extension_test", "test_item");
// Now we create a registry alias that will be broadcasted but NOT used for
// internal call lookups. Aliasing was introduced for testing such that an
// EM/E could exist in the same process (the same registry) without having
// duplicate registry items in the internal registry list AND extension
// registry route table.
Registry::addAlias("extension_test", "test_item", "test_alias");
Registry::allowDuplicates(true);
// Before registering the extension there is NO route to "test_alias" since
// alias resolutions are performed by the EM.
EXPECT_TRUE(Registry::exists("extension_test", "test_item"));
EXPECT_FALSE(Registry::exists("extension_test", "test_alias"));
status = startExtension(socket_path, "test", "0.1", "0.0.0", "0.0.1");
EXPECT_TRUE(status.ok());
RouteUUID uuid;
try {
uuid = (RouteUUID)stoi(status.getMessage(), nullptr, 0);
} catch (const std::exception& e) {
EXPECT_TRUE(false);
return;
}
auto ext_socket = socket_path + "." + std::to_string(uuid);
EXPECT_TRUE(socketExists(ext_socket));
// Make sure the EM registered the extension (called in start extension).
auto extensions = registeredExtensions();
// Expect two, since `getExtensions` includes the core.
ASSERT_EQ(extensions.size(), 2U);
EXPECT_EQ(extensions.count(uuid), 1U);
EXPECT_EQ(extensions.at(uuid).name, "test");
EXPECT_EQ(extensions.at(uuid).version, "0.1");
EXPECT_EQ(extensions.at(uuid).sdk_version, "0.0.1");
// We are broadcasting to our own registry in the test, which internally has
// a "test_item" aliased to "test_alias", "test_item" is internally callable
// but "test_alias" can only be resolved by an EM call.
EXPECT_TRUE(Registry::exists("extension_test", "test_item"));
// Now "test_alias" exists since it is in the extensions route table.
EXPECT_TRUE(Registry::exists("extension_test", "test_alias"));
PluginResponse response;
// This registry call will fail, since "test_alias" cannot be resolved using
// a local registry call.
status = Registry::call("extension_test", "test_alias", {{}}, response);
EXPECT_FALSE(status.ok());
// The following will be the result of a:
// Registry::call("extension_test", "test_alias", {{}}, response);
status = callExtension(ext_socket,
"extension_test",
"test_alias",
{{"test_key", "test_value"}},
response);
EXPECT_TRUE(status.ok());
EXPECT_EQ(response.size(), 1U);
EXPECT_EQ(response[0]["test_key"], "test_value");
Registry::removeBroadcast(uuid);
Registry::allowDuplicates(false);
}
Status Config::updateSource(const std::string& name, const std::string& json) {
// Compute a 'synthesized' hash using the content before it is parsed.
hashSource(name, json);
// load the config (source.second) into a pt::ptree
pt::ptree tree;
try {
auto clone = json;
stripConfigComments(clone);
std::stringstream json_stream;
json_stream << clone;
pt::read_json(json_stream, tree);
} catch (const pt::json_parser::json_parser_error& e) {
return Status(1, "Error parsing the config JSON");
}
// extract the "schedule" key and store it as the main pack
if (tree.count("schedule") > 0 && !Registry::external()) {
auto& schedule = tree.get_child("schedule");
pt::ptree main_pack;
main_pack.add_child("queries", schedule);
addPack("main", name, main_pack);
}
if (tree.count("scheduledQueries") > 0 && !Registry::external()) {
auto& scheduled_queries = tree.get_child("scheduledQueries");
pt::ptree queries;
for (const std::pair<std::string, pt::ptree>& query : scheduled_queries) {
auto query_name = query.second.get<std::string>("name", "");
if (query_name.empty()) {
return Status(1, "Error getting name from legacy scheduled query");
}
queries.add_child(query_name, query.second);
}
pt::ptree legacy_pack;
legacy_pack.add_child("queries", queries);
addPack("legacy_main", name, legacy_pack);
}
// extract the "packs" key into additional pack objects
if (tree.count("packs") > 0 && !Registry::external()) {
auto& packs = tree.get_child("packs");
for (const auto& pack : packs) {
auto value = packs.get<std::string>(pack.first, "");
if (value.empty()) {
addPack(pack.first, name, pack.second);
} else {
PluginResponse response;
PluginRequest request = {
{"action", "genPack"}, {"name", pack.first}, {"value", value}};
Registry::call("config", request, response);
if (response.size() == 0 || response[0].count(pack.first) == 0) {
continue;
}
try {
pt::ptree pack_tree;
std::stringstream pack_stream;
pack_stream << response[0][pack.first];
pt::read_json(pack_stream, pack_tree);
addPack(pack.first, name, pack_tree);
} catch (const pt::json_parser::json_parser_error& e) {
LOG(WARNING) << "Error parsing the pack JSON: " << pack.first;
}
}
}
}
// Iterate each parser.
for (const auto& plugin : Registry::all("config_parser")) {
std::shared_ptr<ConfigParserPlugin> parser = nullptr;
try {
parser = std::dynamic_pointer_cast<ConfigParserPlugin>(plugin.second);
} catch (const std::bad_cast& e) {
LOG(ERROR) << "Error casting config parser plugin: " << plugin.first;
}
if (parser == nullptr || parser.get() == nullptr) {
continue;
}
// For each key requested by the parser, add a property tree reference.
std::map<std::string, pt::ptree> parser_config;
for (const auto& key : parser->keys()) {
if (tree.count(key) > 0) {
parser_config[key] = tree.get_child(key);
} else {
parser_config[key] = pt::ptree();
}
}
// The config parser plugin will receive a copy of each property tree for
// each top-level-config key. The parser may choose to update the config's
// internal state
parser->update(name, parser_config);
}
return Status(0, "OK");
}
Status Config::updateSource(const std::string& name, const std::string& json) {
// Compute a 'synthesized' hash using the content before it is parsed.
hashSource(name, json);
// Remove all packs from this source.
schedule_->removeAll(name);
// Remove all files from this source.
removeFiles(name);
// load the config (source.second) into a pt::ptree
pt::ptree tree;
try {
auto clone = json;
stripConfigComments(clone);
std::stringstream json_stream;
json_stream << clone;
pt::read_json(json_stream, tree);
} catch (const pt::json_parser::json_parser_error& e) {
return Status(1, "Error parsing the config JSON");
}
// extract the "schedule" key and store it as the main pack
if (tree.count("schedule") > 0 && !Registry::external()) {
auto& schedule = tree.get_child("schedule");
pt::ptree main_pack;
main_pack.add_child("queries", schedule);
addPack("main", name, main_pack);
}
if (tree.count("scheduledQueries") > 0 && !Registry::external()) {
auto& scheduled_queries = tree.get_child("scheduledQueries");
pt::ptree queries;
for (const std::pair<std::string, pt::ptree>& query : scheduled_queries) {
auto query_name = query.second.get<std::string>("name", "");
if (query_name.empty()) {
return Status(1, "Error getting name from legacy scheduled query");
}
queries.add_child(query_name, query.second);
}
pt::ptree legacy_pack;
legacy_pack.add_child("queries", queries);
addPack("legacy_main", name, legacy_pack);
}
// extract the "packs" key into additional pack objects
if (tree.count("packs") > 0 && !Registry::external()) {
auto& packs = tree.get_child("packs");
for (const auto& pack : packs) {
auto value = packs.get<std::string>(pack.first, "");
if (value.empty()) {
// The pack is a JSON object, treat the content as pack data.
addPack(pack.first, name, pack.second);
} else {
// If the pack value is a string (and not a JSON object) then it is a
// resource to be handled by the config plugin.
PluginResponse response;
PluginRequest request = {
{"action", "genPack"}, {"name", pack.first}, {"value", value}};
Registry::call("config", request, response);
if (response.size() == 0 || response[0].count(pack.first) == 0) {
continue;
}
try {
pt::ptree pack_tree;
std::stringstream pack_stream;
pack_stream << response[0][pack.first];
pt::read_json(pack_stream, pack_tree);
addPack(pack.first, name, pack_tree);
} catch (const pt::json_parser::json_parser_error& e) {
LOG(WARNING) << "Error parsing the pack JSON: " << pack.first;
}
}
}
}
applyParsers(name, tree, false);
return Status(0, "OK");
}