int storage_load_paths_from_conf_file(IniContext *pItemContext)
{
char *pPath;
int result;
pPath = iniGetStrValue(NULL, "base_path", pItemContext);
if (pPath == NULL)
{
logError("file: "__FILE__", line: %d, " \
"conf file must have item \"base_path\"!", __LINE__);
return ENOENT;
}
snprintf(g_fdfs_base_path, sizeof(g_fdfs_base_path), "%s", pPath);
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__, STRERROR(errno), g_fdfs_base_path);
return errno != 0 ? errno : ENOENT;
}
if (!isDir(g_fdfs_base_path))
{
logError("file: "__FILE__", line: %d, " \
"\"%s\" is not a directory!", \
__LINE__, g_fdfs_base_path);
return ENOTDIR;
}
g_fdfs_store_paths.paths = storage_load_paths_from_conf_file_ex( \
pItemContext, NULL, true, &g_fdfs_store_paths.count, &result);
return result;
}
static int tracker_load_storage_id_info(const char *config_filename, \
IniContext *pItemContext)
{
char *pIdType;
g_use_storage_id = iniGetBoolValue(NULL, "use_storage_id", \
pItemContext, false);
if (!g_use_storage_id)
{
return 0;
}
pIdType = iniGetStrValue(NULL, "id_type_in_filename", \
pItemContext);
if (pIdType != NULL && strcasecmp(pIdType, "id") == 0)
{
g_id_type_in_filename = FDFS_ID_TYPE_SERVER_ID;
}
else
{
g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS;
}
return fdfs_load_storage_ids_from_file(config_filename, pItemContext);
}
static int tracker_load_store_lookup(const char *filename, \
IniContext *pItemContext)
{
char *pGroupName;
g_groups.store_lookup = iniGetIntValue(NULL, "store_lookup", \
pItemContext, FDFS_STORE_LOOKUP_ROUND_ROBIN);
if (g_groups.store_lookup == FDFS_STORE_LOOKUP_ROUND_ROBIN)
{
g_groups.store_group[0] = '\0';
return 0;
}
if (g_groups.store_lookup == FDFS_STORE_LOOKUP_LOAD_BALANCE)
{
g_groups.store_group[0] = '\0';
return 0;
}
if (g_groups.store_lookup != FDFS_STORE_LOOKUP_SPEC_GROUP)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", the value of \"store_lookup\" is " \
"invalid, value=%d!", \
__LINE__, filename, g_groups.store_lookup);
return EINVAL;
}
pGroupName = iniGetStrValue(NULL, "store_group", pItemContext);
if (pGroupName == NULL)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" must have item " \
"\"store_group\"!", __LINE__, filename);
return ENOENT;
}
if (pGroupName[0] == '\0')
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", " \
"store_group is empty!", __LINE__, filename);
return EINVAL;
}
snprintf(g_groups.store_group, sizeof(g_groups.store_group), \
"%s", pGroupName);
if (fdfs_validate_group_name(g_groups.store_group) != 0) \
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", " \
"the group name \"%s\" is invalid!", \
__LINE__, filename, g_groups.store_group);
return EINVAL;
}
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;
}
double iniGetDoubleValue(const char *szSectionName, const char *szItemName, \
IniContext *pContext, const double dbDefaultValue)
{
char *pValue;
pValue = iniGetStrValue(szSectionName, szItemName, pContext);
if (pValue == NULL)
{
return dbDefaultValue;
}
else
{
return strtod(pValue, NULL);
}
}
int iniGetIntValue(const char *szSectionName, const char *szItemName, \
IniContext *pContext, const int nDefaultValue)
{
char *pValue;
pValue = iniGetStrValue(szSectionName, szItemName, pContext);
if (pValue == NULL)
{
return nDefaultValue;
}
else
{
return atoi(pValue);
}
}
int64_t iniGetInt64Value(const char *szSectionName, const char *szItemName, \
IniContext *pContext, const int64_t nDefaultValue)
{
char *pValue;
pValue = iniGetStrValue(szSectionName, szItemName, pContext);
if (pValue == NULL)
{
return nDefaultValue;
}
else
{
return strtoll(pValue, NULL, 10);
}
}
bool iniGetBoolValue(const char *szSectionName, const char *szItemName, \
IniContext *pContext, const bool bDefaultValue)
{
char *pValue;
pValue = iniGetStrValue(szSectionName, szItemName, pContext);
if (pValue == NULL)
{
return bDefaultValue;
}
else
{
return strcasecmp(pValue, "true") == 0 ||
strcasecmp(pValue, "yes") == 0 ||
strcasecmp(pValue, "on") == 0 ||
strcmp(pValue, "1") == 0;
}
}
int get_time_item_from_conf(IniContext *pIniContext, \
const char *item_name, TimeInfo *pTimeInfo, \
const byte default_hour, const byte default_minute)
{
char *pValue;
int hour;
int minute;
int second;
int count;
pValue = iniGetStrValue(NULL, item_name, pIniContext);
if (pValue == NULL)
{
pTimeInfo->hour = default_hour;
pTimeInfo->minute = default_minute;
return 0;
}
second = 0;
count = sscanf(pValue, "%d:%d:%d", &hour, &minute, &second);
if (count != 2 && count != 3)
{
logError("file: "__FILE__", line: %d, " \
"item \"%s\" 's value \"%s\" is not an valid time", \
__LINE__, item_name, pValue);
return EINVAL;
}
if ((hour < 0 || hour > 23) || (minute < 0 || minute > 59)
|| (second < 0 || second > 59))
{
logError("file: "__FILE__", line: %d, " \
"item \"%s\" 's value \"%s\" is not an valid time", \
__LINE__, item_name, pValue);
return EINVAL;
}
pTimeInfo->hour = (byte)hour;
pTimeInfo->minute = (byte)minute;
pTimeInfo->second = (byte)second;
return 0;
}
int fdfs_parse_storage_reserved_space(IniContext *pIniContext, \
FDFSStorageReservedSpace *pStorageReservedSpace)
{
int result;
int len;
char *pReservedSpaceStr;
int64_t storage_reserved;
pReservedSpaceStr = iniGetStrValue(NULL, \
"reserved_storage_space", pIniContext);
if (pReservedSpaceStr == NULL)
{
pStorageReservedSpace->flag = \
TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB;
pStorageReservedSpace->rs.mb = FDFS_DEF_STORAGE_RESERVED_MB;
return 0;
}
if (*pReservedSpaceStr == '\0')
{
logError("file: "__FILE__", line: %d, " \
"item \"reserved_storage_space\" is empty!", \
__LINE__);
return EINVAL;
}
len = strlen(pReservedSpaceStr);
if (*(pReservedSpaceStr + len - 1) == '%')
{
char *endptr;
pStorageReservedSpace->flag = \
TRACKER_STORAGE_RESERVED_SPACE_FLAG_RATIO;
endptr = NULL;
*(pReservedSpaceStr + len - 1) = '\0';
pStorageReservedSpace->rs.ratio = \
strtod(pReservedSpaceStr, &endptr);
if (endptr != NULL && *endptr != '\0')
{
logError("file: "__FILE__", line: %d, " \
"item \"reserved_storage_space\": %s%%"\
" is invalid!", __LINE__, \
pReservedSpaceStr);
return EINVAL;
}
if (pStorageReservedSpace->rs.ratio <= 0.00 || \
pStorageReservedSpace->rs.ratio >= 100.00)
{
logError("file: "__FILE__", line: %d, " \
"item \"reserved_storage_space\": %s%%"\
" is invalid!", __LINE__, \
pReservedSpaceStr);
return EINVAL;
}
pStorageReservedSpace->rs.ratio /= 100.00;
return 0;
}
if ((result=parse_bytes(pReservedSpaceStr, 1, &storage_reserved)) != 0)
{
return result;
}
pStorageReservedSpace->flag = TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB;
pStorageReservedSpace->rs.mb = storage_reserved / FDFS_ONE_MB;
return 0;
}
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;
}
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 fdfs_load_storage_ids_from_file(const char *config_filename, \
IniContext *pItemContext)
{
char *pStorageIdsFilename;
char *content;
int64_t file_size;
int result;
pStorageIdsFilename = iniGetStrValue(NULL, "storage_ids_filename", \
pItemContext);
if (pStorageIdsFilename == NULL)
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\" must have item " \
"\"storage_ids_filename\"!", __LINE__, config_filename);
return ENOENT;
}
if (*pStorageIdsFilename == '\0')
{
logError("file: "__FILE__", line: %d, " \
"conf file \"%s\", storage_ids_filename is emtpy!", \
__LINE__, config_filename);
return EINVAL;
}
if (*pStorageIdsFilename == '/') //absolute path
{
result = getFileContent(pStorageIdsFilename, \
&content, &file_size);
}
else
{
const char *lastSlash = strrchr(config_filename, '/');
if (lastSlash == NULL)
{
result = getFileContent(pStorageIdsFilename, \
&content, &file_size);
}
else
{
char filepath[MAX_PATH_SIZE];
char full_filename[MAX_PATH_SIZE];
int len;
len = lastSlash - config_filename;
if (len >= sizeof(filepath))
{
logError("file: "__FILE__", line: %d, " \
"conf filename: \"%s\" is too long!", \
__LINE__, config_filename);
return ENOSPC;
}
memcpy(filepath, config_filename, len);
*(filepath + len) = '\0';
snprintf(full_filename, sizeof(full_filename), \
"%s/%s", filepath, pStorageIdsFilename);
result = getFileContent(full_filename, \
&content, &file_size);
}
}
if (result != 0)
{
return result;
}
result = fdfs_load_storage_ids(content, pStorageIdsFilename);
free(content);
return result;
}
void load_log_level(IniContext *pIniContext)
{
set_log_level(iniGetStrValue(NULL, "log_level", pIniContext));
}
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;
}