You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
314 lines
9.8 KiB
314 lines
9.8 KiB
#pragma once
|
|
|
|
#include <assert.h>
|
|
#include <inttypes.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <jsmn.h>
|
|
|
|
#include "runtime.h"
|
|
#include "http.h"
|
|
#include "module.h"
|
|
#include "module_config.h"
|
|
|
|
#define JSON_TOKENS_CAPACITY 16384
|
|
|
|
enum
|
|
{
|
|
module_name,
|
|
module_path,
|
|
module_port,
|
|
module_route,
|
|
module_expected_execution_us,
|
|
module_admissions_percentile,
|
|
module_relative_deadline_us,
|
|
module_http_req_size,
|
|
module_http_resp_size,
|
|
module_http_resp_content_type,
|
|
module_keys_len
|
|
};
|
|
|
|
static const char *module_keys[module_keys_len] = { "name",
|
|
"path",
|
|
"port",
|
|
"route",
|
|
"expected-execution-us",
|
|
"admissions-percentile",
|
|
"relative-deadline-us",
|
|
"http-req-size",
|
|
"http-resp-size",
|
|
"http-resp-content-type" };
|
|
|
|
static inline char *
|
|
jsmn_type(jsmntype_t type)
|
|
{
|
|
switch (type) {
|
|
case JSMN_UNDEFINED:
|
|
return "Undefined";
|
|
case JSMN_OBJECT:
|
|
return "Object";
|
|
case JSMN_ARRAY:
|
|
return "Array";
|
|
case JSMN_STRING:
|
|
return "String";
|
|
case JSMN_PRIMITIVE:
|
|
return "Primitive";
|
|
default:
|
|
return "Invalid";
|
|
}
|
|
}
|
|
|
|
static inline bool
|
|
has_valid_size(jsmntok_t tok, char *key, int expected_size)
|
|
{
|
|
if (tok.size != expected_size) {
|
|
fprintf(stderr, "%s has size %d, expected %d\n", key, tok.size, expected_size);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool
|
|
has_valid_type(jsmntok_t tok, char *key, jsmntype_t expected_type)
|
|
{
|
|
if (tok.type != expected_type) {
|
|
fprintf(stderr, "The value of the key %s should be a %s, was a %s\n", key, jsmn_type(expected_type),
|
|
jsmn_type(tok.type));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool
|
|
is_nonempty_string(jsmntok_t tok, char *key)
|
|
{
|
|
if (!has_valid_type(tok, key, JSMN_STRING)) return false;
|
|
|
|
if (tok.end - tok.start < 1) {
|
|
fprintf(stderr, "The value of the key %s was an empty string\n", key);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool
|
|
is_valid_key(jsmntok_t tok)
|
|
{
|
|
if (tok.type != JSMN_STRING) {
|
|
fprintf(stderr, "Expected token to be a key with a type of string, was a %s\n", jsmn_type(tok.type));
|
|
return false;
|
|
}
|
|
|
|
if (tok.end - tok.start < 1) {
|
|
fprintf(stderr, "Key was an empty string\n");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline int
|
|
parse_uint8_t(jsmntok_t tok, const char *json_buf, const char *key, uint8_t *ret)
|
|
{
|
|
char *end = NULL;
|
|
intmax_t temp = strtoimax(&json_buf[tok.start], &end, 10);
|
|
|
|
if (end != &json_buf[tok.end] || temp < 0 || temp > UINT8_MAX) {
|
|
fprintf(stderr, "Unable to parse uint8_t for key %s\n", key);
|
|
return -1;
|
|
}
|
|
|
|
*ret = (uint8_t)temp;
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
parse_uint16_t(jsmntok_t tok, const char *json_buf, const char *key, uint16_t *ret)
|
|
{
|
|
char *end = NULL;
|
|
intmax_t temp = strtoimax(&json_buf[tok.start], &end, 10);
|
|
|
|
if (end != &json_buf[tok.end] || temp < 0 || temp > UINT16_MAX) {
|
|
fprintf(stderr, "Unable to parse uint16_t for key %s\n", key);
|
|
return -1;
|
|
}
|
|
|
|
*ret = (uint16_t)temp;
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
parse_uint32_t(jsmntok_t tok, const char *json_buf, const char *key, uint32_t *ret)
|
|
{
|
|
char *end = NULL;
|
|
uintmax_t temp = strtoimax(&json_buf[tok.start], &end, 10);
|
|
|
|
if (end != &json_buf[tok.end] || temp < 0 || temp > UINT32_MAX) {
|
|
fprintf(stderr, "Unable to parse uint32_t for key %s\n", key);
|
|
return -1;
|
|
}
|
|
|
|
*ret = (uint32_t)temp;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Parses a JSON file into an array of module configs
|
|
* @param file_name The path of the JSON file
|
|
* @return module_config_vec_len on success. -1 on Error
|
|
*/
|
|
static inline int
|
|
parse_json(const char *json_buf, ssize_t json_buf_size, struct module_config **module_config_vec)
|
|
{
|
|
assert(json_buf != NULL);
|
|
assert(json_buf_size > 0);
|
|
assert(module_config_vec != NULL);
|
|
|
|
jsmntok_t tokens[JSON_TOKENS_CAPACITY];
|
|
int module_config_vec_len = 0;
|
|
|
|
|
|
/* Initialize the Jasmine Parser and an array to hold the tokens */
|
|
jsmn_parser module_parser;
|
|
jsmn_init(&module_parser);
|
|
|
|
/* Use Jasmine to parse the JSON */
|
|
int total_tokens = jsmn_parse(&module_parser, json_buf, json_buf_size, tokens, JSON_TOKENS_CAPACITY);
|
|
if (total_tokens < 0) {
|
|
if (total_tokens == JSMN_ERROR_INVAL) {
|
|
fprintf(stderr, "Error parsing %s: bad token, JSON string is corrupted\n", json_buf);
|
|
} else if (total_tokens == JSMN_ERROR_PART) {
|
|
fprintf(stderr, "Error parsing %s: JSON string is too short, expecting more JSON data\n",
|
|
json_buf);
|
|
} else if (total_tokens == JSMN_ERROR_NOMEM) {
|
|
/*
|
|
* According to the README at https://github.com/zserge/jsmn, this is a potentially recoverable
|
|
* error. More tokens can be allocated and jsmn_parse can be re-invoked.
|
|
*/
|
|
fprintf(stderr, "Error parsing %s: Not enough tokens, JSON string is too large\n", json_buf);
|
|
}
|
|
goto err;
|
|
}
|
|
|
|
if (tokens[0].type != JSMN_ARRAY) {
|
|
fprintf(stderr, "Outermost Config should be a JSON array, was a JSON %s\n", jsmn_type(tokens[0].type));
|
|
goto err;
|
|
}
|
|
|
|
module_config_vec_len = tokens[0].size;
|
|
if (module_config_vec_len == 0) {
|
|
fprintf(stderr, "Config is an empty JSON array\n");
|
|
goto err;
|
|
}
|
|
|
|
*module_config_vec = (struct module_config *)calloc(module_config_vec_len, sizeof(struct module_config));
|
|
int module_idx = -1;
|
|
int module_fields_remaining = 0;
|
|
|
|
for (int i = 1; i < total_tokens; i++) {
|
|
char key[32] = { 0 };
|
|
|
|
/* Assumption: Objects are never used within a module_config. This likely will not be true in the
|
|
* future due to routes or multiple entrypoints */
|
|
if (tokens[i].type == JSMN_OBJECT) {
|
|
assert(module_fields_remaining == 0);
|
|
module_fields_remaining = tokens[i].size;
|
|
module_idx++;
|
|
} else {
|
|
/* Inside Object */
|
|
|
|
/* Validate that key is non-emptry string */
|
|
if (!is_valid_key(tokens[i])) goto json_parse_err;
|
|
|
|
sprintf(key, "%.*s", tokens[i].end - tokens[i].start, json_buf + tokens[i].start);
|
|
|
|
/* Validate that key has a value */
|
|
if (!has_valid_size(tokens[i], key, 1)) goto json_parse_err;
|
|
|
|
/* Advance to Value */
|
|
i++;
|
|
|
|
if (strcmp(key, module_keys[module_name]) == 0) {
|
|
if (!is_nonempty_string(tokens[i], key)) goto json_parse_err;
|
|
|
|
(*module_config_vec)[module_idx].name = strndup(json_buf + tokens[i].start,
|
|
tokens[i].end - tokens[i].start);
|
|
} else if (strcmp(key, module_keys[module_path]) == 0) {
|
|
if (!is_nonempty_string(tokens[i], key)) goto json_parse_err;
|
|
|
|
(*module_config_vec)[module_idx].path = strndup(json_buf + tokens[i].start,
|
|
tokens[i].end - tokens[i].start);
|
|
} else if (strcmp(key, module_keys[module_port]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_PRIMITIVE)) goto json_parse_err;
|
|
|
|
int rc = parse_uint16_t(tokens[i], json_buf, module_keys[module_port],
|
|
&(*module_config_vec)[module_idx].port);
|
|
if (rc < 0) goto json_parse_err;
|
|
} else if (strcmp(key, module_keys[module_route]) == 0) {
|
|
if (!is_nonempty_string(tokens[i], key)) goto json_parse_err;
|
|
|
|
(*module_config_vec)[module_idx].route = strndup(json_buf + tokens[i].start,
|
|
tokens[i].end - tokens[i].start);
|
|
} else if (strcmp(key, module_keys[module_expected_execution_us]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_PRIMITIVE)) goto json_parse_err;
|
|
|
|
int rc = parse_uint32_t(tokens[i], json_buf, module_keys[module_expected_execution_us],
|
|
&(*module_config_vec)[module_idx].expected_execution_us);
|
|
if (rc < 0) goto json_parse_err;
|
|
} else if (strcmp(key, module_keys[module_admissions_percentile]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_PRIMITIVE)) goto json_parse_err;
|
|
|
|
int rc = parse_uint8_t(tokens[i], json_buf, module_keys[module_admissions_percentile],
|
|
&(*module_config_vec)[module_idx].admissions_percentile);
|
|
if (rc < 0) goto json_parse_err;
|
|
} else if (strcmp(key, module_keys[module_relative_deadline_us]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_PRIMITIVE)) goto json_parse_err;
|
|
|
|
int rc = parse_uint32_t(tokens[i], json_buf, module_keys[module_relative_deadline_us],
|
|
&(*module_config_vec)[module_idx].relative_deadline_us);
|
|
if (rc < 0) goto json_parse_err;
|
|
} else if (strcmp(key, module_keys[module_http_req_size]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_PRIMITIVE)) goto json_parse_err;
|
|
|
|
int rc = parse_uint32_t(tokens[i], json_buf, module_keys[module_http_req_size],
|
|
&(*module_config_vec)[module_idx].http_req_size);
|
|
if (rc < 0) goto json_parse_err;
|
|
} else if (strcmp(key, module_keys[module_http_resp_size]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_PRIMITIVE)) goto json_parse_err;
|
|
|
|
int rc = parse_uint32_t(tokens[i], json_buf, module_keys[module_http_resp_size],
|
|
&(*module_config_vec)[module_idx].http_resp_size);
|
|
if (rc < 0) goto json_parse_err;
|
|
} else if (strcmp(key, module_keys[module_http_resp_content_type]) == 0) {
|
|
if (!has_valid_type(tokens[i], key, JSMN_STRING)) goto json_parse_err;
|
|
|
|
(*module_config_vec)[module_idx].http_resp_content_type =
|
|
strndup(json_buf + tokens[i].start, tokens[i].end - tokens[i].start);
|
|
} else {
|
|
fprintf(stderr, "%s is not a valid key\n", key);
|
|
goto json_parse_err;
|
|
}
|
|
module_fields_remaining--;
|
|
}
|
|
}
|
|
|
|
#ifdef LOG_MODULE_LOADING
|
|
debuglog("Loaded %d module%s!\n", module_count, module_count > 1 ? "s" : "");
|
|
#endif
|
|
|
|
done:
|
|
return module_config_vec_len;
|
|
json_parse_err:
|
|
free(*module_config_vec);
|
|
err:
|
|
fprintf(stderr, "JSON:\n%s\n", json_buf);
|
|
module_config_vec_len = -1;
|
|
goto done;
|
|
}
|