mirror of
https://github.com/emsesp/EMS-ESP32.git
synced 2026-07-29 01:52:51 +00:00
465 lines
17 KiB
C++
465 lines
17 KiB
C++
/*
|
|
* EMS-ESP - https://github.com/emsesp/EMS-ESP
|
|
* Copyright 2020-2025 emsesp.org
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "emsesp.h"
|
|
#include "WebCommandService.h"
|
|
|
|
#include "shuntingYard.h"
|
|
|
|
namespace emsesp {
|
|
|
|
#ifndef EMSESP_STANDALONE
|
|
QueueHandle_t WebCommandService::commandQueue_ = nullptr;
|
|
#endif
|
|
|
|
WebCommandService::WebCommandService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
|
|
: _httpEndpoint(WebCommands::read, WebCommands::update, this, server, EMSESP_COMMANDS_SERVICE_PATH, securityManager, AuthenticationPredicates::IS_AUTHENTICATED)
|
|
, _fsPersistence(WebCommands::read, WebCommands::update, this, fs, EMSESP_COMMANDS_FILE) {
|
|
}
|
|
|
|
void WebCommandService::begin() {
|
|
_fsPersistence.readFromFS();
|
|
|
|
EMSESP::webCommandService.read([&](WebCommands & webCommands) { commandItems_ = &webCommands.commandItems; });
|
|
|
|
EMSESP::logger().info("Starting Commands service");
|
|
char topic[Mqtt::MQTT_TOPIC_MAX_SIZE];
|
|
snprintf(topic, sizeof(topic), "%s/#", F_(commands));
|
|
Mqtt::subscribe(EMSdevice::DeviceType::COMMAND, topic, nullptr);
|
|
|
|
#ifndef EMSESP_STANDALONE
|
|
// when PSRAM is available, run command execution (potentially blocking, e.g. HTTP) in its own task
|
|
// so it never stalls the main loop. Without PSRAM we execute inline (see queueCommand()).
|
|
if (EMSESP::system_.PSram()) {
|
|
commandQueue_ = xQueueCreate(EMSESP_COMMAND_QUEUE_SIZE, sizeof(CommandJob *));
|
|
if (commandQueue_ != nullptr) {
|
|
#if defined(CONFIG_FREERTOS_UNICORE) || (EMSESP_COMMAND_RUNNING_CORE < 0)
|
|
xTaskCreate((TaskFunction_t)command_task, "command_task", EMSESP_COMMAND_STACKSIZE, NULL, EMSESP_COMMAND_PRIORITY, NULL);
|
|
#else
|
|
xTaskCreatePinnedToCore(
|
|
(TaskFunction_t)command_task, "command_task", EMSESP_COMMAND_STACKSIZE, NULL, EMSESP_COMMAND_PRIORITY, NULL, EMSESP_COMMAND_RUNNING_CORE);
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if defined(EMSESP_TEST)
|
|
load_test_data();
|
|
#endif
|
|
}
|
|
|
|
// enqueue a command for the worker task. Fire-and-forget: returns true when the job was queued
|
|
// (or executed inline when no worker exists). It does NOT report the command's success/failure.
|
|
bool WebCommandService::queueCommand(const char * name, const char * value) {
|
|
#ifndef EMSESP_STANDALONE
|
|
if (commandQueue_ != nullptr) {
|
|
CommandJob * job = new CommandJob();
|
|
if (job == nullptr) {
|
|
return false;
|
|
}
|
|
job->name = name ? name : "";
|
|
job->has_value = (value != nullptr);
|
|
job->value = value ? value : "";
|
|
if (xQueueSend(commandQueue_, &job, 0) != pdPASS) {
|
|
EMSESP::logger().warning("Command queue full, dropping '%s'", job->name.c_str());
|
|
delete job;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
// no worker task available (no PSRAM or standalone build) - run synchronously
|
|
return executeCommand(name, value);
|
|
}
|
|
|
|
// true if the command definition is a HTTP/URL command (JSON with a http(s):// url),
|
|
// i.e. one that will do a blocking TCP/TLS request when executed
|
|
bool WebCommandService::isUrlCommand(const std::string & command) {
|
|
JsonDocument doc;
|
|
if (deserializeJson(doc, command) != DeserializationError::Ok) {
|
|
return false;
|
|
}
|
|
std::string url = doc["url"] | "";
|
|
auto lower_url = Helpers::toLower(url.c_str());
|
|
return lower_url.starts_with("http://") || lower_url.starts_with("https://");
|
|
}
|
|
|
|
// true if a value expression contains an embedded {"url":...} JSON snippet, which compute()
|
|
// will resolve with a blocking HTTP request. Mirrors the scan compute() does in shuntingYard.cpp
|
|
bool WebCommandService::valueContainsUrl(const std::string & value) {
|
|
auto f = value.find_first_of('{');
|
|
while (f != std::string::npos) {
|
|
// find the matching closing brace, like compute() does
|
|
auto e = f + 1;
|
|
for (uint8_t i = 1; i > 0; e++) {
|
|
if (e >= value.length()) {
|
|
return false; // unbalanced braces, compute() will give up too
|
|
} else if (value[e] == '}') {
|
|
i--;
|
|
} else if (value[e] == '{') {
|
|
i++;
|
|
}
|
|
}
|
|
JsonDocument doc;
|
|
if (deserializeJson(doc, value.substr(f, e - f)) == DeserializationError::Ok) {
|
|
for (JsonPairConst p : doc.as<JsonObjectConst>()) {
|
|
if (Helpers::toLower(p.key().c_str()) == "url") {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
f = value.find_first_of('{', e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// smart dispatch: commands that will do a blocking HTTP/TLS request - either a URL command or an
|
|
// internal command whose value embeds a {url} fetch - are offloaded to the worker task so they
|
|
// can't stall the caller (main loop for MQTT, async_tcp task for the web API). Everything else
|
|
// runs synchronously, so the caller still gets the command's real success/failure.
|
|
// for queued commands the return value only means "dispatched".
|
|
bool WebCommandService::dispatchCommand(const char * name, const char * value) {
|
|
#ifndef EMSESP_STANDALONE
|
|
if (commandQueue_ != nullptr) {
|
|
const CommandItem * ci = find(name);
|
|
if (ci != nullptr) {
|
|
if (isUrlCommand(ci->cmd.c_str())) {
|
|
return queueCommand(name, value);
|
|
}
|
|
// internal command whose value embeds a {url} fetch (e.g. system/message) - the value is
|
|
// resolved by compute() at execution time and would block, so offload it to the worker task
|
|
// the effective value is the override if given, else the command's stored default
|
|
const std::string effective_value = value ? value : std::string(ci->value.c_str());
|
|
if (valueContainsUrl(effective_value)) {
|
|
return queueCommand(name, value);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return executeCommand(name, value);
|
|
}
|
|
|
|
#ifndef EMSESP_STANDALONE
|
|
// worker task: blocks on the queue and executes each command in turn, off the main loop
|
|
void WebCommandService::command_task(void * pvParameters) {
|
|
CommandJob * job = nullptr;
|
|
while (1) {
|
|
if (xQueueReceive(commandQueue_, &job, portMAX_DELAY) == pdPASS && job != nullptr) {
|
|
EMSESP::webCommandService.executeCommand(job->name.c_str(), job->has_value ? job->value.c_str() : nullptr);
|
|
delete job;
|
|
job = nullptr;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void WebCommands::read(WebCommands & webCommands, JsonObject root) {
|
|
JsonArray items = root["commands"].to<JsonArray>();
|
|
uint8_t counter = 1;
|
|
for (const CommandItem & ci : webCommands.commandItems) {
|
|
JsonObject obj = items.add<JsonObject>();
|
|
obj["id"] = counter++;
|
|
obj["cmd"] = ci.cmd;
|
|
obj["value"] = ci.value;
|
|
obj["name"] = (const char *)ci.name;
|
|
}
|
|
}
|
|
|
|
StateUpdateResult WebCommands::update(JsonObject root, WebCommands & webCommands) {
|
|
Command::erase_device_commands(EMSdevice::DeviceType::COMMAND);
|
|
webCommands.commandItems.clear();
|
|
|
|
auto items = root["commands"].as<JsonArray>();
|
|
for (const JsonObject item : items) {
|
|
auto ci = CommandItem();
|
|
ci.cmd = item["cmd"].as<std::string>();
|
|
ci.value = item["value"].as<std::string>();
|
|
strlcpy(ci.name, item["name"].as<const char *>(), sizeof(ci.name));
|
|
|
|
webCommands.commandItems.push_back(ci);
|
|
Command::add(
|
|
EMSdevice::DeviceType::COMMAND,
|
|
webCommands.commandItems.back().name,
|
|
[name = std::string(webCommands.commandItems.back().name)](const char * value, const int8_t id, JsonObject output) {
|
|
return EMSESP::webCommandService.dispatchCommand(name.c_str(), value); // value is optional
|
|
},
|
|
FL_(command_cmd),
|
|
CommandFlag::ADMIN_ONLY);
|
|
}
|
|
return StateUpdateResult::CHANGED;
|
|
}
|
|
|
|
// find a command item by name (case-insensitive)
|
|
const CommandItem * WebCommandService::find(const char * name) {
|
|
if (name == nullptr || name[0] == '\0') {
|
|
return nullptr;
|
|
}
|
|
auto lower_name = Helpers::toLower(name);
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (ci.name[0] != '\0' && Helpers::toLower(ci.name) == lower_name) {
|
|
return &ci;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// execute a named command — looks up by name and runs it
|
|
bool WebCommandService::executeCommand(const char * name, const char * value) {
|
|
const CommandItem * ci = find(name);
|
|
if (!ci) {
|
|
EMSESP::logger().warning("Command '%s' not found", name ? name : "");
|
|
return false;
|
|
}
|
|
// if there is a value use it, otherwise use the command's default value
|
|
std::string cmd_value = value ? value : ci->value.c_str();
|
|
return executeCommand(ci->name, std::string(ci->cmd.c_str()), cmd_value);
|
|
}
|
|
|
|
// execute a command with explicit cmd and value strings
|
|
// handles both HTTP URLs (JSON format) and internal API commands
|
|
bool WebCommandService::executeCommand(const char * name, const std::string & command, const std::string & data) {
|
|
std::string cmd = Helpers::toLower(command);
|
|
|
|
// run the value through the shunting-yard calculator so expressions like "custom/heatcnt + 1"
|
|
// are resolved (entity references replaced by their values, then computed). Plain values pass
|
|
// through unchanged. Applies to both URL and internal commands, like the old scheduler code
|
|
// which computed the value before executing. system/message runs the shunting-yard on its own
|
|
// argument, so pre-computing it here would run it twice - pass it through raw.
|
|
std::string computed_data = data;
|
|
if (!data.empty() && cmd != "system/message") {
|
|
computed_data = compute(data);
|
|
if (computed_data.empty()) {
|
|
EMSESP::logger().warning("Command '%s': cannot compute value '%s'", name, data.c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// handle HTTP commands (JSON with url/method/value)
|
|
JsonDocument doc;
|
|
if (deserializeJson(doc, cmd) == DeserializationError::Ok) {
|
|
std::string url = doc["url"] | "";
|
|
auto q = url.find_first_of('?');
|
|
if (q != std::string::npos) {
|
|
auto s = url.substr(q + 1);
|
|
auto l = s.length();
|
|
commands(s, false);
|
|
url.replace(q + 1, l, s);
|
|
}
|
|
// the cmd's embedded value only gets entity substitution (commands), the passed value is fully computed
|
|
std::string value = doc["value"] | computed_data;
|
|
std::string method = doc["method"] | "GET";
|
|
commands(value, false);
|
|
auto lower_url = Helpers::toLower(url.c_str());
|
|
if (lower_url.starts_with("http://") || lower_url.starts_with("https://")) {
|
|
std::string result;
|
|
int httpResult = http_request(url, method, value, doc["header"].as<JsonObjectConst>(), result);
|
|
if (httpResult != 200) {
|
|
EMSESP::logger().warning("Command '%s': URL command failed with http code %d", name, httpResult);
|
|
return false;
|
|
}
|
|
#if defined(EMSESP_DEBUG)
|
|
EMSESP::logger().debug("Command '%s': URL '%s' successful with http code %d", name, url.c_str(), httpResult);
|
|
#endif
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// handle internal API commands
|
|
doc.clear();
|
|
JsonObject input = doc.to<JsonObject>();
|
|
if (!computed_data.empty()) {
|
|
input["data"] = computed_data;
|
|
}
|
|
|
|
JsonDocument doc_output;
|
|
JsonObject output = doc_output.to<JsonObject>();
|
|
|
|
char command_str[COMMAND_MAX_LENGTH];
|
|
snprintf(command_str, sizeof(command_str), "/api/%s", cmd.c_str());
|
|
|
|
uint8_t return_code = Command::process(command_str, true, input, output);
|
|
if (return_code == CommandRet::OK) {
|
|
#if defined(EMSESP_DEBUG)
|
|
EMSESP::logger().debug("Command '%s' (%s with data '%s') was successful", name, cmd.c_str(), data.c_str());
|
|
#endif
|
|
if (data.empty() && output.size()) {
|
|
Mqtt::queue_publish("response", output);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
char error[100];
|
|
if (output.size()) {
|
|
snprintf(error, sizeof(error), "Command '%s': %s", name ? name : "", (const char *)output["message"]);
|
|
} else {
|
|
snprintf(error, sizeof(error), "Command '%s': %s failed with error %s", name, cmd.c_str(), Command::return_code_string(return_code));
|
|
}
|
|
EMSESP::logger().warning(error);
|
|
return false;
|
|
}
|
|
|
|
bool WebCommandService::get_value_info(JsonObject output, const char * cmd) {
|
|
if (commandItems_->empty()) {
|
|
return true;
|
|
}
|
|
|
|
if (!strlen(cmd) || !strcmp(cmd, F_(values))) {
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (ci.name[0] != '\0') {
|
|
output[(const char *)ci.name] = ci.value.c_str();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!strcmp(cmd, F_(info))) {
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (ci.name[0] != '\0') {
|
|
output[(const char *)ci.name] = std::string(ci.cmd + ": " + ci.value);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!strcmp(cmd, F_(entities))) {
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (ci.name[0] != '\0') {
|
|
get_value_json(output[ci.name].to<JsonObject>(), ci);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!strcmp(cmd, F_(metrics))) {
|
|
std::string metrics = get_metrics_prometheus();
|
|
if (!metrics.empty()) {
|
|
output["api_data"] = metrics;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// look up specific command by name
|
|
const char * attribute_s = Command::get_attribute(cmd);
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (Helpers::toLower(ci.name) == cmd) {
|
|
get_value_json(output, ci);
|
|
return Command::get_attribute(output, cmd, attribute_s);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
std::string WebCommandService::get_metrics_prometheus() {
|
|
std::string result;
|
|
result.reserve(commandItems_->size() * 100);
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (ci.name[0] == '\0') {
|
|
continue;
|
|
}
|
|
result += (std::string) "# HELP emsesp_cmd_" + ci.name + " " + ci.name + ", readable, writable, visible\n";
|
|
result += (std::string) "# TYPE emsesp_cmd_" + ci.name + " gauge\n";
|
|
result += (std::string) "emsesp_cmd_" + ci.name + " 1\n";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void WebCommandService::get_value_json(JsonObject output, const CommandItem & ci) {
|
|
output["name"] = (const char *)ci.name;
|
|
output["fullname"] = (const char *)ci.name;
|
|
output["type"] = "string";
|
|
output["command"] = ci.cmd;
|
|
output["value"] = ci.value;
|
|
output["readable"] = true;
|
|
output["writeable"] = true;
|
|
output["visible"] = true;
|
|
}
|
|
|
|
void WebCommandService::publish(const bool force) {
|
|
if (!Mqtt::enabled() || commandItems_->empty()) {
|
|
return;
|
|
}
|
|
if (force && !EMSESP::mqtt_.get_publish_onchange(EMSdevice::DeviceType::SYSTEM)) {
|
|
return;
|
|
}
|
|
|
|
JsonDocument doc(PSRAM_DOC);
|
|
JsonObject output = doc.to<JsonObject>();
|
|
for (const CommandItem & ci : *commandItems_) {
|
|
if (ci.name[0] != '\0' && !output[ci.name].is<JsonVariantConst>()) {
|
|
output[(const char *)ci.name] = ci.value.c_str();
|
|
}
|
|
}
|
|
|
|
if (!doc.isNull()) {
|
|
char topic[Mqtt::MQTT_TOPIC_MAX_SIZE];
|
|
snprintf(topic, sizeof(topic), "%s_data", F_(commands));
|
|
Mqtt::queue_publish(topic, output);
|
|
}
|
|
}
|
|
|
|
uint8_t WebCommandService::count_entities() {
|
|
return static_cast<uint8_t>(commandItems_ ? commandItems_->size() : 0);
|
|
}
|
|
|
|
#if defined(EMSESP_TEST)
|
|
void WebCommandService::load_test_data() {
|
|
Command::erase_device_commands(EMSdevice::DeviceType::COMMAND);
|
|
update([&](WebCommands & webCommands) {
|
|
webCommands.commandItems.clear();
|
|
|
|
auto ci = CommandItem();
|
|
ci.cmd = "system/fetch";
|
|
ci.value = "10";
|
|
strcpy(ci.name, "fetch_values");
|
|
webCommands.commandItems.push_back(ci);
|
|
|
|
ci = CommandItem();
|
|
ci.cmd = "system/message";
|
|
ci.value = "hello";
|
|
strcpy(ci.name, "send_message");
|
|
webCommands.commandItems.push_back(ci);
|
|
|
|
ci = CommandItem();
|
|
ci.cmd = "system/message";
|
|
ci.value = "{\"url\":\"http://emsesp.org/versions.json\"}";
|
|
strcpy(ci.name, "get_versions");
|
|
webCommands.commandItems.push_back(ci);
|
|
|
|
// manually add the commands
|
|
for (const auto & item : webCommands.commandItems) {
|
|
if (item.name[0] != '\0') {
|
|
Command::add(
|
|
EMSdevice::DeviceType::COMMAND,
|
|
item.name,
|
|
[name = std::string(item.name)](const char * value, const int8_t id, JsonObject output) {
|
|
return EMSESP::webCommandService.dispatchCommand(name.c_str(), value);
|
|
},
|
|
FL_(command_cmd),
|
|
CommandFlag::ADMIN_ONLY);
|
|
}
|
|
}
|
|
|
|
return StateUpdateResult::CHANGED;
|
|
});
|
|
}
|
|
#endif
|
|
|
|
} // namespace emsesp
|