upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-04-10 19:36:14 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 12
haproxy/include/haproxy/hlua.h

85 lines
3.6 KiB
C
Raw Normal View History

REORG: include: move hlua.h to haproxy/hlua{,-t}.h This one required a few more includes as it uses list and ebpt_node. It still references lots of types/ files for now.
2020-06-04 03:20:54 -04:00
/*
* include/haproxy/hlua.h
* Lua core management functions
*
* Copyright (C) 2015-2016 Thierry Fournier <tfournier@arpalert.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
MEDIUM: lua: lua integration in the build and init system. This is the first step of the lua integration. We add the useful files in the HAProxy project. These files contains the main includes, the Makefile options and empty initialisation function. Is is the LUA skeleton.
2015-01-23 08:06:13 -05:00
REORG: include: move hlua.h to haproxy/hlua{,-t}.h This one required a few more includes as it uses list and ebpt_node. It still references lots of types/ files for now.
2020-06-04 03:20:54 -04:00
#ifndef _HAPROXY_HLUA_H
#define _HAPROXY_HLUA_H
MINOR: lua: remove some #define The #define compilation directives are centralized in the hlua include files. This permits to remove ome #ifdef from the haproxy main code.
2015-03-04 10:48:34 -05:00
REORG: include: move hlua.h to haproxy/hlua{,-t}.h This one required a few more includes as it uses list and ebpt_node. It still references lots of types/ files for now.
2020-06-04 03:20:54 -04:00
#include <haproxy/hlua-t.h>
MEDIUM: lua: lua integration in the build and init system. This is the first step of the lua integration. We add the useful files in the HAProxy project. These files contains the main includes, the Makefile options and empty initialisation function. Is is the LUA skeleton.
2015-01-23 08:06:13 -05:00
REORG: include: move hlua.h to haproxy/hlua{,-t}.h This one required a few more includes as it uses list and ebpt_node. It still references lots of types/ files for now.
2020-06-04 03:20:54 -04:00
#ifdef USE_LUA
MEDIUM: lua: lua integration in the build and init system. This is the first step of the lua integration. We add the useful files in the HAProxy project. These files contains the main includes, the Makefile options and empty initialisation function. Is is the LUA skeleton.
2015-01-23 08:06:13 -05:00
MINOR: lua: use bitfield and macro in place of integer and enum In the future, the lua execution must return scheduling informations. We want more than one flag, so I convert an integer used with an enum into an interer used as bitfield.
2015-03-03 09:17:35 -05:00
/* The following macros are used to set flags. */
#define HLUA_SET_RUN(__hlua) do {(__hlua)->flags |= HLUA_RUN;} while(0)
#define HLUA_CLR_RUN(__hlua) do {(__hlua)->flags &= ~HLUA_RUN;} while(0)
#define HLUA_IS_RUNNING(__hlua) ((__hlua)->flags & HLUA_RUN)
DEBUG: lua: precisely identify if stream is stuck inside lua or not When ha_panic() is called by the watchdog, we try to guess from ha_task_dump() and ha_thread_dump_one() if the thread was stuck while executing lua from the stream context. However we consider this is the case by simply checking if the stream hlua context was set, but this is not very precise because if the hlua context is set, then it simply means that at least one lua instruction was executed at the stream level, not that the stuck was currently executing lua when the panic occured. This is especially true with filters, one could simply register a lua filter that does nothing but this will still end up initializing the stream hlua context for each stream. If the thread end up being stuck during the stream handling, then debug dumping functions will report that the stream was stuck while handling lua, which is not necessarilly true, and could in fact confuse us even more. So here we take another approach, we add the BUSY flag to hlua context: this flag is set by hlua_ctx_resume() around lua_resume() call, this way we can precisely tell if the thread was handling lua when it was interrupted, and we rely on this flag in debug functions to check if the thread was effectively stuck inside lua or not while processing the stream No backport needed unless a commit depends on it.
2024-03-11 19:22:44 -04:00
#define HLUA_SET_BUSY(__hlua) do {(__hlua)->flags |= HLUA_BUSY;} while(0)
#define HLUA_CLR_BUSY(__hlua) do {(__hlua)->flags &= ~HLUA_BUSY;} while(0)
#define HLUA_IS_BUSY(__hlua) ((__hlua)->flags & HLUA_BUSY)
MINOR: lua: adds "forced yield" flag This flag indicate that the current yield is returned by the Lua execution task control. If this flag is set, the current task may quit but will be set in the run queue to be re-executed immediatly. This patch modify the "hlua_yieldk()" function, it adds an argument that contain a field containing yield options.
2015-03-03 11:29:06 -05:00
#define HLUA_SET_CTRLYIELD(__hlua) do {(__hlua)->flags |= HLUA_CTRLYIELD;} while(0)
#define HLUA_CLR_CTRLYIELD(__hlua) do {(__hlua)->flags &= ~HLUA_CTRLYIELD;} while(0)
#define HLUA_IS_CTRLYIELDING(__hlua) ((__hlua)->flags & HLUA_CTRLYIELD)
BUG/MEDIUM: lua: fix infinite loop about channel Before this patch, each yield in a Lua action set a flags to be waked up when some activity were detected on the response channel. This behavior causes loop in the analyzer process. This patch set the wake up on response buffer activity only if we really want to be waked up on this activity.
2015-03-05 11:45:34 -05:00
#define HLUA_SET_WAKERESWR(__hlua) do {(__hlua)->flags |= HLUA_WAKERESWR;} while(0)
#define HLUA_CLR_WAKERESWR(__hlua) do {(__hlua)->flags &= ~HLUA_WAKERESWR;} while(0)
#define HLUA_IS_WAKERESWR(__hlua) ((__hlua)->flags & HLUA_WAKERESWR)
BUG/MEDIUM: lua: the Lua process is not waked up after sending data on requests side If we are writing in the request buffer, we are not waked up when the data are forwarded because it is useles. The request analyzers are waked up only when data is incoming. So, if the request buffer is full, we set the WAKE_ON_WRITE flag.
2015-03-05 18:35:53 -05:00
#define HLUA_SET_WAKEREQWR(__hlua) do {(__hlua)->flags |= HLUA_WAKEREQWR;} while(0)
#define HLUA_CLR_WAKEREQWR(__hlua) do {(__hlua)->flags &= ~HLUA_WAKEREQWR;} while(0)
#define HLUA_IS_WAKEREQWR(__hlua) ((__hlua)->flags & HLUA_WAKEREQWR)
MINOR: lua: Add a flag on lua context to know the yield capability at run time When a script is executed, a flag is used to allow it to yield. An error is returned if a lua function yield, explicitly or not. But there is no way to get this capability in C functions. So there is no way to choose to yield or not depending on this capability. To fill this gap, the flag HLUA_NOYIELD is introduced and added on the lua context if the current script execution is not authorized to yield. Macros to set, clear and test this flags are also added. This feature will be usefull to fix some bugs in lua actions execution.
2021-08-04 11:58:21 -04:00
#define HLUA_CLR_NOYIELD(__hlua) do {(__hlua)->flags &= ~HLUA_NOYIELD;} while(0)
#define HLUA_SET_NOYIELD(__hlua) do {(__hlua)->flags |= HLUA_NOYIELD;} while(0)
#define HLUA_CANT_YIELD(__hlua) ((__hlua)->flags & HLUA_NOYIELD)
MINOR: lua: use bitfield and macro in place of integer and enum In the future, the lua execution must return scheduling informations. We want more than one flag, so I convert an integer used with an enum into an interer used as bitfield.
2015-03-03 09:17:35 -05:00
MINOR: lua: remove some #define The #define compilation directives are centralized in the hlua include files. This permits to remove ome #ifdef from the haproxy main code.
2015-03-04 10:48:34 -05:00
#define HLUA_INIT(__hlua) do { (__hlua)->T = 0; } while(0)
MEDIUM: lua: lua integration in the build and init system. This is the first step of the lua integration. We add the useful files in the HAProxy project. These files contains the main includes, the Makefile options and empty initialisation function. Is is the LUA skeleton.
2015-01-23 08:06:13 -05:00
/* Lua HAProxy integration functions. */
MINOR: lua: Slightly improve function dumping the lua traceback The separator string is now configurable, passing it as parameter when the function is called. In addition, the message have been slightly changed to be a bit more readable.
2021-03-24 09:48:45 -04:00
const char *hlua_traceback(lua_State *L, const char* sep);
MINOR: lua: add runtime execution context The functions added permits to execute the LUA stack execution in HAProxy. It provides all the runtie environment and initialise the main LUA stack.
2015-01-23 08:27:52 -05:00
void hlua_ctx_destroy(struct hlua *lua);
MEDIUM: lua: lua integration in the build and init system. This is the first step of the lua integration. We add the useful files in the HAProxy project. These files contains the main includes, the Makefile options and empty initialisation function. Is is the LUA skeleton.
2015-01-23 08:06:13 -05:00
void hlua_init();
MINOR: lua: post initialisation bindings This system permits to execute some lua function after than HAProxy complete his initialisation. These functions are executed between the end of the configuration parsing and check and the begin of the scheduler.
2015-01-23 06:08:30 -05:00
int hlua_post_init();
MINOR: lua: export applet and task handlers The current functions are seen outside from the debugging code and are convenient to export so that we can improve the thread dump output : void hlua_applet_tcp_fct(struct appctx *ctx); void hlua_applet_http_fct(struct appctx *ctx); struct task *hlua_process_task(struct task *task, void *context, unsigned short state); Of course they are only available when USE_LUA is defined.
2019-08-21 08:14:50 -04:00
void hlua_applet_tcp_fct(struct appctx *ctx);
void hlua_applet_http_fct(struct appctx *ctx);
MEDIUM: hlua/event_hdl: initial support for event handlers Now that the event handler API is pretty mature, we can expose it in the lua API. Introducing the core.event_sub(<event_types>, <cb>) lua function that takes an array of event types <event_types> as well as a callback function <cb> as argument. The function returns a subscription <sub> on success. Subscription <sub> allows you to manage the subscription from anywhere in the script. To this day only the sub->unsub method is implemented. The following event types are currently supported: - "SERVER_ADD": when a server is added - "SERVER_DEL": when a server is removed from haproxy - "SERVER_DOWN": server states goes from up to down - "SERVER_UP": server states goes from down to up As for the <cb> function: it will be called when one of the registered event types occur. The function will be called with 3 arguments: cb(<event>,<data>,<sub>) <event>: event type (string) that triggered the function. (could be any of the types used in <event_types> when registering the subscription) <data>: data associated with the event (specific to each event family). For "SERVER_" family events, server details such as server name/id/proxy will be provided. If the server still exists (not yet deleted), a reference to the live server is provided to spare you from an additionnal lookup if you need to have direct access to the server from lua. <sub> refers to the subscription. In case you need to manage it from within an event handler. (It refers to the same subscription that the one returned from core.event_sub()) Subscriptions are per-thread: the thread that will be handling the event is the one who performed the subscription using core.event_sub() function. Each thread treats events sequentially, it means that if you have, let's say SERVER_UP, then SERVER_DOWN in a short timelapse, then your cb function will first be called with SERVER_UP, and once you're done handling the event, your function will be called again with SERVER_DOWN. This is to ensure event consitency when it comes to logging / triggering logic from lua. Your lua cb function may yield if needed, but you're pleased to process the event as fast as possible to prevent the event queue from growing up To prevent abuses, if the event queue for the current subscription goes over 100 unconsumed events, the subscription will pause itself automatically for as long as it takes for your handler to catch up. This would lead to events being missed, so a warning will be emitted in the logs to inform you about that. This is not something you want to let happen too often, it may indicate that you subscribed to an event that is occurring too frequently or/and that your callback function is too slow to keep up the pace and you should review it. If you want to do some parallel processing because your callback functions are slow: you might want to create subtasks from lua using core.register_task() from within your callback function to perform the heavy job in a dedicated task and allow remaining events to be processed more quickly. Please check the lua documentation for more information.
2023-02-20 12:18:59 -05:00
int hlua_event_sub(lua_State *L, event_hdl_sub_list *sub_list);
MEDIUM: task: extend the state field to 32 bits It's been too short for quite a while now and is now full. It's still time to extend it to 32-bits since we have room for this without wasting any space, so we now gained 16 new bits for future flags. The values were not reassigned just in case there would be a few hidden u16 or short somewhere in which these flags are placed (as it used to be the case with stream->pending_events). The patch is tagged MEDIUM because this required to update the task's process() prototype to use an int instead of a short, that's quite a bunch of places.
2021-03-02 10:09:26 -05:00
struct task *hlua_process_task(struct task *task, void *context, unsigned int state);
MINOR: hlua: add a new hlua_show_current_location() function This function may be used to try to show where some Lua code is currently being executed. It tries hard to detect the initialization phase, both for the global and the per-thread states, and for runtime states. This intends to be used by error handlers to provide the users with indications about what Lua code was being executed when the error triggered.
2022-06-19 11:39:33 -04:00
const char *hlua_show_current_location(const char *pfx);
MINOR: hlua: declare hlua_{ref,pushref,unref} functions Declaring hlua_{ref,pushref,unref} functions to make them usable from hlua_fcn.c to simplify reference handling.
2023-05-03 11:43:02 -04:00
int hlua_ref(lua_State *L);
void hlua_pushref(lua_State *L, int ref);
void hlua_unref(lua_State *L, int ref);
MINOR: hlua: declare hlua_gethlua() function Declaring hlua_gethlua() function to make it usable from hlua_fcn.c.
2023-05-04 07:59:48 -04:00
struct hlua *hlua_gethlua(lua_State *L);
BUG/MINOR: hlua: hlua_yieldk ctx argument should support pointers lua_yieldk ctx argument is of type lua_KContext which is typedefed to intptr_t when available so it can be used to store pointers. But the wrapper function hlua_yieldk() passes it as a regular it so it breaks that promise. Changing hlua_yieldk() prototype so that ctx argument is of type lua_KContext. This bug had no functional impact because ctx argument is not being actively used so far. This may be backported to all stable versions anyway.
2023-07-13 04:18:04 -04:00
void hlua_yieldk(lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k, int timeout, unsigned int flags);
MEDIUM: lua: lua integration in the build and init system. This is the first step of the lua integration. We add the useful files in the HAProxy project. These files contains the main includes, the Makefile options and empty initialisation function. Is is the LUA skeleton.
2015-01-23 08:06:13 -05:00
MINOR: lua: remove some #define The #define compilation directives are centralized in the hlua include files. This permits to remove ome #ifdef from the haproxy main code.
2015-03-04 10:48:34 -05:00
#else /* USE_LUA */
REORG: include: move hlua.h to haproxy/hlua{,-t}.h This one required a few more includes as it uses list and ebpt_node. It still references lots of types/ files for now.
2020-06-04 03:20:54 -04:00
/************************ For use when Lua is disabled ********************/
MINOR: lua: use bitfield and macro in place of integer and enum In the future, the lua execution must return scheduling informations. We want more than one flag, so I convert an integer used with an enum into an interer used as bitfield.
2015-03-03 09:17:35 -05:00
#define HLUA_IS_RUNNING(__hlua) 0
MINOR: lua: remove some #define The #define compilation directives are centralized in the hlua include files. This permits to remove ome #ifdef from the haproxy main code.
2015-03-04 10:48:34 -05:00
#define HLUA_INIT(__hlua)
/* Empty function for compilation without Lua. */
static inline void hlua_init() { }
static inline int hlua_post_init() { return 1; }
BUILD/MINOR: lua: ensure that hlua_ctx_destroy is properly defined When Lua is disabled, the alternate functions must have the same prototype as the original ones, otherwise we get such warnings : src/stream.c:278:27: warning: too many arguments in call to 'hlua_ctx_destroy' hlua_ctx_destroy(&s->hlua); ~~~~~~~~~~~~~~~~ ^ No backport is needed.
2015-06-17 14:18:54 -04:00
static inline void hlua_ctx_destroy(struct hlua *lua) { }
MINOR: hlua: add a new hlua_show_current_location() function This function may be used to try to show where some Lua code is currently being executed. It tries hard to detect the initialization phase, both for the global and the per-thread states, and for runtime states. This intends to be used by error handlers to provide the users with indications about what Lua code was being executed when the error triggered.
2022-06-19 11:39:33 -04:00
static inline const char *hlua_show_current_location(const char *pfx) { return NULL; }
MINOR: lua: remove some #define The #define compilation directives are centralized in the hlua include files. This permits to remove ome #ifdef from the haproxy main code.
2015-03-04 10:48:34 -05:00
#endif /* USE_LUA */
REORG: include: move hlua.h to haproxy/hlua{,-t}.h This one required a few more includes as it uses list and ebpt_node. It still references lots of types/ files for now.
2020-06-04 03:20:54 -04:00
#endif /* _HAPROXY_HLUA_H */
Reference in a new issue Copy permalink