1608 lines
44 KiB
C++
1608 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;
|
|
}
|