OVMS3/OVMS.V3/main/ovms_command.cpp

1607 lines
44 KiB
C++

/*
; Project: Open Vehicle Monitor System
; Date: 14th March 2017
;
; Changes:
; 1.0 Initial release
;
; (C) 2011 Michael Stegen / Stegen Electronics
; (C) 2011-2017 Mark Webb-Johnson
; (C) 2011 Sonny Chen @ EPRO/DX
;
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice shall be included in
; all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
; THE SOFTWARE.
*/
#include "ovms_log.h"
static const char *TAG = "command";
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <functional>
#include <esp_log.h>
#include <sys/time.h>
#include <sys/types.h>
#include <dirent.h>
#include "freertos/FreeRTOS.h"
#include "ovms_command.h"
#include "ovms_config.h"
#include "ovms_events.h"
#include "ovms_peripherals.h"
#include "ovms_utils.h"
#include "ovms_script.h"
#include "buffered_shell.h"
#include "log_buffers.h"
#include "ovms_semaphore.h"
OvmsCommandApp MyCommandApp __attribute__ ((init_priority (1010)));
bool CompareCharPtr::operator()(const char* a, const char* b)
{
return strcmp(a, b) < 0;
}
OvmsWriter::OvmsWriter()
{
std::string p = MyConfig.GetParamValue("password","module");
if (p.empty())
m_issecure = true;
else
m_issecure = false;
m_insert = NULL;
m_userData = NULL;
m_monitoring = false;
}
OvmsWriter::~OvmsWriter()
{
}
void OvmsWriter::Exit()
{
puts("This console cannot exit.");
}
void OvmsWriter::RegisterInsertCallback(InsertCallback cb, void* ctx)
{
m_insert = cb;
m_userData = ctx;
}
void OvmsWriter::DeregisterInsertCallback(InsertCallback cb)
{
if (m_insert == cb)
{
m_insert = NULL;
m_userData = NULL;
finalise();
ProcessChar('\n');
}
}
bool OvmsWriter::IsSecure()
{
return m_issecure;
}
void OvmsWriter::SetSecure(bool secure)
{
m_issecure = secure;
}
OvmsCommand* OvmsCommandMap::FindUniquePrefix(const char* key)
{
int len = strlen(key);
OvmsCommand* found = NULL;
for (iterator it = begin(); it != end(); ++it)
{
if (strncmp(it->first, key, len) == 0)
{
if (len == strlen(it->first))
{
return it->second;
}
if (found)
{
return NULL;
}
else
{
found = it->second;
}
}
}
return found;
}
OvmsCommand* OvmsCommandMap::FindCommand(const char* key)
{
iterator it = find(key);
if (it == end())
return NULL;
else
return it->second;
}
char ** OvmsCommandMap::GetCompletion(OvmsWriter* writer, const char* token)
{
unsigned int index = 0;
char** tokens = writer->SetCompletion(index, NULL);
if (token)
{
for (iterator it = begin(); it != end(); ++it)
{
if (it->second->IsSecure() && !writer->IsSecure())
continue;
if (strncmp(it->first, token, strlen(token)) == 0)
writer->SetCompletion(index++, it->first);
}
}
return tokens;
}
OvmsCommand::OvmsCommand()
{
m_execute = NULL;
m_usage_template= "";
m_parent = NULL;
m_validate = NULL;
}
OvmsCommand::OvmsCommand(const char* name, const char* title, OvmsCommandExecuteCallback_t execute,
const char *usage, int min, int max, bool secure,
OvmsCommandValidateCallback_t validate)
{
m_name = name;
m_title = title;
m_execute = execute;
m_usage_template= !usage ? "" : usage;
m_min = min;
m_max = max;
m_parent = NULL;
m_secure = secure;
m_validate = validate;
}
OvmsCommand::~OvmsCommand()
{
for (auto it = m_children.begin(); it != m_children.end(); ++it)
{
OvmsCommand* cmd = it->second;
delete cmd;
}
m_children.clear();
}
const char* OvmsCommand::GetName()
{
return m_name;
}
const char* OvmsCommand::GetTitle()
{
return m_title;
}
// Dynamic generation of "Usage:" messages. Syntax of the usage template string:
// - Prefix is "Usage: " followed by names from ancestors (if any) and name of self
// - "$C" expands to children as child1|child2|child3
// - "[$C]" expands to optional children as [child1|child2|child3]
// - $G$ expands to the usage of the first child (typically used after $C)
// - $Gfoo$ expands to the usage of the child named "foo"
// - $L lists a full usage line for each of the children
// - Parameters after command and subcommand tokens may be explicit like " <metric>"
// - Empty usage template "" defaults to "$C" for non-terminal OvmsCommand
void OvmsCommand::PutUsage(OvmsWriter* writer)
{
std::string result ="Usage: ";
size_t pos = result.size();
for (OvmsCommand* parent = m_parent; parent && parent->m_parent; parent = parent->m_parent)
{
if (parent->m_validate)
{
size_t len = strlen(parent->m_usage_template);
char* dollar = index(parent->m_usage_template, '$');
if (dollar)
{
len = dollar - parent->m_usage_template;
if (len > 0 && *(dollar-1) == '[')
--len;
}
else
result.insert(pos, " ");
result.insert(pos, parent->m_usage_template, len);
}
result.insert(pos, " ");
result.insert(pos, parent->m_name);
}
result += m_name;
result += " ";
ExpandUsage(m_usage_template, writer, result);
writer->puts(result.c_str());
}
void OvmsCommand::ExpandUsage(const char* templ, OvmsWriter* writer, std::string& result)
{
std::string usage = (*templ || m_children.empty()) ? templ : m_execute ? "[$C]" : "$C";
size_t pos;
if ((pos = usage.find("$L")) != std::string::npos)
{
result += usage.substr(0, pos);
pos += 2;
size_t z = result.size();
bool found = false;
for (OvmsCommandMap::iterator it = m_children.begin(); it != m_children.end(); ++it)
{
OvmsCommand* child = it->second;
if (!child->m_secure || writer->m_issecure)
{
if (found)
{
result += "\n";
result += result.substr(0, z);
}
result += it->first;
result += " ";
found = true;
child->ExpandUsage(child->m_usage_template, writer, result);
}
}
if (result.size() == z)
{
result = "All subcommands require 'enable' mode";
pos = usage.size(); // Don't append any more
}
result += usage.substr(pos);
return;
}
if ((pos = usage.find("$C")) != std::string::npos)
{
result += usage.substr(0, pos);
pos += 2;
size_t z = result.size();
bool found = false;
for (OvmsCommandMap::iterator it = m_children.begin(); it != m_children.end(); ++it)
{
if (!it->second->m_secure || writer->m_issecure)
{
if (found)
result += "|";
result += it->first;
found = true;
}
}
if (result.size() == z)
{
result = "All subcommands require 'enable' mode";
pos = usage.size(); // Don't append any more
}
}
else pos = 0;
size_t pos2;
if ((pos2 = usage.find("$G", pos)) != std::string::npos)
{
result += usage.substr(pos, pos2-pos);
pos2 += 2;
size_t pos3;
OvmsCommandMap::iterator it = m_children.end();
if ((pos3 = usage.find('$', pos2)) != std::string::npos)
{
if (pos3 == pos2)
it = m_children.begin();
else
it = m_children.find(usage.substr(pos2, pos3-pos2).c_str());
pos = pos3 + 1;
if (it != m_children.end() && (!it->second->m_secure || writer->m_issecure))
{
OvmsCommand* child = it->second;
child->ExpandUsage(child->m_usage_template, writer, result);
}
}
else
pos = pos2;
if (it == m_children.end())
result += "ERROR IN USAGE TEMPLATE";
}
result += usage.substr(pos);
}
OvmsCommand* OvmsCommand::RegisterCommand(const char* name, const char* title, OvmsCommandExecuteCallback_t execute,
const char *usage, int min, int max, bool secure,
OvmsCommandValidateCallback_t validate)
{
// Protect against duplicate registrations
OvmsCommand* cmd = FindCommand(name);
if (cmd == NULL)
{
cmd = new OvmsCommand(name, title, execute, usage, min, max, secure, validate);
m_children[name] = cmd;
cmd->m_parent = this;
}
return cmd;
}
bool OvmsCommand::UnregisterCommand(const char* name)
{
if (name == NULL)
{
// Unregister this command
return m_parent->UnregisterCommand(m_name);
}
// Unregister the specified child command
auto pos = m_children.find(name);
if (pos == m_children.end())
{
return false;
}
else
{
OvmsCommand* cmd = pos->second;
m_children.erase(pos);
delete cmd;
return true;
}
}
char ** OvmsCommand::Complete(OvmsWriter* writer, int argc, const char * const * argv)
{
writer->SetCompletion(0, NULL); // Start with no completion tokens
if (m_validate)
{
int used = -1;
if (argc > 0)
used = m_validate(writer, this, argc > m_max ? m_max : argc, argv, true);
if (used < 0 || used == argc)
return writer->GetCompletions();
argc -= used;
argv += used;
}
if (argc <= 1)
{
return m_children.GetCompletion(writer, argc > 0 ? argv[0] : "");
}
OvmsCommand* cmd = m_children.FindUniquePrefix(argv[0]);
if (!cmd)
{
return writer->SetCompletion(0, NULL);
}
return cmd->Complete(writer, argc-1, ++argv);
}
void OvmsCommand::Execute(int verbosity, OvmsWriter* writer, int argc, const char * const * argv)
{
// if (argc>0)
// {
// printf("Execute(%s/%d) verbosity=%d argc=%d first=%s\n",m_title, m_children.size(), verbosity,argc,argv[0]);
// }
// else
// {
// printf("Execute(%s/%d) verbosity=%d (no args)\n",m_title, m_children.size(), verbosity);
// }
if (m_execute && (m_children.empty() || argc == 0))
{
//puts("Executing directly...");
if (argc < m_min || argc > m_max || (argc > 0 && strcmp(argv[argc-1],"?")==0))
{
PutUsage(writer);
return;
}
if ((!m_secure)||(m_secure && writer->m_issecure))
m_execute(verbosity,writer,this,argc,argv);
else
writer->puts("Error: Secure command requires 'enable' mode");
return;
}
else
{
if (m_validate && argc >= m_min)
{
int used = m_validate(writer, this, argc > m_max ? m_max : argc, argv, false);
if (used < 0)
{
if (argc > 0 && strcmp(argv[argc-1],"?") != 0)
writer->puts("Unrecognised command");
PutUsage(writer);
return;
}
argc -= used;
argv += used;
}
//puts("Looking for a matching command");
if (argc <= 0)
{
if (m_execute)
{
if ((!m_secure)||(m_secure && writer->m_issecure))
m_execute(verbosity,writer,this,argc,argv);
else
writer->puts("Error: Secure command requires 'enable' mode");
return;
}
writer->puts("Subcommand required");
PutUsage(writer);
return;
}
if (strcmp(argv[0],"?")==0)
{
// Skip usage line if it's just the one-line list of children.
if (*m_usage_template || m_execute)
PutUsage(writer);
// Show available commands
int avail = 0;
for (OvmsCommandMap::iterator it=m_children.begin(); it!=m_children.end(); ++it)
{
if (it->second->IsSecure() && !writer->m_issecure)
continue;
const char* k = it->first;
const char* v = it->second->GetTitle();
writer->printf("%-20.20s %s\n",k,v);
++avail;
}
if (!avail)
writer->printf("All subcommands require 'enable' mode\n");
return;
}
OvmsCommand* cmd = m_children.FindUniquePrefix(argv[0]);
if (!cmd)
{
writer->puts("Unrecognised command");
if (GetParent()) // No usage line for root command
PutUsage(writer);
return;
}
cmd->Execute(verbosity,writer,argc-1,++argv);
}
}
OvmsCommand* OvmsCommand::GetParent()
{
return m_parent;
}
OvmsCommand* OvmsCommand::FindCommand(const char* name)
{
return m_children.FindCommand(name);
}
// List all OvmsCommand objects in the tree as a tab-separated CSV-format table
// (which requires doubling " marks).
void OvmsCommand::Display(OvmsWriter* writer, int level)
{
static const char* const spaces = " ";
static const int len = strlen(spaces);
static const char* const end = spaces + len;
if (level >= 0)
{
const char* usage = m_usage_template;
if (!usage)
usage = "NULL";
const char* p = usage;
int quotes = 0;
for ( ; *p; ++p)
if (*p == '"')
++quotes;
char* m = (char*)malloc(p - m_usage_template + quotes + 1);
if (m)
{
char* q = m;
for (p = usage; *p; )
{
if (*p == '"')
*q++ = '"';
*q++ = *p++;
}
*q = '\0';
usage = m;
}
if (2*level > len)
level = 0;
writer->printf("\"%s%s\"\t\"%s\"\t\"%s\"\t%d\t%d\t%s\t%s\t%s\t%s\n",
end-2*level, m_name, m_title, usage, m_min, m_max, m_children.empty() ? "--" : "children",
m_execute ? "execute" : "--", m_secure ? "secure" : "--", m_validate ? "validate" : "--");
if (m)
free(m);
}
for (OvmsCommandMap::iterator it=m_children.begin(); it!=m_children.end(); ++it)
it->second->Display(writer, level + 1);
}
void help(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
writer->puts("Enter a single \"?\" to get the root command list.");
writer->puts("Commands can have multiple levels of subcommands.");
writer->puts("Use \"command [...] ?\" to get the list of subcommands and parameters.");
writer->puts("Commands can be abbreviated, push <TAB> for auto completion at any level");
writer->puts("including at the start of a subcommand to get a list of subcommands.");
writer->puts("Use \"enable\" to enter secure (admin) mode.");
}
void cmd_exit(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
writer->Exit();
}
void log_level(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
const char* tag = "*";
if (argc > 0)
tag = argv[0];
const char* title = cmd->GetTitle();
esp_log_level_t level_num = (esp_log_level_t)(*(title+strlen(title)-2) - '0');
esp_log_level_set(tag, level_num);
writer->printf("Logging level for %s set to %s\n",tag,cmd->GetName());
}
void log_file(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
std::string path;
if (argc == 1)
path = argv[0];
else
path = MyConfig.GetParamValue("log", "file.path");
if (MyConfig.ProtectedPath(path))
{
writer->puts("Error: protected path");
return;
}
if (!MyCommandApp.SetLogfile(path))
{
writer->puts("Error: VFS file cannot be opened for append");
return;
}
writer->printf("Logging to file: %s\n", path.c_str());
}
void log_close(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
std::string path = MyCommandApp.GetLogfile();
if (path.empty())
{
writer->puts("Error: no log file path has been set");
return;
}
if (MyCommandApp.CloseLogfile())
writer->printf("File logging to '%s' stopped\n", path.c_str());
else
writer->printf("Error: stop file logging to '%s' failed, see log for details\n", path.c_str());
}
void log_open(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
std::string path = MyCommandApp.GetLogfile();
if (path.empty())
{
writer->puts("Error: no log file path has been set");
return;
}
if (MyCommandApp.OpenLogfile())
writer->printf("File logging to '%s' started\n", path.c_str());
else
writer->printf("Error: start file logging to '%s' failed, see log for details\n", path.c_str());
}
void log_status(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
MyCommandApp.ShowLogStatus(verbosity, writer);
}
void log_expire(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
if (MyCommandApp.m_expiretask)
{
writer->puts("Abort: expire task is currently running");
return;
}
int keepdays;
if (argc == 0)
keepdays = MyConfig.GetParamValueInt("log", "file.keepdays", 30);
else
keepdays = atoi(argv[0]);
MyCommandApp.ExpireLogFiles(verbosity, writer, keepdays);
}
static OvmsCommand* monitor;
static OvmsCommand* monitor_yes;
void log_monitor(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
bool state;
if (cmd == monitor)
state = !writer->IsMonitoring();
else
state = (cmd == monitor_yes);
writer->printf("Monitoring log messages %s\n", state ? "enabled" : "disabled");
writer->SetMonitoring(state);
}
typedef struct
{
std::string password;
int tries;
} PasswordContext;
bool enableInsert(OvmsWriter* writer, void* v, char ch)
{
PasswordContext* pc = (PasswordContext*)v;
if (ch == '\n')
{
std::string p = MyConfig.GetParamValue("password","module");
if (p.compare(pc->password) == 0)
{
writer->SetSecure(true);
writer->printf("\nSecure mode");
delete pc;
return false;
}
if (++pc->tries == 3)
{
writer->printf("\nError: %d incorrect password attempts", pc->tries);
vTaskDelay(5000 / portTICK_PERIOD_MS);
delete pc;
return false;
}
writer->printf("\nSorry, try again.\nPassword:");
pc->password.erase();
return true;
}
if (ch == 'C'-0100)
{
delete pc;
return false;
}
if (ch != '\r')
pc->password.append(1, ch);
return true;
}
void enable(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
std::string p = MyConfig.GetParamValue("password","module");
if ((p.empty())||((argc==1)&&(p.compare(argv[0])==0)))
{
writer->SetSecure(true);
writer->puts("Secure mode");
}
else if (argc == 1)
{
vTaskDelay(5000 / portTICK_PERIOD_MS);
writer->puts("Error: Invalid password");
}
else
{
PasswordContext* pc = new PasswordContext;
pc->tries = 0;
writer->printf("Password:");
writer->RegisterInsertCallback(enableInsert, pc);
}
}
void disable(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
writer->SetSecure(false);
}
void cmd_sleep(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
int milliseconds = atof(argv[0]) * 1000;
if (milliseconds >= 0)
vTaskDelay(pdMS_TO_TICKS(milliseconds));
}
void cmd_echo(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
{
int i;
for (i = 0; i < argc; i++)
writer->puts(argv[i]);
if (!i)
writer->puts("");
}
#ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
static duk_ret_t DukOvmsCommandExec(duk_context *ctx)
{
const char *cmd = duk_to_string(ctx,0);
if (cmd != NULL)
{
BufferedShell* bs = new BufferedShell(false, COMMAND_RESULT_NORMAL);
bs->SetSecure(true); // this is an authorized channel
bs->ProcessChars(cmd, strlen(cmd));
bs->ProcessChar('\n');
std::string val; bs->Dump(val);
delete bs;
duk_push_string(ctx, val.c_str());
return 1; /* one return value */
}
else
{
return 0;
}
}
//static void DukOvmsCommandRegisterRun(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
// {
// writer->printf("Duktape: Command %s run\n",cmd->GetName());
// }
static duk_ret_t DukOvmsCommandRegister(duk_context *ctx)
{
std::string filename, function;
int linenumber = 0;
MyDuktape.DukGetCallInfo(ctx, &filename, &linenumber, &function);
const char *fullcommand = duk_to_string(ctx,0);
const char *name = duk_to_string(ctx,1);
const char *title = duk_to_string(ctx,2);
const char *usage = duk_to_string(ctx,3);
uint32_t min = duk_is_number(ctx,4) ? duk_to_uint32(ctx,4) : 0;
uint32_t max = duk_is_number(ctx,5) ? duk_to_uint32(ctx,5) : 0;
MyDuktape.RegisterDuktapeConsoleCommand(
ctx, 0,
filename.c_str(),
fullcommand,
name,
title,
usage,
min,
max);
ESP_LOGD(TAG,"Duktape: Script %s %s:%d registered command %s/%s",
filename.c_str(), function.c_str(), linenumber, fullcommand, name);
return 0;
}
#endif // #ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
OvmsCommandApp::OvmsCommandApp()
{
ESP_LOGI(TAG, "Initialising COMMAND (1010)");
m_logfile = NULL;
m_logfile_path = "";
m_logfile_size = 0;
m_logfile_maxsize = 0;
m_logtask = NULL;
m_logtask_queue = NULL;
m_logtask_dropcnt = 0;
m_logfile_cyclecnt = 0;
m_expiretask = 0;
m_root.RegisterCommand("help", "Ask for help", help, "", 0, 0, false);
m_root.RegisterCommand("exit", "End console session", cmd_exit, "", 0, 0, false);
OvmsCommand* cmd_log = MyCommandApp.RegisterCommand("log","LOG framework", log_status, "", 0, 0, false);
cmd_log->RegisterCommand("file", "Start logging to specified file", log_file, "[<vfspath>]\nDefault: config log[file.path]", 0, 1);
cmd_log->RegisterCommand("open", "Start file logging", log_open);
cmd_log->RegisterCommand("close", "Stop file logging", log_close);
cmd_log->RegisterCommand("status", "Show logging status", log_status);
cmd_log->RegisterCommand("expire", "Expire old log files", log_expire, "[<keepdays>]", 0, 1);
OvmsCommand* level_cmd = cmd_log->RegisterCommand("level", "Set logging level", NULL, "$C [<tag>]", 0, 0, false);
level_cmd->RegisterCommand("verbose", "Log at the VERBOSE level (5)", log_level , "[<tag>]", 0, 1);
level_cmd->RegisterCommand("debug", "Log at the DEBUG level (4)", log_level , "[<tag>]", 0, 1);
level_cmd->RegisterCommand("info", "Log at the INFO level (3)", log_level , "[<tag>]", 0, 1);
level_cmd->RegisterCommand("warn", "Log at the WARN level (2)", log_level , "[<tag>]", 0, 1, false);
level_cmd->RegisterCommand("error", "Log at the ERROR level (1)", log_level , "[<tag>]", 0, 1, false);
level_cmd->RegisterCommand("none", "No logging (0)", log_level , "[<tag>]", 0, 1, false);
monitor = cmd_log->RegisterCommand("monitor", "Monitor log on this console", log_monitor);
monitor_yes = monitor->RegisterCommand("yes", "Monitor log", log_monitor);
monitor->RegisterCommand("no", "Don't monitor log", log_monitor);
m_root.RegisterCommand("enable","Enter secure mode (enable access to all commands)", enable, "[<password>]", 0, 1, false);
m_root.RegisterCommand("disable","Leave secure mode (disable access to most commands)", disable);
m_root.RegisterCommand("sleep", "Script utility: pause execution", cmd_sleep,
"<seconds>\nFractions of seconds are supported, e.g. 0.2 = 200 ms", 1, 1);
m_root.RegisterCommand("echo", "Script utility: output text", cmd_echo,
"[<text>] […]\nOutputs up to 10 arguments as separate lines, just a newline if no text is given.", 0, 10);
#ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
ESP_LOGI(TAG, "Expanding DUKTAPE javascript engine");
DuktapeObjectRegistration* dto = new DuktapeObjectRegistration("OvmsCommand");
dto->RegisterDuktapeFunction(DukOvmsCommandExec, 1, "Exec");
dto->RegisterDuktapeFunction(DukOvmsCommandRegister, 6, "Register");
MyDuktape.RegisterDuktapeObject(dto);
#endif // #ifdef CONFIG_OVMS_SC_JAVASCRIPT_DUKTAPE
}
OvmsCommandApp::~OvmsCommandApp()
{
}
void OvmsCommandApp::ConfigureLogging()
{
MyConfig.RegisterParam("log", "Logging configuration", true, true);
using std::placeholders::_1;
using std::placeholders::_2;
MyEvents.RegisterEvent(TAG, "config.changed", std::bind(&OvmsCommandApp::EventHandler, this, _1, _2));
MyEvents.RegisterEvent(TAG, "sd.mounted", std::bind(&OvmsCommandApp::EventHandler, this, _1, _2));
MyEvents.RegisterEvent(TAG, "sd.unmounting", std::bind(&OvmsCommandApp::EventHandler, this, _1, _2));
MyEvents.RegisterEvent(TAG, "ticker.3600", std::bind(&OvmsCommandApp::EventHandler, this, _1, _2));
ReadConfig();
}
OvmsCommand* OvmsCommandApp::RegisterCommand(const char* name, const char* title, OvmsCommandExecuteCallback_t execute,
const char *usage, int min, int max, bool secure)
{
return m_root.RegisterCommand(name, title, execute, usage, min, max, secure);
}
bool OvmsCommandApp::UnregisterCommand(const char* name)
{
// Unregister the specified child command
return m_root.UnregisterCommand(name);
}
OvmsCommand* OvmsCommandApp::FindCommand(const char* name)
{
return m_root.FindCommand(name);
}
OvmsCommand* OvmsCommandApp::FindCommandFullName(const char* name)
{
OvmsCommand* found = &m_root;
const char* p = name;
while (*p != 0)
{
const char* d = strchr(p,' ');
if (d)
{
std::string command(p,0,d-p);
found = found->FindCommand(command.c_str());
p = d+1;
}
else
{
found = found->FindCommand(p);
return found;
}
if (found==NULL) return found;
}
return found;
}
void OvmsCommandApp::RegisterConsole(OvmsWriter* writer)
{
m_consoles.insert(writer);
}
void OvmsCommandApp::DeregisterConsole(OvmsWriter* writer)
{
m_consoles.erase(writer);
}
int OvmsCommandApp::Log(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
size_t ret = Log(fmt, args);
va_end(args);
return ret;
}
int OvmsCommandApp::Log(const char* fmt, va_list args)
{
LogBuffers* lb;
TaskHandle_t task = xTaskGetCurrentTaskHandle();
PartialLogs::iterator it = m_partials.find(task);
if (it == m_partials.end())
lb = new LogBuffers();
else
{
lb = it->second;
m_partials.erase(task);
}
int ret = LogBuffer(lb, fmt, args);
lb->set(m_consoles.size());
for (ConsoleSet::iterator it = m_consoles.begin(); it != m_consoles.end(); ++it)
{
(*it)->Log(lb);
}
return ret;
}
int OvmsCommandApp::LogPartial(const char* fmt, ...)
{
LogBuffers* lb;
TaskHandle_t task = xTaskGetCurrentTaskHandle();
PartialLogs::iterator it = m_partials.find(task);
if (it == m_partials.end())
{
lb = new LogBuffers();
m_partials[task] = lb;
}
else
{
lb = it->second;
}
va_list args;
va_start(args, fmt);
int ret = LogBuffer(lb, fmt, args);
va_end(args);
return ret;
}
int OvmsCommandApp::LogBuffer(LogBuffers* lb, const char* fmt, va_list args)
{
char *buffer;
int ret = vasprintf(&buffer, fmt, args);
if (ret < 0) return ret;
// Replace CR/LF except last by "|", but don't leave '|' at the end.
// An ESC sequence to change color may be appended after the log text.
char* s;
for (s=buffer; *s; s++)
{
if (*s=='\r' || *s=='\n')
{
char *t = s;
if (*(s+1) == '\033')
++s;
else if (*(s+1) != '\0')
{
*s = '|';
continue;
}
while (t > buffer && *(t-1) == '|')
--t;
while ((*t++ = *s++)) ;
break;
}
}
lb->append(buffer);
return ret;
}
int OvmsCommandApp::HexDump(const char* tag, const char* prefix, const char* data, size_t length, size_t colsize /*=16*/)
{
char* buffer = NULL;
int rlength = (int)length;
while (rlength>0)
{
rlength = FormatHexDump(&buffer, data, rlength, colsize);
data += colsize;
ESP_LOGV(tag, "%s: %s", prefix, buffer);
}
if (buffer)
free(buffer);
return length;
}
char ** OvmsCommandApp::Complete(OvmsWriter* writer, int argc, const char * const * argv)
{
return m_root.Complete(writer, argc, argv);
}
void OvmsCommandApp::Execute(int verbosity, OvmsWriter* writer, int argc, const char * const * argv)
{
if (argc == 0)
{
writer->puts("Error: Empty command unrecognised");
}
else
{
writer->SetArgv(argv);
m_root.Execute(verbosity, writer, argc, argv);
}
}
/**
* LogTask: file logging task
*/
struct LogTaskCmd
{
enum
{
LTC_Log, // write data.logbuffers to file
LTC_Exit, // close file, give data.cmdack, exit
} type;
union
{
LogBuffers* logbuffers;
OvmsSemaphore* cmdack;
} data;
};
static void LogTaskEntry(void* me)
{
((OvmsCommandApp*)me)->LogTask();
}
void OvmsCommandApp::LogTask()
{
LogTaskCmd cmd;
char tb[64];
m_logtask_linecnt = 0;
m_logtask_fsynctime = 0;
m_logtask_laststamp = -11;
m_logtask_basetime.tv_sec = 0;
m_logtask_basetime.tv_usec = 0;
// syncperiod: 0 = never, <0 = every n lines, >0 = after n/2 seconds idle
uint32_t linecnt_synced = 0;
int syncperiod = MyConfig.GetParamValueInt("log", "file.syncperiod", 3);
TickType_t timeout = (syncperiod<=0) ? portMAX_DELAY : pdMS_TO_TICKS(syncperiod*500);
for (;;)
{
if (xQueueReceive(m_logtask_queue, (void*)&cmd, timeout) == pdTRUE)
{
// cmd received:
if (cmd.type == LogTaskCmd::LTC_Log)
{
// write logbuffers messages:
for (auto it = cmd.data.logbuffers->begin(); it != cmd.data.logbuffers->end(); it++)
{
std::string le = stripesc(*it);
if (*(le.data() + 1) == ' ' && *(le.data() + 2) == '(')
{
struct timeval stamp;
stamp.tv_sec = atoi(le.data() + 3);
stamp.tv_usec = (stamp.tv_sec % 1000) * 1000;
stamp.tv_sec /= 1000;
// If 10 seconds have elapsed since the previous log message or if a
// real base time hasn't been set yet, recalculate the correspondence
// of real time to system time.
if (stamp.tv_sec - m_logtask_laststamp > 10 || m_logtask_basetime.tv_sec < 1609459200)
{
struct timeval daytime, uptime;
gettimeofday(&daytime, NULL);
uptime.tv_sec = xTaskGetTickCount();
uptime.tv_usec = (uptime.tv_sec % 100) * 10000;
uptime.tv_sec /= 100;
daytime.tv_usec -= daytime.tv_usec % 10000; // Always show 0 for ms units
timersub(&daytime, &uptime, &m_logtask_basetime);
}
m_logtask_laststamp = stamp.tv_sec;
// write timestamp:
timeradd(&m_logtask_basetime, &stamp, &stamp);
struct tm* tmu = localtime(&stamp.tv_sec);
strftime(tb, sizeof(tb), "%Y-%m-%d %H:%M:%S", tmu);
m_logfile_size += fwrite(tb, 1, strlen(tb), m_logfile);
snprintf(tb, sizeof(tb), ".%03lu ", stamp.tv_usec / 1000);
int len = strlen(tb);
strftime(tb+len, sizeof(tb)-len, "%Z ", tmu);
m_logfile_size += fwrite(tb, 1, strlen(tb), m_logfile);
}
// write log entry:
m_logfile_size += fwrite(le.data(), 1, le.size(), m_logfile);
m_logtask_linecnt++;
}
cmd.data.logbuffers->release();
// check file size:
if (m_logfile_maxsize && m_logfile_size > (m_logfile_maxsize*1024))
{
if (!CycleLogfile())
break;
}
else if (syncperiod < 0 && m_logtask_linecnt >= linecnt_synced - syncperiod)
{
linecnt_synced = m_logtask_linecnt;
uint32_t t0 = esp_timer_get_time();
fflush(m_logfile);
fsync(fileno(m_logfile));
m_logtask_fsynctime += esp_timer_get_time() - t0;
}
// check file status:
if (ferror(m_logfile))
{
ESP_LOGE(TAG, "LogTask: writing to file failed, terminating");
break;
}
}
else if (cmd.type == LogTaskCmd::LTC_Exit)
{
break;
}
}
else
{
// cmd timeout: anything to sync?
if (m_logtask_linecnt != linecnt_synced)
{
linecnt_synced = m_logtask_linecnt;
uint32_t t0 = esp_timer_get_time();
fflush(m_logfile);
fsync(fileno(m_logfile));
m_logtask_fsynctime += esp_timer_get_time() - t0;
}
}
}
// cleanup & terminate:
if (m_logfile)
fclose(m_logfile);
LogTaskCmd drop;
while (xQueueReceive(m_logtask_queue, (void*)&drop, 0) == pdTRUE)
{
if (drop.type == LogTaskCmd::LTC_Log)
{
drop.data.logbuffers->release();
}
else if (drop.type == LogTaskCmd::LTC_Exit)
{
if (drop.data.cmdack)
drop.data.cmdack->Give();
}
}
vQueueDelete(m_logtask_queue);
m_logfile = NULL;
m_logtask_queue = NULL;
m_logtask = NULL;
if (cmd.type == LogTaskCmd::LTC_Exit && cmd.data.cmdack)
cmd.data.cmdack->Give();
vTaskDelete(NULL);
}
bool OvmsCommandApp::StartLogTask(FILE* file)
{
OvmsMutexLock lock(&m_logtask_mutex);
m_logfile = file;
if (m_logtask)
return true;
// create queue:
m_logtask_dropcnt = 0;
m_logtask_queue = xQueueCreate(CONFIG_OVMS_LOGFILE_QUEUE_SIZE, sizeof(LogTaskCmd));
if (!m_logtask_queue)
{
ESP_LOGE(TAG, "StartLogTask: unable to create queue (out of memory)");
return false;
}
// create task:
BaseType_t res = xTaskCreatePinnedToCore(LogTaskEntry, "OVMS FileLog", 3*1024, (void*)this,
CONFIG_OVMS_LOGFILE_TASK_PRIORITY, &m_logtask, CORE(1));
if (res != pdPASS)
{
ESP_LOGE(TAG, "StartLogTask: unable to create task, error code=%d", res);
vQueueDelete(m_logtask_queue);
m_logtask_queue = NULL;
return false;
}
// register as logging console:
SetMonitoring(true);
MyCommandApp.RegisterConsole(this);
return true;
}
bool OvmsCommandApp::StopLogTask()
{
OvmsMutexLock lock(&m_logtask_mutex);
if (!m_logtask)
return true;
// detach from logging:
SetMonitoring(false);
MyCommandApp.DeregisterConsole(this);
// send exit command to task:
OvmsSemaphore ack;
LogTaskCmd cmd;
cmd.type = LogTaskCmd::LTC_Exit;
cmd.data.cmdack = &ack;
if (xQueueSend(m_logtask_queue, &cmd, (portTickType)portMAX_DELAY) != pdTRUE)
{
ESP_LOGE(TAG, "StopLogTask: unable to send command to task");
return false;
}
// …and wait for it to finish:
ack.Take();
return true;
}
bool OvmsCommandApp::CloseLogfile()
{
if (!m_logfile)
return true;
if (!StopLogTask())
return false;
ESP_LOGI(TAG, "CloseLogfile: file logging stopped");
return true;
}
bool OvmsCommandApp::OpenLogfile()
{
if (m_logfile && !CloseLogfile())
return false;
if (m_logfile_path.empty())
return true;
#ifdef CONFIG_OVMS_COMP_SDCARD
if (startsWith(m_logfile_path, "/sd") &&
(!MyPeripherals || !MyPeripherals->m_sdcard || !MyPeripherals->m_sdcard->isavailable()))
{
ESP_LOGW(TAG, "OpenLogfile: cannot open '%s', will retry on SD mount", m_logfile_path.c_str());
return false;
}
#endif // #ifdef CONFIG_OVMS_COMP_SDCARD
// get current file size:
struct stat st;
if (stat(m_logfile_path.c_str(), &st) == 0)
m_logfile_size = st.st_size;
else
m_logfile_size = 0;
// open file, start task:
FILE* file = fopen(m_logfile_path.c_str(), "a+");
if (file == NULL)
{
ESP_LOGE(TAG, "OpenLogfile: cannot open '%s'", m_logfile_path.c_str());
return false;
}
if (!StartLogTask(file))
{
ESP_LOGE(TAG, "OpenLogfile: cannot start log task on '%s'", m_logfile_path.c_str());
return false;
}
ESP_LOGI(TAG, "OpenLogfile: now logging to file '%s'", m_logfile_path.c_str());
return true;
}
bool OvmsCommandApp::SetLogfile(std::string path)
{
if (path.empty())
{
// close:
if (m_logfile && !CloseLogfile())
{
ESP_LOGE(TAG, "SetLogfile: error closing '%s'", m_logfile_path.c_str());
return false;
}
m_logfile_path = "";
}
else
{
// check new path:
if (MyConfig.ProtectedPath(path))
{
ESP_LOGE(TAG, "SetLogfile: '%s' is a protected path", path.c_str());
return false;
}
// open:
m_logfile_path = path;
if (!OpenLogfile())
return false;
}
return true;
}
bool OvmsCommandApp::CycleLogfile()
{
if (!m_logfile || m_logfile_path.empty())
return false;
fclose(m_logfile);
m_logfile = NULL;
char ts[20];
time_t tm = time(NULL);
strftime(ts, sizeof(ts), ".%Y%m%d-%H%M%S", localtime(&tm));
std::string archpath = m_logfile_path;
archpath.append(ts);
if (rename(m_logfile_path.c_str(), archpath.c_str()) == 0)
{
ESP_LOGI(TAG, "CycleLogfile: log file '%s' archived as '%s'", m_logfile_path.c_str(), archpath.c_str());
m_logfile_cyclecnt++;
}
else
{
ESP_LOGE(TAG, "CycleLogfile: rename log file '%s' to '%s' failed", m_logfile_path.c_str(), archpath.c_str());
}
return OpenLogfile();
}
void OvmsCommandApp::Log(LogBuffers* msg)
{
if (!m_logtask || !m_logtask_queue)
{
msg->release();
return;
}
// send to LogTask:
LogTaskCmd cmd;
cmd.type = LogTaskCmd::LTC_Log;
cmd.data.logbuffers = msg;
if (xQueueSend(m_logtask_queue, &cmd, 0) != pdTRUE)
{
m_logtask_dropcnt++;
msg->release();
}
}
void OvmsCommandApp::SetLoglevel(std::string tag, std::string level)
{
int level_num;
if (level == "verbose")
level_num = 5;
else if (level == "debug")
level_num = 4;
else if (level == "info")
level_num = 3;
else if (level == "warn")
level_num = 2;
else if (level == "error")
level_num = 1;
else if (level == "none")
level_num = 0;
else
level_num = CONFIG_LOG_DEFAULT_LEVEL;
if (tag.empty())
esp_log_level_set("*", (esp_log_level_t)level_num);
else
esp_log_level_set(tag.c_str(), (esp_log_level_t)level_num);
}
void OvmsCommandApp::ExpireLogFiles(int verbosity, OvmsWriter* writer, int keepdays)
{
if (keepdays <= 0)
{
if (writer)
writer->printf("Abort: expire disabled (keepdays=%d)\n", keepdays);
else
ESP_LOGD(TAG, "ExpireLogFiles: disabled (keepdays=%d)", keepdays);
return;
}
// get archive directory:
std::string archdir = m_logfile_path;
std::string::size_type p = archdir.find_last_of('/');
if (p == std::string::npos)
{
if (writer)
writer->puts("Error: log path not set");
else
ESP_LOGE(TAG, "ExpireLogFiles: log path not set");
return;
}
archdir.resize(p);
DIR *dir = opendir(archdir.c_str());
if (!dir)
{
if (writer)
writer->printf("Error: cannot open log directory '%s'\n", archdir.c_str());
else
ESP_LOGE(TAG, "ExpireLogFiles: cannot open log directory '%s'", archdir.c_str());
return;
}
else if (writer && verbosity >= COMMAND_RESULT_NORMAL)
{
writer->printf("Scanning directory '%s'...\n", archdir.c_str());
}
time_t tm = time(NULL) - keepdays * 86400;
struct dirent *dp;
char path[PATH_MAX];
struct stat st;
int delcnt = 0;
while ((dp = readdir(dir)) != NULL)
{
snprintf(path, sizeof(path), "%s/%s", archdir.c_str(), dp->d_name);
if (strncmp(path, m_logfile_path.c_str(), m_logfile_path.size()) != 0)
continue;
if (stat(path, &st))
{
if (writer)
writer->printf("Error: cannot stat '%s'\n", path);
else
ESP_LOGE(TAG, "ExpireLogFiles: cannot stat '%s'", path);
continue;
}
if (st.st_mtime < tm)
{
if (writer && verbosity >= COMMAND_RESULT_NORMAL)
writer->printf("Deleting '%s'\n", path);
else
ESP_LOGD(TAG, "ExpireLogFiles: deleting '%s'", path);
if (unlink(path))
{
if (writer)
writer->printf("Error: cannot delete '%s'\n", path);
else
ESP_LOGE(TAG, "ExpireLogFiles: cannot delete '%s'", path);
}
else
delcnt++;
}
}
closedir(dir);
if (writer)
writer->printf("Done, %d file(s) deleted.\n", delcnt);
else
ESP_LOGI(TAG, "ExpireLogFiles: %d file(s) deleted", delcnt);
}
void OvmsCommandApp::ExpireTask(void* data)
{
int keepdays = MyConfig.GetParamValueInt("log", "file.keepdays", 30);
MyCommandApp.ExpireLogFiles(0, NULL, keepdays);
MyCommandApp.m_expiretask = 0;
vTaskDelete(NULL);
}
void OvmsCommandApp::ShowLogStatus(int verbosity, OvmsWriter* writer)
{
writer->printf(
"Log listeners : %u\n"
"File logging status: %s\n"
" Log file path : %s\n"
" Current size : %.1f kB\n"
" Cycle size : %u kB\n"
" Cycle count : %u\n"
" Dropped messages : %u\n"
" Messages logged : %u\n"
" Total fsync time : %.1f s\n"
, m_consoles.size()
, m_logfile ? "active" : "inactive"
, m_logfile_path.empty() ? "-" : m_logfile_path.c_str()
, (float) m_logfile_size / 1024.0f
, m_logfile_maxsize
, m_logfile_cyclecnt
, m_logtask_dropcnt
, m_logtask_linecnt
, m_logtask_fsynctime / 1e6);
}
void OvmsCommandApp::EventHandler(std::string event, void* data)
{
if (event == "config.changed")
{
OvmsConfigParam* param = (OvmsConfigParam*) data;
if (param && param->GetName() == "log")
ReadConfig();
}
else if (event == "sd.mounted")
{
if (startsWith(m_logfile_path, "/sd"))
OpenLogfile();
}
else if (event == "sd.unmounting")
{
if (startsWith(m_logfile_path, "/sd"))
CloseLogfile();
}
else if (event == "ticker.3600")
{
int keepdays = MyConfig.GetParamValueInt("log", "file.keepdays", 30);
time_t utm = time(NULL);
struct tm* ltm = localtime(&utm);
if (keepdays && ltm->tm_hour == 0 && !m_expiretask)
xTaskCreatePinnedToCore(ExpireTask, "OVMS ExpireLogs", 4096, NULL, 0, &m_expiretask, CORE(1));
}
}
void OvmsCommandApp::ReadConfig()
{
OvmsConfigParam* param = MyConfig.CachedParam("log");
// configure log levels:
std::string level = MyConfig.GetParamValue("log", "level");
if (!level.empty())
SetLoglevel("*", level);
for (auto const& kv : param->m_map)
{
if (startsWith(kv.first, "level.") && !kv.second.empty())
SetLoglevel(kv.first.substr(6), kv.second);
}
// configure log file:
m_logfile_maxsize = MyConfig.GetParamValueInt("log", "file.maxsize", 1024);
if (MyConfig.GetParamValueBool("log", "file.enable", false) == true)
SetLogfile(MyConfig.GetParamValue("log", "file.path"));
}
void OvmsCommandApp::Display(OvmsWriter* writer)
{
m_root.Display(writer, -1);
}
OvmsCommandTask::OvmsCommandTask(int _verbosity, OvmsWriter* _writer, OvmsCommand* _cmd, int _argc, const char* const* _argv)
: TaskBase(_cmd->GetName(), CONFIG_OVMS_SYS_COMMAND_STACK_SIZE, CONFIG_OVMS_SYS_COMMAND_PRIORITY)
{
m_state = OCS_Init;
// clone command arguments:
verbosity = _verbosity;
writer = _writer;
cmd = _cmd;
argc = _argc;
if (argc == 0)
argv = NULL;
else
{
argv = (char**) ExternalRamMalloc(argc * sizeof(char*));
for (int i=0; i < argc; i++)
argv[i] = strdup(_argv[i]);
}
}
OvmsCommandState_t OvmsCommandTask::Prepare()
{
return (writer->IsInteractive()) ? OCS_RunLoop : OCS_RunOnce;
}
bool OvmsCommandTask::Run()
{
m_state = Prepare();
switch (m_state)
{
case OCS_RunLoop:
// start task:
writer->RegisterInsertCallback(Terminator, (void*) this);
if (!Instantiate())
{
delete this;
return false;
}
return true;
break;
case OCS_RunOnce:
Service();
Cleanup();
delete this;
return true;
break;
default:
// preparation failed:
delete this;
return false;
break;
}
}
OvmsCommandTask::~OvmsCommandTask()
{
if (m_state == OCS_StopRequested)
writer->puts("^C");
writer->DeregisterInsertCallback(Terminator);
if (argv)
{
for (int i=0; i < argc; i++)
free(argv[i]);
free(argv);
}
}
bool OvmsCommandTask::Terminator(OvmsWriter* writer, void* userdata, char ch)
{
if (ch == 3) // Ctrl-C
((OvmsCommandTask*) userdata)->m_state = OCS_StopRequested;
return true;
}