int main(int argc, char *argv[])
{
int result;
IniContext context;
const char *szFilename = "test.ini";
AnnotationEntry annotations[1];
if (argc > 1) {
szFilename = argv[1];
}
log_init();
memset(annotations, 0, sizeof(annotations));
annotations[0].func_name = "EXPRESS_CALC";
annotations[0].func_get = iniAnnotationFuncExpressCalc;
//printf("sizeof(IniContext): %d\n", (int)sizeof(IniContext));
result = iniLoadFromFileEx(szFilename, &context,
FAST_INI_ANNOTATION_WITH_BUILTIN, annotations, 1,
FAST_INI_FLAGS_SHELL_EXECUTE);
if (result != 0)
{
return result;
}
iniPrintItems(&context);
iniDestroyAnnotationCallBack();
iniFreeContext(&context);
return 0;
}
int main(int argc, char *argv[])
{
int result;
IniContext context;
const char *szFilename = "/home/yuqing/watchd-config/order.conf";
if (argc > 1) {
szFilename = argv[1];
}
log_init();
g_log_context.log_level = LOG_DEBUG;
log_take_over_stderr();
log_take_over_stdout();
log_set_compress_log_flags(LOG_COMPRESS_FLAGS_ENABLED | LOG_COMPRESS_FLAGS_NEW_THREAD);
printf("sizeof(LogContext): %d, time_precision: %d, compress_log_flags: %d, "
"use_file_write_lock: %d\n", (int)sizeof(LogContext),
g_log_context.time_precision,
g_log_context.compress_log_flags,
g_log_context.use_file_write_lock);
if ((result=iniLoadFromFile(szFilename, &context)) != 0)
{
return result;
}
iniPrintItems(&context);
iniFreeContext(&context);
return 0;
}
int get_base_path_from_conf_file(const char *filename, char *base_path,
const int path_size)
{
char *pBasePath;
IniContext iniContext;
int result;
memset(&iniContext, 0, sizeof(IniContext));
if ((result=iniLoadFromFileEx(filename, &iniContext, true)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load conf file \"%s\" fail, ret code: %d", \
__LINE__, filename, result);
return result;
}
do
{
pBasePath = iniGetStrValue(NULL, "base_path", &iniContext);
if (pBasePath == NULL)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" must have item " \
"\"base_path\"!", __LINE__, filename);
result = ENOENT;
break;
}
snprintf(base_path, path_size, "%s", pBasePath);
chopPath(base_path);
if (!fileExists(base_path))
{
logError("file: "__FILE__", line: %d, " \
"\"%s\" can't be accessed, error info: %s", \
__LINE__, base_path, STRERROR(errno));
result = errno != 0 ? errno : ENOENT;
break;
}
if (!isDir(base_path))
{
logError("file: "__FILE__", line: %d, " \
"\"%s\" is not a directory!", \
__LINE__, base_path);
result = ENOTDIR;
break;
}
} while (0);
iniFreeContext(&iniContext);
return result;
}
int main(int argc, char *argv[])
{
IniContext context;
IniItem *items;
int result;
int count;
int input_len;
int out_len;
char input[8 * 1024];
char output[10 * 1024];
FastCharConverter converter;
if (argc >= 2) {
input_len = snprintf(input, sizeof(input), "%s", argv[1]);
} else {
input_len = read(0, input, sizeof(input) - 1);
if (input_len < 0) {
fprintf(stderr, "read from stdin fail");
return errno;
}
*(input + input_len) = '\0';
}
log_init();
if ((result=iniLoadFromFile("test.ini", &context)) != 0)
{
return result;
}
iniPrintItems(&context);
printf("input_len: %d\n%s\n\n", (int)strlen(input), input);
items = iniGetSectionItems("AccessLogSpaceCharConvert", &context, &count);
result = char_convert_loader_init(&converter, items, count);
if (result != 0) {
return result;
}
iniFreeContext(&context);
count = fast_char_convert(&converter, input, input_len,
output, &out_len, sizeof(output));
printf("count: %d\n", count);
printf("out_len: %d\n%.*s\n", out_len, out_len, output);
return 0;
}
int load_log_level_ex(const char *conf_filename)
{
int result;
IniContext iniContext;
if ((result=iniLoadFromFile(conf_filename, &iniContext)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load conf file \"%s\" fail, ret code: %d", \
__LINE__, conf_filename, result);
return result;
}
load_log_level(&iniContext);
iniFreeContext(&iniContext);
return 0;
}
int iniLoadFromBuffer(char *content, IniContext *pContext)
{
int result;
if ((result=iniInitContext(pContext)) != 0)
{
return result;
}
result = iniDoLoadItemsFromBuffer(content, pContext);
if (result == 0)
{
iniSortItems(pContext);
}
else
{
iniFreeContext(pContext);
}
return result;
}
int fdfs_mod_init() {
IniContext iniContext;
int result;
char *pBasePath;
char *pLogFilename;
char *pReponseMode;
char *pGroupName;
char *pIfAliasPrefix;
log_init();
if ((result = iniLoadFromFile(FDFS_MOD_CONF_FILENAME, &iniContext)) != 0) {
logError("file: "__FILE__", line: %d, "
"load conf file \"%s\" fail, ret code: %d", __LINE__,
FDFS_MOD_CONF_FILENAME, result);
return result;
}
do {
pBasePath = iniGetStrValue(NULL, "base_path", &iniContext);
if (pBasePath == NULL) {
logError("file: "__FILE__", line: %d, "
"conf file \"%s\" must have item "
"\"base_path\"!", __LINE__, FDFS_MOD_CONF_FILENAME);
result = ENOENT;
break;
}
snprintf(g_fdfs_base_path, sizeof(g_fdfs_base_path), "%s", pBasePath);
chopPath(g_fdfs_base_path);
if (!fileExists(g_fdfs_base_path)) {
logError("file: "__FILE__", line: %d, "
"\"%s\" can't be accessed, error info: %s", __LINE__,
g_fdfs_base_path, strerror(errno));
result = errno != 0 ? errno : ENOENT;
break;
}
if (!isDir(g_fdfs_base_path)) {
logError("file: "__FILE__", line: %d, "
"\"%s\" is not a directory!", __LINE__, g_fdfs_base_path);
result = ENOTDIR;
break;
}
g_fdfs_connect_timeout = iniGetIntValue(NULL, "connect_timeout",
&iniContext, DEFAULT_CONNECT_TIMEOUT);
if (g_fdfs_connect_timeout <= 0) {
g_fdfs_connect_timeout = DEFAULT_CONNECT_TIMEOUT;
}
g_fdfs_network_timeout = iniGetIntValue(NULL, "network_timeout",
&iniContext, DEFAULT_NETWORK_TIMEOUT);
if (g_fdfs_network_timeout <= 0) {
g_fdfs_network_timeout = DEFAULT_NETWORK_TIMEOUT;
}
load_log_level(&iniContext);
pLogFilename = iniGetStrValue(NULL, "log_filename", &iniContext);
if (pLogFilename != NULL && *pLogFilename != '\0') {
if ((result = log_set_filename(pLogFilename)) != 0) {
break;
}
}
result = fdfs_load_tracker_group_ex(&g_tracker_group,
FDFS_MOD_CONF_FILENAME, &iniContext);
if (result != 0) {
break;
}
storage_server_port = iniGetIntValue(NULL, "storage_server_port",
&iniContext, FDFS_STORAGE_SERVER_DEF_PORT);
url_have_group_name = iniGetBoolValue(NULL, "url_have_group_name",
&iniContext, false);
pGroupName = iniGetStrValue(NULL, "group_name", &iniContext);
if (pGroupName != NULL) {
snprintf(group_name, sizeof(group_name), "%s", pGroupName);
}
group_name_len = strlen(group_name);
if ((!url_have_group_name) && group_name_len == 0) {
logError("file: "__FILE__", line: %d, "
"you must set parameter: group_name!", __LINE__);
result = ENOENT;
break;
}
if ((result = fdfs_http_params_load(&iniContext, FDFS_MOD_CONF_FILENAME,
&g_http_params)) != 0) {
break;
}
pReponseMode = iniGetStrValue(NULL, "response_mode", &iniContext);
//add client 模式
if (pReponseMode != NULL) {
if (strcmp(pReponseMode, "redirect") == 0) {
response_mode = FDFS_MOD_REPONSE_MODE_REDIRECT;
} else if (strcmp(pReponseMode, "client") == 0) {
response_mode = FDFS_MOD_REPONSE_MODE_CLIENT;
}
}
pIfAliasPrefix = iniGetStrValue(NULL, "if_alias_prefix", &iniContext);
if (pIfAliasPrefix == NULL) {
*g_if_alias_prefix = '\0';
} else {
snprintf(g_if_alias_prefix, sizeof(g_if_alias_prefix), "%s",
pIfAliasPrefix);
}
} while (false);
iniFreeContext(&iniContext);
if (result != 0) {
return result;
}
load_local_host_ip_addrs();
fdfs_get_params_from_tracker();
logInfo("fastdfs apache / nginx module v1.04, "
"response_mode=%s, "
"base_path=%s, "
"connect_timeout=%d, "
"network_timeout=%d, "
"tracker_server_count=%d, "
"storage_server_port=%d, "
"group_name=%s, "
"if_alias_prefix=%s, "
"local_host_ip_count=%d, "
"need_find_content_type=%d, "
"default_content_type=%s, "
"anti_steal_token=%d, "
"token_ttl=%ds, "
"anti_steal_secret_key length=%d, "
"token_check_fail content_type=%s, "
"token_check_fail buff length=%d, "
"storage_sync_file_max_delay=%ds",
response_mode == FDFS_MOD_REPONSE_MODE_PROXY ? "proxy" : "redirect",
g_fdfs_base_path, g_fdfs_connect_timeout, g_fdfs_network_timeout,
g_tracker_group.server_count, storage_server_port, group_name,
g_if_alias_prefix, g_local_host_ip_count,
g_http_params.need_find_content_type,
g_http_params.default_content_type, g_http_params.anti_steal_token,
g_http_params.token_ttl, g_http_params.anti_steal_secret_key.length,
g_http_params.token_check_fail_content_type,
g_http_params.token_check_fail_buff.length,
storage_sync_file_max_delay);
//print_local_host_ip_addrs();
return 0;
}
int storage_func_init(const char *filename, \
char *bind_addr, const int addr_size)
{
char *pBindAddr;
char *pGroupName;
char *pRunByGroup;
char *pRunByUser;
char *pFsyncAfterWrittenBytes;
char *pThreadStackSize;
char *pBuffSize;
char *pIfAliasPrefix;
char *pHttpDomain;
IniContext iniContext;
int result;
int64_t fsync_after_written_bytes;
int64_t thread_stack_size;
int64_t buff_size;
TrackerServerInfo *pServer;
TrackerServerInfo *pEnd;
/*
while (nThreadCount > 0)
{
sleep(1);
}
*/
if ((result=iniLoadFromFile(filename, &iniContext)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load conf file \"%s\" fail, ret code: %d", \
__LINE__, filename, result);
return result;
}
do
{
if (iniGetBoolValue(NULL, "disabled", &iniContext, false))
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" disabled=true, exit", \
__LINE__, filename);
result = ECANCELED;
break;
}
g_subdir_count_per_path=iniGetIntValue(NULL, \
"subdir_count_per_path", &iniContext, \
DEFAULT_DATA_DIR_COUNT_PER_PATH);
if (g_subdir_count_per_path <= 0 || \
g_subdir_count_per_path > 256)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", invalid subdir_count: %d", \
__LINE__, filename, g_subdir_count_per_path);
result = EINVAL;
break;
}
if ((result=storage_load_paths(&iniContext)) != 0)
{
break;
}
load_log_level(&iniContext);
if ((result=log_set_prefix(g_fdfs_base_path, \
STORAGE_ERROR_LOG_FILENAME)) != 0)
{
break;
}
g_fdfs_connect_timeout = iniGetIntValue(NULL, "connect_timeout", \
&iniContext, DEFAULT_CONNECT_TIMEOUT);
if (g_fdfs_connect_timeout <= 0)
{
g_fdfs_connect_timeout = DEFAULT_CONNECT_TIMEOUT;
}
g_fdfs_network_timeout = iniGetIntValue(NULL, "network_timeout", \
&iniContext, DEFAULT_NETWORK_TIMEOUT);
if (g_fdfs_network_timeout <= 0)
{
g_fdfs_network_timeout = DEFAULT_NETWORK_TIMEOUT;
}
g_network_tv.tv_sec = g_fdfs_network_timeout;
g_server_port = iniGetIntValue(NULL, "port", &iniContext, \
FDFS_STORAGE_SERVER_DEF_PORT);
if (g_server_port <= 0)
{
g_server_port = FDFS_STORAGE_SERVER_DEF_PORT;
}
g_heart_beat_interval = iniGetIntValue(NULL, \
"heart_beat_interval", &iniContext, \
STORAGE_BEAT_DEF_INTERVAL);
if (g_heart_beat_interval <= 0)
{
g_heart_beat_interval = STORAGE_BEAT_DEF_INTERVAL;
}
g_stat_report_interval = iniGetIntValue(NULL, \
"stat_report_interval", &iniContext, \
STORAGE_REPORT_DEF_INTERVAL);
if (g_stat_report_interval <= 0)
{
g_stat_report_interval = STORAGE_REPORT_DEF_INTERVAL;
}
pBindAddr = iniGetStrValue(NULL, "bind_addr", &iniContext);
if (pBindAddr == NULL)
{
*bind_addr = '\0';
}
else
{
snprintf(bind_addr, addr_size, "%s", pBindAddr);
}
g_client_bind_addr = iniGetBoolValue(NULL, "client_bind", \
&iniContext, true);
pGroupName = iniGetStrValue(NULL, "group_name", &iniContext);
if (pGroupName == NULL)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" must have item " \
"\"group_name\"!", \
__LINE__, filename);
result = ENOENT;
break;
}
if (pGroupName[0] == '\0')
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", " \
"group_name is empty!", \
__LINE__, filename);
result = EINVAL;
break;
}
snprintf(g_group_name, sizeof(g_group_name), "%s", pGroupName);
if ((result=fdfs_validate_group_name(g_group_name)) != 0) \
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", " \
"the group name \"%s\" is invalid!", \
__LINE__, filename, g_group_name);
result = EINVAL;
break;
}
result = fdfs_load_tracker_group_ex(&g_tracker_group, \
filename, &iniContext);
if (result != 0)
{
break;
}
pEnd = g_tracker_group.servers + g_tracker_group.server_count;
for (pServer=g_tracker_group.servers; pServer<pEnd; pServer++)
{
//printf("server=%s:%d\n", pServer->ip_addr, pServer->port);
if (strcmp(pServer->ip_addr, "127.0.0.1") == 0)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", " \
"tracker: \"%s:%d\" is invalid, " \
"tracker server ip can't be 127.0.0.1",\
__LINE__, filename, pServer->ip_addr, \
pServer->port);
result = EINVAL;
break;
}
}
if (result != 0)
{
break;
}
g_sync_wait_usec = iniGetIntValue(NULL, "sync_wait_msec",\
&iniContext, STORAGE_DEF_SYNC_WAIT_MSEC);
if (g_sync_wait_usec <= 0)
{
g_sync_wait_usec = STORAGE_DEF_SYNC_WAIT_MSEC;
}
g_sync_wait_usec *= 1000;
g_sync_interval = iniGetIntValue(NULL, "sync_interval",\
&iniContext, 0);
if (g_sync_interval < 0)
{
g_sync_interval = 0;
}
g_sync_interval *= 1000;
if ((result=get_time_item_from_conf(&iniContext, \
"sync_start_time", &g_sync_start_time, 0, 0)) != 0)
{
break;
}
if ((result=get_time_item_from_conf(&iniContext, \
"sync_end_time", &g_sync_end_time, 23, 59)) != 0)
{
break;
}
g_sync_part_time = !((g_sync_start_time.hour == 0 && \
g_sync_start_time.minute == 0) && \
(g_sync_end_time.hour == 23 && \
g_sync_end_time.minute == 59));
g_max_connections = iniGetIntValue(NULL, "max_connections", \
&iniContext, DEFAULT_MAX_CONNECTONS);
if (g_max_connections <= 0)
{
g_max_connections = DEFAULT_MAX_CONNECTONS;
}
if ((result=set_rlimit(RLIMIT_NOFILE, g_max_connections)) != 0)
{
break;
}
g_work_threads = iniGetIntValue(NULL, "work_threads", \
&iniContext, DEFAULT_WORK_THREADS);
if (g_work_threads <= 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"work_threads\" is invalid, " \
"value: %d <= 0!", __LINE__, g_work_threads);
result = EINVAL;
break;
}
pBuffSize = iniGetStrValue(NULL, \
"buff_size", &iniContext);
if (pBuffSize == NULL)
{
buff_size = STORAGE_DEFAULT_BUFF_SIZE;
}
else if ((result=parse_bytes(pBuffSize, 1, &buff_size)) != 0)
{
return result;
}
g_buff_size = buff_size;
if (g_buff_size < 4 * 1024 || \
g_buff_size < sizeof(TrackerHeader) + \
TRUNK_BINLOG_BUFFER_SIZE)
{
logError("file: "__FILE__", line: %d, " \
"item \"buff_size\" is too small, " \
"value: %d < %d or < %d!", __LINE__, \
g_buff_size, 4 * 1024, \
(int)sizeof(TrackerHeader) + \
TRUNK_BINLOG_BUFFER_SIZE);
result = EINVAL;
break;
}
g_disk_rw_separated = iniGetBoolValue(NULL, \
"disk_rw_separated", &iniContext, true);
g_disk_reader_threads = iniGetIntValue(NULL, \
"disk_reader_threads", \
&iniContext, DEFAULT_DISK_READER_THREADS);
if (g_disk_reader_threads < 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"disk_reader_threads\" is invalid, " \
"value: %d < 0!", __LINE__, \
g_disk_reader_threads);
result = EINVAL;
break;
}
g_disk_writer_threads = iniGetIntValue(NULL, \
"disk_writer_threads", \
&iniContext, DEFAULT_DISK_WRITER_THREADS);
if (g_disk_writer_threads < 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"disk_writer_threads\" is invalid, " \
"value: %d < 0!", __LINE__, \
g_disk_writer_threads);
result = EINVAL;
break;
}
if (g_disk_rw_separated)
{
if (g_disk_reader_threads == 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"disk_reader_threads\" is " \
"invalid, value = 0!", __LINE__);
result = EINVAL;
break;
}
if (g_disk_writer_threads == 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"disk_writer_threads\" is " \
"invalid, value = 0!", __LINE__);
result = EINVAL;
break;
}
}
else if (g_disk_reader_threads + g_disk_writer_threads == 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"disk_reader_threads\" and " \
"\"disk_writer_threads\" are " \
"invalid, both value = 0!", __LINE__);
result = EINVAL;
break;
}
/*
g_disk_rw_direct = iniGetBoolValue(NULL, \
"disk_rw_direct", &iniContext, false);
*/
pRunByGroup = iniGetStrValue(NULL, "run_by_group", &iniContext);
pRunByUser = iniGetStrValue(NULL, "run_by_user", &iniContext);
if (pRunByGroup == NULL)
{
*g_run_by_group = '\0';
}
else
{
snprintf(g_run_by_group, sizeof(g_run_by_group), \
"%s", pRunByGroup);
}
if (*g_run_by_group == '\0')
{
g_run_by_gid = getegid();
}
else
{
struct group *pGroup;
pGroup = getgrnam(g_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_run_by_gid = pGroup->gr_gid;
}
if (pRunByUser == NULL)
{
*g_run_by_user = '******';
}
else
{
snprintf(g_run_by_user, sizeof(g_run_by_user), \
"%s", pRunByUser);
}
if (*g_run_by_user == '\0')
{
g_run_by_uid = geteuid();
}
else
{
struct passwd *pUser;
pUser = getpwnam(g_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_run_by_uid = pUser->pw_uid;
}
if ((result=load_allow_hosts(&iniContext, \
&g_allow_ip_addrs, &g_allow_ip_count)) != 0)
{
return result;
}
g_file_distribute_path_mode = iniGetIntValue(NULL, \
"file_distribute_path_mode", &iniContext, \
FDFS_FILE_DIST_PATH_ROUND_ROBIN);
g_file_distribute_rotate_count = iniGetIntValue(NULL, \
"file_distribute_rotate_count", &iniContext, \
FDFS_FILE_DIST_DEFAULT_ROTATE_COUNT);
if (g_file_distribute_rotate_count <= 0)
{
g_file_distribute_rotate_count = \
FDFS_FILE_DIST_DEFAULT_ROTATE_COUNT;
}
pFsyncAfterWrittenBytes = iniGetStrValue(NULL, \
"fsync_after_written_bytes", &iniContext);
if (pFsyncAfterWrittenBytes == NULL)
{
fsync_after_written_bytes = 0;
}
else if ((result=parse_bytes(pFsyncAfterWrittenBytes, 1, \
&fsync_after_written_bytes)) != 0)
{
return result;
}
g_fsync_after_written_bytes = fsync_after_written_bytes;
g_sync_log_buff_interval = iniGetIntValue(NULL, \
"sync_log_buff_interval", &iniContext, \
SYNC_LOG_BUFF_DEF_INTERVAL);
if (g_sync_log_buff_interval <= 0)
{
g_sync_log_buff_interval = SYNC_LOG_BUFF_DEF_INTERVAL;
}
g_sync_binlog_buff_interval = iniGetIntValue(NULL, \
"sync_binlog_buff_interval", &iniContext,\
SYNC_BINLOG_BUFF_DEF_INTERVAL);
if (g_sync_binlog_buff_interval <= 0)
{
g_sync_binlog_buff_interval=SYNC_BINLOG_BUFF_DEF_INTERVAL;
}
g_write_mark_file_freq = iniGetIntValue(NULL, \
"write_mark_file_freq", &iniContext, \
FDFS_DEFAULT_SYNC_MARK_FILE_FREQ);
if (g_write_mark_file_freq <= 0)
{
g_write_mark_file_freq = FDFS_DEFAULT_SYNC_MARK_FILE_FREQ;
}
g_sync_stat_file_interval = iniGetIntValue(NULL, \
"sync_stat_file_interval", &iniContext, \
DEFAULT_SYNC_STAT_FILE_INTERVAL);
if (g_sync_stat_file_interval <= 0)
{
g_sync_stat_file_interval=DEFAULT_SYNC_STAT_FILE_INTERVAL;
}
pThreadStackSize = iniGetStrValue(NULL, \
"thread_stack_size", &iniContext);
if (pThreadStackSize == NULL)
{
thread_stack_size = 512 * 1024;
}
else if ((result=parse_bytes(pThreadStackSize, 1, \
&thread_stack_size)) != 0)
{
return result;
}
g_thread_stack_size = (int)thread_stack_size;
if (g_thread_stack_size < 64 * 1024)
{
logError("file: "__FILE__", line: %d, " \
"item \"thread_stack_size\" %d is invalid, " \
"which < %d", __LINE__, g_thread_stack_size, \
64 * 1024);
result = EINVAL;
break;
}
g_upload_priority = iniGetIntValue(NULL, \
"upload_priority", &iniContext, \
DEFAULT_UPLOAD_PRIORITY);
pIfAliasPrefix = iniGetStrValue(NULL, \
"if_alias_prefix", &iniContext);
if (pIfAliasPrefix == NULL)
{
*g_if_alias_prefix = '\0';
}
else
{
snprintf(g_if_alias_prefix, sizeof(g_if_alias_prefix),
"%s", pIfAliasPrefix);
}
g_check_file_duplicate = iniGetBoolValue(NULL, \
"check_file_duplicate", &iniContext, false);
if (g_check_file_duplicate)
{
char *pKeyNamespace;
strcpy(g_fdht_base_path, g_fdfs_base_path);
g_fdht_connect_timeout = g_fdfs_connect_timeout;
g_fdht_network_timeout = g_fdfs_network_timeout;
pKeyNamespace = iniGetStrValue(NULL, \
"key_namespace", &iniContext);
if (pKeyNamespace == NULL || *pKeyNamespace == '\0')
{
logError("file: "__FILE__", line: %d, " \
"item \"key_namespace\" does not " \
"exist or is empty", __LINE__);
result = EINVAL;
break;
}
g_namespace_len = strlen(pKeyNamespace);
if (g_namespace_len >= sizeof(g_key_namespace))
{
g_namespace_len = sizeof(g_key_namespace) - 1;
}
memcpy(g_key_namespace, pKeyNamespace, g_namespace_len);
*(g_key_namespace + g_namespace_len) = '\0';
if ((result=fdht_load_groups(&iniContext, \
&g_group_array)) != 0)
{
break;
}
g_keep_alive = iniGetBoolValue(NULL, "keep_alive", \
&iniContext, false);
}
g_http_port = iniGetIntValue(NULL, "http.server_port", \
&iniContext, 80);
if (g_http_port <= 0)
{
logError("file: "__FILE__", line: %d, " \
"invalid param \"http.server_port\": %d", \
__LINE__, g_http_port);
return EINVAL;
}
pHttpDomain = iniGetStrValue(NULL, \
"http.domain_name", &iniContext);
if (pHttpDomain == NULL)
{
*g_http_domain = '\0';
}
else
{
snprintf(g_http_domain, sizeof(g_http_domain), \
"%s", pHttpDomain);
}
#ifdef WITH_HTTPD
{
char *pHttpTrunkSize;
int64_t http_trunk_size;
if ((result=fdfs_http_params_load(&iniContext, \
filename, &g_http_params)) != 0)
{
break;
}
pHttpTrunkSize = iniGetStrValue(NULL, \
"http.trunk_size", &iniContext);
if (pHttpTrunkSize == NULL)
{
http_trunk_size = 64 * 1024;
}
else if ((result=parse_bytes(pHttpTrunkSize, 1, \
&http_trunk_size)) != 0)
{
break;
}
g_http_trunk_size = (int)http_trunk_size;
}
#endif
logInfo("FastDFS v%d.%02d, base_path=%s, store_path_count=%d, " \
"subdir_count_per_path=%d, group_name=%s, " \
"run_by_group=%s, run_by_user=%s, " \
"connect_timeout=%ds, network_timeout=%ds, "\
"port=%d, bind_addr=%s, client_bind=%d, " \
"max_connections=%d, work_threads=%d, " \
"disk_rw_separated=%d, disk_reader_threads=%d, " \
"disk_writer_threads=%d, " \
"buff_size=%dKB, heart_beat_interval=%ds, " \
"stat_report_interval=%ds, tracker_server_count=%d, " \
"sync_wait_msec=%dms, sync_interval=%dms, " \
"sync_start_time=%02d:%02d, sync_end_time=%02d:%02d, "\
"write_mark_file_freq=%d, " \
"allow_ip_count=%d, " \
"file_distribute_path_mode=%d, " \
"file_distribute_rotate_count=%d, " \
"fsync_after_written_bytes=%d, " \
"sync_log_buff_interval=%ds, " \
"sync_binlog_buff_interval=%ds, " \
"sync_stat_file_interval=%ds, " \
"thread_stack_size=%d KB, upload_priority=%d, " \
"if_alias_prefix=%s, " \
"check_file_duplicate=%d, FDHT group count=%d, " \
"FDHT server count=%d, FDHT key_namespace=%s, " \
"FDHT keep_alive=%d, HTTP server port=%d, " \
"domain name=%s", \
g_fdfs_version.major, g_fdfs_version.minor, \
g_fdfs_base_path, g_fdfs_path_count, g_subdir_count_per_path,\
g_group_name, g_run_by_group, g_run_by_user, \
g_fdfs_connect_timeout, \
g_fdfs_network_timeout, g_server_port, bind_addr, \
g_client_bind_addr, g_max_connections, \
g_work_threads, g_disk_rw_separated, \
g_disk_reader_threads, g_disk_writer_threads, \
g_buff_size / 1024, \
g_heart_beat_interval, g_stat_report_interval, \
g_tracker_group.server_count, g_sync_wait_usec / 1000, \
g_sync_interval / 1000, \
g_sync_start_time.hour, g_sync_start_time.minute, \
g_sync_end_time.hour, g_sync_end_time.minute, \
g_write_mark_file_freq, \
g_allow_ip_count, g_file_distribute_path_mode, \
g_file_distribute_rotate_count, \
g_fsync_after_written_bytes, g_sync_log_buff_interval, \
g_sync_binlog_buff_interval, g_sync_stat_file_interval, \
g_thread_stack_size/1024, g_upload_priority, \
g_if_alias_prefix, g_check_file_duplicate, \
g_group_array.group_count, g_group_array.server_count, \
g_key_namespace, g_keep_alive, \
g_http_port, g_http_domain);
#ifdef WITH_HTTPD
if (!g_http_params.disabled)
{
logInfo("HTTP supported: " \
"server_port=%d, " \
"http_trunk_size=%d, " \
"default_content_type=%s, " \
"anti_steal_token=%d, " \
"token_ttl=%ds, " \
"anti_steal_secret_key length=%d, " \
"token_check_fail content_type=%s, " \
"token_check_fail buff length=%d", \
g_http_params.server_port, \
g_http_trunk_size, \
g_http_params.default_content_type, \
g_http_params.anti_steal_token, \
g_http_params.token_ttl, \
g_http_params.anti_steal_secret_key.length, \
g_http_params.token_check_fail_content_type, \
g_http_params.token_check_fail_buff.length);
}
#endif
} while (0);
iniFreeContext(&iniContext);
if (result != 0)
{
return result;
}
if ((result=storage_get_my_tracker_client_ip()) != 0)
{
return result;
}
if ((result=storage_check_and_make_data_dirs()) != 0)
{
logCrit("file: "__FILE__", line: %d, " \
"storage_check_and_make_data_dirs fail, " \
"program exit!", __LINE__);
return result;
}
if ((result=storage_get_params_from_tracker()) != 0)
{
return result;
}
if ((result=storage_check_ip_changed()) != 0)
{
return result;
}
if ((result=init_pthread_lock(&sync_stat_file_lock)) != 0)
{
return result;
}
return storage_open_stat_file();
}
static int storage_check_and_make_data_dirs()
{
int result;
int i;
char data_path[MAX_PATH_SIZE];
char full_filename[MAX_PATH_SIZE];
bool pathCreated;
snprintf(data_path, sizeof(data_path), "%s/data", \
g_fdfs_base_path);
snprintf(full_filename, sizeof(full_filename), "%s/%s", \
data_path, DATA_DIR_INITED_FILENAME);
if (fileExists(full_filename))
{
IniContext iniContext;
char *pValue;
if ((result=iniLoadFromFile(full_filename, &iniContext)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load from file \"%s/%s\" fail, " \
"error code: %d", \
__LINE__, data_path, \
full_filename, result);
return result;
}
pValue = iniGetStrValue(NULL, INIT_ITEM_STORAGE_JOIN_TIME, \
&iniContext);
if (pValue == NULL)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in file \"%s/%s\", item \"%s\" not exists", \
__LINE__, data_path, full_filename, \
INIT_ITEM_STORAGE_JOIN_TIME);
return ENOENT;
}
g_storage_join_time = atoi(pValue);
pValue = iniGetStrValue(NULL, INIT_ITEM_SYNC_OLD_DONE, \
&iniContext);
if (pValue == NULL)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in file \"%s/%s\", item \"%s\" not exists", \
__LINE__, data_path, full_filename, \
INIT_ITEM_SYNC_OLD_DONE);
return ENOENT;
}
g_sync_old_done = atoi(pValue);
pValue = iniGetStrValue(NULL, INIT_ITEM_SYNC_SRC_SERVER, \
&iniContext);
if (pValue == NULL)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in file \"%s/%s\", item \"%s\" not exists", \
__LINE__, data_path, full_filename, \
INIT_ITEM_SYNC_SRC_SERVER);
return ENOENT;
}
snprintf(g_sync_src_ip_addr, sizeof(g_sync_src_ip_addr), \
"%s", pValue);
g_sync_until_timestamp = iniGetIntValue(NULL, \
INIT_ITEM_SYNC_UNTIL_TIMESTAMP, \
&iniContext, 0);
pValue = iniGetStrValue(NULL, INIT_ITEM_LAST_IP_ADDRESS, \
&iniContext);
if (pValue != NULL)
{
snprintf(g_last_storage_ip, sizeof(g_last_storage_ip), \
"%s", pValue);
}
pValue = iniGetStrValue(NULL, INIT_ITEM_LAST_SERVER_PORT, \
&iniContext);
if (pValue != NULL)
{
g_last_server_port = atoi(pValue);
}
pValue = iniGetStrValue(NULL, INIT_ITEM_LAST_HTTP_PORT, \
&iniContext);
if (pValue != NULL)
{
g_last_http_port = atoi(pValue);
}
g_current_trunk_file_id = iniGetIntValue(NULL, \
INIT_ITEM_CURRENT_TRUNK_FILE_ID, &iniContext, 0);
iniFreeContext(&iniContext);
if (g_last_server_port == 0 || g_last_http_port == 0)
{
if (g_last_server_port == 0)
{
g_last_server_port = g_server_port;
}
if (g_last_http_port == 0)
{
g_last_http_port = g_http_port;
}
if ((result=storage_write_to_sync_ini_file()) != 0)
{
return result;
}
}
/*
printf("g_sync_old_done = %d\n", g_sync_old_done);
printf("g_sync_src_ip_addr = %s\n", g_sync_src_ip_addr);
printf("g_sync_until_timestamp = %d\n", g_sync_until_timestamp);
printf("g_last_storage_ip = %s\n", g_last_storage_ip);
printf("g_last_server_port = %d\n", g_last_server_port);
printf("g_last_http_port = %d\n", g_last_http_port);
printf("g_current_trunk_file_id = %d\n", g_current_trunk_file_id);
*/
}
else
{
if (!fileExists(data_path))
{
if (mkdir(data_path, 0755) != 0)
{
logError("file: "__FILE__", line: %d, " \
"mkdir \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, data_path, \
errno, STRERROR(errno));
return errno != 0 ? errno : EPERM;
}
STORAGE_CHOWN(data_path, geteuid(), getegid())
}
g_last_server_port = g_server_port;
g_last_http_port = g_http_port;
g_storage_join_time = time(NULL);
if ((result=storage_write_to_sync_ini_file()) != 0)
{
return result;
}
}
for (i=0; i<g_fdfs_path_count; i++)
{
if ((result=storage_make_data_dirs(g_fdfs_store_paths[i], \
&pathCreated)) != 0)
{
return result;
}
if (g_sync_old_done && pathCreated) //repair damaged disk
{
if ((result=storage_disk_recovery_start(i)) != 0)
{
return result;
}
}
result = storage_disk_recovery_restore(g_fdfs_store_paths[i]);
if (result == EAGAIN) //need to re-fetch binlog
{
if ((result=storage_disk_recovery_start(i)) != 0)
{
return result;
}
result=storage_disk_recovery_restore(g_fdfs_store_paths[i]);
}
if (result != 0)
{
return result;
}
}
return 0;
}
static int storage_open_stat_file()
{
char full_filename[MAX_PATH_SIZE];
IniContext iniContext;
int result;
get_storage_stat_filename(NULL, full_filename);
if (fileExists(full_filename))
{
if ((result=iniLoadFromFile(full_filename, &iniContext)) \
!= 0)
{
logError("file: "__FILE__", line: %d, " \
"load from stat file \"%s\" fail, " \
"error code: %d", \
__LINE__, full_filename, result);
return result;
}
if (iniContext.global.count < 12)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in stat file \"%s\", item count: %d < 12", \
__LINE__, full_filename, iniContext.global.count);
return ENOENT;
}
g_storage_stat.total_upload_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_UPLOAD, &iniContext, 0);
g_storage_stat.success_upload_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_UPLOAD, &iniContext, 0);
g_storage_stat.total_append_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_APPEND, &iniContext, 0);
g_storage_stat.success_append_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_APPEND, &iniContext, 0);
g_storage_stat.total_download_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_DOWNLOAD, &iniContext, 0);
g_storage_stat.success_download_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_DOWNLOAD, &iniContext, 0);
g_storage_stat.last_source_update = iniGetIntValue(NULL, \
STAT_ITEM_LAST_SOURCE_UPD, &iniContext, 0);
g_storage_stat.last_sync_update = iniGetIntValue(NULL, \
STAT_ITEM_LAST_SYNC_UPD, &iniContext, 0);
g_storage_stat.total_set_meta_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_SET_META, &iniContext, 0);
g_storage_stat.success_set_meta_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_SET_META, &iniContext, 0);
g_storage_stat.total_delete_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_DELETE, &iniContext, 0);
g_storage_stat.success_delete_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_DELETE, &iniContext, 0);
g_storage_stat.total_get_meta_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_GET_META, &iniContext, 0);
g_storage_stat.success_get_meta_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_GET_META, &iniContext, 0);
g_storage_stat.total_create_link_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_CREATE_LINK, &iniContext, 0);
g_storage_stat.success_create_link_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_CREATE_LINK, &iniContext, 0);
g_storage_stat.total_delete_link_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_DELETE_LINK, &iniContext, 0);
g_storage_stat.success_delete_link_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_DELETE_LINK, &iniContext, 0);
g_storage_stat.total_upload_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_UPLOAD_BYTES, &iniContext, 0);
g_storage_stat.success_upload_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_UPLOAD_BYTES, &iniContext, 0);
g_storage_stat.total_append_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_APPEND_BYTES, &iniContext, 0);
g_storage_stat.success_append_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_APPEND_BYTES, &iniContext, 0);
g_storage_stat.total_download_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_DOWNLOAD_BYTES, &iniContext, 0);
g_storage_stat.success_download_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_DOWNLOAD_BYTES, &iniContext, 0);
g_storage_stat.total_sync_in_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_SYNC_IN_BYTES, &iniContext, 0);
g_storage_stat.success_sync_in_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_SYNC_IN_BYTES, &iniContext, 0);
g_storage_stat.total_sync_out_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_SYNC_OUT_BYTES, &iniContext, 0);
g_storage_stat.success_sync_out_bytes = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_SYNC_OUT_BYTES, &iniContext, 0);
g_storage_stat.total_file_open_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_FILE_OPEN_COUNT, &iniContext, 0);
g_storage_stat.success_file_open_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_FILE_OPEN_COUNT, &iniContext, 0);
g_storage_stat.total_file_read_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_FILE_READ_COUNT, &iniContext, 0);
g_storage_stat.success_file_read_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_FILE_READ_COUNT, &iniContext, 0);
g_storage_stat.total_file_write_count = iniGetInt64Value(NULL, \
STAT_ITEM_TOTAL_FILE_WRITE_COUNT, &iniContext, 0);
g_storage_stat.success_file_write_count = iniGetInt64Value(NULL, \
STAT_ITEM_SUCCESS_FILE_WRITE_COUNT, &iniContext, 0);
g_dist_path_index_high = iniGetIntValue(NULL, \
STAT_ITEM_DIST_PATH_INDEX_HIGH, &iniContext, 0);
g_dist_path_index_low = iniGetIntValue(NULL, \
STAT_ITEM_DIST_PATH_INDEX_LOW, &iniContext, 0);
g_dist_write_file_count = iniGetIntValue(NULL, \
STAT_ITEM_DIST_WRITE_FILE_COUNT, &iniContext, 0);
iniFreeContext(&iniContext);
}
else
{
memset(&g_storage_stat, 0, sizeof(g_storage_stat));
}
storage_stat_fd = open(full_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (storage_stat_fd < 0)
{
logError("file: "__FILE__", line: %d, " \
"open stat file \"%s\" fail, " \
"error no: %d, error info: %s", \
__LINE__, full_filename, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
if ((result=storage_write_to_stat_file()) != 0)
{
return result;
}
STORAGE_FCHOWN(storage_stat_fd, full_filename, geteuid(), getegid())
return 0;
}
static int recovery_reader_init(const char *pBasePath, \
StorageBinLogReader *pReader)
{
char full_mark_filename[MAX_PATH_SIZE];
IniContext iniContext;
int result;
memset(pReader, 0, sizeof(StorageBinLogReader));
pReader->mark_fd = -1;
pReader->binlog_fd = -1;
pReader->binlog_index = g_binlog_index + 1;
pReader->binlog_buff.buffer = (char *)malloc( \
STORAGE_BINLOG_BUFFER_SIZE);
if (pReader->binlog_buff.buffer == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, STORAGE_BINLOG_BUFFER_SIZE, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
pReader->binlog_buff.current = pReader->binlog_buff.buffer;
recovery_get_mark_filename(pBasePath, full_mark_filename);
memset(&iniContext, 0, sizeof(IniContext));
if ((result=iniLoadFromFile(full_mark_filename, &iniContext)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load from mark file \"%s\" fail, " \
"error code: %d", __LINE__, \
full_mark_filename, result);
return result;
}
if (!iniGetBoolValue(NULL, MARK_ITEM_FETCH_BINLOG_DONE, \
&iniContext, false))
{
iniFreeContext(&iniContext);
logInfo("file: "__FILE__", line: %d, " \
"mark file \"%s\", %s=0, " \
"need to fetch binlog again", __LINE__, \
full_mark_filename, MARK_ITEM_FETCH_BINLOG_DONE);
return EAGAIN;
}
saved_storage_status = iniGetIntValue(NULL, \
MARK_ITEM_SAVED_STORAGE_STATUS, &iniContext, -1);
if (saved_storage_status < 0)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in mark file \"%s\", %s: %d < 0", __LINE__, \
full_mark_filename, MARK_ITEM_SAVED_STORAGE_STATUS, \
saved_storage_status);
return EINVAL;
}
pReader->binlog_offset = iniGetInt64Value(NULL, \
MARK_ITEM_BINLOG_OFFSET, &iniContext, -1);
if (pReader->binlog_offset < 0)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in mark file \"%s\", %s: "\
"%"PRId64" < 0", __LINE__, \
full_mark_filename, MARK_ITEM_BINLOG_OFFSET, \
pReader->binlog_offset);
return EINVAL;
}
iniFreeContext(&iniContext);
pReader->mark_fd = open(full_mark_filename, O_WRONLY | O_CREAT, 0644);
if (pReader->mark_fd < 0)
{
logError("file: "__FILE__", line: %d, " \
"open mark file \"%s\" fail, " \
"error no: %d, error info: %s", \
__LINE__, full_mark_filename, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
if ((result=storage_open_readable_binlog(pReader, \
recovery_get_binlog_filename, pBasePath)) != 0)
{
return result;
}
return 0;
}
int iniLoadFromFile(const char *szFilename, IniContext *pContext)
{
int result;
int len;
char *pLast;
char full_filename[MAX_PATH_SIZE];
if ((result=iniInitContext(pContext)) != 0)
{
return result;
}
if (strncasecmp(szFilename, "http://", 7) == 0)
{
*pContext->config_path = '\0';
snprintf(full_filename, sizeof(full_filename),"%s",szFilename);
}
else
{
if (*szFilename == '/')
{
pLast = strrchr(szFilename, '/');
len = pLast - szFilename;
if (len >= sizeof(pContext->config_path))
{
logError("file: "__FILE__", line: %d, "\
"the path of the config file: %s is " \
"too long!", __LINE__, szFilename);
return ENOSPC;
}
memcpy(pContext->config_path, szFilename, len);
*(pContext->config_path + len) = '\0';
snprintf(full_filename, sizeof(full_filename), \
"%s", szFilename);
}
else
{
memset(pContext->config_path, 0, \
sizeof(pContext->config_path));
if (getcwd(pContext->config_path, sizeof( \
pContext->config_path)) == NULL)
{
logError("file: "__FILE__", line: %d, " \
"getcwd fail, errno: %d, " \
"error info: %s", \
__LINE__, errno, STRERROR(errno));
return errno != 0 ? errno : EPERM;
}
len = strlen(pContext->config_path);
if (len > 0 && pContext->config_path[len - 1] == '/')
{
len--;
*(pContext->config_path + len) = '\0';
}
snprintf(full_filename, sizeof(full_filename), \
"%s/%s", pContext->config_path, szFilename);
pLast = strrchr(szFilename, '/');
if (pLast != NULL)
{
int tail_len;
tail_len = pLast - szFilename;
if (len + 1 + tail_len >= sizeof( \
pContext->config_path))
{
logError("file: "__FILE__", line: %d, "\
"the path of the config " \
"file: %s is too long!", \
__LINE__, szFilename);
return ENOSPC;
}
*(pContext->config_path + len++) = '/';
memcpy(pContext->config_path + len, \
szFilename, tail_len);
len += tail_len;
*(pContext->config_path + len) = '\0';
}
}
}
result = iniDoLoadFromFile(full_filename, pContext);
if (result == 0)
{
iniSortItems(pContext);
}
else
{
iniFreeContext(pContext);
}
return result;
}
int fdht_db_recovery_init()
{
int result;
char full_filename[MAX_PATH_SIZE];
IniContext iniContext;
char *pValue;
int synced_binlog_index;
int64_t synced_binlog_offset;
bool bMarkFileExists;
bool bRecovery;
time_t start_time;
struct timeval tvStart;
struct timeval tvEnd;
fdht_get_db_recovery_mark_filename(NULL, full_filename);
if ((bMarkFileExists=fileExists(full_filename)))
{
if ((result=iniLoadFromFile(full_filename, \
&iniContext)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load from file \"%s\" fail, " \
"error code: %d, error info: %s", \
__LINE__, full_filename, \
result, STRERROR(result));
return result;
}
pValue = iniGetStrValue(NULL, MARK_ITEM_BINLOG_FILE_INDEX, \
&iniContext);
if (pValue == NULL)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in file \"%s\", item \"%s\" not exists", \
__LINE__, full_filename, \
MARK_ITEM_BINLOG_FILE_INDEX);
return ENOENT;
}
synced_binlog_index = atoi(pValue);
pValue = iniGetStrValue(NULL, MARK_ITEM_BINLOG_FILE_OFFSET, \
&iniContext);
if (pValue == NULL)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in file \"%s\", item \"%s\" not exists", \
__LINE__, full_filename, \
MARK_ITEM_BINLOG_FILE_OFFSET);
return ENOENT;
}
synced_binlog_offset = strtoll(pValue, NULL, 10);
iniFreeContext(&iniContext);
}
else
{
synced_binlog_index = 0;
synced_binlog_offset = 0;
}
fdht_db_recovery_mark_fd = open(full_filename, O_WRONLY | O_CREAT, 0644);
if (fdht_db_recovery_mark_fd < 0)
{
logError("file: "__FILE__", line: %d, " \
"open local db sync mark file \"%s\" fail, " \
"error no: %d, error info: %s", \
__LINE__, full_filename, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
gettimeofday(&tvStart, NULL);
start_time = tvStart.tv_sec;
if ((synced_binlog_index < g_binlog_index) || \
(synced_binlog_offset < g_binlog_file_size))
{
bRecovery = true;
result = fdht_recover_data(synced_binlog_index, \
synced_binlog_offset);
}
else
{
bRecovery = false;
result = 0;
}
if (result == 0 && (!bMarkFileExists || bRecovery))
{
gettimeofday(&tvEnd, NULL);
result = fdht_write_to_db_recovery_mark_file(start_time, \
g_binlog_index, g_binlog_file_size, 0, \
1000 * (tvEnd.tv_sec - tvStart.tv_sec) + \
(tvEnd.tv_usec - tvStart.tv_usec) / 1000);
}
return result;
}
int storage_get_params_from_tracker()
{
IniContext iniContext;
int result;
bool use_trunk_file;
char reserved_space_str[32];
char *pIdType;
if ((result=fdfs_get_ini_context_from_tracker(&g_tracker_group, \
&iniContext, (bool * volatile)&g_continue_flag, \
g_client_bind_addr, g_bind_addr)) != 0)
{
return result;
}
g_storage_ip_changed_auto_adjust = iniGetBoolValue(NULL, \
"storage_ip_changed_auto_adjust", \
&iniContext, false);
g_store_path_mode = iniGetIntValue(NULL, "store_path", &iniContext, \
FDFS_STORE_PATH_ROUND_ROBIN);
if ((result=fdfs_parse_storage_reserved_space(&iniContext, \
&g_storage_reserved_space)) != 0)
{
iniFreeContext(&iniContext);
return result;
}
if (g_storage_reserved_space.flag == \
TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB)
{
g_avg_storage_reserved_mb = g_storage_reserved_space.rs.mb \
/ g_fdfs_store_paths.count;
}
else
{
g_avg_storage_reserved_mb = 0;
}
g_use_storage_id = iniGetBoolValue(NULL, "use_storage_id", \
&iniContext, false);
use_trunk_file = iniGetBoolValue(NULL, "use_trunk_file", \
&iniContext, false);
g_slot_min_size = iniGetIntValue(NULL, "slot_min_size", \
&iniContext, 256);
g_trunk_file_size = iniGetIntValue(NULL, "trunk_file_size", \
&iniContext, 64 * 1024 * 1024);
g_slot_max_size = iniGetIntValue(NULL, "slot_max_size", \
&iniContext, g_trunk_file_size / 2);
g_trunk_create_file_advance = iniGetBoolValue(NULL, \
"trunk_create_file_advance", &iniContext, false);
if ((result=get_time_item_from_conf(&iniContext, \
"trunk_create_file_time_base", \
&g_trunk_create_file_time_base, 2, 0)) != 0)
{
iniFreeContext(&iniContext);
return result;
}
g_trunk_create_file_interval = iniGetIntValue(NULL, \
"trunk_create_file_interval", &iniContext, \
86400);
g_trunk_create_file_space_threshold = iniGetInt64Value(NULL, \
"trunk_create_file_space_threshold", \
&iniContext, 0);
g_trunk_init_check_occupying = iniGetBoolValue(NULL, \
"trunk_init_check_occupying", &iniContext, false);
g_trunk_init_reload_from_binlog = iniGetBoolValue(NULL, \
"trunk_init_reload_from_binlog", &iniContext, false);
g_trunk_compress_binlog_min_interval = iniGetIntValue(NULL, \
"trunk_compress_binlog_min_interval", &iniContext, 0);
g_store_slave_file_use_link = iniGetBoolValue(NULL, \
"store_slave_file_use_link", &iniContext, false);
pIdType = iniGetStrValue(NULL, "id_type_in_filename", &iniContext);
if (pIdType != NULL && strcasecmp(pIdType, "id") == 0)
{
if (g_use_storage_id)
{
g_id_type_in_filename = FDFS_ID_TYPE_SERVER_ID;
}
else
{
g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS;
}
}
else
{
g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS;
}
iniFreeContext(&iniContext);
if (use_trunk_file && !g_if_use_trunk_file)
{
if ((result=trunk_sync_init()) != 0)
{
return result;
}
}
g_if_use_trunk_file = use_trunk_file;
logInfo("file: "__FILE__", line: %d, " \
"use_storage_id=%d, " \
"id_type_in_filename=%s, " \
"storage_ip_changed_auto_adjust=%d, " \
"store_path=%d, " \
"reserved_storage_space=%s, " \
"use_trunk_file=%d, " \
"slot_min_size=%d, " \
"slot_max_size=%d MB, " \
"trunk_file_size=%d MB, " \
"trunk_create_file_advance=%d, " \
"trunk_create_file_time_base=%02d:%02d, " \
"trunk_create_file_interval=%d, " \
"trunk_create_file_space_threshold=%d GB, " \
"trunk_init_check_occupying=%d, " \
"trunk_init_reload_from_binlog=%d, " \
"trunk_compress_binlog_min_interval=%d, " \
"store_slave_file_use_link=%d", \
__LINE__, g_use_storage_id, \
g_id_type_in_filename == FDFS_ID_TYPE_SERVER_ID ? "id" : "ip", \
g_storage_ip_changed_auto_adjust, \
g_store_path_mode, fdfs_storage_reserved_space_to_string( \
&g_storage_reserved_space, reserved_space_str), \
g_if_use_trunk_file, g_slot_min_size, \
g_slot_max_size / FDFS_ONE_MB, \
g_trunk_file_size / FDFS_ONE_MB, \
g_trunk_create_file_advance, \
g_trunk_create_file_time_base.hour, \
g_trunk_create_file_time_base.minute, \
g_trunk_create_file_interval, \
(int)(g_trunk_create_file_space_threshold / \
(FDFS_ONE_MB * 1024)), g_trunk_init_check_occupying, \
g_trunk_init_reload_from_binlog, \
g_trunk_compress_binlog_min_interval, \
g_store_slave_file_use_link);
if (g_use_storage_id && *g_sync_src_id != '\0' && \
!fdfs_is_server_id_valid(g_sync_src_id))
{
if ((result=storage_convert_src_server_id()) == 0)
{
storage_write_to_sync_ini_file();
}
else
{
if (result == ENOENT)
{
*g_sync_src_id = '\0';
storage_write_to_sync_ini_file();
}
else
{
return result;
}
}
}
return 0;
}
int tracker_load_from_conf_file(const char *filename, \
char *bind_addr, const int addr_size)
{
char *pBasePath;
char *pBindAddr;
char *pRunByGroup;
char *pRunByUser;
char *pThreadStackSize;
char *pSlotMinSize;
char *pSlotMaxSize;
char *pSpaceThreshold;
char *pTrunkFileSize;
char *pRotateErrorLogSize;
char *pMinBuffSize;
char *pMaxBuffSize;
#ifdef WITH_HTTPD
char *pHttpCheckUri;
char *pHttpCheckType;
#endif
IniContext iniContext;
int result;
int64_t thread_stack_size;
int64_t trunk_file_size;
int64_t slot_min_size;
int64_t slot_max_size;
int64_t rotate_error_log_size;
int64_t min_buff_size;
int64_t max_buff_size;
char sz_min_buff_size[32];
char sz_max_buff_size[32];
char reserved_space_str[32];
memset(&g_groups, 0, sizeof(FDFSGroups));
memset(&iniContext, 0, sizeof(IniContext));
if ((result=iniLoadFromFile(filename, &iniContext)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"load conf file \"%s\" fail, ret code: %d", \
__LINE__, filename, result);
return result;
}
//iniPrintItems(&iniContext);
do
{
if (iniGetBoolValue(NULL, "disabled", &iniContext, false))
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" disabled=true, exit", \
__LINE__, filename);
result = ECANCELED;
break;
}
pBasePath = iniGetStrValue(NULL, "base_path", &iniContext);
if (pBasePath == NULL)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" must have item " \
"\"base_path\"!", __LINE__, filename);
result = ENOENT;
break;
}
snprintf(g_fdfs_base_path, sizeof(g_fdfs_base_path), "%s", pBasePath);
chopPath(g_fdfs_base_path);
if (!fileExists(g_fdfs_base_path))
{
logError("file: "__FILE__", line: %d, " \
"\"%s\" can't be accessed, error info: %s", \
__LINE__, g_fdfs_base_path, STRERROR(errno));
result = errno != 0 ? errno : ENOENT;
break;
}
if (!isDir(g_fdfs_base_path))
{
logError("file: "__FILE__", line: %d, " \
"\"%s\" is not a directory!", \
__LINE__, g_fdfs_base_path);
result = ENOTDIR;
break;
}
load_log_level(&iniContext);
if ((result=log_set_prefix(g_fdfs_base_path, \
TRACKER_ERROR_LOG_FILENAME)) != 0)
{
break;
}
g_fdfs_connect_timeout = iniGetIntValue(NULL, "connect_timeout", \
&iniContext, DEFAULT_CONNECT_TIMEOUT);
if (g_fdfs_connect_timeout <= 0)
{
g_fdfs_connect_timeout = DEFAULT_CONNECT_TIMEOUT;
}
g_fdfs_network_timeout = iniGetIntValue(NULL, "network_timeout", \
&iniContext, DEFAULT_NETWORK_TIMEOUT);
if (g_fdfs_network_timeout <= 0)
{
g_fdfs_network_timeout = DEFAULT_NETWORK_TIMEOUT;
}
g_server_port = iniGetIntValue(NULL, "port", &iniContext, \
FDFS_TRACKER_SERVER_DEF_PORT);
if (g_server_port <= 0)
{
g_server_port = FDFS_TRACKER_SERVER_DEF_PORT;
}
pBindAddr = iniGetStrValue(NULL, "bind_addr", &iniContext);
if (pBindAddr == NULL)
{
bind_addr[0] = '\0';
}
else
{
snprintf(bind_addr, addr_size, "%s", pBindAddr);
}
if ((result=tracker_load_store_lookup(filename, \
&iniContext)) != 0)
{
break;
}
g_groups.store_server = (byte)iniGetIntValue(NULL, \
"store_server", &iniContext, \
FDFS_STORE_SERVER_ROUND_ROBIN);
if (!(g_groups.store_server == FDFS_STORE_SERVER_FIRST_BY_IP ||\
g_groups.store_server == FDFS_STORE_SERVER_FIRST_BY_PRI||
g_groups.store_server == FDFS_STORE_SERVER_ROUND_ROBIN))
{
logWarning("file: "__FILE__", line: %d, " \
"store_server 's value %d is invalid, " \
"set to %d (round robin)!", \
__LINE__, g_groups.store_server, \
FDFS_STORE_SERVER_ROUND_ROBIN);
g_groups.store_server = FDFS_STORE_SERVER_ROUND_ROBIN;
}
g_groups.download_server = (byte)iniGetIntValue(NULL, \
"download_server", &iniContext, \
FDFS_DOWNLOAD_SERVER_ROUND_ROBIN);
if (!(g_groups.download_server==FDFS_DOWNLOAD_SERVER_ROUND_ROBIN
|| g_groups.download_server ==
FDFS_DOWNLOAD_SERVER_SOURCE_FIRST))
{
logWarning("file: "__FILE__", line: %d, " \
"download_server 's value %d is invalid, " \
"set to %d (round robin)!", \
__LINE__, g_groups.download_server, \
FDFS_DOWNLOAD_SERVER_ROUND_ROBIN);
g_groups.download_server = \
FDFS_DOWNLOAD_SERVER_ROUND_ROBIN;
}
g_groups.store_path = (byte)iniGetIntValue(NULL, "store_path", \
&iniContext, FDFS_STORE_PATH_ROUND_ROBIN);
if (!(g_groups.store_path == FDFS_STORE_PATH_ROUND_ROBIN || \
g_groups.store_path == FDFS_STORE_PATH_LOAD_BALANCE))
{
logWarning("file: "__FILE__", line: %d, " \
"store_path 's value %d is invalid, " \
"set to %d (round robin)!", \
__LINE__, g_groups.store_path , \
FDFS_STORE_PATH_ROUND_ROBIN);
g_groups.store_path = FDFS_STORE_PATH_ROUND_ROBIN;
}
if ((result=fdfs_parse_storage_reserved_space(&iniContext, \
&g_storage_reserved_space)) != 0)
{
break;
}
g_max_connections = iniGetIntValue(NULL, "max_connections", \
&iniContext, DEFAULT_MAX_CONNECTONS);
if (g_max_connections <= 0)
{
g_max_connections = DEFAULT_MAX_CONNECTONS;
}
g_accept_threads = iniGetIntValue(NULL, "accept_threads", \
&iniContext, 1);
if (g_accept_threads <= 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"accept_threads\" is invalid, " \
"value: %d <= 0!", __LINE__, g_accept_threads);
result = EINVAL;
break;
}
g_work_threads = iniGetIntValue(NULL, "work_threads", \
&iniContext, DEFAULT_WORK_THREADS);
if (g_work_threads <= 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"work_threads\" is invalid, " \
"value: %d <= 0!", __LINE__, g_work_threads);
result = EINVAL;
break;
}
if ((result=set_rlimit(RLIMIT_NOFILE, g_max_connections)) != 0)
{
break;
}
pRunByGroup = iniGetStrValue(NULL, "run_by_group", &iniContext);
pRunByUser = iniGetStrValue(NULL, "run_by_user", &iniContext);
if (pRunByGroup == NULL)
{
*g_run_by_group = '\0';
}
else
{
snprintf(g_run_by_group, sizeof(g_run_by_group), \
"%s", pRunByGroup);
}
if (*g_run_by_group == '\0')
{
g_run_by_gid = getegid();
}
else
{
struct group *pGroup;
pGroup = getgrnam(g_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_run_by_gid = pGroup->gr_gid;
}
if (pRunByUser == NULL)
{
*g_run_by_user = '******';
}
else
{
snprintf(g_run_by_user, sizeof(g_run_by_user), \
"%s", pRunByUser);
}
if (*g_run_by_user == '\0')
{
g_run_by_uid = geteuid();
}
else
{
struct passwd *pUser;
pUser = getpwnam(g_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_run_by_uid = pUser->pw_uid;
}
if ((result=load_allow_hosts(&iniContext, \
&g_allow_ip_addrs, &g_allow_ip_count)) != 0)
{
return result;
}
g_sync_log_buff_interval = iniGetIntValue(NULL, \
"sync_log_buff_interval", &iniContext, \
SYNC_LOG_BUFF_DEF_INTERVAL);
if (g_sync_log_buff_interval <= 0)
{
g_sync_log_buff_interval = SYNC_LOG_BUFF_DEF_INTERVAL;
}
g_check_active_interval = iniGetIntValue(NULL, \
"check_active_interval", &iniContext, \
CHECK_ACTIVE_DEF_INTERVAL);
if (g_check_active_interval <= 0)
{
g_check_active_interval = CHECK_ACTIVE_DEF_INTERVAL;
}
pThreadStackSize = iniGetStrValue(NULL, \
"thread_stack_size", &iniContext);
if (pThreadStackSize == NULL)
{
thread_stack_size = 64 * 1024;
}
else if ((result=parse_bytes(pThreadStackSize, 1, \
&thread_stack_size)) != 0)
{
return result;
}
g_thread_stack_size = (int)thread_stack_size;
g_storage_ip_changed_auto_adjust = iniGetBoolValue(NULL, \
"storage_ip_changed_auto_adjust", \
&iniContext, true);
g_storage_sync_file_max_delay = iniGetIntValue(NULL, \
"storage_sync_file_max_delay", &iniContext, \
DEFAULT_STORAGE_SYNC_FILE_MAX_DELAY);
if (g_storage_sync_file_max_delay <= 0)
{
g_storage_sync_file_max_delay = \
DEFAULT_STORAGE_SYNC_FILE_MAX_DELAY;
}
g_storage_sync_file_max_time = iniGetIntValue(NULL, \
"storage_sync_file_max_time", &iniContext, \
DEFAULT_STORAGE_SYNC_FILE_MAX_TIME);
if (g_storage_sync_file_max_time <= 0)
{
g_storage_sync_file_max_time = \
DEFAULT_STORAGE_SYNC_FILE_MAX_TIME;
}
g_if_use_trunk_file = iniGetBoolValue(NULL, \
"use_trunk_file", &iniContext, false);
pSlotMinSize = iniGetStrValue(NULL, \
"slot_min_size", &iniContext);
if (pSlotMinSize == NULL)
{
slot_min_size = 256;
}
else if ((result=parse_bytes(pSlotMinSize, 1, \
&slot_min_size)) != 0)
{
return result;
}
g_slot_min_size = (int)slot_min_size;
if (g_slot_min_size <= 0)
{
logError("file: "__FILE__", line: %d, " \
"item \"slot_min_size\" %d is invalid, " \
"which <= 0", __LINE__, g_slot_min_size);
result = EINVAL;
break;
}
if (g_slot_min_size > 64 * 1024)
{
logWarning("file: "__FILE__", line: %d, " \
"item \"slot_min_size\" %d is too large, " \
"change to 64KB", __LINE__, g_slot_min_size);
g_slot_min_size = 64 * 1024;
}
pTrunkFileSize = iniGetStrValue(NULL, \
"trunk_file_size", &iniContext);
if (pTrunkFileSize == NULL)
{
trunk_file_size = 64 * 1024 * 1024;
}
else if ((result=parse_bytes(pTrunkFileSize, 1, \
&trunk_file_size)) != 0)
{
return result;
}
g_trunk_file_size = (int)trunk_file_size;
if (g_trunk_file_size < 4 * 1024 * 1024)
{
logWarning("file: "__FILE__", line: %d, " \
"item \"trunk_file_size\" %d is too small, " \
"change to 4MB", __LINE__, g_trunk_file_size);
g_trunk_file_size = 4 * 1024 * 1024;
}
pSlotMaxSize = iniGetStrValue(NULL, \
"slot_max_size", &iniContext);
if (pSlotMaxSize == NULL)
{
slot_max_size = g_trunk_file_size / 2;
}
else if ((result=parse_bytes(pSlotMaxSize, 1, \
&slot_max_size)) != 0)
{
return result;
}
g_slot_max_size = (int)slot_max_size;
if (g_slot_max_size <= g_slot_min_size)
{
logError("file: "__FILE__", line: %d, " \
"item \"slot_max_size\" %d is invalid, " \
"which <= slot_min_size: %d", \
__LINE__, g_slot_max_size, g_slot_min_size);
result = EINVAL;
break;
}
if (g_slot_max_size > g_trunk_file_size / 2)
{
logWarning("file: "__FILE__", line: %d, " \
"item \"slot_max_size\": %d is too large, " \
"change to %d", __LINE__, g_slot_max_size, \
g_trunk_file_size / 2);
g_slot_max_size = g_trunk_file_size / 2;
}
g_trunk_create_file_advance = iniGetBoolValue(NULL, \
"trunk_create_file_advance", &iniContext, false);
if ((result=get_time_item_from_conf(&iniContext, \
"trunk_create_file_time_base", \
&g_trunk_create_file_time_base, 2, 0)) != 0)
{
return result;
}
g_trunk_create_file_interval = iniGetIntValue(NULL, \
"trunk_create_file_interval", &iniContext, \
86400);
pSpaceThreshold = iniGetStrValue(NULL, \
"trunk_create_file_space_threshold", &iniContext);
if (pSpaceThreshold == NULL)
{
g_trunk_create_file_space_threshold = 0;
}
else if ((result=parse_bytes(pSpaceThreshold, 1, \
&g_trunk_create_file_space_threshold)) != 0)
{
return result;
}
g_trunk_compress_binlog_min_interval = iniGetIntValue(NULL, \
"trunk_compress_binlog_min_interval", \
&iniContext, 0);
g_trunk_init_check_occupying = iniGetBoolValue(NULL, \
"trunk_init_check_occupying", &iniContext, false);
g_trunk_init_reload_from_binlog = iniGetBoolValue(NULL, \
"trunk_init_reload_from_binlog", &iniContext, false);
if ((result=tracker_load_storage_id_info( \
filename, &iniContext)) != 0)
{
return result;
}
g_rotate_error_log = iniGetBoolValue(NULL, "rotate_error_log",\
&iniContext, false);
if ((result=get_time_item_from_conf(&iniContext, \
"error_log_rotate_time", &g_error_log_rotate_time, \
0, 0)) != 0)
{
break;
}
pRotateErrorLogSize = iniGetStrValue(NULL, \
"rotate_error_log_size", &iniContext);
if (pRotateErrorLogSize == NULL)
{
rotate_error_log_size = 0;
}
else if ((result=parse_bytes(pRotateErrorLogSize, 1, \
&rotate_error_log_size)) != 0)
{
break;
}
if (rotate_error_log_size > 0 && \
rotate_error_log_size < FDFS_ONE_MB)
{
logWarning("file: "__FILE__", line: %d, " \
"item \"rotate_error_log_size\": " \
"%"PRId64" is too small, " \
"change to 1 MB", __LINE__, \
rotate_error_log_size);
rotate_error_log_size = FDFS_ONE_MB;
}
fdfs_set_log_rotate_size(&g_log_context, rotate_error_log_size);
g_log_file_keep_days = iniGetIntValue(NULL, \
"log_file_keep_days", &iniContext, 0);
g_store_slave_file_use_link = iniGetBoolValue(NULL, \
"store_slave_file_use_link", &iniContext, false);
if ((result=fdfs_connection_pool_init(filename, &iniContext)) != 0)
{
break;
}
pMinBuffSize = iniGetStrValue(NULL,
"min_buff_size", &iniContext);
if (pMinBuffSize == NULL) {
min_buff_size = TRACKER_MAX_PACKAGE_SIZE;
}
else if ((result=parse_bytes(pMinBuffSize, 1,
&min_buff_size)) != 0)
{
return result;
}
g_min_buff_size = (int)min_buff_size;
pMaxBuffSize = iniGetStrValue(NULL,
"max_buff_size", &iniContext);
if (pMaxBuffSize == NULL) {
max_buff_size = 16 * TRACKER_MAX_PACKAGE_SIZE;
}
else if ((result=parse_bytes(pMaxBuffSize, 1,
&max_buff_size)) != 0)
{
return result;
}
g_max_buff_size = (int)max_buff_size;
if (g_min_buff_size < TRACKER_MAX_PACKAGE_SIZE) {
g_min_buff_size = TRACKER_MAX_PACKAGE_SIZE;
}
if (g_max_buff_size < g_min_buff_size) {
g_max_buff_size = g_min_buff_size;
}
#ifdef WITH_HTTPD
if ((result=fdfs_http_params_load(&iniContext, \
filename, &g_http_params)) != 0)
{
return result;
}
g_http_check_interval = iniGetIntValue(NULL, \
"http.check_alive_interval", &iniContext, 30);
pHttpCheckType = iniGetStrValue(NULL, \
"http.check_alive_type", &iniContext);
if (pHttpCheckType != NULL && \
strcasecmp(pHttpCheckType, "http") == 0)
{
g_http_check_type = FDFS_HTTP_CHECK_ALIVE_TYPE_HTTP;
}
else
{
g_http_check_type = FDFS_HTTP_CHECK_ALIVE_TYPE_TCP;
}
pHttpCheckUri = iniGetStrValue(NULL, \
"http.check_alive_uri", &iniContext);
if (pHttpCheckUri == NULL)
{
*g_http_check_uri = '/';
*(g_http_check_uri+1) = '\0';
}
else if (*pHttpCheckUri == '/')
{
snprintf(g_http_check_uri, sizeof(g_http_check_uri), \
"%s", pHttpCheckUri);
}
else
{
snprintf(g_http_check_uri, sizeof(g_http_check_uri), \
"/%s", pHttpCheckUri);
}
#endif
if (g_if_use_trunk_file && g_groups.store_server == FDFS_STORE_SERVER_ROUND_ROBIN)
{
logInfo("file: "__FILE__", line: %d, "
"set store_server to %d because use_trunk_file is true",
__LINE__, FDFS_STORE_SERVER_FIRST_BY_IP);
g_groups.store_server = FDFS_STORE_SERVER_FIRST_BY_IP;
}
int_to_comma_str(g_min_buff_size, sz_min_buff_size);
int_to_comma_str(g_max_buff_size, sz_max_buff_size);
logInfo("FastDFS v%d.%02d, base_path=%s, " \
"run_by_group=%s, run_by_user=%s, " \
"connect_timeout=%ds, " \
"network_timeout=%ds, " \
"port=%d, bind_addr=%s, " \
"max_connections=%d, " \
"accept_threads=%d, " \
"work_threads=%d, " \
"min_buff_size=%s, " \
"max_buff_size=%s, " \
"store_lookup=%d, store_group=%s, " \
"store_server=%d, store_path=%d, " \
"reserved_storage_space=%s, " \
"download_server=%d, " \
"allow_ip_count=%d, sync_log_buff_interval=%ds, " \
"check_active_interval=%ds, " \
"thread_stack_size=%d KB, " \
"storage_ip_changed_auto_adjust=%d, " \
"storage_sync_file_max_delay=%ds, " \
"storage_sync_file_max_time=%ds, " \
"use_trunk_file=%d, " \
"slot_min_size=%d, " \
"slot_max_size=%d MB, " \
"trunk_file_size=%d MB, " \
"trunk_create_file_advance=%d, " \
"trunk_create_file_time_base=%02d:%02d, " \
"trunk_create_file_interval=%d, " \
"trunk_create_file_space_threshold=%d GB, " \
"trunk_init_check_occupying=%d, " \
"trunk_init_reload_from_binlog=%d, " \
"trunk_compress_binlog_min_interval=%d, " \
"use_storage_id=%d, " \
"id_type_in_filename=%s, " \
"storage_id_count=%d, " \
"rotate_error_log=%d, " \
"error_log_rotate_time=%02d:%02d, " \
"rotate_error_log_size=%"PRId64", " \
"log_file_keep_days=%d, " \
"store_slave_file_use_link=%d, " \
"use_connection_pool=%d, " \
"g_connection_pool_max_idle_time=%ds", \
g_fdfs_version.major, g_fdfs_version.minor, \
g_fdfs_base_path, g_run_by_group, g_run_by_user, \
g_fdfs_connect_timeout, \
g_fdfs_network_timeout, g_server_port, bind_addr, \
g_max_connections, g_accept_threads, g_work_threads, \
sz_min_buff_size, sz_max_buff_size, \
g_groups.store_lookup, g_groups.store_group, \
g_groups.store_server, g_groups.store_path, \
fdfs_storage_reserved_space_to_string( \
&g_storage_reserved_space, reserved_space_str), \
g_groups.download_server, \
g_allow_ip_count, g_sync_log_buff_interval, \
g_check_active_interval, g_thread_stack_size / 1024, \
g_storage_ip_changed_auto_adjust, \
g_storage_sync_file_max_delay, \
g_storage_sync_file_max_time, \
g_if_use_trunk_file, g_slot_min_size, \
g_slot_max_size / FDFS_ONE_MB, \
g_trunk_file_size / FDFS_ONE_MB, \
g_trunk_create_file_advance, \
g_trunk_create_file_time_base.hour, \
g_trunk_create_file_time_base.minute, \
g_trunk_create_file_interval, \
(int)(g_trunk_create_file_space_threshold / \
(FDFS_ONE_MB * 1024)), g_trunk_init_check_occupying, \
g_trunk_init_reload_from_binlog, \
g_trunk_compress_binlog_min_interval, \
g_use_storage_id, g_id_type_in_filename == \
FDFS_ID_TYPE_SERVER_ID ? "id" : "ip", g_storage_id_count, \
g_rotate_error_log, g_error_log_rotate_time.hour, \
g_error_log_rotate_time.minute, \
g_log_context.rotate_size, g_log_file_keep_days,
g_store_slave_file_use_link, \
g_use_connection_pool, g_connection_pool_max_idle_time);
#ifdef WITH_HTTPD
if (!g_http_params.disabled)
{
logInfo("HTTP supported: " \
"server_port=%d, " \
"default_content_type=%s, " \
"anti_steal_token=%d, " \
"token_ttl=%ds, " \
"anti_steal_secret_key length=%d, " \
"token_check_fail content_type=%s, " \
"token_check_fail buff length=%d, " \
"check_active_interval=%d, " \
"check_active_type=%s, " \
"check_active_uri=%s", \
g_http_params.server_port, \
g_http_params.default_content_type, \
g_http_params.anti_steal_token, \
g_http_params.token_ttl, \
g_http_params.anti_steal_secret_key.length, \
g_http_params.token_check_fail_content_type, \
g_http_params.token_check_fail_buff.length, \
g_http_check_interval, g_http_check_type == \
FDFS_HTTP_CHECK_ALIVE_TYPE_TCP ? "tcp":"http",\
g_http_check_uri);
}
#endif
} while (0);
iniFreeContext(&iniContext);
load_local_host_ip_addrs();
return result;
}
int trunk_reader_init(FDFSStorageBrief *pStorage, TrunkBinLogReader *pReader)
{
char full_filename[MAX_PATH_SIZE];
IniContext iniContext;
int result;
int64_t saved_binlog_offset;
bool bFileExist;
saved_binlog_offset = pReader->binlog_offset;
memset(pReader, 0, sizeof(TrunkBinLogReader));
pReader->mark_fd = -1;
pReader->binlog_fd = -1;
pReader->binlog_buff.buffer = (char *)malloc( \
TRUNK_BINLOG_BUFFER_SIZE);
if (pReader->binlog_buff.buffer == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, TRUNK_BINLOG_BUFFER_SIZE, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
pReader->binlog_buff.current = pReader->binlog_buff.buffer;
if (pStorage == NULL)
{
strcpy(pReader->storage_id, "0.0.0.0");
}
else
{
strcpy(pReader->storage_id, pStorage->id);
}
trunk_mark_filename_by_reader(pReader, full_filename);
if (pStorage == NULL)
{
bFileExist = false;
pReader->binlog_offset = saved_binlog_offset;
}
else
{
bFileExist = fileExists(full_filename);
if (!bFileExist && (g_use_storage_id && pStorage != NULL))
{
char old_mark_filename[MAX_PATH_SIZE];
trunk_get_mark_filename_by_ip_and_port( \
pStorage->ip_addr, g_server_port, \
old_mark_filename, sizeof(old_mark_filename));
if (fileExists(old_mark_filename))
{
if (rename(old_mark_filename, full_filename)!=0)
{
logError("file: "__FILE__", line: %d, "\
"rename file %s to %s fail" \
", errno: %d, error info: %s", \
__LINE__, old_mark_filename, \
full_filename, errno, \
STRERROR(errno));
return errno != 0 ? errno : EACCES;
}
bFileExist = true;
}
}
}
if (bFileExist)
{
memset(&iniContext, 0, sizeof(IniContext));
if ((result=iniLoadFromFile(full_filename, &iniContext)) \
!= 0)
{
logError("file: "__FILE__", line: %d, " \
"load from mark file \"%s\" fail, " \
"error code: %d", \
__LINE__, full_filename, result);
return result;
}
if (iniContext.global.count < 1)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in mark file \"%s\", item count: %d < 7", \
__LINE__, full_filename, iniContext.global.count);
return ENOENT;
}
pReader->binlog_offset = iniGetInt64Value(NULL, \
MARK_ITEM_BINLOG_FILE_OFFSET, \
&iniContext, -1);
if (pReader->binlog_offset < 0)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in mark file \"%s\", binlog_offset: "\
"%"PRId64" < 0", \
__LINE__, full_filename, \
pReader->binlog_offset);
return EINVAL;
}
iniFreeContext(&iniContext);
}
pReader->last_binlog_offset = pReader->binlog_offset;
pReader->mark_fd = open(full_filename, O_WRONLY | O_CREAT, 0644);
if (pReader->mark_fd < 0)
{
logError("file: "__FILE__", line: %d, " \
"open mark file \"%s\" fail, " \
"error no: %d, error info: %s", \
__LINE__, full_filename, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
if (!bFileExist && pStorage != NULL)
{
if ((result=trunk_write_to_mark_file(pReader)) != 0)
{
return result;
}
}
if ((result=trunk_open_readable_binlog(pReader, \
get_binlog_readable_filename, pReader)) != 0)
{
return result;
}
result = trunk_binlog_preread(pReader);
if (result != 0 && result != ENOENT)
{
return result;
}
return 0;
}
