secgateway/Platform/user/configm/config-server/configserver.c

375 lines
9.3 KiB
C

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "rpc.h"
#include "configm.h"
config_service_t g_config_service[] = CONFIG_SERVICE_ARRAY;
void test_big_data(rpc_conn *conn, pointer input, int input_len, void* data) {
char buf[input_len];
memcpy(buf, input, input_len);
buf[input_len] = '\0';
printf("get data is %s\n", buf);
//sleep(15);
rpc_return_null(conn);
}
void cm_return(rpc_conn *conn, ret_code err_code, char* err_message)
{
cJSON *res;
char *ret_char = NULL;
res = cJSON_CreateObject();
if(res == NULL)
{
return;
}
cJSON_AddStringToObject(res, "result", err_message);
ret_char = cJSON_PrintUnformatted(res);
cJSON_Delete(res);
rpc_return_error(conn, err_code, ret_char);
rpc_free(ret_char);
return;
}
config_service_t *cm_config_service_get(uint64 config_id)
{
int len = sizeof(g_config_service) / sizeof(config_service_t);
int config_idx;
for(config_idx = 0; config_idx < len; config_idx++)
{
if(config_id == g_config_service[config_idx].config_id)
{
return &(g_config_service[config_idx]);
}
}
return NULL;
}
ret_code cm_config_rec_pre(char **input, int *input_len, char **output, int *output_len)
{
/*if((access(CONFIG_RECOVERY_DONE, F_OK))!=-1)
{
return RET_ERR;
} */
*input = rpc_new(char, CM_BUFF_SIZE);
*output = rpc_new(char, CM_BUFF_SIZE);
*input_len = CM_BUFF_SIZE;
*output_len = CM_BUFF_SIZE;
if(*input == NULL
|| *output == NULL)
{
return RET_NOMEM;
}
memset(*input, 0, CM_BUFF_SIZE);
memset(*output, 0, CM_BUFF_SIZE);
rpc_log_info("==>config revocery start\n");
return RET_OK;
}
ret_code cm_config_rec_done(char *input, char *output)
{
int fd;
memset(input, 0, CM_BUFF_SIZE);
memset(output, 0, CM_BUFF_SIZE);
free(input);
free(output);
fd = open(CONFIG_RECOVERY_DONE, O_CREAT, 0777);
if(fd <= 0)
{
rpc_log_error("create recovery file error");
}
else
{
close(fd);
}
rpc_log_info("==>config revocery done!\n");
return RET_OK;
}
ret_code cm_config_get_allconfig(uint source,
config_service_t *config_svr,
char *input, int *intput_len)
{
ret_code ret = RET_OK;
memset(input, 0, CM_BUFF_SIZE);
ret = config_svr->getall_callback(source, input, intput_len);
ASSERT_RET(ret);
return ret;
}
ret_code cm_config_config_rec(uint source,
config_service_t *config_svr,
char *input, int input_len,
char *output, int *output_len)
{
int config_type = CM_CONFIG_SET;
ret_code ret = RET_OK;
ret = config_svr->chk_callback(source, &config_type,
input, &input_len,
output, output_len);
if(ret == RET_OK)
{
config_svr->proc_callback(source, config_type,
input, input_len,
output, output_len);
}
return ret;
}
/* 配置恢复 */
void cm_config_recovery()
{
int len = sizeof(g_config_service) / sizeof(config_service_t);
config_service_t *config_svr;
int input_len = 0;
int output_len = 0;
char *input = NULL;
char *output = NULL;
ret_code ret = RET_OK;
int config_idx;
int recover_idx = 1,recover_phase;
ret = cm_config_rec_pre(&input, &input_len, &output, &output_len);
ASSERT_RET_VOID(ret);
while(recover_idx <= 2)
{
if(recover_idx == 1)
{
recover_phase = CONFIG_FROM_RECOVER1;
}
else if(recover_idx == 2)
{
recover_phase = CONFIG_FROM_RECOVER2;
}
else
{
break;
}
for(config_idx = 0; config_idx < len; config_idx++)
{
config_svr = &(g_config_service[config_idx]);
if(config_svr->recovery != TRUE)
{
continue;
}
if(config_svr->chk_callback == NULL
|| config_svr->proc_callback == NULL)
{
continue;
}
cm_config_get_allconfig(recover_phase, config_svr,
input, &input_len);
cm_config_config_rec(recover_phase, config_svr,
input, input_len,
output, &output_len);
}
recover_idx++;
}
cm_config_rec_done(input, output);
return;
}
/* 配置处理入口函数,所有的配置,均在此函数中处理 */
void cm_config_process(rpc_conn *conn, pointer input, int input_len, void* data)
{
config_service_t *config_svr;
config_msg_t *config_msg;
char *cm_get_buff = NULL;
char *cm_set_buff = NULL;
ret_code ret = RET_OK;
int config_len = 0;
int buff_len = CM_BUFF_SIZE;
if(conn == NULL || input == NULL)
{
cm_return(conn, RET_NULLP, "NULL pointer");
return;
}
/*parse message*/
if(input_len < sizeof(config_msg_t))
{
cm_return(conn, RET_NOMEM, "not enough memery");
return;
}
config_msg = (config_msg_t *)input;
config_len = input_len - sizeof(config_msg_t);
rpc_log_info("recv config from %d, config type is %d config id is 0x%llx ,len is %d\r\n",
config_msg->source, config_msg->config_type, config_msg->config_id,
config_len);
config_svr = cm_config_service_get(config_msg->config_id);
if(config_svr == NULL)
{
cm_return(conn, RET_NULLP, "NULL pointer");
return;
}
/*source check*/
if(!(config_svr->config_src & config_msg->source))
{
cm_return(conn, RET_CHKERR, "source check error!\r\n");
return;
}
cm_set_buff = rpc_new(char, buff_len);
cm_get_buff = rpc_new(char, buff_len);
if(cm_get_buff == NULL || cm_set_buff == NULL)
{
cm_return(conn, RET_NOMEM, "not enough memery");
return;
}
memset(cm_set_buff, 0, buff_len);
memset(cm_get_buff, 0, buff_len);
memcpy(cm_set_buff, config_msg->config_buff, config_len);
/*config check*/
if(config_svr->chk_callback)
{
ret = config_svr->chk_callback(config_msg->source,
&(config_msg->config_type),
cm_set_buff,
&config_len,
cm_get_buff,
&buff_len);
if(ret != RET_OK)
{
cm_return(conn, ret, cm_get_buff);
goto exit;
}
}
/*config exec*/
switch(config_msg->config_type)
{
case CM_CONFIG_GET:
if(config_svr->get_callback)
{
ret = config_svr->get_callback(config_msg->source,
cm_set_buff,
config_len,
cm_get_buff,
&buff_len);
}
break;
case CM_CONFIG_GET_ALL:
if(config_svr->getall_callback)
{
ret = config_svr->getall_callback(config_msg->source,
cm_get_buff,
&buff_len);
}
break;
case CM_CONFIG_ADD:
case CM_CONFIG_DEL:
case CM_CONFIG_SET:
if(config_svr->proc_callback)
{
ret = config_svr->proc_callback(config_msg->source,
config_msg->config_type,
cm_set_buff,
config_len,
cm_get_buff,
&buff_len);
}
break;
default:
ret = RET_INPUTERR;
break;
}
if(buff_len > CM_BUFF_SIZE)
{
ret = RET_NOMEM;
}
if(ret != RET_OK)
{
cm_return(conn, ret, cm_get_buff);
goto exit;
}
rpc_return(conn, cm_get_buff, buff_len);
exit:
rpc_free(cm_set_buff);
rpc_free(cm_get_buff);
return;
}
int main(int argc, char **argv)
{
rpc_server *server;
if (server= rpc_server_create_ex("ConfigManger#0"))
{
rpc_log_info("start server\n");
}
else
{
rpc_log_error("start server error\n");
return EXIT_FAILURE;
}
/* 配置恢复 */
cm_config_recovery();
/* 注册配置处理函数 */
rpc_server_regservice(server, "ConfigManger#0", "cm_config_process", cm_config_process);
//rpc_server_regservice(server, "ConfigManger#0", "test_big_data", test_big_data);
for(;;)
{
rpc_sleep(1000);
}
return EXIT_SUCCESS;
}