src/lua.c

   1 /**
   2  * collectd - src/lua.c
   3  * Copyright (C) 2010       Julien Ammous
   4  * Copyright (C) 2010       Florian Forster
   5  * Copyright (C) 2016       Ruben Kerkhof
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *   Julien Ammous
  27  *   Florian Forster <octo at collectd.org>
  28  *   Ruben Kerkhof <ruben at rubenkerkhof.com>
  29  **/
  30
  31 #include "collectd.h"
  32 #include "plugin.h"
  33 #include "utils/common/common.h"
  34 #include "utils_lua.h"
  35
  36 /* Include the Lua API header files. */
  37 #include <lauxlib.h>
  38 #include <lua.h>
  39 #include <lualib.h>
  40
  41 #include <pthread.h>
  42
  43 typedef struct lua_script_s {
  44   lua_State *lua_state;
  45   struct lua_script_s *next;
  46 } lua_script_t;
  47
  48 typedef struct {
  49   lua_State *lua_state;
  50   char *lua_function_name;
  51   pthread_mutex_t lock;
  52   int callback_id;
  53 } clua_callback_data_t;
  54
  55 static char base_path[PATH_MAX];
  56 static lua_script_t *scripts;
  57
  58 static int clua_store_callback(lua_State *L, int idx) /* {{{ */
  59 {
  60   /* Copy the function pointer */
  61   lua_pushvalue(L, idx);
  62
  63   return luaL_ref(L, LUA_REGISTRYINDEX);
  64 } /* }}} int clua_store_callback */
  65
  66 static int clua_load_callback(lua_State *L, int callback_ref) /* {{{ */
  67 {
  68   lua_rawgeti(L, LUA_REGISTRYINDEX, callback_ref);
  69
  70   if (!lua_isfunction(L, -1)) {
  71     lua_pop(L, 1);
  72     return -1;
  73   }
  74
  75   return 0;
  76 } /* }}} int clua_load_callback */
  77
  78 /* Store the threads in a global variable so they are not cleaned up by the
  79  * garbage collector. */
  80 static int clua_store_thread(lua_State *L, int idx) /* {{{ */
  81 {
  82   if (!lua_isthread(L, idx)) {
  83     return -1;
  84   }
  85
  86   /* Copy the thread pointer */
  87   lua_pushvalue(L, idx);
  88
  89   luaL_ref(L, LUA_REGISTRYINDEX);
  90   return 0;
  91 } /* }}} int clua_store_thread */
  92
  93 static int clua_read(user_data_t *ud) /* {{{ */
  94 {
  95   clua_callback_data_t *cb = ud->data;
  96
  97   pthread_mutex_lock(&cb->lock);
  98
  99   lua_State *L = cb->lua_state;
 100
 101   int status = clua_load_callback(L, cb->callback_id);
 102   if (status != 0) {
 103     ERROR("Lua plugin: Unable to load callback \"%s\" (id %i).",
 104           cb->lua_function_name, cb->callback_id);
 105     pthread_mutex_unlock(&cb->lock);
 106     return -1;
 107   }
 108   /* +1 = 1 */
 109
 110   status = lua_pcall(L, 0, 1, 0);
 111   if (status != 0) {
 112     const char *errmsg = lua_tostring(L, -1);
 113     if (errmsg == NULL)
 114       ERROR("Lua plugin: Calling a read callback failed. "
 115             "In addition, retrieving the error message failed.");
 116     else
 117       ERROR("Lua plugin: Calling a read callback failed: %s", errmsg);
 118     lua_pop(L, 1);
 119     pthread_mutex_unlock(&cb->lock);
 120     return -1;
 121   }
 122
 123   if (!lua_isnumber(L, -1)) {
 124     ERROR("Lua plugin: Read function \"%s\" (id %i) did not return a numeric "
 125           "status.",
 126           cb->lua_function_name, cb->callback_id);
 127     status = -1;
 128   } else {
 129     status = (int)lua_tointeger(L, -1);
 130   }
 131
 132   /* pop return value and function */
 133   lua_pop(L, 1); /* -1 = 0 */
 134
 135   pthread_mutex_unlock(&cb->lock);
 136   return status;
 137 } /* }}} int clua_read */
 138
 139 static int clua_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
 140                       user_data_t *ud) {
 141   clua_callback_data_t *cb = ud->data;
 142
 143   pthread_mutex_lock(&cb->lock);
 144
 145   lua_State *L = cb->lua_state;
 146
 147   int status = clua_load_callback(L, cb->callback_id);
 148   if (status != 0) {
 149     ERROR("Lua plugin: Unable to load callback \"%s\" (id %i).",
 150           cb->lua_function_name, cb->callback_id);
 151     pthread_mutex_unlock(&cb->lock);
 152     return -1;
 153   }
 154   /* +1 = 1 */
 155
 156   status = luaC_pushvaluelist(L, ds, vl);
 157   if (status != 0) {
 158     lua_pop(L, 1); /* -1 = 0 */
 159     pthread_mutex_unlock(&cb->lock);
 160     ERROR("Lua plugin: luaC_pushvaluelist failed.");
 161     return -1;
 162   }
 163   /* +1 = 2 */
 164
 165   status = lua_pcall(L, 1, 1, 0); /* -2+1 = 1 */
 166   if (status != 0) {
 167     const char *errmsg = lua_tostring(L, -1);
 168     if (errmsg == NULL)
 169       ERROR("Lua plugin: Calling the write callback failed. "
 170             "In addition, retrieving the error message failed.");
 171     else
 172       ERROR("Lua plugin: Calling the write callback failed:\n%s", errmsg);
 173     lua_pop(L, 1); /* -1 = 0 */
 174     pthread_mutex_unlock(&cb->lock);
 175     return -1;
 176   }
 177
 178   if (!lua_isnumber(L, -1)) {
 179     ERROR("Lua plugin: Write function \"%s\" (id %i) did not return a numeric "
 180           "value.",
 181           cb->lua_function_name, cb->callback_id);
 182     status = -1;
 183   } else {
 184     status = (int)lua_tointeger(L, -1);
 185   }
 186
 187   lua_pop(L, 1); /* -1 = 0 */
 188   pthread_mutex_unlock(&cb->lock);
 189   return status;
 190 } /* }}} int clua_write */
 191
 192 /*
 193  * Exported functions
 194  */
 195
 196 static int lua_cb_log_debug(lua_State *L) /* {{{ */
 197 {
 198   const char *msg = luaL_checkstring(L, 1);
 199   plugin_log(LOG_DEBUG, "%s", msg);
 200   return 0;
 201 } /* }}} int lua_cb_log_debug */
 202
 203 static int lua_cb_log_error(lua_State *L) /* {{{ */
 204 {
 205   const char *msg = luaL_checkstring(L, 1);
 206   plugin_log(LOG_ERR, "%s", msg);
 207   return 0;
 208 } /* }}} int lua_cb_log_error */
 209
 210 static int lua_cb_log_info(lua_State *L) /* {{{ */
 211 {
 212   const char *msg = luaL_checkstring(L, 1);
 213   plugin_log(LOG_INFO, "%s", msg);
 214   return 0;
 215 } /* }}} int lua_cb_log_info */
 216
 217 static int lua_cb_log_notice(lua_State *L) /* {{{ */
 218 {
 219   const char *msg = luaL_checkstring(L, 1);
 220   plugin_log(LOG_NOTICE, "%s", msg);
 221   return 0;
 222 } /* }}} int lua_cb_log_notice */
 223
 224 static int lua_cb_log_warning(lua_State *L) /* {{{ */
 225 {
 226   const char *msg = luaL_checkstring(L, 1);
 227   plugin_log(LOG_WARNING, "%s", msg);
 228   return 0;
 229 } /* }}} int lua_cb_log_warning */
 230
 231 static int lua_cb_dispatch_values(lua_State *L) /* {{{ */
 232 {
 233   int nargs = lua_gettop(L);
 234
 235   if (nargs != 1)
 236     return luaL_error(L, "Invalid number of arguments (%d != 1)", nargs);
 237
 238   luaL_checktype(L, 1, LUA_TTABLE);
 239
 240   value_list_t *vl = luaC_tovaluelist(L, -1);
 241   if (vl == NULL)
 242     return luaL_error(L, "%s", "luaC_tovaluelist failed");
 243
 244 #if COLLECT_DEBUG
 245   char identifier[6 * DATA_MAX_NAME_LEN];
 246   FORMAT_VL(identifier, sizeof(identifier), vl);
 247
 248   DEBUG("Lua plugin: collectd.dispatch_values(): Received value list \"%s\", "
 249         "time %.3f, interval %.3f.",
 250         identifier, CDTIME_T_TO_DOUBLE(vl->time),
 251         CDTIME_T_TO_DOUBLE(vl->interval));
 252 #endif
 253
 254   plugin_dispatch_values(vl);
 255
 256   sfree(vl->values);
 257   sfree(vl);
 258   return 0;
 259 } /* }}} lua_cb_dispatch_values */
 260
 261 static void lua_cb_free(void *data) {
 262   clua_callback_data_t *cb = data;
 263   free(cb->lua_function_name);
 264   pthread_mutex_destroy(&cb->lock);
 265   free(cb);
 266 }
 267
 268 static int lua_cb_register_read(lua_State *L) /* {{{ */
 269 {
 270   int nargs = lua_gettop(L);
 271
 272   if (nargs != 1)
 273     return luaL_error(L, "Invalid number of arguments (%d != 1)", nargs);
 274
 275   luaL_checktype(L, 1, LUA_TFUNCTION);
 276
 277   char function_name[DATA_MAX_NAME_LEN];
 278   snprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
 279
 280   int callback_id = clua_store_callback(L, 1);
 281   if (callback_id < 0)
 282     return luaL_error(L, "%s", "Storing callback function failed");
 283
 284   lua_State *thread = lua_newthread(L);
 285   if (thread == NULL)
 286     return luaL_error(L, "%s", "lua_newthread failed");
 287   clua_store_thread(L, -1);
 288   lua_pop(L, 1);
 289
 290   clua_callback_data_t *cb = calloc(1, sizeof(*cb));
 291   if (cb == NULL)
 292     return luaL_error(L, "%s", "calloc failed");
 293
 294   cb->lua_state = thread;
 295   cb->callback_id = callback_id;
 296   cb->lua_function_name = strdup(function_name);
 297   pthread_mutex_init(&cb->lock, NULL);
 298
 299   int status =
 300       plugin_register_complex_read(/* group = */ "lua",
 301                                    /* name      = */ function_name,
 302                                    /* callback  = */ clua_read,
 303                                    /* interval  = */ 0,
 304                                    &(user_data_t){
 305                                        .data = cb, .free_func = lua_cb_free,
 306                                    });
 307
 308   if (status != 0)
 309     return luaL_error(L, "%s", "plugin_register_complex_read failed");
 310   return 0;
 311 } /* }}} int lua_cb_register_read */
 312
 313 static int lua_cb_register_write(lua_State *L) /* {{{ */
 314 {
 315   int nargs = lua_gettop(L);
 316
 317   if (nargs != 1)
 318     return luaL_error(L, "Invalid number of arguments (%d != 1)", nargs);
 319
 320   luaL_checktype(L, 1, LUA_TFUNCTION);
 321
 322   char function_name[DATA_MAX_NAME_LEN] = "";
 323   snprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
 324
 325   int callback_id = clua_store_callback(L, 1);
 326   if (callback_id < 0)
 327     return luaL_error(L, "%s", "Storing callback function failed");
 328
 329   lua_State *thread = lua_newthread(L);
 330   if (thread == NULL)
 331     return luaL_error(L, "%s", "lua_newthread failed");
 332   clua_store_thread(L, -1);
 333   lua_pop(L, 1);
 334
 335   clua_callback_data_t *cb = calloc(1, sizeof(*cb));
 336   if (cb == NULL)
 337     return luaL_error(L, "%s", "calloc failed");
 338
 339   cb->lua_state = thread;
 340   cb->callback_id = callback_id;
 341   cb->lua_function_name = strdup(function_name);
 342   pthread_mutex_init(&cb->lock, NULL);
 343
 344   int status = plugin_register_write(/* name = */ function_name,
 345                                      /* callback  = */ clua_write,
 346                                      &(user_data_t){
 347                                          .data = cb, .free_func = lua_cb_free,
 348                                      });
 349
 350   if (status != 0)
 351     return luaL_error(L, "%s", "plugin_register_write failed");
 352   return 0;
 353 } /* }}} int lua_cb_register_write */
 354
 355 static const luaL_Reg collectdlib[] = {
 356     {"log_debug", lua_cb_log_debug},
 357     {"log_error", lua_cb_log_error},
 358     {"log_info", lua_cb_log_info},
 359     {"log_notice", lua_cb_log_notice},
 360     {"log_warning", lua_cb_log_warning},
 361     {"dispatch_values", lua_cb_dispatch_values},
 362     {"register_read", lua_cb_register_read},
 363     {"register_write", lua_cb_register_write},
 364     {NULL, NULL}};
 365
 366 static int open_collectd(lua_State *L) /* {{{ */
 367 {
 368 #if LUA_VERSION_NUM < 502
 369   luaL_register(L, "collectd", collectdlib);
 370 #else
 371   luaL_newlib(L, collectdlib);
 372 #endif
 373   return 1;
 374 } /* }}} */
 375
 376 static void lua_script_free(lua_script_t *script) /* {{{ */
 377 {
 378   if (script == NULL)
 379     return;
 380
 381   lua_script_t *next = script->next;
 382
 383   if (script->lua_state != NULL) {
 384     lua_close(script->lua_state);
 385     script->lua_state = NULL;
 386   }
 387
 388   sfree(script);
 389
 390   lua_script_free(next);
 391 } /* }}} void lua_script_free */
 392
 393 static int lua_script_init(lua_script_t *script) /* {{{ */
 394 {
 395   memset(script, 0, sizeof(*script));
 396
 397   /* initialize the lua context */
 398   script->lua_state = luaL_newstate();
 399   if (script->lua_state == NULL) {
 400     ERROR("Lua plugin: luaL_newstate() failed.");
 401     return -1;
 402   }
 403
 404   /* Open up all the standard Lua libraries. */
 405   luaL_openlibs(script->lua_state);
 406
 407 /* Load the 'collectd' library */
 408 #if LUA_VERSION_NUM < 502
 409   lua_pushcfunction(script->lua_state, open_collectd);
 410   lua_pushstring(script->lua_state, "collectd");
 411   lua_call(script->lua_state, 1, 0);
 412 #else
 413   luaL_requiref(script->lua_state, "collectd", open_collectd, 1);
 414   lua_pop(script->lua_state, 1);
 415 #endif
 416
 417   /* Prepend BasePath to package.path */
 418   if (base_path[0] != '\0') {
 419     lua_getglobal(script->lua_state, "package");
 420     lua_getfield(script->lua_state, -1, "path");
 421
 422     const char *cur_path = lua_tostring(script->lua_state, -1);
 423     char *new_path = ssnprintf_alloc("%s/?.lua;%s", base_path, cur_path);
 424
 425     lua_pop(script->lua_state, 1);
 426     lua_pushstring(script->lua_state, new_path);
 427
 428     free(new_path);
 429
 430     lua_setfield(script->lua_state, -2, "path");
 431     lua_pop(script->lua_state, 1);
 432   }
 433
 434   return 0;
 435 } /* }}} int lua_script_init */
 436
 437 static int lua_script_load(const char *script_path) /* {{{ */
 438 {
 439   lua_script_t *script = malloc(sizeof(*script));
 440   if (script == NULL) {
 441     ERROR("Lua plugin: malloc failed.");
 442     return -1;
 443   }
 444
 445   int status = lua_script_init(script);
 446   if (status != 0) {
 447     lua_script_free(script);
 448     return status;
 449   }
 450
 451   status = luaL_loadfile(script->lua_state, script_path);
 452   if (status != 0) {
 453     ERROR("Lua plugin: luaL_loadfile failed: %s",
 454           lua_tostring(script->lua_state, -1));
 455     lua_pop(script->lua_state, 1);
 456     lua_script_free(script);
 457     return -1;
 458   }
 459
 460   status = lua_pcall(script->lua_state,
 461                      /* nargs = */ 0,
 462                      /* nresults = */ LUA_MULTRET,
 463                      /* errfunc = */ 0);
 464   if (status != 0) {
 465     const char *errmsg = lua_tostring(script->lua_state, -1);
 466
 467     if (errmsg == NULL)
 468       ERROR("Lua plugin: lua_pcall failed with status %i. "
 469             "In addition, no error message could be retrieved from the stack.",
 470             status);
 471     else
 472       ERROR("Lua plugin: Executing script \"%s\" failed:\n%s",
 473             script_path, errmsg);
 474
 475     lua_script_free(script);
 476     return -1;
 477   }
 478
 479   /* Append this script to the global list of scripts. */
 480   if (scripts) {
 481     lua_script_t *last = scripts;
 482     while (last->next)
 483       last = last->next;
 484
 485     last->next = script;
 486   } else {
 487     scripts = script;
 488   }
 489
 490   return 0;
 491 } /* }}} int lua_script_load */
 492
 493 static int lua_config_base_path(const oconfig_item_t *ci) /* {{{ */
 494 {
 495   int status = cf_util_get_string_buffer(ci, base_path, sizeof(base_path));
 496   if (status != 0)
 497     return status;
 498
 499   size_t len = strlen(base_path);
 500   while ((len > 0) && (base_path[len - 1] == '/')) {
 501     len--;
 502     base_path[len] = '\0';
 503   }
 504
 505   DEBUG("Lua plugin: base_path = \"%s\";", base_path);
 506
 507   return 0;
 508 } /* }}} int lua_config_base_path */
 509
 510 static int lua_config_script(const oconfig_item_t *ci) /* {{{ */
 511 {
 512   char rel_path[PATH_MAX];
 513
 514   int status = cf_util_get_string_buffer(ci, rel_path, sizeof(rel_path));
 515   if (status != 0)
 516     return status;
 517
 518   char abs_path[PATH_MAX];
 519
 520   if (base_path[0] == '\0')
 521     sstrncpy(abs_path, rel_path, sizeof(abs_path));
 522   else
 523     snprintf(abs_path, sizeof(abs_path), "%s/%s", base_path, rel_path);
 524
 525   DEBUG("Lua plugin: abs_path = \"%s\";", abs_path);
 526
 527   status = lua_script_load(abs_path);
 528   if (status != 0)
 529     return status;
 530
 531   INFO("Lua plugin: File \"%s\" loaded successfully", abs_path);
 532
 533   return 0;
 534 } /* }}} int lua_config_script */
 535
 536 /*
 537  * <Plugin lua>
 538  *   BasePath "/"
 539  *   Script "script1.lua"
 540  *   Script "script2.lua"
 541  * </Plugin>
 542  */
 543 static int lua_config(oconfig_item_t *ci) /* {{{ */
 544 {
 545   int status = 0;
 546   for (int i = 0; i < ci->children_num; i++) {
 547     oconfig_item_t *child = ci->children + i;
 548
 549     if (strcasecmp("BasePath", child->key) == 0) {
 550       status = lua_config_base_path(child);
 551     } else if (strcasecmp("Script", child->key) == 0) {
 552       status = lua_config_script(child);
 553     } else {
 554       ERROR("Lua plugin: Option `%s' is not allowed here.", child->key);
 555       status = 1;
 556     }
 557   }
 558
 559   return status;
 560 } /* }}} int lua_config */
 561
 562 static int lua_shutdown(void) /* {{{ */
 563 {
 564   lua_script_free(scripts);
 565
 566   return 0;
 567 } /* }}} int lua_shutdown */
 568
 569 void module_register(void) {
 570   plugin_register_complex_config("lua", lua_config);
 571   plugin_register_shutdown("lua", lua_shutdown);
 572 }