pdxx
/
libserverframe
mirror of https://github.com/happyfish100/libserverframe.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
libserverframe/src/sf_global.c

453 lines
15 KiB
C
Raw Blame History

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#include <grp.h>
#include <pwd.h>
#include "fastcommon/common_define.h"
#include "fastcommon/shared_func.h"
#include "fastcommon/logger.h"
#include "sf_nio.h"
#include "sf_global.h"
SFGlobalVariables g_sf_global_vars = {
DEFAULT_CONNECT_TIMEOUT, DEFAULT_NETWORK_TIMEOUT,
{'/', 't', 'm', 'p', '\0'}, true,
SF_DEF_THREAD_STACK_SIZE, DEFAULT_MAX_CONNECTONS,
SF_DEF_MAX_PACKAGE_SIZE, SF_DEF_MIN_BUFF_SIZE, SF_DEF_MAX_BUFF_SIZE,
SYNC_LOG_BUFF_DEF_INTERVAL, 0, 0, 0, {'\0'}, {'\0'}, false, 0, {0, 0}
};
SFContext g_sf_context = {
NULL, 0, -1, -1, 0, 0, 1, DEFAULT_WORK_THREADS,
{'\0'}, {'\0'}, 0, true, true, NULL, NULL, NULL,
sf_task_finish_clean_up, NULL
};
static inline void set_config_str_value(const char *value,
char *dest, const int dest_size)
{
if (value == NULL) {
*dest = '\0';
} else {
snprintf(dest, dest_size, "%s", value);
}
}
static int load_network_parameters(IniContext *pIniContext)
{
int result;
char *pMaxPkgSize;
char *pMinBuffSize;
char *pMaxBuffSize;
int64_t max_pkg_size;
int64_t min_buff_size;
int64_t max_buff_size;
g_sf_global_vars.connect_timeout = iniGetIntValue(NULL,
"connect_timeout", pIniContext, DEFAULT_CONNECT_TIMEOUT);
if (g_sf_global_vars.connect_timeout <= 0) {
g_sf_global_vars.connect_timeout = DEFAULT_CONNECT_TIMEOUT;
}
g_sf_global_vars.network_timeout = iniGetIntValue(NULL,
"network_timeout", pIniContext, DEFAULT_NETWORK_TIMEOUT);
if (g_sf_global_vars.network_timeout <= 0) {
g_sf_global_vars.network_timeout = DEFAULT_NETWORK_TIMEOUT;
}
g_sf_global_vars.max_connections = iniGetIntValue(NULL,
"max_connections", pIniContext, DEFAULT_MAX_CONNECTONS);
if (g_sf_global_vars.max_connections <= 0) {
g_sf_global_vars.max_connections = DEFAULT_MAX_CONNECTONS;
}
if ((result=set_rlimit(RLIMIT_NOFILE, g_sf_global_vars.
max_connections)) != 0)
{
return result;
}
pMaxPkgSize = iniGetStrValue(NULL,
"max_pkg_size", pIniContext);
if (pMaxPkgSize == NULL) {
max_pkg_size = SF_DEF_MAX_PACKAGE_SIZE;
}
else if ((result=parse_bytes(pMaxPkgSize, 1,
&max_pkg_size)) != 0)
{
return result;
} else if (max_pkg_size < 4096) {
logWarning("file: "__FILE__", line: %d, "
"max_pkg_size: %d is too small, set to 4096",
__LINE__, (int)max_pkg_size);
max_pkg_size = 4096;
}
g_sf_global_vars.max_pkg_size = (int)max_pkg_size;
pMinBuffSize = iniGetStrValue(NULL,
"min_buff_size", pIniContext);
if (pMinBuffSize == NULL) {
min_buff_size = SF_DEF_MIN_BUFF_SIZE;
}
else if ((result=parse_bytes(pMinBuffSize, 1,
&min_buff_size)) != 0)
{
return result;
} else if (min_buff_size < 2048) {
logWarning("file: "__FILE__", line: %d, "
"min_buff_size: %d is too small, set to 2048",
__LINE__, (int)min_buff_size);
min_buff_size = 2048;
}
g_sf_global_vars.min_buff_size = (int)min_buff_size;
pMaxBuffSize = iniGetStrValue(NULL,
"max_buff_size", pIniContext);
if (pMaxBuffSize == NULL) {
max_buff_size = SF_DEF_MAX_BUFF_SIZE;
}
else if ((result=parse_bytes(pMaxBuffSize, 1,
&max_buff_size)) != 0)
{
return result;
}
g_sf_global_vars.max_buff_size = (int)max_buff_size;
if (pMinBuffSize == NULL || pMaxBuffSize == NULL) {
g_sf_global_vars.min_buff_size = g_sf_global_vars.max_pkg_size;
g_sf_global_vars.max_buff_size = g_sf_global_vars.max_pkg_size;
}
else {
if (g_sf_global_vars.max_buff_size < g_sf_global_vars.max_pkg_size) {
g_sf_global_vars.max_buff_size = g_sf_global_vars.max_pkg_size;
}
if (g_sf_global_vars.max_buff_size < g_sf_global_vars.min_buff_size) {
logWarning("file: "__FILE__", line: %d, "
"max_buff_size: %d < min_buff_size: %d, "
"set max_buff_size to min_buff_size", __LINE__,
g_sf_global_vars.max_buff_size,
g_sf_global_vars.min_buff_size);
g_sf_global_vars.max_buff_size = g_sf_global_vars.min_buff_size;
}
}
return 0;
}
int sf_load_global_config_ex(const char *server_name, const char *filename,
IniContext *pIniContext, const bool load_network_params)
{
int result;
char *pBasePath;
char *pRunByGroup;
char *pRunByUser;
char *pThreadStackSize;
int64_t thread_stack_size;
pBasePath = iniGetStrValue(NULL, "base_path", pIniContext);
if (pBasePath == NULL) {
logError("file: "__FILE__", line: %d, "
"conf file \"%s\" must have item "
"\"base_path\"!", __LINE__, filename);
return ENOENT;
}
snprintf(g_sf_global_vars.base_path, sizeof(g_sf_global_vars.base_path),
"%s", pBasePath);
chopPath(g_sf_global_vars.base_path);
if (!fileExists(g_sf_global_vars.base_path)) {
logError("file: "__FILE__", line: %d, "
"\"%s\" can't be accessed, error info: %s",
__LINE__, g_sf_global_vars.base_path, strerror(errno));
return errno != 0 ? errno : ENOENT;
}
if (!isDir(g_sf_global_vars.base_path)) {
logError("file: "__FILE__", line: %d, "
"\"%s\" is not a directory!",
__LINE__, g_sf_global_vars.base_path);
return ENOTDIR;
}
if (load_network_params) {
if ((result=load_network_parameters(pIniContext)) != 0) {
return result;
}
}
pRunByGroup = iniGetStrValue(NULL, "run_by_group", pIniContext);
pRunByUser = iniGetStrValue(NULL, "run_by_user", pIniContext);
if (pRunByGroup == NULL) {
*g_sf_global_vars.run_by_group = '\0';
}
else {
snprintf(g_sf_global_vars.run_by_group,
sizeof(g_sf_global_vars.run_by_group),
"%s", pRunByGroup);
}
if (*(g_sf_global_vars.run_by_group) == '\0') {
g_sf_global_vars.run_by_gid = getegid();
}
else {
struct group *pGroup;
pGroup = getgrnam(g_sf_global_vars.run_by_group);
if (pGroup == NULL) {
result = errno != 0 ? errno : ENOENT;
logError("file: "__FILE__", line: %d, "
"getgrnam fail, errno: %d, "
"error info: %s", __LINE__,
result, strerror(result));
return result;
}
g_sf_global_vars.run_by_gid = pGroup->gr_gid;
}
if (pRunByUser == NULL) {
*g_sf_global_vars.run_by_user = '\0';
}
else {
snprintf(g_sf_global_vars.run_by_user,
sizeof(g_sf_global_vars.run_by_user),
"%s", pRunByUser);
}
if (*(g_sf_global_vars.run_by_user) == '\0') {
g_sf_global_vars.run_by_uid = geteuid();
}
else {
struct passwd *pUser;
pUser = getpwnam(g_sf_global_vars.run_by_user);
if (pUser == NULL) {
result = errno != 0 ? errno : ENOENT;
logError("file: "__FILE__", line: %d, "
"getpwnam fail, errno: %d, "
"error info: %s", __LINE__,
result, strerror(result));
return result;
}
g_sf_global_vars.run_by_uid = pUser->pw_uid;
}
if ((result=set_run_by(g_sf_global_vars.run_by_group,
g_sf_global_vars.run_by_user)) != 0)
{
return result;
}
g_sf_global_vars.sync_log_buff_interval = iniGetIntValue(NULL,
"sync_log_buff_interval", pIniContext,
SYNC_LOG_BUFF_DEF_INTERVAL);
if (g_sf_global_vars.sync_log_buff_interval <= 0) {
g_sf_global_vars.sync_log_buff_interval = SYNC_LOG_BUFF_DEF_INTERVAL;
}
pThreadStackSize = iniGetStrValue(NULL,
"thread_stack_size", pIniContext);
if (pThreadStackSize == NULL) {
thread_stack_size = SF_DEF_THREAD_STACK_SIZE;
}
else if ((result=parse_bytes(pThreadStackSize, 1,
&thread_stack_size)) != 0)
{
return result;
}
g_sf_global_vars.thread_stack_size = (int)thread_stack_size;
g_sf_global_vars.rotate_error_log = iniGetBoolValue(NULL,
"rotate_error_log", pIniContext, false);
g_sf_global_vars.log_file_keep_days = iniGetIntValue(NULL,
"log_file_keep_days", pIniContext, 0);
load_log_level(pIniContext);
if ((result=log_set_prefix(g_sf_global_vars.base_path, server_name)) != 0) {
return result;
}
return 0;
}
int sf_load_config_ex(const char *server_name, const char *filename,
IniContext *pIniContext, const char *section_name,
const int default_inner_port, const int default_outer_port)
{
int result;
if ((result=sf_load_global_config(server_name,
filename, pIniContext)) != 0)
{
return result;
}
return sf_load_context_from_config(&g_sf_context, filename, pIniContext,
section_name, default_inner_port, default_outer_port);
}
int sf_load_config(const char *server_name, const char *filename,
IniContext *pIniContext, const int default_inner_port,
const int default_outer_port)
{
return sf_load_config_ex(server_name, filename, pIniContext, "",
default_inner_port, default_outer_port);
}
int sf_load_context_from_config(SFContext *sf_context,
const char *filename, IniContext *pIniContext,
const char *section_name, const int default_inner_port,
const int default_outer_port)
{
char *inner_port;
char *outer_port;
char *inner_bind_addr;
char *outer_bind_addr;
char *bind_addr;
int port;
sf_context->inner_port = sf_context->outer_port = 0;
inner_port = iniGetStrValue(section_name, "inner_port", pIniContext);
outer_port = iniGetStrValue(section_name, "outer_port", pIniContext);
if (inner_port == NULL && outer_port == NULL) {
port = iniGetIntValue(section_name, "port", pIniContext, 0);
if (port > 0) {
sf_context->inner_port = sf_context->outer_port = port;
}
} else {
if (inner_port != NULL) {
sf_context->inner_port = atoi(inner_port);
}
if (outer_port != NULL) {
sf_context->outer_port = atoi(outer_port);
}
}
if (sf_context->inner_port <= 0) {
sf_context->inner_port = default_inner_port;
}
if (sf_context->outer_port <= 0) {
sf_context->outer_port = default_outer_port;
}
inner_bind_addr = iniGetStrValue(section_name,
"inner_bind_addr", pIniContext);
outer_bind_addr = iniGetStrValue(section_name,
"outer_bind_addr", pIniContext);
if (inner_bind_addr == NULL && outer_bind_addr == NULL) {
bind_addr = iniGetStrValue(section_name,
"bind_addr", pIniContext);
if (bind_addr != NULL) {
inner_bind_addr = outer_bind_addr = bind_addr;
}
}
set_config_str_value(inner_bind_addr, sf_context->inner_bind_addr,
sizeof(sf_context->inner_bind_addr));
set_config_str_value(outer_bind_addr, sf_context->outer_bind_addr,
sizeof(sf_context->outer_bind_addr));
sf_context->accept_threads = iniGetIntValue(section_name,
"accept_threads", pIniContext, 1);
if (sf_context->accept_threads <= 0) {
logError("file: "__FILE__", line: %d, "
"config file: %s, section: %s, "
"item \"accept_threads\" is invalid, "
"value: %d <= 0!", __LINE__, filename,
section_name, sf_context->accept_threads);
return EINVAL;
}
sf_context->work_threads = iniGetIntValue(section_name,
"work_threads", pIniContext, DEFAULT_WORK_THREADS);
if (sf_context->work_threads <= 0) {
logError("file: "__FILE__", line: %d, "
"config file: %s, section: %s, "
"item \"work_threads\" is invalid, "
"value: %d <= 0!", __LINE__, filename,
section_name, sf_context->work_threads);
return EINVAL;
}
return 0;
}
void sf_context_config_to_string(const SFContext *sf_context,
char *output, const int size)
{
int len;
len = 0;
if ((sf_context->inner_port == sf_context->outer_port) &&
(strcmp(sf_context->inner_bind_addr,
sf_context->outer_bind_addr) == 0))
{
len += snprintf(output + len, size - len,
"port=%d, bind_addr=%s",
sf_context->inner_port,
sf_context->inner_bind_addr);
} else {
len += snprintf(output + len, size - len,
"inner_port=%d, inner_bind_addr=%s, "
"outer_port=%d, outer_bind_addr=%s",
sf_context->inner_port, sf_context->inner_bind_addr,
sf_context->outer_port, sf_context->outer_bind_addr);
}
len += snprintf(output + len, size - len,
", accept_threads=%d, work_threads=%d",
sf_context->accept_threads, sf_context->work_threads);
}
void sf_global_config_to_string(char *output, const int size)
{
char sz_thread_stack_size[32];
char sz_max_pkg_size[32];
char sz_min_buff_size[32];
char sz_max_buff_size[32];
snprintf(output, size,
"base_path=%s, max_connections=%d, connect_timeout=%d, "
"network_timeout=%d, thread_stack_size=%s, max_pkg_size=%s, "
"min_buff_size=%s, max_buff_size=%s, log_level=%s, "
"sync_log_buff_interval=%d, rotate_error_log=%d, "
"log_file_keep_days=%d, run_by_group=%s, run_by_user=%s",
g_sf_global_vars.base_path,
g_sf_global_vars.max_connections,
g_sf_global_vars.connect_timeout,
g_sf_global_vars.network_timeout,
int_to_comma_str(g_sf_global_vars.thread_stack_size,
sz_thread_stack_size),
int_to_comma_str(g_sf_global_vars.max_pkg_size, sz_max_pkg_size),
int_to_comma_str(g_sf_global_vars.min_buff_size, sz_min_buff_size),
int_to_comma_str(g_sf_global_vars.max_buff_size, sz_max_buff_size),
log_get_level_caption(),
g_sf_global_vars.sync_log_buff_interval,
g_sf_global_vars.rotate_error_log,
g_sf_global_vars.log_file_keep_days,
g_sf_global_vars.run_by_group,
g_sf_global_vars.run_by_user
);
}
void sf_log_config_ex(const char *other_config)
{
char sz_global_config[512];
char sz_context_config[128];
sf_global_config_to_string(sz_global_config, sizeof(sz_global_config));
sf_context_config_to_string(&g_sf_context,
sz_context_config, sizeof(sz_context_config));
logInfo("%s, %s%s%s",
sz_global_config, sz_context_config,
(other_config != NULL && *other_config != '\0') ? ", " : "",
(other_config != NULL) ? other_config : ""
);
}
Reference in New Issue View Git Blame Copy Permalink