feat: port the remaining v1 API to the v2 controller
Profiles seed presets, a default zone and a palette, and clone with their own copies; deleting a profile removes what it owned. Zones get the v1 list shape, set-current, current, clone and content-fragment. Devices are keyed by MAC with v1 validation and identify. Patterns: definitions, OTA file and manifest, upload, driver, and send over ESP-NOW (the led-driver pattern sources are embedded in the firmware). Pixel outputs get v1 validation and a DDP/Art-Net/sACN test pattern. Sequences, palettes and settings follow v1 replies and validation, and /ws forwards browser messages to the drivers. The resource handlers move out of api.c into res_*.c, patterns.c and outputs.c. cJSON now allocates from PSRAM: the store had grown enough to starve internal RAM and abort the mic at boot. /status reports free_internal. The Wi-Fi AP and led-tool routes are left out. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
4b42391a46
commit
57182188ba
30 files changed
+2846
-425
No files matched your search
+470
@@ -0,0 +1,470 @@
|
||||
// Patterns: the v1 app's controllers/pattern.py. Pattern metadata lives in the "pattern" collection,
|
||||
// keyed by name. Pattern sources (.py) come from led-driver/src/patterns, embedded in the firmware
|
||||
// (see tools/build_web.sh), and from uploads stored under /db/patterns, which take precedence.
|
||||
|
||||
#include <ctype.h>
|
||||
#include <dirent.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include "api_util.h"
|
||||
#include "drv_ota.h"
|
||||
#include "esp_log.h"
|
||||
#include "store.h"
|
||||
#include "web.h"
|
||||
|
||||
static const char *TAG = "patterns";
|
||||
|
||||
#define PAT_DIR "/db/patterns"
|
||||
#define CODE_MAX (64 * 1024)
|
||||
#define NAME_MAX_LEN 64
|
||||
|
||||
// on and off are built into the driver firmware; there is no file to serve or send
|
||||
static bool builtin(const char *name)
|
||||
{
|
||||
return !strcmp(name, "on") || !strcmp(name, "off");
|
||||
}
|
||||
|
||||
// "blink", "blink.py" or "blink.py.py" -> "blink"; false for anything that is not a plain file name
|
||||
static bool base_name(const char *in, char out[NAME_MAX_LEN + 1])
|
||||
{
|
||||
size_t n = strlen(in);
|
||||
while (n >= 3 && !strncmp(in + n - 3, ".py", 3)) {
|
||||
n -= 3;
|
||||
}
|
||||
if (n == 0 || n > NAME_MAX_LEN) {
|
||||
return false;
|
||||
}
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
char c = in[i];
|
||||
if (!(isalnum((unsigned char)c) || c == '_' || c == '-')) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
memcpy(out, in, n);
|
||||
out[n] = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void file_path(const char *base, char *path, size_t len)
|
||||
{
|
||||
snprintf(path, len, PAT_DIR "/%s.py", base);
|
||||
}
|
||||
|
||||
// Pattern source: an upload, else the copy in the firmware. *heap says whether the caller frees *data.
|
||||
static bool load(const char *base, const uint8_t **data, size_t *len, bool *heap)
|
||||
{
|
||||
char path[96];
|
||||
file_path(base, path, sizeof(path));
|
||||
FILE *f = fopen(path, "rb");
|
||||
if (f) {
|
||||
fseek(f, 0, SEEK_END);
|
||||
long size = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
uint8_t *buf = size >= 0 ? malloc(size + 1) : NULL;
|
||||
bool ok = buf && fread(buf, 1, size, f) == (size_t)size;
|
||||
fclose(f);
|
||||
if (ok) {
|
||||
*data = buf;
|
||||
*len = size;
|
||||
*heap = true;
|
||||
return true;
|
||||
}
|
||||
free(buf);
|
||||
}
|
||||
char name[NAME_MAX_LEN + 16];
|
||||
snprintf(name, sizeof(name), "patterns/%s.py", base);
|
||||
uint32_t n;
|
||||
if (web_file(name, data, &n)) {
|
||||
*len = n;
|
||||
*heap = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool exists(const char *base)
|
||||
{
|
||||
const uint8_t *d;
|
||||
size_t n;
|
||||
bool heap;
|
||||
if (!load(base, &d, &n, &heap)) {
|
||||
return false;
|
||||
}
|
||||
if (heap) {
|
||||
free((void *)d);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static void add_name(const char *file, void *ctx)
|
||||
{
|
||||
char base[NAME_MAX_LEN + 1];
|
||||
if (base_name(file, base) && strcmp(base, "__init__") && !cJSON_GetObjectItem(ctx, base)) {
|
||||
cJSON_AddItemToObject(ctx, base, cJSON_CreateObject());
|
||||
}
|
||||
}
|
||||
|
||||
// Every pattern with a source file, as {name: {}}
|
||||
static cJSON *file_names(void)
|
||||
{
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
web_each("patterns/", add_name, o);
|
||||
DIR *dir = opendir(PAT_DIR);
|
||||
struct dirent *e;
|
||||
while (dir && (e = readdir(dir))) {
|
||||
add_name(e->d_name, o);
|
||||
}
|
||||
if (dir) {
|
||||
closedir(dir);
|
||||
}
|
||||
return o;
|
||||
}
|
||||
|
||||
static esp_err_t write_file(const char *base, const char *code, size_t len)
|
||||
{
|
||||
if (mkdir(PAT_DIR, 0775) != 0 && errno != EEXIST) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
char path[96];
|
||||
file_path(base, path, sizeof(path));
|
||||
FILE *f = fopen(path, "wb");
|
||||
if (!f) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
bool ok = fwrite(code, 1, len, f) == len;
|
||||
ok = fclose(f) == 0 && ok;
|
||||
return ok ? ESP_OK : ESP_FAIL;
|
||||
}
|
||||
|
||||
// GET /patterns and /patterns/definitions: stored metadata plus {} for every other pattern file
|
||||
static esp_err_t list_patterns(httpd_req_t *req)
|
||||
{
|
||||
cJSON *o = cJSON_Duplicate(store_coll("pattern"), true);
|
||||
cJSON *files = file_names(), *it;
|
||||
cJSON_ArrayForEach(it, files)
|
||||
{
|
||||
if (!cJSON_GetObjectItem(o, it->string)) {
|
||||
cJSON_AddItemToObject(o, it->string, cJSON_CreateObject());
|
||||
}
|
||||
}
|
||||
cJSON_Delete(files);
|
||||
return api_json(req, "200 OK", o, true);
|
||||
}
|
||||
|
||||
// POST /patterns {name, data: {...}, ...}: data (plus any other keys) becomes the record under name
|
||||
static esp_err_t create_pattern(httpd_req_t *req)
|
||||
{
|
||||
cJSON *body = api_body(req);
|
||||
if (!body) {
|
||||
return ESP_OK;
|
||||
}
|
||||
const cJSON *name = cJSON_GetObjectItem(body, "name");
|
||||
const cJSON *data = cJSON_GetObjectItem(body, "data");
|
||||
char key[NAME_MAX_LEN + 1];
|
||||
if (cJSON_IsString(name) && name->valuestring[0]) {
|
||||
snprintf(key, sizeof(key), "%s", name->valuestring);
|
||||
} else {
|
||||
store_next_id("pattern", key, sizeof(key));
|
||||
}
|
||||
cJSON *rec = cJSON_IsObject(data) ? cJSON_Duplicate(data, true) : cJSON_CreateObject();
|
||||
cJSON_DeleteItemFromObject(body, "data");
|
||||
cJSON_DeleteItemFromObject(body, "name");
|
||||
api_merge(rec, body);
|
||||
cJSON_Delete(body);
|
||||
cJSON *all = store_coll("pattern");
|
||||
cJSON_DeleteItemFromObject(all, key);
|
||||
cJSON_AddItemToObject(all, key, rec);
|
||||
store_save("pattern");
|
||||
return api_json(req, "201 Created", rec, false);
|
||||
}
|
||||
|
||||
static esp_err_t serve_file(httpd_req_t *req, const char *name)
|
||||
{
|
||||
char base[NAME_MAX_LEN + 1];
|
||||
if (!base_name(name, base)) {
|
||||
return api_error(req, "400 Bad Request", "Invalid pattern file name");
|
||||
}
|
||||
if (builtin(base)) {
|
||||
return api_error(req, "400 Bad Request", "on and off are built into the driver firmware");
|
||||
}
|
||||
const uint8_t *data;
|
||||
size_t len;
|
||||
bool heap;
|
||||
if (!load(base, &data, &len, &heap)) {
|
||||
return api_error(req, "404 Not Found", "Pattern file not found");
|
||||
}
|
||||
httpd_resp_set_type(req, "text/plain; charset=utf-8");
|
||||
esp_err_t r = httpd_resp_send(req, (const char *)data, len);
|
||||
if (heap) {
|
||||
free((void *)data);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
static esp_err_t manifest(httpd_req_t *req)
|
||||
{
|
||||
char host[64];
|
||||
if (httpd_req_get_hdr_value_str(req, "Host", host, sizeof(host)) != ESP_OK || !host[0]) {
|
||||
return api_error(req, "400 Bad Request", "Host header required");
|
||||
}
|
||||
cJSON *o = cJSON_CreateObject(), *files = cJSON_AddArrayToObject(o, "files");
|
||||
cJSON *names = file_names(), *it;
|
||||
cJSON_ArrayForEach(it, names)
|
||||
{
|
||||
char url[192];
|
||||
cJSON *f = cJSON_CreateObject();
|
||||
snprintf(url, sizeof(url), "%s.py", it->string);
|
||||
cJSON_AddStringToObject(f, "name", url);
|
||||
snprintf(url, sizeof(url), "http://%s/patterns/ota/file/%s.py", host, it->string);
|
||||
cJSON_AddStringToObject(f, "url", url);
|
||||
cJSON_AddItemToArray(files, f);
|
||||
}
|
||||
cJSON_Delete(names);
|
||||
return api_json(req, "200 OK", o, true);
|
||||
}
|
||||
|
||||
// The name and code of an upload; on error a response has been sent and false returned
|
||||
static bool upload_args(httpd_req_t *req, cJSON *body, char base[NAME_MAX_LEN + 1], const char **code, bool *overwrite,
|
||||
esp_err_t *ret)
|
||||
{
|
||||
const cJSON *name = cJSON_GetObjectItem(body, "name");
|
||||
if (!cJSON_IsString(name)) {
|
||||
name = cJSON_GetObjectItem(body, "filename");
|
||||
}
|
||||
const cJSON *c = cJSON_GetObjectItem(body, "code");
|
||||
const cJSON *ow = cJSON_GetObjectItem(body, "overwrite");
|
||||
const char *err = !cJSON_IsString(name) || !base_name(name->valuestring, base) ? "a valid name is required"
|
||||
: builtin(base) ? "on and off are built into the driver firmware"
|
||||
: !cJSON_IsString(c) || !c->valuestring[0] ? "code is required"
|
||||
: strlen(c->valuestring) > CODE_MAX ? "code must be at most 64 KB"
|
||||
: NULL;
|
||||
if (err) {
|
||||
*ret = api_error(req, "400 Bad Request", err);
|
||||
return false;
|
||||
}
|
||||
*code = c->valuestring;
|
||||
*overwrite = !cJSON_IsFalse(ow);
|
||||
if (!*overwrite && exists(base)) {
|
||||
*ret = api_error(req, "409 Conflict", "Pattern already exists");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// POST /patterns/upload {name, code, overwrite}: store a pattern source
|
||||
static esp_err_t upload(httpd_req_t *req)
|
||||
{
|
||||
cJSON *body = api_body(req);
|
||||
if (!body) {
|
||||
return ESP_OK;
|
||||
}
|
||||
char base[NAME_MAX_LEN + 1];
|
||||
const char *code;
|
||||
bool overwrite;
|
||||
esp_err_t ret;
|
||||
if (!upload_args(req, body, base, &code, &overwrite, &ret)) {
|
||||
cJSON_Delete(body);
|
||||
return ret;
|
||||
}
|
||||
bool had = exists(base);
|
||||
if (write_file(base, code, strlen(code)) != ESP_OK) {
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "500 Internal Server Error", "could not save the pattern");
|
||||
}
|
||||
cJSON_Delete(body);
|
||||
char fname[NAME_MAX_LEN + 4];
|
||||
snprintf(fname, sizeof(fname), "%s.py", base);
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "message", "Pattern uploaded");
|
||||
cJSON_AddStringToObject(o, "name", fname);
|
||||
cJSON_AddBoolToObject(o, "overwrote", had);
|
||||
return api_json(req, "201 Created", o, true);
|
||||
}
|
||||
|
||||
// POST /patterns/driver {name, code, overwrite, min_delay, max_delay, max_colors, n1..n8}: store the
|
||||
// source and its metadata (n1..n8 are the parameter labels)
|
||||
static esp_err_t create_driver_pattern(httpd_req_t *req)
|
||||
{
|
||||
cJSON *body = api_body(req);
|
||||
if (!body) {
|
||||
return ESP_OK;
|
||||
}
|
||||
char base[NAME_MAX_LEN + 1];
|
||||
const char *code;
|
||||
bool overwrite;
|
||||
esp_err_t ret;
|
||||
if (!upload_args(req, body, base, &code, &overwrite, &ret)) {
|
||||
cJSON_Delete(body);
|
||||
return ret;
|
||||
}
|
||||
if (!isalpha((unsigned char)base[0]) && base[0] != '_') {
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "400 Bad Request", "name must start with a letter or _");
|
||||
}
|
||||
for (const char *c = base; *c; c++) {
|
||||
if (*c == '-') {
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "400 Bad Request", "name may only hold letters, digits and _");
|
||||
}
|
||||
}
|
||||
cJSON *meta = cJSON_CreateObject();
|
||||
static const char *const INTS[] = { "min_delay", "max_delay", "max_colors" };
|
||||
for (size_t i = 0; i < sizeof(INTS) / sizeof(INTS[0]); i++) {
|
||||
const cJSON *v = cJSON_GetObjectItem(body, INTS[i]);
|
||||
if (!v || cJSON_IsNull(v) || (cJSON_IsString(v) && !v->valuestring[0])) {
|
||||
continue;
|
||||
}
|
||||
double d = cJSON_IsNumber(v) ? v->valuedouble : (cJSON_IsString(v) ? strtod(v->valuestring, NULL) : 0.5);
|
||||
if (d != (int)d) {
|
||||
cJSON_Delete(meta);
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "400 Bad Request", "min_delay, max_delay and max_colors must be integers");
|
||||
}
|
||||
cJSON_AddNumberToObject(meta, INTS[i], (int)d);
|
||||
}
|
||||
for (int i = 1; i <= 8; i++) {
|
||||
char key[4];
|
||||
snprintf(key, sizeof(key), "n%d", i);
|
||||
const cJSON *v = cJSON_GetObjectItem(body, key);
|
||||
if (cJSON_IsString(v) && v->valuestring[0]) {
|
||||
cJSON_AddStringToObject(meta, key, v->valuestring);
|
||||
}
|
||||
}
|
||||
if (write_file(base, code, strlen(code)) != ESP_OK) {
|
||||
cJSON_Delete(meta);
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "500 Internal Server Error", "could not save the pattern");
|
||||
}
|
||||
cJSON_Delete(body);
|
||||
cJSON *all = store_coll("pattern");
|
||||
cJSON *rec = cJSON_GetObjectItem(all, base);
|
||||
if (!cJSON_IsObject(rec)) {
|
||||
cJSON_DeleteItemFromObject(all, base);
|
||||
rec = cJSON_AddObjectToObject(all, base);
|
||||
}
|
||||
api_merge(rec, meta);
|
||||
store_save("pattern");
|
||||
char fname[NAME_MAX_LEN + 4];
|
||||
snprintf(fname, sizeof(fname), "%s.py", base);
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "message", "Pattern created");
|
||||
cJSON_AddStringToObject(o, "name", base);
|
||||
cJSON_AddStringToObject(o, "file", fname);
|
||||
cJSON_AddItemToObject(o, "metadata", meta);
|
||||
return api_json(req, "201 Created", o, true);
|
||||
}
|
||||
|
||||
// POST /patterns/<name>/send {device_id?}: push the source to one driver or every ESP-NOW driver
|
||||
// (patterns/<name>.py on the driver), which then resets to load it
|
||||
static esp_err_t send_pattern(httpd_req_t *req, const char *name)
|
||||
{
|
||||
char base[NAME_MAX_LEN + 1];
|
||||
if (!base_name(name, base)) {
|
||||
return api_error(req, "400 Bad Request", "Invalid pattern name");
|
||||
}
|
||||
if (builtin(base)) {
|
||||
return api_error(req, "400 Bad Request", "on and off are built into the driver firmware");
|
||||
}
|
||||
cJSON *body = api_body_opt(req);
|
||||
if (!body) {
|
||||
return ESP_OK;
|
||||
}
|
||||
char macs[16] = "all";
|
||||
const cJSON *did = cJSON_GetObjectItem(body, "device_id");
|
||||
if (cJSON_IsString(did) && did->valuestring[0]) {
|
||||
const cJSON *dev = cJSON_GetObjectItem(store_coll("device"), did->valuestring);
|
||||
const cJSON *tr = cJSON_GetObjectItem(dev, "transport"), *addr = cJSON_GetObjectItem(dev, "address");
|
||||
if (!dev) {
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "404 Not Found", "Device not found");
|
||||
}
|
||||
if (!cJSON_IsString(tr) || strcmp(tr->valuestring, "espnow") || !cJSON_IsString(addr) ||
|
||||
strlen(addr->valuestring) != 12) {
|
||||
cJSON_Delete(body);
|
||||
return api_error(req, "400 Bad Request", "Device is not an ESP-NOW driver");
|
||||
}
|
||||
snprintf(macs, sizeof(macs), "%s", addr->valuestring);
|
||||
}
|
||||
cJSON_Delete(body);
|
||||
const uint8_t *data;
|
||||
size_t len;
|
||||
bool heap;
|
||||
if (!load(base, &data, &len, &heap)) {
|
||||
return api_error(req, "404 Not Found", "Pattern file not found");
|
||||
}
|
||||
char path[NAME_MAX_LEN + 16];
|
||||
snprintf(path, sizeof(path), "patterns/%s.py", base);
|
||||
esp_err_t err;
|
||||
store_unlock(); // the transfer takes seconds; the sequencer must keep running
|
||||
cJSON *results = drv_ota_send(macs, path, data, len, true, &err);
|
||||
store_lock();
|
||||
if (heap) {
|
||||
free((void *)data);
|
||||
}
|
||||
if (!results) {
|
||||
return err == ESP_ERR_INVALID_STATE ? api_error(req, "409 Conflict", "a driver update is already running")
|
||||
: err == ESP_ERR_NOT_FOUND ? api_error(req, "404 Not Found", "No ESP-NOW drivers")
|
||||
: api_error(req, "400 Bad Request", "Pattern cannot be sent");
|
||||
}
|
||||
cJSON *o = cJSON_CreateObject(), *ids = cJSON_CreateArray(), *it;
|
||||
cJSON_ArrayForEach(it, results)
|
||||
{
|
||||
const cJSON *res = cJSON_GetObjectItem(it, "result");
|
||||
if (cJSON_IsString(res) && strcmp(res->valuestring, "error")) {
|
||||
cJSON_AddItemToArray(ids, cJSON_CreateString(it->string));
|
||||
}
|
||||
}
|
||||
int sent = cJSON_GetArraySize(ids);
|
||||
ESP_LOGI(TAG, "%s sent to %d driver(s)", path, sent);
|
||||
cJSON_AddStringToObject(o, sent ? "message" : "error", sent ? "Pattern sent" : "No driver accepted the pattern");
|
||||
cJSON_AddStringToObject(o, "pattern", path + strlen("patterns/"));
|
||||
cJSON_AddItemToObject(o, "device_ids", ids);
|
||||
cJSON_AddNumberToObject(o, "sent_count", sent);
|
||||
cJSON_AddItemToObject(o, "results", results);
|
||||
return api_json(req, sent ? "200 OK" : "503 Service Unavailable", o, true);
|
||||
}
|
||||
|
||||
bool patterns_route(httpd_req_t *req, int n, api_seg_t seg, esp_err_t *ret)
|
||||
{
|
||||
static const char FILE_PREFIX[] = "/patterns/ota/file/";
|
||||
const int method = req->method;
|
||||
if (method == HTTP_GET && !strncmp(req->uri, FILE_PREFIX, sizeof(FILE_PREFIX) - 1)) {
|
||||
char name[NAME_MAX_LEN + 8];
|
||||
const char *s = req->uri + sizeof(FILE_PREFIX) - 1;
|
||||
size_t len = strcspn(s, "?");
|
||||
if (len >= sizeof(name)) {
|
||||
*ret = api_error(req, "400 Bad Request", "Invalid pattern file name");
|
||||
return true;
|
||||
}
|
||||
memcpy(name, s, len);
|
||||
name[len] = 0;
|
||||
*ret = serve_file(req, name);
|
||||
return true;
|
||||
}
|
||||
if (n == 3 && method == HTTP_GET && !strcmp(seg[1], "ota") && !strcmp(seg[2], "manifest")) {
|
||||
*ret = manifest(req);
|
||||
return true;
|
||||
}
|
||||
if (method == HTTP_GET && (n == 1 || (n == 2 && !strcmp(seg[1], "definitions")))) {
|
||||
*ret = list_patterns(req);
|
||||
return true;
|
||||
}
|
||||
if (method != HTTP_POST) {
|
||||
return false;
|
||||
}
|
||||
if (n == 1) {
|
||||
*ret = create_pattern(req);
|
||||
} else if (n == 2 && !strcmp(seg[1], "upload")) {
|
||||
*ret = upload(req);
|
||||
} else if (n == 2 && !strcmp(seg[1], "driver")) {
|
||||
*ret = create_driver_pattern(req);
|
||||
} else if (n == 3 && !strcmp(seg[2], "send")) {
|
||||
*ret = send_pattern(req, seg[1]);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
Reference in new issue
Block a user