lsb_heka_stats lsb_heka_get_stats(lsb_heka_sandbox *hsb)
{
if (!hsb) return (struct lsb_heka_stats){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
return (struct lsb_heka_stats){
.mem_cur = lsb_usage(hsb->lsb, LSB_UT_MEMORY, LSB_US_CURRENT),
.mem_max = lsb_usage(hsb->lsb, LSB_UT_MEMORY, LSB_US_MAXIMUM),
.out_max = lsb_usage(hsb->lsb, LSB_UT_OUTPUT, LSB_US_MAXIMUM),
.ins_max = lsb_usage(hsb->lsb, LSB_UT_INSTRUCTION, LSB_US_MAXIMUM),
.im_cnt = hsb->stats.im_cnt,
.im_bytes = hsb->stats.im_bytes,
.pm_cnt = hsb->stats.pm_cnt,
.pm_failures = hsb->stats.pm_failures,
.pm_avg = hsb->stats.pm.mean,
.pm_sd = lsb_sd_running_stats(&hsb->stats.pm),
.te_avg = hsb->stats.te.mean,
.te_sd = lsb_sd_running_stats(&hsb->stats.te)
};
}
bool lsb_heka_is_running(lsb_heka_sandbox *hsb)
{
if (!hsb) return false;
if (lsb_get_state(hsb->lsb) == LSB_RUNNING) return true;
return false;
}
static char* test_usage_error()
{
size_t u = lsb_usage(NULL, LSB_UT_MEMORY, LSB_US_CURRENT);
mu_assert(u == 0, "NULL sandbox memory usage received: %" PRIuSIZE, u);
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/simple.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
u = lsb_usage(NULL, LSB_UT_MAX + 1, LSB_US_CURRENT);
mu_assert(u == 0, "Invalid usage type received: %" PRIuSIZE, u);
u = lsb_usage(NULL, LSB_UT_MEMORY, LSB_US_MAX + 1);
mu_assert(u == 0, "Invalid usage stat received: %" PRIuSIZE, u);
mu_assert(sb, "lsb_create() received: NULL");
lsb_terminate(sb, "forced termination");
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_TERMINATED, "lsb_get_state() received: %d", s);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_CURRENT);
mu_assert(u > 0, "Terminated memory usage received: 0");
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_api_assertion()
{
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/counter.lua", "", NULL);
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_stop_sandbox(NULL);
mu_assert(lsb_destroy(NULL) == NULL, "not null");
mu_assert(lsb_usage(NULL, 0, 0) == 0, "not 0");
mu_assert(lsb_usage(sb, LSB_UT_MAX, 0) == 0, "not 0");
mu_assert(lsb_usage(sb, 0, LSB_US_MAX) == 0, "not 0");
mu_assert(strcmp(lsb_get_error(NULL), "") == 0, "not empty");
lsb_set_error(NULL, "foo");
mu_assert(lsb_get_lua(NULL) == NULL, "not null");
mu_assert(lsb_get_lua_file(NULL) == NULL, "not null");
mu_assert(lsb_get_parent(NULL) == NULL, "not null");
mu_assert(lsb_get_logger(NULL) == NULL, "not null");
mu_assert(lsb_get_state(NULL) == LSB_UNKNOWN, "not unknown");
lsb_add_function(NULL, lsb_test_write_output, "foo");
lsb_add_function(sb, NULL, "foo");
lsb_add_function(sb, lsb_test_write_output, NULL);
mu_assert(lsb_pcall_setup(NULL, "foo") == LSB_ERR_UTIL_NULL, "not null");
mu_assert(lsb_pcall_setup(sb, NULL) == LSB_ERR_UTIL_NULL, "not null");
lsb_add_function(NULL, NULL, NULL);
lsb_pcall_teardown(NULL);
lsb_terminate(NULL, NULL);
lsb_terminate(sb, NULL);
lsb_add_function(sb, lsb_test_write_output, "write_output");
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_init_error()
{
// null sandbox
int result = lsb_init(NULL, NULL);
mu_assert(result == 0, "lsb_init() null sandbox ptr");
// load error
lua_sandbox* sb = lsb_create(NULL, "lua/simple1.lua", 65765, 1000,
1024);
mu_assert(sb, "lsb_create() received: NULL");
result = lsb_init(sb, NULL);
mu_assert(result == 2, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_TERMINATED, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
// out of memory
sb = lsb_create(NULL, "lua/simple.lua", 6000, 1000, 1024);
mu_assert(sb, "lsb_create() received: NULL");
result = lsb_init(sb, NULL);
mu_assert(result == 2, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s\n", e);
return NULL;
}
static char* test_cbuf()
{
const char* outputs[] = {
"{\"time\":0,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n0\t0\t0\n0\t0\t0\n0\t0\t0\n"
, "{\"time\":0,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n1\t1\t1\n2\t1\t2\n3\t1\t3\n"
, "{\"time\":2,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n3\t1\t3\n0\t0\t0\n1\t1\t1\n"
, "{\"time\":8,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n0\t0\t0\n0\t0\t0\n1\t1\t1\n"
, NULL
};
lua_sandbox* sb = lsb_create(NULL, "lua/circular_buffer.lua", 32767,
1000, 32767);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
lsb_add_function(sb, &write_output, "write");
result = report(sb, 0);
mu_assert(lsb_get_state(sb) == LSB_RUNNING, "error %s",
lsb_get_error(sb));
mu_assert(strcmp(outputs[0], written_data) == 0, "received: %s",
written_data);
process(sb, 0);
process(sb, 1e9);
process(sb, 1e9);
process(sb, 2e9);
process(sb, 2e9);
process(sb, 2e9);
result = report(sb, 0);
mu_assert(result == 0, "report() received: %d", result);
mu_assert(strcmp(outputs[1], written_data) == 0, "received: %s",
written_data);
process(sb, 4e9);
result = report(sb, 0);
mu_assert(result == 0, "report() received: %d", result);
mu_assert(strcmp(outputs[2], written_data) == 0, "received: %s",
written_data);
process(sb, 10e9);
result = report(sb, 0);
mu_assert(result == 0, "report() received: %d", result);
mu_assert(strcmp(outputs[3], written_data) == 0, "received: %s",
written_data);
result = report(sb, 1);
mu_assert(result == 0, "report() received: %d", result);
result = report(sb, 3);
mu_assert(result == 0, "report() received: %d", result);
e = lsb_destroy(sb, "circular_buffer.preserve");
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static void shutdown_timer_event(hs_output_plugin* p)
{
if (lsb_get_state(p->sb->lsb) != LSB_TERMINATED) {
if (hs_timer_event(p->sb->lsb, time(NULL))) {
hs_log(g_module, 3, "terminated: %s msg: %s", p->sb->name,
lsb_get_error(p->sb->lsb));
}
}
}
static char* test_misc()
{
lsb_state s = lsb_get_state(NULL);
mu_assert(s == LSB_UNKNOWN, "lsb_get_state() received: %d", s);
const char* le = lsb_get_error(NULL);
mu_assert(strlen(le) == 0, "lsb_get_error() received: %s", le);
return NULL;
}
static char* test_simple()
{
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/simple.lua",
"memory_limit = 65765;"
"instruction_limit = 1000;"
"output_limit = 1024;", NULL);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, "simple.preserve");
mu_assert(!ret, "lsb_init() received: %s", ret);
size_t u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_CURRENT);
mu_assert(u > 0, "Current memory usage received: %" PRIuSIZE, u);
printf("cur_mem %" PRIuSIZE "\n", u);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_MAXIMUM);
mu_assert(u > 0, "Maximum memory usage received: %" PRIuSIZE, u);
printf("max_mem %" PRIuSIZE "\n", u);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_LIMIT);
mu_assert(u == 65765, "Memory limit received: %" PRIuSIZE, u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_CURRENT);
mu_assert(u == 7, "Current instructions received: %" PRIuSIZE, u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_MAXIMUM);
mu_assert(u == 7, "Maximum instructions received: %" PRIuSIZE, u);
printf("max_ins %" PRIuSIZE "\n", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_LIMIT);
mu_assert(u == 1000, "Instruction limit received: %" PRIuSIZE, u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_CURRENT);
mu_assert(u == 0, "Current output received: %" PRIuSIZE, u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_MAXIMUM);
mu_assert(u == 0, "Maximum output received: %" PRIuSIZE, u);
printf("max_out %" PRIuSIZE "\n", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_LIMIT);
mu_assert(u == 1024, "Output limit received: %" PRIuSIZE, u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_LIMIT);
mu_assert(u == 1024, "Output limit received: %" PRIuSIZE, u);
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_RUNNING, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_simple()
{
lua_sandbox* sb = lsb_create(NULL, "lua/simple.lua", 65765, 1000,
1024);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
unsigned u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_CURRENT);
mu_assert(u > 0, "Current memory usage received: %u", u);
printf("cur_mem %u\n", u);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_MAXIMUM);
mu_assert(u > 0, "Maximum memory usage received: %u", u);
printf("max_mem %u\n", u);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_LIMIT);
mu_assert(u == 65765, "Memory limit received: %u", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_CURRENT);
mu_assert(u == 7, "Current instructions received: %u", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_MAXIMUM);
mu_assert(u == 7, "Maximum instructions received: %u", u);
printf("max_ins %u\n", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_LIMIT);
mu_assert(u == 1000, "Instruction limit received: %u", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_CURRENT);
mu_assert(u == 0, "Current output received: %u", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_MAXIMUM);
mu_assert(u == 0, "Maximum output received: %u", u);
printf("max_out %u\n", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_LIMIT);
mu_assert(u == 1024, "Output limit received: %u", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_LIMIT);
mu_assert(u == 1024, "Output limit received: %u", u);
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_RUNNING, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb, "simple.preserve");
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_init_error()
{
// null sandbox
lsb_err_value ret = lsb_init(NULL, NULL);
mu_assert(ret == LSB_ERR_UTIL_NULL, "lsb_init() null sandbox ptr");
// load error
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/simple1.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
ret = lsb_init(sb, NULL);
mu_assert(ret == LSB_ERR_LUA, "lsb_init() received: %s", lsb_err_string(ret));
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_TERMINATED, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
// out of memory
sb = lsb_create(NULL, "lua/simple.lua", "memory_limit = 6000", NULL);
mu_assert(sb, "lsb_create() received: NULL");
ret = lsb_init(sb, NULL);
mu_assert(ret == LSB_ERR_LUA, "lsb_init() received: %s", lsb_err_string(ret));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s\n", e);
sb = lsb_create(NULL, "lua/no_external_modules.lua", NULL, NULL);
mu_assert(sb, "lsb_create() received: NULL");
// disabled external modules
ret = lsb_init(sb, NULL);
mu_assert(ret == LSB_ERR_LUA, "lsb_init() received: %s", lsb_err_string(ret));
const char *expected = "no 'path' configuration was specified for the "
"sandbox; external modules have been disabled";
mu_assert(strcmp(lsb_get_error(sb), expected) == 0,
"lsb_get_error() received: %s", lsb_get_error(sb));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
