650 lines
22 KiB
C
650 lines
22 KiB
C
/*************************************************************************
|
|
> File Name: lua_plugin_manage.c
|
|
> Author:
|
|
> Created Time: 2024-08
|
|
> Encoding : UTF-8
|
|
************************************************************************/
|
|
|
|
/*************************************************************************
|
|
* version
|
|
* [ v0.1 ]
|
|
* 08-05
|
|
* 1. 实现函数
|
|
* void specific_instance_copy;
|
|
* void specific_instance_destory;
|
|
* int script_instance_init_byname;
|
|
* int script_instance_init_byrefid;
|
|
* void script_instance_clean;
|
|
* int script_execute; (暂未实现)
|
|
* int session_plugin_instance_init;
|
|
* void session_plugin_instance_destory;
|
|
* int plugin_env_instance_init;
|
|
* void plugin_env_instance_destory;
|
|
* int thread_state_instance_init;
|
|
* void thread_state_instance_destory;
|
|
* int thread_state_instance_load;
|
|
* int lua_plugin_manage_config_load;
|
|
* int lua_plugin_manage_thread_load;
|
|
************************************************************************/
|
|
#include "lua_plugin_manage_internal.h"
|
|
#include "lpm_log.h"
|
|
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <toml.h>
|
|
|
|
static UT_icd specific_icd = {sizeof(struct lua_config_specific), NULL, specific_instance_copy, specific_instance_destory};
|
|
static UT_icd session_plugin_icd = {sizeof(struct lua_session_plugin), NULL, NULL, session_plugin_instance_destory};
|
|
static UT_icd plugin_env_icd = {sizeof(struct lua_plugin_env), NULL, NULL, plugin_env_instance_destory};
|
|
static UT_icd thread_state_icd = {sizeof(struct lua_thread_state), NULL, NULL, thread_state_instance_destory};
|
|
|
|
/*
|
|
* Function: specific_instance_copy
|
|
* Input: | void * | dst | 拷贝数据目的地址
|
|
* | void * | src | 拷贝数据源地址
|
|
* Output:
|
|
* Return:
|
|
* Description: 配置的插件信息拷贝函数, 由于可能存在多线程, 将数据完整拷贝一次
|
|
*/
|
|
void specific_instance_copy(void *dst, const void *src)
|
|
{
|
|
struct lua_config_specific *dst_spec = (struct lua_config_specific *)dst;
|
|
struct lua_config_specific *src_spec = (struct lua_config_specific *)src;
|
|
if (__glibc_unlikely(!dst_spec || !src_spec))
|
|
return;
|
|
dst_spec->lua_config_specific_file = strdup(src_spec->lua_config_specific_file);
|
|
// dst_spec->lua_config_specific_name = strdup(src_spec->lua_config_specific_name);
|
|
dst_spec->lua_config_specific_load_func = strdup(src_spec->lua_config_specific_load_func);
|
|
dst_spec->lua_config_specific_unload_func = strdup(src_spec->lua_config_specific_unload_func);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function: specific_instance_destory
|
|
* Input: | void * | elt | 待销毁的specific实例
|
|
* Output:
|
|
* Return:
|
|
* Description: 销毁一个specific实例, 并释放内部占用的内存
|
|
*/
|
|
void specific_instance_destory(void *elt)
|
|
{
|
|
struct lua_config_specific *element = (struct lua_config_specific *)elt;
|
|
if (!element)
|
|
return;
|
|
if (element->lua_config_specific_file)
|
|
free(element->lua_config_specific_file);
|
|
// if (element->lua_config_specific_name)
|
|
// free(element->lua_config_specific_name);
|
|
if (element->lua_config_specific_load_func)
|
|
free(element->lua_config_specific_load_func);
|
|
if (element->lua_config_specific_unload_func)
|
|
free(element->lua_config_specific_unload_func);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function: script_instance_init_byname
|
|
* Input: | struct lua_script * | script | 需要进行初始化的脚本结构
|
|
* | lua_State * | state | 脚本注册使用的状态机
|
|
* | const char * | filepath | 脚本加载的文件路径
|
|
* | const char * | funcname | 脚本加载的函数名称
|
|
* Output:
|
|
* Return: | 0 | 加载成功
|
|
* | -1 | 参数错误
|
|
* | -3 | 状态机读取文件失败
|
|
* | -4 | 状态机加载文件后运行失败
|
|
* | -5 | 加载函数过程中未找到该函数
|
|
* | -6 | 创建函数引用ID失败
|
|
* Description: 将一个lua文件中的函数创建成一个lua_script结构, 方便调用运行
|
|
*/
|
|
int script_instance_init_byname(
|
|
struct lua_script *script,
|
|
lua_State *state,
|
|
const char *filepath,
|
|
const char *funcname)
|
|
{
|
|
if (__glibc_unlikely(!script || !state || !filepath || !funcname))
|
|
return -1;
|
|
|
|
#if 0
|
|
/* 在加载配置文件的时候检查过了, 这里不检查 */
|
|
if (access(filepath, F_OK))
|
|
/* 文件不存在 */
|
|
return -2;
|
|
#endif
|
|
if (luaL_loadfile(state, filepath))
|
|
/* 加载文件失败 */
|
|
return -3;
|
|
/* 仅加载不运行 */
|
|
// lua_settop(state, 0);
|
|
/* Bugfix: 这里还是需要运行一次, 否则可能加载不完整 */
|
|
if (lua_pcall(state, 0, 0, 0))
|
|
{
|
|
/* 文件加载完成后检查存在错误 */
|
|
lua_settop(state, 0);
|
|
return -4;
|
|
}
|
|
lua_settop(state, 0);
|
|
|
|
/* 加载全局变量, 找到函数后进行类型判断 */
|
|
lua_getglobal(state, funcname);
|
|
if (lua_type(state, -1) != LUA_TFUNCTION)
|
|
{
|
|
/* 在已经加载的文件中未找到对应的函数名称 */
|
|
lua_settop(state, 0);
|
|
return -5;
|
|
}
|
|
/* 创建索引 */
|
|
int ref_id = luaL_ref(state, LUA_REGISTRYINDEX);
|
|
if (ref_id == LUA_REFNIL)
|
|
{
|
|
/* 索引创建失败 */
|
|
lua_settop(state, 0);
|
|
return -6;
|
|
}
|
|
|
|
script_instance_init_byrefid(script, state, ref_id);
|
|
lua_settop(state, 0);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: script_instance_init_byrefid
|
|
* Input: | struct lua_script * | script | 需要进行初始化的脚本结构
|
|
* | lua_State * | state | 脚本注册使用的状态机
|
|
* | int | ref_id | 代码已经在状态机中生成的refid
|
|
* Output:
|
|
* Return: | 0 | 初始化成功
|
|
* | -1 | 参数错误
|
|
* Description: 根据已经生成的refid初始化一个脚本结构实例
|
|
*/
|
|
int script_instance_init_byrefid(
|
|
struct lua_script *script,
|
|
lua_State *state,
|
|
int ref_id)
|
|
{
|
|
if (__glibc_unlikely(!script || !state || ref_id == LUA_REFNIL))
|
|
return -1;
|
|
script->script_state = state;
|
|
script->script_ref_id = ref_id;
|
|
script->script_run_success = 0;
|
|
script->script_run_failed = 0;
|
|
script->script_total_ms = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: script_instance_clean
|
|
* Input: | struct lua_script * | script | 需要清理的脚本实例
|
|
* Output:
|
|
* Return:
|
|
* Description: 清理一个脚本, 并在状态机中释放该脚本的引用
|
|
*/
|
|
void script_instance_clean(struct lua_script *script)
|
|
{
|
|
if (__glibc_unlikely(!script))
|
|
return;
|
|
|
|
lua_State *state = script->script_state;
|
|
luaL_unref(state, LUA_REGISTRYINDEX, script->script_ref_id);
|
|
lua_settop(state, 0);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* Input:
|
|
* Output:
|
|
* Return:
|
|
* Description:
|
|
*/
|
|
int script_execute(struct lua_script *script)
|
|
{
|
|
if (!script)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: session_plugin_instance_init
|
|
* Input: | struct lua_session_plugin * | session_plugin | 需要进行初始化的插件实例
|
|
* | lua_State * | state | 插件注册使用的状态机
|
|
* | int | plugin_id | 插件注册完成后得到的插件编号
|
|
* | int | new_refid | ctx_new函数在状态机中的引用
|
|
* | int | free_refid | ctx_free函数在状态机中的引用
|
|
* Output:
|
|
* Return: | 0 | 初始化成功
|
|
* | -1 | 参数错误
|
|
* Description: 初始化一个插件实例
|
|
*/
|
|
int session_plugin_instance_init(
|
|
struct lua_session_plugin *session_plugin,
|
|
lua_State *state,
|
|
int plugin_id,
|
|
int new_refid,
|
|
int free_refid)
|
|
{
|
|
if (__glibc_unlikely(!session_plugin || !state))
|
|
return -1;
|
|
session_plugin->plugin_id = plugin_id;
|
|
script_instance_init_byrefid(&session_plugin->plugin_ctx_new_script, state, new_refid);
|
|
script_instance_init_byrefid(&session_plugin->plugin_ctx_free_script, state, free_refid);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: session_plugin_instance_destory
|
|
* Input: | void * | elt | 待销毁的插件实例
|
|
* Output:
|
|
* Return:
|
|
* Description: 销毁一个插件实例, 并将插件中引用的函数在状态机中释放
|
|
*/
|
|
void session_plugin_instance_destory(void *elt)
|
|
{
|
|
if (__glibc_unlikely(!elt))
|
|
return;
|
|
struct lua_session_plugin *session_plugin = (struct lua_session_plugin *)elt;
|
|
script_instance_clean(&session_plugin->plugin_ctx_new_script);
|
|
script_instance_clean(&session_plugin->plugin_ctx_free_script);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function: plugin_env_instance_init
|
|
* Input: | struct lua_plugin_env * | plugin_env | 插件的运行环境实例
|
|
* | lua_State * | state | 插件注册的状态机
|
|
* | struct lua_config_specific * | specific | 插件需要加载的配置实例
|
|
* Output:
|
|
* Return: | 0 | 初始化成功
|
|
* | -1 | 参数错误
|
|
* | -2 | 加载函数加载错误
|
|
* | -3 | 卸载函数加载错误
|
|
* | -4 | 创建全局函数变量失败
|
|
* Description: 初始化一个插件的运行环境变量
|
|
*/
|
|
int plugin_env_instance_init(
|
|
struct lua_plugin_env *plugin_env,
|
|
lua_State *state,
|
|
struct lua_config_specific *specific)
|
|
{
|
|
if (__glibc_unlikely(!plugin_env || !state || !specific))
|
|
return -1;
|
|
|
|
memset(plugin_env, 0, sizeof(struct lua_plugin_env));
|
|
plugin_env->lua_plugin_env_state = state;
|
|
plugin_env->lua_plugin_env_plugin_array = NULL;
|
|
// plugin_env->lua_plugin_env_name = strdup(specific->lua_config_specific_name);
|
|
/* 从文件中加载load函数, 但此时不调用 */
|
|
if (script_instance_init_byname(&plugin_env->lua_plugin_env_load_func,
|
|
state,
|
|
specific->lua_config_specific_file,
|
|
specific->lua_config_specific_load_func))
|
|
{
|
|
return -2;
|
|
}
|
|
/* 从文件中加载unload函数 */
|
|
if (script_instance_init_byname(&plugin_env->lua_plugin_env_unload_func,
|
|
state,
|
|
specific->lua_config_specific_file,
|
|
specific->lua_config_specific_unload_func))
|
|
{
|
|
script_instance_clean(&plugin_env->lua_plugin_env_load_func);
|
|
return -3;
|
|
}
|
|
/* 创建私有数据空间 */
|
|
lua_newtable(plugin_env->lua_plugin_env_state);
|
|
int ref_id = luaL_ref(plugin_env->lua_plugin_env_state, LUA_REGISTRYINDEX);
|
|
if (ref_id == LUA_REFNIL)
|
|
return -4;
|
|
plugin_env->lua_plugin_env_ref_id = ref_id;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: plugin_env_instance_destory
|
|
* Input: | void * | elt | 待销毁的插件运行环境实例
|
|
* Output:
|
|
* Return:
|
|
* Description: 销毁一个插件运行环境实例, 并在状态机中释放其引用
|
|
*/
|
|
void plugin_env_instance_destory(void *elt)
|
|
{
|
|
if (__glibc_unlikely(!elt))
|
|
return;
|
|
struct lua_plugin_env *plugin_env = (struct lua_plugin_env *)elt;
|
|
/* 释放已经注册的插件 */
|
|
if (plugin_env->lua_plugin_env_plugin_array)
|
|
utarray_free(plugin_env->lua_plugin_env_plugin_array);
|
|
/* 释放插件的加载函数与卸载函数 */
|
|
script_instance_clean(&plugin_env->lua_plugin_env_load_func);
|
|
script_instance_clean(&plugin_env->lua_plugin_env_unload_func);
|
|
/* 将lua中的私有环境数据取消引用 */
|
|
if (plugin_env->lua_plugin_env_ref_id)
|
|
luaL_unref(plugin_env->lua_plugin_env_state, LUA_REGISTRYINDEX, plugin_env->lua_plugin_env_ref_id);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function: thread_state_instance_init
|
|
* Input: | struct lua_thread_state * | thread_state | 待初始化的线程状态机
|
|
* | int | state_id | 线程的ID号
|
|
* Output:
|
|
* Return: | 0 | 初始化成功
|
|
* | -1 | 参数错误
|
|
* | -2 | 创建新的状态机失败
|
|
* Description: 在线程中创建一个状态机, 并进行初始化
|
|
*/
|
|
int thread_state_instance_init(
|
|
struct lua_thread_state *thread_state,
|
|
int state_id)
|
|
{
|
|
if (__glibc_unlikely(!thread_state))
|
|
return -1;
|
|
|
|
lua_State *new_state = luaL_newstate();
|
|
if (__glibc_unlikely(!new_state))
|
|
return -2;
|
|
luaL_openlibs(new_state);
|
|
/* 绑定所有注册函数 */
|
|
lua_cbinding_functions(new_state);
|
|
/* 绑定所有全局变量 */
|
|
lua_cbinding_datas(new_state);
|
|
lua_settop(new_state, 0);
|
|
|
|
memset(thread_state, 0, sizeof(struct lua_thread_state));
|
|
thread_state->lua_thread_id = state_id;
|
|
thread_state->lua_thread_plugin_count = 0;
|
|
thread_state->lua_thread_state = new_state;
|
|
thread_state->lua_thread_env_array = NULL;
|
|
thread_state->lua_thread_begin_time = time(NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: thread_state_instance_destory
|
|
* Input: | void * | elt | 待销毁的状态机
|
|
* Output:
|
|
* Return:
|
|
* Description: 销毁一个线程状态机
|
|
*/
|
|
void thread_state_instance_destory(void *elt)
|
|
{
|
|
if (__glibc_unlikely(!elt))
|
|
return;
|
|
struct lua_thread_state *thread_state = (struct lua_thread_state *)elt;
|
|
/* 卸载所有已经注册的插件 */
|
|
if (thread_state->lua_thread_env_array)
|
|
utarray_free(thread_state->lua_thread_env_array);
|
|
/* 关闭状态机 */
|
|
if (thread_state->lua_thread_state)
|
|
lua_close(thread_state->lua_thread_state);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function: thread_state_instance_load
|
|
* Input: | struct lua_thread_state * | thread_state | 进行初始化加载的状态机
|
|
* | struct lua_plugin_manage_schema * | schema | 已经完成配置读取的全局实例
|
|
* Output:
|
|
* Return: | 0 | 加载成功
|
|
* | -1 | 参数错误
|
|
* | -2 | 根据加载的配置初始化插件失败
|
|
* Description: 在线程的状态机中依次加载插件
|
|
*/
|
|
int thread_state_instance_load(
|
|
struct lua_thread_state *thread_state,
|
|
struct lua_plugin_manage_schema *schema)
|
|
{
|
|
if (__glibc_unlikely(!thread_state || !schema))
|
|
return -1;
|
|
|
|
lua_State *state = thread_state->lua_thread_state;
|
|
utarray_new(thread_state->lua_thread_env_array, &plugin_env_icd);
|
|
utarray_reserve(thread_state->lua_thread_env_array, schema->lua_config_specific_count);
|
|
struct lua_config_specific *specific = NULL;
|
|
|
|
/* 读取所有插件并加入插件列表中 */
|
|
struct lua_plugin_env new_plugin_env;
|
|
while ((specific = utarray_next(schema->lua_config_specific_array, specific)))
|
|
{
|
|
memset(&new_plugin_env, 0, sizeof(new_plugin_env));
|
|
if (plugin_env_instance_init(&new_plugin_env, state, specific))
|
|
return -2;
|
|
utarray_push_back(thread_state->lua_thread_env_array, &new_plugin_env);
|
|
}
|
|
|
|
/* 依次执行插件加载函数, 调用lua中load函数 */
|
|
struct lua_plugin_env *plugin_env = NULL;
|
|
while ((plugin_env = utarray_next(thread_state->lua_thread_env_array, plugin_env)))
|
|
{
|
|
utarray_new(plugin_env->lua_plugin_env_plugin_array, &session_plugin_icd);
|
|
lua_rawgeti(state, LUA_REGISTRYINDEX, plugin_env->lua_plugin_env_ref_id);
|
|
/* 在lua中的全局参数中加入plugin_env指针 */
|
|
lua_pushlightuserdata(state, plugin_env);
|
|
lua_setfield(state, -2, PLUGIN_ENV_DEFAULT_KEY);
|
|
lua_settop(state, 0);
|
|
|
|
script_execute(&plugin_env->lua_plugin_env_load_func);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: specific_check
|
|
* Input: | struct lua_config_specific * | specific | 待减产的配置项
|
|
* Output:
|
|
* Return: | 0 | 检查无问题
|
|
* | -1 | 参数错误
|
|
* | -2 | 配置中的插件文件不存在
|
|
* Description: 检查配置是否有明显问题
|
|
* TODO: 目前仅检查文件是否存在, 后续逐步补充, 比如文件内是否有不应该使用的函数等
|
|
*/
|
|
static int specific_check(struct lua_config_specific *specific)
|
|
{
|
|
if (__glibc_unlikely(!specific))
|
|
return -1;
|
|
|
|
if (access(specific->lua_config_specific_file, F_OK))
|
|
return -2;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function: lua_plugin_manage_config_load
|
|
* Input: | struct lua_plugin_manage_schema * | scheme | 加载插件的全局变量
|
|
* | const char * | config_file_name | 插件配置文件
|
|
* Output:
|
|
* Return: | >=0 | 加载成功, 返回读取的配置插件数量
|
|
* | -1 | 参数错误
|
|
* | -2 | 配置文件不存在或打开文件错误
|
|
* | -3 | toml加载失败
|
|
* | -4 | 获取插件列表失败
|
|
* | -5 | 插件配置项错误
|
|
* | -6 | 插件配置检查出现问题
|
|
* Description: 从配置文件中读取所有插件配置
|
|
*/
|
|
int lua_plugin_manage_config_load(
|
|
struct lua_plugin_manage_schema *schema,
|
|
const char *config_file_name)
|
|
{
|
|
if (__glibc_unlikely(!schema || !config_file_name))
|
|
return -1;
|
|
int specific_num = 0;
|
|
char errbuff[256] = {0};
|
|
|
|
if (access(config_file_name, F_OK))
|
|
return -2;
|
|
FILE *fp = fopen(config_file_name, "r");
|
|
if (!fp)
|
|
return -2;
|
|
|
|
toml_table_t *conf = toml_parse_file(fp, errbuff, sizeof(errbuff));
|
|
if (fp)
|
|
fclose(fp);
|
|
if (!conf)
|
|
{
|
|
LOGERROR("parse config file failed, filename %s, err %s\n", config_file_name, errbuff);
|
|
return -3;
|
|
}
|
|
|
|
toml_array_t *plugin_array = toml_array_in(conf, "plugin");
|
|
if (!plugin_array)
|
|
return -4;
|
|
|
|
/* 获取配置中配置的插件数量 */
|
|
specific_num = toml_array_nelem(plugin_array);
|
|
utarray_new(schema->lua_config_specific_array, &specific_icd);
|
|
utarray_reserve(schema->lua_config_specific_array, specific_num);
|
|
struct lua_config_specific *specific = (struct lua_config_specific *)calloc(sizeof(struct lua_config_specific), 1);
|
|
|
|
for (int i = 0; i < specific_num; ++i)
|
|
{
|
|
toml_table_t *plugin = toml_table_at(plugin_array, i);
|
|
const char *raw_filepath = toml_raw_in(plugin, "path");
|
|
// const char *raw_name = toml_raw_in(plugin, "name");
|
|
const char *raw_load_func_name = toml_raw_in(plugin, "init");
|
|
const char *raw_unload_func_name = toml_raw_in(plugin, "exit");
|
|
|
|
/* 从配置中拷贝字符串到specific实例中 */
|
|
if (toml_rtos(raw_filepath, &specific->lua_config_specific_file) ||
|
|
// toml_rtos(raw_name, &specific->lua_config_specific_name) ||
|
|
toml_rtos(raw_load_func_name, &specific->lua_config_specific_load_func) ||
|
|
toml_rtos(raw_unload_func_name, &specific->lua_config_specific_unload_func))
|
|
{
|
|
toml_free(conf);
|
|
free(specific);
|
|
return -5;
|
|
}
|
|
|
|
/* 插件配置检查 */
|
|
int spec_check_ret = specific_check(specific);
|
|
if (spec_check_ret)
|
|
{
|
|
LOGERROR("check specific failed, ret is %d\n", spec_check_ret);
|
|
toml_free(conf);
|
|
free(specific);
|
|
return -6;
|
|
}
|
|
|
|
/* 插入到队列中 */
|
|
utarray_push_back(schema->lua_config_specific_array, specific);
|
|
specific_instance_destory(specific);
|
|
}
|
|
free(specific);
|
|
|
|
/* 返回加载的插件数量 */
|
|
return specific_num;
|
|
}
|
|
|
|
/*
|
|
* Function: lua_plugin_manage_thread_load
|
|
* Input: | struct lua_plugin_manage_schema * | schema | 初始化的全局变量
|
|
* | int | thread_count | 初始化的线程数量
|
|
* Output:
|
|
* Return: | >= 0 | 创建完成, 并返回创建成功数量
|
|
* | -1 | 参数错误
|
|
* | -2 | 线程状态机初始化失败
|
|
* | -3 | 线程状态机加载过程失败
|
|
* Description: 依次创建好每个线程中的状态机
|
|
*/
|
|
int lua_plugin_manage_thread_load(
|
|
struct lua_plugin_manage_schema *schema,
|
|
int thread_count)
|
|
{
|
|
if (__glibc_unlikely(!schema || thread_count <= 0 || thread_count >= LUA_PLUGIN_MANAGE_MAX_THREAD_COUNT))
|
|
return -1;
|
|
|
|
utarray_new(schema->lua_plugin_thread_array, &thread_state_icd);
|
|
utarray_reserve(schema->lua_plugin_thread_array, thread_count);
|
|
struct lua_thread_state new_thread_state;
|
|
for (int i = 1; i <= thread_count; ++i)
|
|
{
|
|
memset(&new_thread_state, 0, sizeof(new_thread_state));
|
|
if (thread_state_instance_init(&new_thread_state, i))
|
|
return -2;
|
|
utarray_push_back(schema->lua_plugin_thread_array, &new_thread_state);
|
|
}
|
|
|
|
struct lua_thread_state *thread_state = NULL;
|
|
while ((thread_state = utarray_next(schema->lua_plugin_thread_array, thread_state)))
|
|
{
|
|
if (thread_state_instance_load(thread_state, schema))
|
|
return -3;
|
|
}
|
|
|
|
return thread_count;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* Input:
|
|
* Output:
|
|
* Return:
|
|
* Description:
|
|
*/
|
|
struct lua_plugin_manage_schema *lua_plugin_manage_init(
|
|
struct stellar *st,
|
|
const char *config_file_path)
|
|
{
|
|
if (__glibc_unlikely(!st || !config_file_path))
|
|
return NULL;
|
|
|
|
struct lua_plugin_manage_schema *new_schema = (struct lua_plugin_manage_schema *)calloc(1, sizeof(struct lua_plugin_manage_schema));
|
|
if (__glibc_unlikely(!new_schema))
|
|
return NULL;
|
|
memset(new_schema, 0, sizeof(struct lua_plugin_manage_schema));
|
|
|
|
new_schema->lua_plugin_schema_st = st;
|
|
/* 从配置文件中加载插件 */
|
|
new_schema->lua_config_specific_count = lua_plugin_manage_config_load(new_schema, config_file_path);
|
|
LOGDEBUG("load config finish, load count is %d, file path is %s", new_schema->lua_config_specific_count, config_file_path);
|
|
if (new_schema->lua_config_specific_count < 0)
|
|
{
|
|
/* 可以没有插件配置, 但是不能在加载过程中出错 */
|
|
free(new_schema);
|
|
return NULL;
|
|
}
|
|
#ifdef LUAPLUGIN_BASIC_UNITTEST
|
|
struct lua_config_specific *specific = NULL;
|
|
while ((specific = utarray_next(new_schema->lua_config_specific_array, specific)))
|
|
{
|
|
printf("path is %s\n", specific->lua_config_specific_file);
|
|
printf("load is %s\n", specific->lua_config_specific_load_func);
|
|
printf("unload is %s\n", specific->lua_config_specific_unload_func);
|
|
}
|
|
#endif
|
|
|
|
int thread_count = 1;
|
|
/* 依次创建线程状态机, 并加入链表 */
|
|
new_schema->lua_plugin_thread_count = lua_plugin_manage_thread_load(new_schema, thread_count);
|
|
|
|
return new_schema;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* Input:
|
|
* Output:
|
|
* Return:
|
|
* Description:
|
|
*/
|
|
void lua_plugin_manage_exit(struct lua_plugin_manage_schema *lua_plug_mgr)
|
|
{
|
|
if (__glibc_unlikely(!lua_plug_mgr))
|
|
return;
|
|
if (lua_plug_mgr->lua_config_specific_array)
|
|
utarray_free(lua_plug_mgr->lua_config_specific_array);
|
|
if (lua_plug_mgr->lua_plugin_thread_array)
|
|
utarray_free(lua_plug_mgr->lua_plugin_thread_array);
|
|
return;
|
|
}
|
|
|
|
|