pdxx
/
fastdfs
mirror of https://github.com/happyfish100/fastdfs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
fastdfs/tracker/tracker_mem.c

6257 lines
159 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

/**
* Copyright (C) 2008 Happy Fish / YuQing
*
* FastDFS may be copied only under the terms of the GNU General
* Public License V3, which may be found in the FastDFS source kit.
* Please visit the FastDFS Home Page http://www.fastken.com/ for more detail.
**/
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <fcntl.h>
#include <pthread.h>
#include "fdfs_define.h"
#include "fastcommon/logger.h"
#include "fastcommon/sockopt.h"
#include "fdfs_global.h"
#include "fastcommon/shared_func.h"
#include "fastcommon/pthread_func.h"
#include "fastcommon/sched_thread.h"
#include "fdfs_shared_func.h"
#include "tracker_global.h"
#include "tracker_proto.h"
#include "tracker_func.h"
#include "tracker_relationship.h"
#include "tracker_mem.h"
#define TRACKER_MEM_ALLOC_ONCE 2
#define GROUP_SECTION_NAME_GLOBAL "Global"
#define GROUP_SECTION_NAME_PREFIX "Group"
#define GROUP_SECTION_NO_FORMAT "%03d"
#define GROUP_ITEM_GROUP_COUNT "group_count"
#define GROUP_ITEM_GROUP_NAME "group_name"
#define GROUP_ITEM_STORAGE_PORT "storage_port"
#define GROUP_ITEM_STORAGE_HTTP_PORT "storage_http_port"
#define GROUP_ITEM_STORE_PATH_COUNT "store_path_count"
#define GROUP_ITEM_SUBDIR_COUNT_PER_PATH "subdir_count_per_path"
#define GROUP_ITEM_CURRENT_TRUNK_FILE_ID "current_trunk_file_id"
#define GROUP_ITEM_LAST_TRUNK_SERVER "last_trunk_server"
#define GROUP_ITEM_TRUNK_SERVER "trunk_server"
#define STORAGE_SECTION_NAME_GLOBAL "Global"
#define STORAGE_SECTION_NAME_PREFIX "Storage"
#define STORAGE_SECTION_NO_FORMAT "%03d"
#define STORAGE_ITEM_STORAGE_COUNT "storage_count"
#define STORAGE_ITEM_GROUP_NAME "group_name"
#define STORAGE_ITEM_SERVER_ID "id"
#define STORAGE_ITEM_IP_ADDR "ip_addr"
#define STORAGE_ITEM_STATUS "status"
#define STORAGE_ITEM_DOMAIN_NAME "domain_name"
#define STORAGE_ITEM_VERSION "version"
#define STORAGE_ITEM_SYNC_SRC_SERVER "sync_src_server"
#define STORAGE_ITEM_SYNC_UNTIL_TIMESTAMP "sync_until_timestamp"
#define STORAGE_ITEM_JOIN_TIME "join_time"
#define STORAGE_ITEM_TOTAL_MB "total_mb"
#define STORAGE_ITEM_FREE_MB "free_mb"
#define STORAGE_ITEM_CHANGELOG_OFFSET "changelog_offset"
#define STORAGE_ITEM_STORE_PATH_COUNT "store_path_count"
#define STORAGE_ITEM_SUBDIR_COUNT_PER_PATH "subdir_count_per_path"
#define STORAGE_ITEM_UPLOAD_PRIORITY "upload_priority"
#define STORAGE_ITEM_STORAGE_PORT "storage_port"
#define STORAGE_ITEM_STORAGE_HTTP_PORT "storage_http_port"
#define STORAGE_ITEM_TOTAL_UPLOAD_COUNT "total_upload_count"
#define STORAGE_ITEM_SUCCESS_UPLOAD_COUNT "success_upload_count"
#define STORAGE_ITEM_TOTAL_APPEND_COUNT "total_append_count"
#define STORAGE_ITEM_SUCCESS_APPEND_COUNT "success_append_count"
#define STORAGE_ITEM_TOTAL_SET_META_COUNT "total_set_meta_count"
#define STORAGE_ITEM_SUCCESS_SET_META_COUNT "success_set_meta_count"
#define STORAGE_ITEM_TOTAL_DELETE_COUNT "total_delete_count"
#define STORAGE_ITEM_SUCCESS_DELETE_COUNT "success_delete_count"
#define STORAGE_ITEM_TOTAL_DOWNLOAD_COUNT "total_download_count"
#define STORAGE_ITEM_SUCCESS_DOWNLOAD_COUNT "success_download_count"
#define STORAGE_ITEM_TOTAL_GET_META_COUNT "total_get_meta_count"
#define STORAGE_ITEM_SUCCESS_GET_META_COUNT "success_get_meta_count"
#define STORAGE_ITEM_TOTAL_CREATE_LINK_COUNT "total_create_link_count"
#define STORAGE_ITEM_SUCCESS_CREATE_LINK_COUNT "success_create_link_count"
#define STORAGE_ITEM_TOTAL_DELETE_LINK_COUNT "total_delete_link_count"
#define STORAGE_ITEM_SUCCESS_DELETE_LINK_COUNT "success_delete_link_count"
#define STORAGE_ITEM_TOTAL_UPLOAD_BYTES "total_upload_bytes"
#define STORAGE_ITEM_SUCCESS_UPLOAD_BYTES "success_upload_bytes"
#define STORAGE_ITEM_TOTAL_APPEND_BYTES "total_append_bytes"
#define STORAGE_ITEM_SUCCESS_APPEND_BYTES "success_append_bytes"
#define STORAGE_ITEM_TOTAL_DOWNLOAD_BYTES "total_download_bytes"
#define STORAGE_ITEM_SUCCESS_DOWNLOAD_BYTES "success_download_bytes"
#define STORAGE_ITEM_TOTAL_SYNC_IN_BYTES "total_sync_in_bytes"
#define STORAGE_ITEM_SUCCESS_SYNC_IN_BYTES "success_sync_in_bytes"
#define STORAGE_ITEM_TOTAL_SYNC_OUT_BYTES "total_sync_out_bytes"
#define STORAGE_ITEM_SUCCESS_SYNC_OUT_BYTES "success_sync_out_bytes"
#define STORAGE_ITEM_TOTAL_FILE_OPEN_COUNT "total_file_open_count"
#define STORAGE_ITEM_SUCCESS_FILE_OPEN_COUNT "success_file_open_count"
#define STORAGE_ITEM_TOTAL_FILE_READ_COUNT "total_file_read_count"
#define STORAGE_ITEM_SUCCESS_FILE_READ_COUNT "success_file_read_count"
#define STORAGE_ITEM_TOTAL_FILE_WRITE_COUNT "total_file_write_count"
#define STORAGE_ITEM_SUCCESS_FILE_WRITE_COUNT "success_file_write_count"
#define STORAGE_ITEM_LAST_SOURCE_UPDATE "last_source_update"
#define STORAGE_ITEM_LAST_SYNC_UPDATE "last_sync_update"
#define STORAGE_ITEM_LAST_SYNCED_TIMESTAMP "last_synced_timestamp"
#define STORAGE_ITEM_LAST_HEART_BEAT_TIME "last_heart_beat_time"
TrackerServerGroup g_tracker_servers = {0, 0, -1, NULL};
TrackerServerInfo *g_last_tracker_servers = NULL; //for delay free
int g_next_leader_index = -1; //next leader index
int g_trunk_server_chg_count = 1; //for notify other trackers
int g_tracker_leader_chg_count = 0; //for notify storage servers
int64_t g_changelog_fsize = 0; //storage server change log file size
static int changelog_fd = -1; //storage server change log fd for write
static bool need_get_sys_files = true;
static bool get_sys_files_done = false;
static pthread_mutex_t mem_thread_lock;
static pthread_mutex_t mem_file_lock;
static void tracker_mem_find_store_server(FDFSGroupInfo *pGroup);
static int tracker_mem_find_trunk_server(FDFSGroupInfo *pGroup,
const bool save);
static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
FDFSStorageDetail **ppStorageServer, const char *id,
const char *ip_addr, const bool bNeedSleep,
const bool bNeedLock, bool *bInserted);
static int tracker_mem_add_storage(TrackerClientInfo *pClientInfo,
const char *id, const char *ip_addr,
const bool bNeedSleep, const bool bNeedLock, bool *bInserted);
static int tracker_mem_add_storage_from_file(FDFSGroups *pGroups,
const char *data_path, TrackerClientInfo *pClientInfo,
const char *group_name, const char *storage_id, char *ip_addr);
static int tracker_mem_add_group_ex(FDFSGroups *pGroups,
TrackerClientInfo *pClientInfo, const char *group_name,
const bool bNeedSleep, bool *bInserted);
static int tracker_mem_destroy_groups(FDFSGroups *pGroups, const bool saveFiles);
char *g_tracker_sys_filenames[TRACKER_SYS_FILE_COUNT] = {
STORAGE_GROUPS_LIST_FILENAME_NEW,
STORAGE_SERVERS_LIST_FILENAME_NEW,
STORAGE_SYNC_TIMESTAMP_FILENAME,
STORAGE_SERVERS_CHANGELOG_FILENAME
};
int tracker_mem_pthread_lock()
{
int result;
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
return 0;
}
int tracker_mem_pthread_unlock()
{
int result;
if ((result=pthread_mutex_unlock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
return 0;
}
int tracker_mem_file_lock()
{
int result;
if ((result=pthread_mutex_lock(&mem_file_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
return 0;
}
int tracker_mem_file_unlock()
{
int result;
if ((result=pthread_mutex_unlock(&mem_file_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
return 0;
}
static int tracker_write_to_changelog(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pStorage, const char *pArg)
{
char buff[256];
int len;
int result;
tracker_mem_file_lock();
len = snprintf(buff, sizeof(buff), "%d %s %s %d %s\n", \
(int)g_current_time, pGroup->group_name, pStorage->id, \
pStorage->status, pArg != NULL ? pArg : "");
if (fc_safe_write(changelog_fd, buff, len) != len)
{
tracker_mem_file_unlock();
result = errno != 0 ? errno : EIO;
logError("file: "__FILE__", line: %d, " \
"write to file: %s fail, " \
"errno: %d, error info: %s", \
__LINE__, STORAGE_SERVERS_CHANGELOG_FILENAME, \
result, STRERROR(result));
return result;
}
g_changelog_fsize += len;
result = fsync(changelog_fd);
if (result != 0)
{
result = errno != 0 ? errno : EIO;
logError("file: "__FILE__", line: %d, " \
"call fsync of file: %s fail, " \
"errno: %d, error info: %s", \
__LINE__, STORAGE_SERVERS_CHANGELOG_FILENAME, \
result, STRERROR(result));
}
tracker_mem_file_unlock();
return result;
}
static int tracker_malloc_storage_path_mbs(FDFSStorageDetail *pStorage, \
const int store_path_count)
{
int alloc_bytes;
if (store_path_count <= 0)
{
return 0;
}
alloc_bytes = sizeof(int64_t) * store_path_count;
pStorage->path_total_mbs = (int64_t *)malloc(alloc_bytes);
if (pStorage->path_total_mbs == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, alloc_bytes, errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
pStorage->path_free_mbs = (int64_t *)malloc(alloc_bytes);
if (pStorage->path_free_mbs == NULL)
{
free(pStorage->path_total_mbs);
pStorage->path_total_mbs = NULL;
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, alloc_bytes, errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
memset(pStorage->path_total_mbs, 0, alloc_bytes);
memset(pStorage->path_free_mbs, 0, alloc_bytes);
return 0;
}
static int tracker_realloc_storage_path_mbs(FDFSStorageDetail *pStorage, \
const int old_store_path_count, const int new_store_path_count)
{
int alloc_bytes;
int copy_bytes;
int64_t *new_path_total_mbs;
int64_t *new_path_free_mbs;
if (new_store_path_count <= 0)
{
return EINVAL;
}
alloc_bytes = sizeof(int64_t) * new_store_path_count;
new_path_total_mbs = (int64_t *)malloc(alloc_bytes);
if (new_path_total_mbs == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, alloc_bytes, errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
new_path_free_mbs = (int64_t *)malloc(alloc_bytes);
if (new_path_free_mbs == NULL)
{
free(new_path_total_mbs);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, alloc_bytes, errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
memset(new_path_total_mbs, 0, alloc_bytes);
memset(new_path_free_mbs, 0, alloc_bytes);
if (old_store_path_count == 0)
{
pStorage->path_total_mbs = new_path_total_mbs;
pStorage->path_free_mbs = new_path_free_mbs;
return 0;
}
copy_bytes = (old_store_path_count < new_store_path_count ? \
old_store_path_count : new_store_path_count) * sizeof(int64_t);
memcpy(new_path_total_mbs, pStorage->path_total_mbs, copy_bytes);
memcpy(new_path_free_mbs, pStorage->path_free_mbs, copy_bytes);
free(pStorage->path_total_mbs);
free(pStorage->path_free_mbs);
pStorage->path_total_mbs = new_path_total_mbs;
pStorage->path_free_mbs = new_path_free_mbs;
return 0;
}
static int tracker_realloc_group_path_mbs(FDFSGroupInfo *pGroup, \
const int new_store_path_count)
{
FDFSStorageDetail **ppStorage;
FDFSStorageDetail **ppEnd;
int result;
ppEnd = pGroup->all_servers + pGroup->alloc_size;
for (ppStorage=pGroup->all_servers; ppStorage<ppEnd; ppStorage++)
{
if ((result=tracker_realloc_storage_path_mbs(*ppStorage, \
pGroup->store_path_count, new_store_path_count)) != 0)
{
return result;
}
}
pGroup->store_path_count = new_store_path_count;
return 0;
}
static int tracker_malloc_group_path_mbs(FDFSGroupInfo *pGroup)
{
FDFSStorageDetail **ppStorage;
FDFSStorageDetail **ppEnd;
int result;
ppEnd = pGroup->all_servers + pGroup->alloc_size;
for (ppStorage=pGroup->all_servers; ppStorage<ppEnd; ppStorage++)
{
if ((result=tracker_malloc_storage_path_mbs(*ppStorage, \
pGroup->store_path_count)) != 0)
{
return result;
}
}
return 0;
}
static int tracker_malloc_all_group_path_mbs(FDFSGroups *pGroups)
{
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppEnd;
int result;
ppEnd = pGroups->groups + pGroups->alloc_size;
for (ppGroup=pGroups->groups; ppGroup<ppEnd; ppGroup++)
{
if ((*ppGroup)->store_path_count == 0)
{
continue;
}
if ((result=tracker_malloc_group_path_mbs(*ppGroup)) != 0)
{
return result;
}
}
return 0;
}
static int tracker_load_groups_old(FDFSGroups *pGroups, const char *data_path)
{
#define STORAGE_DATA_GROUP_FIELDS 4
FILE *fp;
char szLine[256];
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char *fields[STORAGE_DATA_GROUP_FIELDS];
int result;
int col_count;
TrackerClientInfo clientInfo;
bool bInserted;
if ((fp=fopen(STORAGE_GROUPS_LIST_FILENAME_OLD, "r")) == NULL)
{
logError("file: "__FILE__", line: %d, " \
"open file \"%s/%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, data_path, STORAGE_GROUPS_LIST_FILENAME_OLD, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
result = 0;
while (fgets(szLine, sizeof(szLine), fp) != NULL)
{
if (*szLine == '\0')
{
continue;
}
col_count = splitEx(szLine, STORAGE_DATA_FIELD_SEPERATOR, \
fields, STORAGE_DATA_GROUP_FIELDS);
if (col_count != STORAGE_DATA_GROUP_FIELDS && \
col_count != STORAGE_DATA_GROUP_FIELDS - 2)
{
logError("file: "__FILE__", line: %d, " \
"the format of the file \"%s/%s\" is invalid", \
__LINE__, data_path, \
STORAGE_GROUPS_LIST_FILENAME_OLD);
result = errno != 0 ? errno : EINVAL;
break;
}
memset(&clientInfo, 0, sizeof(TrackerClientInfo));
snprintf(group_name, sizeof(group_name),\
"%s", fc_trim(fields[0]));
if ((result=tracker_mem_add_group_ex(pGroups, &clientInfo, \
group_name, false, &bInserted)) != 0)
{
break;
}
if (!bInserted)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"group \"%s\" is duplicate", \
__LINE__, data_path, \
STORAGE_GROUPS_LIST_FILENAME_OLD, \
group_name);
result = errno != 0 ? errno : EEXIST;
break;
}
clientInfo.pGroup->storage_port = atoi(fc_trim(fields[1]));
if (col_count == STORAGE_DATA_GROUP_FIELDS - 2)
{ //version < V1.12
clientInfo.pGroup->store_path_count = 0;
clientInfo.pGroup->subdir_count_per_path = 0;
}
else
{
clientInfo.pGroup->store_path_count = \
atoi(fc_trim(fields[2]));
clientInfo.pGroup->subdir_count_per_path = \
atoi(fc_trim(fields[3]));
}
}
fclose(fp);
return result;
}
static int tracker_mem_get_storage_id(const char *group_name, \
const char *pIpAddr, char *storage_id)
{
FDFSStorageIdInfo *pStorageIdInfo;
pStorageIdInfo = fdfs_get_storage_id_by_ip(group_name, pIpAddr);
if (pStorageIdInfo == NULL)
{
return ENOENT;
}
strcpy(storage_id, pStorageIdInfo->id);
return 0;
}
static int tracker_load_groups_new(FDFSGroups *pGroups, const char *data_path,
FDFSStorageSync **ppTrunkServers, int *nTrunkServerCount)
{
IniContext iniContext;
FDFSGroupInfo *pGroup;
char *group_name;
char *pValue;
int nStorageSyncSize;
int group_count;
int result;
int i;
char section_name[64];
TrackerClientInfo clientInfo;
bool bInserted;
*nTrunkServerCount = 0;
*ppTrunkServers = NULL;
if (!fileExists(STORAGE_GROUPS_LIST_FILENAME_NEW) && \
fileExists(STORAGE_GROUPS_LIST_FILENAME_OLD))
{
logDebug("file: "__FILE__", line: %d, " \
"convert old data file %s to new data file %s", \
__LINE__, STORAGE_GROUPS_LIST_FILENAME_OLD, \
STORAGE_GROUPS_LIST_FILENAME_NEW);
if ((result=tracker_load_groups_old(pGroups, data_path)) == 0)
{
if ((result=tracker_save_groups()) == 0)
{
unlink(STORAGE_GROUPS_LIST_FILENAME_OLD);
}
}
return result;
}
if ((result=iniLoadFromFile(STORAGE_GROUPS_LIST_FILENAME_NEW, \
&iniContext)) != 0)
{
return result;
}
group_count = iniGetIntValue(GROUP_SECTION_NAME_GLOBAL, \
GROUP_ITEM_GROUP_COUNT, \
&iniContext, -1);
if (group_count < 0)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"item \"%s\" is not found", \
__LINE__, data_path, \
STORAGE_GROUPS_LIST_FILENAME_NEW, \
GROUP_ITEM_GROUP_COUNT);
return ENOENT;
}
nStorageSyncSize = 0;
for (i=1; i<=group_count; i++)
{
sprintf(section_name, "%s"GROUP_SECTION_NO_FORMAT, \
GROUP_SECTION_NAME_PREFIX, i);
group_name = iniGetStrValue(section_name, \
GROUP_ITEM_GROUP_NAME, &iniContext);
if (group_name == NULL)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"item \"%s\" is not found", \
__LINE__, data_path, \
STORAGE_GROUPS_LIST_FILENAME_NEW, \
GROUP_ITEM_GROUP_NAME);
result = ENOENT;
break;
}
memset(&clientInfo, 0, sizeof(TrackerClientInfo));
if ((result=tracker_mem_add_group_ex(pGroups, &clientInfo, \
group_name, false, &bInserted)) != 0)
{
break;
}
if (!bInserted)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"group \"%s\" is duplicate", \
__LINE__, data_path, \
STORAGE_GROUPS_LIST_FILENAME_NEW, \
group_name);
result = errno != 0 ? errno : EEXIST;
break;
}
pGroup = clientInfo.pGroup;
pGroup->storage_port = iniGetIntValue(section_name, \
GROUP_ITEM_STORAGE_PORT, &iniContext, 0);
pGroup->storage_http_port = iniGetIntValue(section_name, \
GROUP_ITEM_STORAGE_HTTP_PORT, &iniContext, 0);
pGroup->store_path_count = iniGetIntValue(section_name, \
GROUP_ITEM_STORE_PATH_COUNT, &iniContext, 0);
pGroup->subdir_count_per_path = iniGetIntValue(section_name, \
GROUP_ITEM_SUBDIR_COUNT_PER_PATH, &iniContext, 0);
pGroup->current_trunk_file_id = iniGetIntValue(section_name, \
GROUP_ITEM_CURRENT_TRUNK_FILE_ID, &iniContext, 0);
pValue = iniGetStrValue(section_name, \
GROUP_ITEM_LAST_TRUNK_SERVER, &iniContext);
if (pValue != NULL)
{
snprintf(pGroup->last_trunk_server_id,
sizeof(pGroup->last_trunk_server_id), \
"%s", pValue);
if (g_use_storage_id && (*pValue != '\0' && \
!fdfs_is_server_id_valid(pValue)))
{
if (tracker_mem_get_storage_id( \
pGroup->group_name, pValue, \
pGroup->last_trunk_server_id) != 0)
{
logWarning("file: "__FILE__", line: %d,"\
"server id of group name: %s " \
"and last trunk ip address: %s"\
" NOT exist", __LINE__, \
pGroup->group_name, pValue);
*pGroup->last_trunk_server_id = '\0';
}
}
}
pValue = iniGetStrValue(section_name, \
GROUP_ITEM_TRUNK_SERVER, &iniContext);
if (pValue != NULL && *pValue != '\0')
{
if (nStorageSyncSize <= *nTrunkServerCount)
{
nStorageSyncSize += 8;
FDFSStorageSync *new_trunk_servers = (FDFSStorageSync *)
realloc(*ppTrunkServers, \
sizeof(FDFSStorageSync) * nStorageSyncSize);
if (new_trunk_servers == NULL)
{
result = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"realloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageSync) * \
nStorageSyncSize);
free(*ppTrunkServers);
*ppTrunkServers = NULL;
break;
}
*ppTrunkServers = new_trunk_servers;
}
strcpy((*ppTrunkServers)[*nTrunkServerCount].group_name, \
clientInfo.pGroup->group_name);
snprintf((*ppTrunkServers)[*nTrunkServerCount].id, \
FDFS_STORAGE_ID_MAX_SIZE, "%s", pValue);
if (g_use_storage_id && !fdfs_is_server_id_valid(pValue))
{
if ((result=tracker_mem_get_storage_id( \
clientInfo.pGroup->group_name, pValue, \
(*ppTrunkServers)[*nTrunkServerCount].id)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"server id of group name: %s and " \
"trunk server ip address: %s NOT " \
"exist", __LINE__, \
clientInfo.pGroup->group_name, pValue);
break;
}
}
(*nTrunkServerCount)++;
}
}
iniFreeContext(&iniContext);
return result;
}
static int tracker_locate_group_trunk_servers(FDFSGroups *pGroups, \
FDFSStorageSync *pTrunkServers, \
const int nTrunkServerCount, const bool bLoadFromFile)
{
FDFSGroupInfo *pGroup;
FDFSStorageDetail *pStorage;
FDFSStorageSync *pServer;
FDFSStorageSync *pTrunkEnd;
if (nTrunkServerCount == 0)
{
return 0;
}
pTrunkEnd = pTrunkServers + nTrunkServerCount;
for (pServer=pTrunkServers; pServer<pTrunkEnd; pServer++)
{
pGroup = tracker_mem_get_group_ex(pGroups, \
pServer->group_name);
if (pGroup == NULL)
{
continue;
}
pStorage = tracker_mem_get_storage(pGroup, pServer->id);
if (pStorage == NULL)
{
char buff[MAX_PATH_SIZE+64];
if (bLoadFromFile)
{
snprintf(buff, sizeof(buff), \
"in the file \"%s/data/%s\", ", \
SF_G_BASE_PATH_STR, \
STORAGE_GROUPS_LIST_FILENAME_NEW);
}
else
{
*buff = '\0';
}
logError("file: "__FILE__", line: %d, " \
"%sgroup_name: %s, trunk server \"%s\" " \
"does not exist", __LINE__, buff, \
pServer->group_name, pServer->id);
return ENOENT;
}
pGroup->pTrunkServer = pStorage;
pGroup->trunk_chg_count++;
if (*(pGroup->last_trunk_server_id) == '\0')
{
strcpy(pGroup->last_trunk_server_id, pStorage->id);
}
}
return 0;
}
static int tracker_locate_storage_sync_server(FDFSGroups *pGroups, \
FDFSStorageSync *pStorageSyncs, \
const int nStorageSyncCount, const bool bLoadFromFile)
{
FDFSGroupInfo *pGroup;
FDFSStorageDetail *pStorage;
FDFSStorageSync *pSyncServer;
FDFSStorageSync *pSyncEnd;
if (nStorageSyncCount == 0)
{
return 0;
}
pSyncEnd = pStorageSyncs + nStorageSyncCount;
for (pSyncServer=pStorageSyncs; pSyncServer<pSyncEnd; pSyncServer++)
{
pGroup = tracker_mem_get_group_ex(pGroups, \
pSyncServer->group_name);
if (pGroup == NULL)
{
continue;
}
pStorage=tracker_mem_get_storage(pGroup, pSyncServer->id);
if (pStorage == NULL)
{
continue;
}
pStorage->psync_src_server = tracker_mem_get_storage(pGroup, \
pSyncServer->sync_src_id);
if (pStorage->psync_src_server == NULL)
{
char buff[MAX_PATH_SIZE+64];
if (bLoadFromFile)
{
snprintf(buff, sizeof(buff), \
"in the file \"%s/data/%s\", ", \
SF_G_BASE_PATH_STR, \
STORAGE_SERVERS_LIST_FILENAME_NEW);
}
else
{
*buff = '\0';
}
logError("file: "__FILE__", line: %d, " \
"%sgroup_name: %s, storage server \"%s\" " \
"does not exist", __LINE__, buff, \
pSyncServer->group_name, \
pSyncServer->sync_src_id);
return ENOENT;
}
}
return 0;
}
static int tracker_load_storages_old(FDFSGroups *pGroups, const char *data_path)
{
#define STORAGE_DATA_SERVER_FIELDS 22
FILE *fp;
char szLine[256];
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char *fields[STORAGE_DATA_SERVER_FIELDS];
char ip_addr[IP_ADDRESS_SIZE];
char *psync_src_id;
FDFSStorageDetail *pStorage;
FDFSStorageSync *pStorageSyncs;
int nStorageSyncSize;
int nStorageSyncCount;
int cols;
int result;
TrackerClientInfo clientInfo;
bool bInserted;
if ((fp=fopen(STORAGE_SERVERS_LIST_FILENAME_OLD, "r")) == NULL)
{
logError("file: "__FILE__", line: %d, " \
"open file \"%s/%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, data_path, STORAGE_SERVERS_LIST_FILENAME_OLD, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
nStorageSyncSize = 0;
nStorageSyncCount = 0;
pStorageSyncs = NULL;
result = 0;
while (fgets(szLine, sizeof(szLine), fp) != NULL)
{
if (*szLine == '\0')
{
continue;
}
cols = splitEx(szLine, STORAGE_DATA_FIELD_SEPERATOR, \
fields, STORAGE_DATA_SERVER_FIELDS);
if (cols != STORAGE_DATA_SERVER_FIELDS && \
cols != STORAGE_DATA_SERVER_FIELDS - 2 && \
cols != STORAGE_DATA_SERVER_FIELDS - 4 && \
cols != STORAGE_DATA_SERVER_FIELDS - 5)
{
logError("file: "__FILE__", line: %d, " \
"the format of the file \"%s/%s\" is invalid" \
", colums: %d != expect colums: " \
"%d or %d or %d or %d", \
__LINE__, data_path, \
STORAGE_SERVERS_LIST_FILENAME_OLD, \
cols, STORAGE_DATA_SERVER_FIELDS, \
STORAGE_DATA_SERVER_FIELDS - 2, \
STORAGE_DATA_SERVER_FIELDS - 4, \
STORAGE_DATA_SERVER_FIELDS - 5);
result = EINVAL;
break;
}
memset(&clientInfo, 0, sizeof(TrackerClientInfo));
snprintf(group_name, sizeof(group_name), "%s", fc_trim(fields[0]));
snprintf(ip_addr, sizeof(ip_addr), "%s", fc_trim(fields[1]));
if ((clientInfo.pGroup=tracker_mem_get_group_ex(pGroups, \
group_name)) == NULL)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"group \"%s\" is not found", \
__LINE__, data_path, \
STORAGE_SERVERS_LIST_FILENAME_OLD, \
group_name);
result = errno != 0 ? errno : ENOENT;
break;
}
if ((result=tracker_mem_add_storage(&clientInfo, NULL, ip_addr,
false, false, &bInserted)) != 0)
{
break;
}
if (!bInserted)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"storage \"%s\" is duplicate", \
__LINE__, data_path, \
STORAGE_SERVERS_LIST_FILENAME_OLD, ip_addr);
result = errno != 0 ? errno : EEXIST;
break;
}
pStorage = clientInfo.pStorage;
pStorage->status = atoi(trim_left(fields[2]));
if (!((pStorage->status == \
FDFS_STORAGE_STATUS_WAIT_SYNC) || \
(pStorage->status == \
FDFS_STORAGE_STATUS_SYNCING) || \
(pStorage->status == \
FDFS_STORAGE_STATUS_INIT)))
{
pStorage->status = \
FDFS_STORAGE_STATUS_OFFLINE;
}
psync_src_id = fc_trim(fields[3]);
pStorage->sync_until_timestamp = atoi( \
trim_left(fields[4]));
pStorage->stat.total_upload_count = strtoll( \
trim_left(fields[5]), NULL, 10);
pStorage->stat.success_upload_count = strtoll( \
trim_left(fields[6]), NULL, 10);
pStorage->stat.total_set_meta_count = strtoll( \
trim_left(fields[7]), NULL, 10);
pStorage->stat.success_set_meta_count = strtoll( \
trim_left(fields[8]), NULL, 10);
pStorage->stat.total_delete_count = strtoll( \
trim_left(fields[9]), NULL, 10);
pStorage->stat.success_delete_count = strtoll( \
trim_left(fields[10]), NULL, 10);
pStorage->stat.total_download_count = strtoll( \
trim_left(fields[11]), NULL, 10);
pStorage->stat.success_download_count = strtoll( \
trim_left(fields[12]), NULL, 10);
pStorage->stat.total_get_meta_count = strtoll( \
trim_left(fields[13]), NULL, 10);
pStorage->stat.success_get_meta_count = strtoll( \
trim_left(fields[14]), NULL, 10);
pStorage->stat.last_source_update = atoi( \
trim_left(fields[15]));
pStorage->stat.last_sync_update = atoi( \
trim_left(fields[16]));
if (cols > STORAGE_DATA_SERVER_FIELDS - 5)
{
pStorage->changelog_offset = strtoll( \
trim_left(fields[17]), NULL, 10);
if (pStorage->changelog_offset < 0)
{
pStorage->changelog_offset = 0;
}
if (pStorage->changelog_offset > \
g_changelog_fsize)
{
pStorage->changelog_offset = \
g_changelog_fsize;
}
if (cols > STORAGE_DATA_SERVER_FIELDS - 4)
{
pStorage->storage_port = \
atoi(trim_left(fields[18]));
pStorage->storage_http_port = \
atoi(trim_left(fields[19]));
if (cols > STORAGE_DATA_SERVER_FIELDS - 2)
{
pStorage->join_time = \
(time_t)atoi(trim_left(fields[20]));
snprintf(pStorage->version, \
sizeof(pStorage->version),
"%s", fc_trim(fields[21]));
}
}
}
if (*psync_src_id == '\0')
{
continue;
}
if (nStorageSyncSize <= nStorageSyncCount)
{
nStorageSyncSize += 8;
FDFSStorageSync *pNewStorageSyncs = (FDFSStorageSync *)
realloc(pStorageSyncs, \
sizeof(FDFSStorageSync) * nStorageSyncSize);
if (pNewStorageSyncs == NULL)
{
result = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"realloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageSync) * \
nStorageSyncSize);
free(pStorageSyncs);
pStorageSyncs = NULL;
break;
}
pStorageSyncs = pNewStorageSyncs;
}
strcpy(pStorageSyncs[nStorageSyncCount].group_name, \
clientInfo.pGroup->group_name);
strcpy(pStorageSyncs[nStorageSyncCount].id, pStorage->id);
snprintf(pStorageSyncs[nStorageSyncCount].sync_src_id, \
FDFS_STORAGE_ID_MAX_SIZE, "%s", psync_src_id);
nStorageSyncCount++;
}
fclose(fp);
if (pStorageSyncs == NULL)
{
return result;
}
if (result != 0)
{
free(pStorageSyncs);
return result;
}
result = tracker_locate_storage_sync_server(pGroups, pStorageSyncs, \
nStorageSyncCount, true);
free(pStorageSyncs);
return result;
}
static int tracker_load_storages_new(FDFSGroups *pGroups, const char *data_path)
{
IniContext iniContext;
char *group_name;
char *storage_id;
char *ip_addr;
char *psync_src_id;
char *pValue;
FDFSStorageDetail *pStorage;
FDFSStorageStat *pStat;
FDFSStorageSync *pStorageSyncs;
int nStorageSyncSize;
int nStorageSyncCount;
int storage_count;
int i;
int result;
char section_name[64];
TrackerClientInfo clientInfo;
if (!fileExists(STORAGE_SERVERS_LIST_FILENAME_NEW) && \
fileExists(STORAGE_SERVERS_LIST_FILENAME_OLD))
{
logDebug("file: "__FILE__", line: %d, " \
"convert old data file %s to new data file %s", \
__LINE__, STORAGE_SERVERS_LIST_FILENAME_OLD, \
STORAGE_SERVERS_LIST_FILENAME_NEW);
if ((result=tracker_load_storages_old(pGroups, data_path)) == 0)
{
if ((result=tracker_save_storages()) == 0)
{
unlink(STORAGE_SERVERS_LIST_FILENAME_OLD);
}
}
return result;
}
if ((result=iniLoadFromFile(STORAGE_SERVERS_LIST_FILENAME_NEW, \
&iniContext)) != 0)
{
return result;
}
storage_count = iniGetIntValue(STORAGE_SECTION_NAME_GLOBAL, \
STORAGE_ITEM_STORAGE_COUNT, \
&iniContext, -1);
if (storage_count < 0)
{
iniFreeContext(&iniContext);
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"item \"%s\" is not found", \
__LINE__, data_path, \
STORAGE_SERVERS_LIST_FILENAME_NEW, \
STORAGE_ITEM_STORAGE_COUNT);
return ENOENT;
}
nStorageSyncSize = 0;
nStorageSyncCount = 0;
pStorageSyncs = NULL;
result = 0;
for (i=1; i<=storage_count; i++)
{
sprintf(section_name, "%s"STORAGE_SECTION_NO_FORMAT, \
STORAGE_SECTION_NAME_PREFIX, i);
group_name = iniGetStrValue(section_name, \
STORAGE_ITEM_GROUP_NAME, &iniContext);
if (group_name == NULL)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"item \"%s\" is not found", \
__LINE__, data_path, \
STORAGE_SERVERS_LIST_FILENAME_NEW, \
STORAGE_ITEM_GROUP_NAME);
result = ENOENT;
break;
}
storage_id = iniGetStrValue(section_name, \
STORAGE_ITEM_SERVER_ID, &iniContext);
ip_addr = iniGetStrValue(section_name, \
STORAGE_ITEM_IP_ADDR, &iniContext);
if ((result=tracker_mem_add_storage_from_file(pGroups,
data_path, &clientInfo, group_name,
storage_id, ip_addr)) != 0)
{
break;
}
pStorage = clientInfo.pStorage;
pStat = &(pStorage->stat);
pStorage->status = iniGetIntValue(section_name, \
STORAGE_ITEM_STATUS, &iniContext, 0);
pValue = iniGetStrValue(section_name, \
STORAGE_ITEM_DOMAIN_NAME, &iniContext);
if (pValue != NULL)
{
snprintf(pStorage->domain_name, \
sizeof(pStorage->domain_name), "%s", pValue);
}
pValue = iniGetStrValue(section_name, \
STORAGE_ITEM_VERSION, &iniContext);
if (pValue != NULL)
{
snprintf(pStorage->version, \
sizeof(pStorage->version), "%s", pValue);
}
if (!((pStorage->status == \
FDFS_STORAGE_STATUS_WAIT_SYNC) || \
(pStorage->status == \
FDFS_STORAGE_STATUS_SYNCING) || \
(pStorage->status == \
FDFS_STORAGE_STATUS_INIT)))
{
pStorage->status = FDFS_STORAGE_STATUS_OFFLINE;
}
psync_src_id = iniGetStrValue(section_name, \
STORAGE_ITEM_SYNC_SRC_SERVER, &iniContext);
if (psync_src_id == NULL)
{
psync_src_id = "";
}
pStorage->sync_until_timestamp = iniGetIntValue(section_name, \
STORAGE_ITEM_SYNC_UNTIL_TIMESTAMP, &iniContext, 0);
pStorage->join_time = iniGetIntValue(section_name, \
STORAGE_ITEM_JOIN_TIME, &iniContext, 0);
pStorage->total_mb = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_MB, &iniContext, 0);
pStorage->free_mb = iniGetInt64Value(section_name, \
STORAGE_ITEM_FREE_MB, &iniContext, 0);
pStorage->store_path_count = iniGetIntValue(section_name, \
STORAGE_ITEM_STORE_PATH_COUNT, &iniContext, 0);
pStorage->subdir_count_per_path = iniGetIntValue(section_name, \
STORAGE_ITEM_SUBDIR_COUNT_PER_PATH, &iniContext, 0);
pStorage->upload_priority = iniGetIntValue(section_name, \
STORAGE_ITEM_UPLOAD_PRIORITY, &iniContext, 0);
pStorage->storage_port = iniGetIntValue(section_name, \
STORAGE_ITEM_STORAGE_PORT, &iniContext, 0);
pStorage->storage_http_port = iniGetIntValue(section_name, \
STORAGE_ITEM_STORAGE_HTTP_PORT, &iniContext, 0);
pStat->total_upload_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_UPLOAD_COUNT, &iniContext, 0);
pStat->success_upload_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_UPLOAD_COUNT, &iniContext, 0);
pStat->total_append_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_APPEND_COUNT, &iniContext, 0);
pStat->success_append_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_APPEND_COUNT, &iniContext, 0);
pStat->total_set_meta_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_SET_META_COUNT, &iniContext, 0);
pStat->success_set_meta_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_SET_META_COUNT, &iniContext, 0);
pStat->total_delete_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_DELETE_COUNT, &iniContext, 0);
pStat->success_delete_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_DELETE_COUNT, &iniContext, 0);
pStat->total_download_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_DOWNLOAD_COUNT, &iniContext, 0);
pStat->success_download_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_DOWNLOAD_COUNT, &iniContext, 0);
pStat->total_get_meta_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_GET_META_COUNT, &iniContext, 0);
pStat->success_get_meta_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_GET_META_COUNT, &iniContext, 0);
pStat->total_create_link_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_CREATE_LINK_COUNT, &iniContext, 0);
pStat->success_create_link_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_CREATE_LINK_COUNT, &iniContext, 0);
pStat->total_delete_link_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_DELETE_LINK_COUNT, &iniContext, 0);
pStat->success_delete_link_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_DELETE_LINK_COUNT, &iniContext, 0);
pStat->total_upload_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_UPLOAD_BYTES, &iniContext, 0);
pStat->success_upload_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_UPLOAD_BYTES, &iniContext, 0);
pStat->total_append_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_APPEND_BYTES, &iniContext, 0);
pStat->success_append_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_APPEND_BYTES, &iniContext, 0);
pStat->total_download_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_DOWNLOAD_BYTES, &iniContext, 0);
pStat->success_download_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_DOWNLOAD_BYTES, &iniContext, 0);
pStat->total_sync_in_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_SYNC_IN_BYTES, &iniContext, 0);
pStat->success_sync_in_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_SYNC_IN_BYTES, &iniContext, 0);
pStat->total_sync_out_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_SYNC_OUT_BYTES, &iniContext, 0);
pStat->success_sync_out_bytes = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_SYNC_OUT_BYTES, &iniContext, 0);
pStat->total_file_open_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_FILE_OPEN_COUNT, &iniContext, 0);
pStat->success_file_open_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_FILE_OPEN_COUNT, &iniContext, 0);
pStat->total_file_read_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_FILE_READ_COUNT, &iniContext, 0);
pStat->success_file_read_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_FILE_READ_COUNT, &iniContext, 0);
pStat->total_file_write_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_TOTAL_FILE_WRITE_COUNT, &iniContext, 0);
pStat->success_file_write_count = iniGetInt64Value(section_name, \
STORAGE_ITEM_SUCCESS_FILE_WRITE_COUNT, &iniContext, 0);
pStat->last_source_update = iniGetIntValue(section_name, \
STORAGE_ITEM_LAST_SOURCE_UPDATE, &iniContext, 0);
pStat->last_sync_update = iniGetIntValue(section_name, \
STORAGE_ITEM_LAST_SYNC_UPDATE, &iniContext, 0);
pStat->last_synced_timestamp = iniGetIntValue(section_name, \
STORAGE_ITEM_LAST_SYNCED_TIMESTAMP, &iniContext, 0);
pStat->last_heart_beat_time = iniGetIntValue(section_name, \
STORAGE_ITEM_LAST_HEART_BEAT_TIME, &iniContext, 0);
pStorage->changelog_offset = iniGetInt64Value(section_name, \
STORAGE_ITEM_CHANGELOG_OFFSET, &iniContext, 0);
if (*psync_src_id == '\0')
{
continue;
}
if (nStorageSyncSize <= nStorageSyncCount)
{
if (nStorageSyncSize == 0)
{
nStorageSyncSize = 8;
}
else
{
nStorageSyncSize *= 2;
}
FDFSStorageSync *pNewStorageSyncs = (FDFSStorageSync *)
realloc(pStorageSyncs, \
sizeof(FDFSStorageSync) * nStorageSyncSize);
if (pNewStorageSyncs == NULL)
{
result = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"realloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageSync) * \
nStorageSyncSize);
free(pStorageSyncs);
pStorageSyncs = NULL;
break;
}
pStorageSyncs = pNewStorageSyncs;
}
strcpy(pStorageSyncs[nStorageSyncCount].group_name, \
clientInfo.pGroup->group_name);
strcpy(pStorageSyncs[nStorageSyncCount].id, pStorage->id);
snprintf(pStorageSyncs[nStorageSyncCount].sync_src_id, \
FDFS_STORAGE_ID_MAX_SIZE, "%s", psync_src_id);
if (g_use_storage_id && !fdfs_is_server_id_valid( \
psync_src_id))
{
if ((result=tracker_mem_get_storage_id( \
clientInfo.pGroup->group_name, psync_src_id, \
pStorageSyncs[nStorageSyncCount].sync_src_id))\
!= 0)
{
logError("file: "__FILE__", line: %d, " \
"server id of group name: %s and " \
"src storage ip address: %s NOT " \
"exist", __LINE__, \
clientInfo.pGroup->group_name, \
psync_src_id);
break;
}
}
nStorageSyncCount++;
}
iniFreeContext(&iniContext);
if (pStorageSyncs == NULL)
{
return result;
}
if (result != 0)
{
free(pStorageSyncs);
return result;
}
result = tracker_locate_storage_sync_server(pGroups, pStorageSyncs, \
nStorageSyncCount, true);
free(pStorageSyncs);
return result;
}
static int tracker_load_sync_timestamps(FDFSGroups *pGroups, const char *data_path)
{
#define STORAGE_SYNC_TIME_MAX_FIELDS 2 + FDFS_MAX_SERVERS_EACH_GROUP
FILE *fp;
char szLine[512];
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char previous_group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char src_storage_id[FDFS_STORAGE_ID_MAX_SIZE];
char *fields[STORAGE_SYNC_TIME_MAX_FIELDS];
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppEnd;
FDFSGroupInfo *pGroup;
int cols;
int src_index;
int dest_index;
int curr_synced_timestamp;
int result;
if (!fileExists(STORAGE_SYNC_TIMESTAMP_FILENAME))
{
return 0;
}
if ((fp=fopen(STORAGE_SYNC_TIMESTAMP_FILENAME, "r")) == NULL)
{
logError("file: "__FILE__", line: %d, " \
"open file \"%s/%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, data_path, STORAGE_SYNC_TIMESTAMP_FILENAME, \
errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
pGroup = NULL;
src_index = 0;
*previous_group_name = '\0';
result = 0;
while (fgets(szLine, sizeof(szLine), fp) != NULL)
{
if (*szLine == '\0' || *szLine == '\n')
{
continue;
}
if ((cols=splitEx(szLine, STORAGE_DATA_FIELD_SEPERATOR, \
fields, STORAGE_SYNC_TIME_MAX_FIELDS)) <= 2)
{
logError("file: "__FILE__", line: %d, " \
"the format of the file \"%s/%s\" is invalid" \
", colums: %d <= 2", \
__LINE__, data_path, \
STORAGE_SYNC_TIMESTAMP_FILENAME, cols);
result = errno != 0 ? errno : EINVAL;
break;
}
snprintf(group_name, sizeof(group_name), \
"%s", fc_trim(fields[0]));
snprintf(src_storage_id, sizeof(src_storage_id), \
"%s", fc_trim(fields[1]));
if (strcmp(group_name, previous_group_name) != 0 || \
pGroup == NULL)
{
if ((pGroup=tracker_mem_get_group_ex(pGroups, \
group_name)) == NULL)
{
logError("file: "__FILE__", line: %d, " \
"in the file \"%s/%s\", " \
"group \"%s\" is not found", \
__LINE__, data_path, \
STORAGE_SYNC_TIMESTAMP_FILENAME, \
group_name);
result = errno != 0 ? errno : ENOENT;
break;
}
strcpy(previous_group_name, group_name);
src_index = 0;
}
if (src_index >= pGroup->count)
{
logError("file: "__FILE__", line: %d, " \
"the format of the file \"%s/%s\" is invalid" \
", group: %s, row count:%d > server count:%d",\
__LINE__, data_path, \
STORAGE_SYNC_TIMESTAMP_FILENAME, \
group_name, src_index+1, pGroup->count);
result = errno != 0 ? errno : EINVAL;
break;
}
if (g_use_storage_id && !fdfs_is_server_id_valid( \
src_storage_id))
{
if ((result=tracker_mem_get_storage_id( \
group_name, src_storage_id, \
src_storage_id)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"server id of group name: %s and " \
"storage ip address: %s NOT " \
"exist", __LINE__, \
group_name, src_storage_id);
break;
}
}
if (strcmp(pGroup->all_servers[src_index]->id, \
src_storage_id) != 0)
{
logError("file: "__FILE__", line: %d, " \
"in data file: \"%s/%s\", " \
"group: %s, src server id: %s != %s",\
__LINE__, data_path, \
STORAGE_SYNC_TIMESTAMP_FILENAME, \
group_name, src_storage_id, \
pGroup->all_servers[src_index]->id);
result = errno != 0 ? errno : EINVAL;
break;
}
if (cols > pGroup->count + 2)
{
logError("file: "__FILE__", line: %d, " \
"the format of the file \"%s/%s\" is invalid" \
", group_name: %s, colums: %d > %d", \
__LINE__, data_path, \
STORAGE_SYNC_TIMESTAMP_FILENAME, \
group_name, cols, pGroup->count + 2);
result = errno != 0 ? errno : EINVAL;
break;
}
for (dest_index=0; dest_index<cols-2; dest_index++)
{
pGroup->last_sync_timestamps[src_index][dest_index] = \
atoi(trim_left(fields[2 + dest_index]));
}
src_index++;
}
fclose(fp);
if (result != 0)
{
return result;
}
ppEnd = pGroups->groups + pGroups->count;
for (ppGroup=pGroups->groups; ppGroup<ppEnd; ppGroup++)
{
if ((*ppGroup)->count <= 1)
{
continue;
}
for (dest_index=0; dest_index<(*ppGroup)->count; dest_index++)
{
if (pGroups->store_server == FDFS_STORE_SERVER_ROUND_ROBIN)
{
int min_synced_timestamp;
min_synced_timestamp = 0;
for (src_index=0; src_index<(*ppGroup)->count; \
src_index++)
{
if (src_index == dest_index)
{
continue;
}
curr_synced_timestamp = \
(*ppGroup)->last_sync_timestamps \
[src_index][dest_index];
if (curr_synced_timestamp == 0)
{
continue;
}
if (min_synced_timestamp == 0)
{
min_synced_timestamp = \
curr_synced_timestamp;
}
else if (curr_synced_timestamp < \
min_synced_timestamp)
{
min_synced_timestamp = \
curr_synced_timestamp;
}
}
(*ppGroup)->all_servers[dest_index]->stat. \
last_synced_timestamp = min_synced_timestamp;
}
else
{
int max_synced_timestamp;
max_synced_timestamp = 0;
for (src_index=0; src_index<(*ppGroup)->count; \
src_index++)
{
if (src_index == dest_index)
{
continue;
}
curr_synced_timestamp = \
(*ppGroup)->last_sync_timestamps \
[src_index][dest_index];
if (curr_synced_timestamp > \
max_synced_timestamp)
{
max_synced_timestamp = \
curr_synced_timestamp;
}
}
(*ppGroup)->all_servers[dest_index]->stat. \
last_synced_timestamp = max_synced_timestamp;
}
}
}
return result;
}
static int tracker_load_data(FDFSGroups *pGroups)
{
char data_path[MAX_PATH_SIZE];
int result;
FDFSStorageSync *pTrunkServers;
int nTrunkServerCount;
snprintf(data_path, sizeof(data_path), "%s/data", SF_G_BASE_PATH_STR);
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 : ENOENT;
}
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(data_path);
}
if (chdir(data_path) != 0)
{
logError("file: "__FILE__", line: %d, " \
"chdir \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, data_path, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
if (!fileExists(STORAGE_GROUPS_LIST_FILENAME_OLD) && \
!fileExists(STORAGE_GROUPS_LIST_FILENAME_NEW))
{
return 0;
}
if ((result=tracker_load_groups_new(pGroups, data_path, \
&pTrunkServers, &nTrunkServerCount)) != 0)
{
return result;
}
if ((result=tracker_load_storages_new(pGroups, data_path)) != 0)
{
return result;
}
if ((result=tracker_malloc_all_group_path_mbs(pGroups)) != 0)
{
return result;
}
if ((result=tracker_load_sync_timestamps(pGroups, data_path)) != 0)
{
return result;
}
if (g_if_use_trunk_file)
{
if ((result=tracker_locate_group_trunk_servers(pGroups, \
pTrunkServers, nTrunkServerCount, true)) != 0)
{
return result;
}
}
if (pTrunkServers != NULL)
{
free(pTrunkServers);
}
return 0;
}
int tracker_save_groups()
{
char tmpFilename[MAX_PATH_SIZE];
char trueFilename[MAX_PATH_SIZE];
char buff[FDFS_GROUP_NAME_MAX_LEN + 256];
int fd;
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppEnd;
int result;
int len;
tracker_mem_file_lock();
snprintf(trueFilename, sizeof(trueFilename), "%s/data/%s", \
SF_G_BASE_PATH_STR, STORAGE_GROUPS_LIST_FILENAME_NEW);
snprintf(tmpFilename, sizeof(tmpFilename), "%s.tmp", trueFilename);
if ((fd=open(tmpFilename, O_WRONLY | O_CREAT | O_TRUNC, 0644)) < 0)
{
tracker_mem_file_unlock();
logError("file: "__FILE__", line: %d, " \
"open \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
len = sprintf(buff, \
"# global section\n" \
"[%s]\n" \
"\t%s=%d\n\n", \
GROUP_SECTION_NAME_GLOBAL, \
GROUP_ITEM_GROUP_COUNT, g_groups.count);
if (fc_safe_write(fd, buff, len) != len)
{
logError("file: "__FILE__", line: %d, " \
"write to file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
else
{
result = 0;
ppEnd = g_groups.sorted_groups + g_groups.count;
for (ppGroup=g_groups.sorted_groups; ppGroup<ppEnd; ppGroup++)
{
len = sprintf(buff, \
"# group: %s\n" \
"[%s"GROUP_SECTION_NO_FORMAT"]\n" \
"\t%s=%s\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%s\n" \
"\t%s=%s\n\n", \
(*ppGroup)->group_name, \
GROUP_SECTION_NAME_PREFIX, \
(int)(ppGroup - g_groups.sorted_groups) + 1, \
GROUP_ITEM_GROUP_NAME, \
(*ppGroup)->group_name, \
GROUP_ITEM_STORAGE_PORT, \
(*ppGroup)->storage_port, \
GROUP_ITEM_STORAGE_HTTP_PORT, \
(*ppGroup)->storage_http_port, \
GROUP_ITEM_STORE_PATH_COUNT, \
(*ppGroup)->store_path_count, \
GROUP_ITEM_SUBDIR_COUNT_PER_PATH, \
(*ppGroup)->subdir_count_per_path, \
GROUP_ITEM_CURRENT_TRUNK_FILE_ID, \
(*ppGroup)->current_trunk_file_id, \
GROUP_ITEM_TRUNK_SERVER, \
(*ppGroup)->pTrunkServer != NULL ? \
(*ppGroup)->pTrunkServer->id : "",
GROUP_ITEM_LAST_TRUNK_SERVER, \
(*ppGroup)->last_trunk_server_id
);
if (fc_safe_write(fd, buff, len) != len)
{
logError("file: "__FILE__", line: %d, " \
"write to file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
break;
}
}
}
if (result == 0)
{
if (fsync(fd) != 0)
{
logError("file: "__FILE__", line: %d, " \
"fsync file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
}
close(fd);
if (result == 0)
{
if (rename(tmpFilename, trueFilename) != 0)
{
logError("file: "__FILE__", line: %d, " \
"rename file \"%s\" to \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, trueFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(trueFilename);
}
if (result != 0)
{
unlink(tmpFilename);
}
tracker_mem_file_unlock();
return result;
}
int tracker_save_storages()
{
char tmpFilename[MAX_PATH_SIZE];
char trueFilename[MAX_PATH_SIZE];
char buff[4096];
char id_buff[128];
int fd;
int len;
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
FDFSStorageDetail **ppStorage;
FDFSStorageDetail **ppStorageEnd;
FDFSStorageDetail *pStorage;
int result;
int count;
tracker_mem_file_lock();
snprintf(trueFilename, sizeof(trueFilename), "%s/data/%s", \
SF_G_BASE_PATH_STR, STORAGE_SERVERS_LIST_FILENAME_NEW);
snprintf(tmpFilename, sizeof(tmpFilename), "%s.tmp", trueFilename);
if ((fd=open(tmpFilename, O_WRONLY | O_CREAT | O_TRUNC, 0644)) < 0)
{
tracker_mem_file_unlock();
logError("file: "__FILE__", line: %d, " \
"open \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
*id_buff = '\0';
count = 0;
result = 0;
ppGroupEnd = g_groups.sorted_groups + g_groups.count;
for (ppGroup=g_groups.sorted_groups; \
(ppGroup < ppGroupEnd) && (result == 0); ppGroup++)
{
ppStorageEnd = (*ppGroup)->all_servers + (*ppGroup)->count;
for (ppStorage=(*ppGroup)->all_servers; \
ppStorage<ppStorageEnd; ppStorage++)
{
pStorage = *ppStorage;
if (pStorage->status == FDFS_STORAGE_STATUS_DELETED
|| pStorage->status == FDFS_STORAGE_STATUS_IP_CHANGED)
{
continue;
}
if (g_use_storage_id)
{
sprintf(id_buff, "\t%s=%s\n",
STORAGE_ITEM_SERVER_ID, pStorage->id);
}
count++;
len = sprintf(buff, \
"# storage %s:%u\n" \
"[%s"STORAGE_SECTION_NO_FORMAT"]\n" \
"%s" \
"\t%s=%s\n" \
"\t%s=%s\n" \
"\t%s=%d\n" \
"\t%s=%s\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%s\n" \
"\t%s=%s\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%"PRId64"\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%d\n" \
"\t%s=%"PRId64"\n\n", \
FDFS_CURRENT_IP_ADDR(pStorage), \
pStorage->storage_port, \
STORAGE_SECTION_NAME_PREFIX, count, id_buff, \
STORAGE_ITEM_GROUP_NAME, \
(*ppGroup)->group_name, \
STORAGE_ITEM_IP_ADDR, FDFS_CURRENT_IP_ADDR(pStorage), \
STORAGE_ITEM_STATUS, pStorage->status, \
STORAGE_ITEM_VERSION, pStorage->version, \
STORAGE_ITEM_JOIN_TIME, \
(int)pStorage->join_time, \
STORAGE_ITEM_STORAGE_PORT, \
pStorage->storage_port, \
STORAGE_ITEM_STORAGE_HTTP_PORT, \
pStorage->storage_http_port, \
STORAGE_ITEM_DOMAIN_NAME, \
pStorage->domain_name, \
STORAGE_ITEM_SYNC_SRC_SERVER, \
(pStorage->psync_src_server != NULL ? \
pStorage->psync_src_server->id: ""), \
STORAGE_ITEM_SYNC_UNTIL_TIMESTAMP, \
(int)pStorage->sync_until_timestamp, \
STORAGE_ITEM_STORE_PATH_COUNT, \
pStorage->store_path_count, \
STORAGE_ITEM_SUBDIR_COUNT_PER_PATH, \
pStorage->subdir_count_per_path, \
STORAGE_ITEM_UPLOAD_PRIORITY, \
pStorage->upload_priority, \
STORAGE_ITEM_TOTAL_MB, pStorage->total_mb, \
STORAGE_ITEM_FREE_MB, pStorage->free_mb, \
STORAGE_ITEM_TOTAL_UPLOAD_COUNT, \
pStorage->stat.total_upload_count, \
STORAGE_ITEM_SUCCESS_UPLOAD_COUNT, \
pStorage->stat.success_upload_count, \
STORAGE_ITEM_TOTAL_APPEND_COUNT, \
pStorage->stat.total_append_count, \
STORAGE_ITEM_SUCCESS_APPEND_COUNT, \
pStorage->stat.success_append_count, \
STORAGE_ITEM_TOTAL_SET_META_COUNT, \
pStorage->stat.total_set_meta_count, \
STORAGE_ITEM_SUCCESS_SET_META_COUNT, \
pStorage->stat.success_set_meta_count, \
STORAGE_ITEM_TOTAL_DELETE_COUNT, \
pStorage->stat.total_delete_count, \
STORAGE_ITEM_SUCCESS_DELETE_COUNT, \
pStorage->stat.success_delete_count, \
STORAGE_ITEM_TOTAL_DOWNLOAD_COUNT, \
pStorage->stat.total_download_count, \
STORAGE_ITEM_SUCCESS_DOWNLOAD_COUNT, \
pStorage->stat.success_download_count, \
STORAGE_ITEM_TOTAL_GET_META_COUNT, \
pStorage->stat.total_get_meta_count, \
STORAGE_ITEM_SUCCESS_GET_META_COUNT, \
pStorage->stat.success_get_meta_count, \
STORAGE_ITEM_TOTAL_CREATE_LINK_COUNT, \
pStorage->stat.total_create_link_count, \
STORAGE_ITEM_SUCCESS_CREATE_LINK_COUNT, \
pStorage->stat.success_create_link_count, \
STORAGE_ITEM_TOTAL_DELETE_LINK_COUNT, \
pStorage->stat.total_delete_link_count, \
STORAGE_ITEM_SUCCESS_DELETE_LINK_COUNT, \
pStorage->stat.success_delete_link_count, \
STORAGE_ITEM_TOTAL_UPLOAD_BYTES, \
pStorage->stat.total_upload_bytes, \
STORAGE_ITEM_SUCCESS_UPLOAD_BYTES, \
pStorage->stat.success_upload_bytes, \
STORAGE_ITEM_TOTAL_APPEND_BYTES, \
pStorage->stat.total_append_bytes, \
STORAGE_ITEM_SUCCESS_APPEND_BYTES, \
pStorage->stat.success_append_bytes, \
STORAGE_ITEM_TOTAL_DOWNLOAD_BYTES, \
pStorage->stat.total_download_bytes, \
STORAGE_ITEM_SUCCESS_DOWNLOAD_BYTES, \
pStorage->stat.success_download_bytes, \
STORAGE_ITEM_TOTAL_SYNC_IN_BYTES, \
pStorage->stat.total_sync_in_bytes, \
STORAGE_ITEM_SUCCESS_SYNC_IN_BYTES, \
pStorage->stat.success_sync_in_bytes, \
STORAGE_ITEM_TOTAL_SYNC_OUT_BYTES, \
pStorage->stat.total_sync_out_bytes, \
STORAGE_ITEM_SUCCESS_SYNC_OUT_BYTES, \
pStorage->stat.success_sync_out_bytes, \
STORAGE_ITEM_TOTAL_FILE_OPEN_COUNT, \
pStorage->stat.total_file_open_count, \
STORAGE_ITEM_SUCCESS_FILE_OPEN_COUNT, \
pStorage->stat.success_file_open_count, \
STORAGE_ITEM_TOTAL_FILE_READ_COUNT, \
pStorage->stat.total_file_read_count, \
STORAGE_ITEM_SUCCESS_FILE_READ_COUNT, \
pStorage->stat.success_file_read_count, \
STORAGE_ITEM_TOTAL_FILE_WRITE_COUNT, \
pStorage->stat.total_file_write_count, \
STORAGE_ITEM_SUCCESS_FILE_WRITE_COUNT, \
pStorage->stat.success_file_write_count, \
STORAGE_ITEM_LAST_SOURCE_UPDATE, \
(int)(pStorage->stat.last_source_update), \
STORAGE_ITEM_LAST_SYNC_UPDATE, \
(int)(pStorage->stat.last_sync_update), \
STORAGE_ITEM_LAST_SYNCED_TIMESTAMP, \
(int)pStorage->stat.last_synced_timestamp, \
STORAGE_ITEM_LAST_HEART_BEAT_TIME, \
(int)pStorage->stat.last_heart_beat_time, \
STORAGE_ITEM_CHANGELOG_OFFSET, \
pStorage->changelog_offset \
);
if (fc_safe_write(fd, buff, len) != len)
{
logError("file: "__FILE__", line: %d, " \
"write to file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
break;
}
}
}
if (result == 0)
{
len = sprintf(buff, \
"\n# global section\n" \
"[%s]\n" \
"\t%s=%d\n", \
STORAGE_SECTION_NAME_GLOBAL, \
STORAGE_ITEM_STORAGE_COUNT, count);
if (fc_safe_write(fd, buff, len) != len)
{
logError("file: "__FILE__", line: %d, " \
"write to file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
}
if (result == 0)
{
if (fsync(fd) != 0)
{
logError("file: "__FILE__", line: %d, " \
"fsync file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
}
close(fd);
if (result == 0)
{
if (rename(tmpFilename, trueFilename) != 0)
{
logError("file: "__FILE__", line: %d, " \
"rename file \"%s\" to \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, trueFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(trueFilename);
}
if (result != 0)
{
unlink(tmpFilename);
}
tracker_mem_file_unlock();
return result;
}
int tracker_save_sync_timestamps()
{
char tmpFilename[MAX_PATH_SIZE];
char trueFilename[MAX_PATH_SIZE];
char buff[512];
int fd;
int len;
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
int **last_sync_timestamps;
int i;
int k;
int result;
tracker_mem_file_lock();
snprintf(trueFilename, sizeof(trueFilename), "%s/data/%s", \
SF_G_BASE_PATH_STR, STORAGE_SYNC_TIMESTAMP_FILENAME);
snprintf(tmpFilename, sizeof(tmpFilename), "%s.tmp", trueFilename);
if ((fd=open(tmpFilename, O_WRONLY | O_CREAT | O_TRUNC, 0644)) < 0)
{
tracker_mem_file_unlock();
logError("file: "__FILE__", line: %d, " \
"open \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
result = 0;
ppGroupEnd = g_groups.sorted_groups + g_groups.count;
for (ppGroup=g_groups.sorted_groups; \
(ppGroup < ppGroupEnd) && (result == 0); ppGroup++)
{
last_sync_timestamps = (*ppGroup)->last_sync_timestamps;
for (i=0; i<(*ppGroup)->count; i++)
{
if ((*ppGroup)->all_servers[i]->status == \
FDFS_STORAGE_STATUS_DELETED \
|| (*ppGroup)->all_servers[i]->status == \
FDFS_STORAGE_STATUS_IP_CHANGED)
{
continue;
}
len = sprintf(buff, "%s%c%s", (*ppGroup)->group_name, \
STORAGE_DATA_FIELD_SEPERATOR, \
(*ppGroup)->all_servers[i]->id);
for (k=0; k<(*ppGroup)->count; k++)
{
if ((*ppGroup)->all_servers[k]->status == \
FDFS_STORAGE_STATUS_DELETED \
|| (*ppGroup)->all_servers[k]->status == \
FDFS_STORAGE_STATUS_IP_CHANGED)
{
continue;
}
len += sprintf(buff + len, "%c%d", \
STORAGE_DATA_FIELD_SEPERATOR, \
last_sync_timestamps[i][k]);
}
*(buff + len) = '\n';
len++;
if (fc_safe_write(fd, buff, len) != len)
{
logError("file: "__FILE__", line: %d, " \
"write to file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
break;
}
}
}
if (result == 0)
{
if (fsync(fd) != 0)
{
logError("file: "__FILE__", line: %d, " \
"fsync file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
}
close(fd);
if (result == 0)
{
if (rename(tmpFilename, trueFilename) != 0)
{
logError("file: "__FILE__", line: %d, " \
"rename file \"%s\" to \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, tmpFilename, trueFilename, \
errno, STRERROR(errno));
result = errno != 0 ? errno : EIO;
}
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(trueFilename);
}
if (result != 0)
{
unlink(tmpFilename);
}
tracker_mem_file_unlock();
return result;
}
int tracker_save_sys_files()
{
int result;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
if ((result=tracker_save_storages()) != 0)
{
return result;
}
return tracker_save_sync_timestamps();
}
static int tracker_open_changlog_file()
{
char data_path[MAX_PATH_SIZE];
char filename[MAX_PATH_SIZE];
snprintf(data_path, sizeof(data_path), "%s/data", SF_G_BASE_PATH_STR);
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 : ENOENT;
}
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(data_path);
}
snprintf(filename, sizeof(filename), "%s/data/%s", \
SF_G_BASE_PATH_STR, STORAGE_SERVERS_CHANGELOG_FILENAME);
changelog_fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644);
if (changelog_fd < 0)
{
logError("file: "__FILE__", line: %d, " \
"open \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, filename, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
g_changelog_fsize = lseek(changelog_fd, 0, SEEK_END);
if (g_changelog_fsize < 0)
{
logError("file: "__FILE__", line: %d, " \
"lseek file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, filename, errno, STRERROR(errno));
return errno != 0 ? errno : EIO;
}
SF_FCHOWN_TO_RUNBY_RETURN_ON_ERROR(changelog_fd, filename);
return 0;
}
static int tracker_mem_init_groups(FDFSGroups *pGroups)
{
int result;
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
pGroups->alloc_size = TRACKER_MEM_ALLOC_ONCE;
pGroups->count = 0;
pGroups->current_write_group = 0;
pGroups->pStoreGroup = NULL;
pGroups->groups = (FDFSGroupInfo **)malloc( \
sizeof(FDFSGroupInfo *) * pGroups->alloc_size);
if (pGroups->groups == NULL)
{
logCrit("file: "__FILE__", line: %d, " \
"malloc %d bytes fail!", __LINE__, \
(int)sizeof(FDFSGroupInfo *) * pGroups->alloc_size);
return errno != 0 ? errno : ENOMEM;
}
memset(pGroups->groups, 0, \
sizeof(FDFSGroupInfo *) * pGroups->alloc_size);
ppGroupEnd = pGroups->groups + pGroups->alloc_size;
for (ppGroup=pGroups->groups; ppGroup<ppGroupEnd; ppGroup++)
{
*ppGroup = (FDFSGroupInfo *)malloc(sizeof(FDFSGroupInfo));
if (*ppGroup == NULL)
{
logCrit("file: "__FILE__", line: %d, " \
"malloc %d bytes fail!", \
__LINE__, (int)sizeof(FDFSGroupInfo));
return errno != 0 ? errno : ENOMEM;
}
memset(*ppGroup, 0, sizeof(FDFSGroupInfo));
}
pGroups->sorted_groups = (FDFSGroupInfo **) \
malloc(sizeof(FDFSGroupInfo *) * pGroups->alloc_size);
if (pGroups->sorted_groups == NULL)
{
free(pGroups->groups);
pGroups->groups = NULL;
logCrit("file: "__FILE__", line: %d, " \
"malloc %d bytes fail!", __LINE__, \
(int)sizeof(FDFSGroupInfo *) * pGroups->alloc_size);
return errno != 0 ? errno : ENOMEM;
}
memset(pGroups->sorted_groups, 0, \
sizeof(FDFSGroupInfo *) * pGroups->alloc_size);
if ((result=tracker_load_data(pGroups)) != 0)
{
return result;
}
return 0;
}
int tracker_mem_init()
{
int result;
if ((result=init_pthread_lock(&mem_thread_lock)) != 0)
{
return result;
}
if ((result=init_pthread_lock(&mem_file_lock)) != 0)
{
return result;
}
if ((result=tracker_open_changlog_file()) != 0)
{
return result;
}
return tracker_mem_init_groups(&g_groups);
}
static void tracker_free_last_sync_timestamps(int **last_sync_timestamps, \
const int alloc_size)
{
int i;
if (last_sync_timestamps != NULL)
{
for (i=0; i<alloc_size; i++)
{
if (last_sync_timestamps[i] != NULL)
{
free(last_sync_timestamps[i]);
last_sync_timestamps[i] = NULL;
}
}
free(last_sync_timestamps);
}
}
static int **tracker_malloc_last_sync_timestamps(const int alloc_size, \
int *err_no)
{
int **results;
int i;
results = (int **)malloc(sizeof(int *) * alloc_size);
if (results == NULL)
{
*err_no = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(int *) * alloc_size);
return NULL;
}
memset(results, 0, sizeof(int *) * alloc_size);
for (i=0; i<alloc_size; i++)
{
results[i] = (int *)malloc(sizeof(int) * alloc_size);
if (results[i] == NULL)
{
*err_no = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(int) * alloc_size);
tracker_free_last_sync_timestamps(results, alloc_size);
return NULL;
}
memset(results[i], 0, sizeof(int) * alloc_size);
}
*err_no = 0;
return results;
}
static void tracker_mem_free_storages(FDFSStorageDetail **servers, const int count)
{
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
ppServerEnd = servers + count;
for (ppServer=servers; ppServer<ppServerEnd; ppServer++)
{
if (*ppServer != NULL)
{
free(*ppServer);
}
}
free(servers);
}
static void tracker_mem_free_group(FDFSGroupInfo *pGroup)
{
if (pGroup->sorted_servers != NULL)
{
free(pGroup->sorted_servers);
pGroup->sorted_servers = NULL;
}
if (pGroup->active_servers != NULL)
{
free(pGroup->active_servers);
pGroup->active_servers = NULL;
}
if (pGroup->all_servers != NULL)
{
tracker_mem_free_storages(pGroup->all_servers, \
pGroup->alloc_size);
pGroup->all_servers = NULL;
}
#ifdef WITH_HTTPD
if (g_http_check_interval > 0)
{
if (pGroup->http_servers != NULL)
{
free(pGroup->http_servers);
pGroup->http_servers = NULL;
}
}
#endif
tracker_free_last_sync_timestamps(pGroup->last_sync_timestamps, \
pGroup->alloc_size);
pGroup->last_sync_timestamps = NULL;
}
static int tracker_mem_init_group(FDFSGroupInfo *pGroup)
{
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
int err_no;
pGroup->alloc_size = TRACKER_MEM_ALLOC_ONCE;
pGroup->count = 0;
pGroup->all_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
if (pGroup->all_servers == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
return errno != 0 ? errno : ENOMEM;
}
memset(pGroup->all_servers, 0, \
sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
ppServerEnd = pGroup->all_servers + pGroup->alloc_size;
for (ppServer=pGroup->all_servers; ppServer<ppServerEnd; ppServer++)
{
*ppServer = (FDFSStorageDetail *)malloc( \
sizeof(FDFSStorageDetail));
if (*ppServer == NULL)
{
tracker_mem_free_group(pGroup);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail));
return errno != 0 ? errno : ENOMEM;
}
memset(*ppServer, 0, sizeof(FDFSStorageDetail));
}
pGroup->sorted_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
if (pGroup->sorted_servers == NULL)
{
tracker_mem_free_group(pGroup);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
return errno != 0 ? errno : ENOMEM;
}
memset(pGroup->sorted_servers, 0, \
sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
pGroup->active_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
if (pGroup->active_servers == NULL)
{
tracker_mem_free_group(pGroup);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
return errno != 0 ? errno : ENOMEM;
}
memset(pGroup->active_servers, 0, \
sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
#ifdef WITH_HTTPD
if (g_http_check_interval <= 0)
{
pGroup->http_servers = pGroup->active_servers;
}
else
{
pGroup->http_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *)*pGroup->alloc_size);
if (pGroup->http_servers == NULL)
{
tracker_mem_free_group(pGroup);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail *) * \
pGroup->alloc_size);
return errno != 0 ? errno : ENOMEM;
}
memset(pGroup->http_servers, 0, \
sizeof(FDFSStorageDetail *) * pGroup->alloc_size);
g_http_servers_dirty = true;
}
#endif
pGroup->last_sync_timestamps = tracker_malloc_last_sync_timestamps( \
pGroup->alloc_size, &err_no);
return err_no;
}
static int tracker_mem_destroy_groups(FDFSGroups *pGroups, const bool saveFiles)
{
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppEnd;
int result;
if (pGroups->groups == NULL)
{
result = 0;
}
else
{
if (saveFiles)
{
result = tracker_save_sys_files();
}
else
{
result = 0;
}
ppEnd = pGroups->groups + pGroups->count;
for (ppGroup=pGroups->groups; ppGroup<ppEnd; ppGroup++)
{
tracker_mem_free_group(*ppGroup);
}
if (pGroups->sorted_groups != NULL)
{
free(pGroups->sorted_groups);
pGroups->sorted_groups = NULL;
}
free(pGroups->groups);
pGroups->groups = NULL;
}
return result;
}
int tracker_mem_destroy()
{
int result;
result = tracker_mem_destroy_groups(&g_groups, true);
if (changelog_fd >= 0)
{
close(changelog_fd);
changelog_fd = -1;
}
if (pthread_mutex_destroy(&mem_thread_lock) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_destroy fail", \
__LINE__);
}
if (pthread_mutex_destroy(&mem_file_lock) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_destroy fail", \
__LINE__);
}
return result;
}
static void tracker_mem_free_groups(FDFSGroupInfo **groups, const int count)
{
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
ppGroupEnd = groups + count;
for (ppGroup=groups; ppGroup<ppGroupEnd; ppGroup++)
{
if (*ppGroup != NULL)
{
free(*ppGroup);
}
}
free(groups);
}
static int tracker_mem_realloc_groups(FDFSGroups *pGroups, const bool bNeedSleep)
{
FDFSGroupInfo **old_groups;
FDFSGroupInfo **old_sorted_groups;
FDFSGroupInfo **new_groups;
FDFSGroupInfo **new_sorted_groups;
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
int new_size;
new_size = pGroups->alloc_size + TRACKER_MEM_ALLOC_ONCE;
new_groups = (FDFSGroupInfo **)malloc(sizeof(FDFSGroupInfo *) * new_size);
if (new_groups == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", \
__LINE__, (int)sizeof(FDFSGroupInfo *) * new_size);
return errno != 0 ? errno : ENOMEM;
}
memset(new_groups, 0, sizeof(FDFSGroupInfo *) * new_size);
ppGroupEnd = new_groups + new_size;
for (ppGroup=new_groups+pGroups->count; ppGroup<ppGroupEnd; ppGroup++)
{
*ppGroup = (FDFSGroupInfo *)malloc(sizeof(FDFSGroupInfo));
if (*ppGroup == NULL)
{
tracker_mem_free_groups(new_groups, new_size);
logCrit("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", \
__LINE__, (int)sizeof(FDFSGroupInfo));
return errno != 0 ? errno : ENOMEM;
}
memset(*ppGroup, 0, sizeof(FDFSGroupInfo));
}
memcpy(new_groups, pGroups->groups, \
sizeof(FDFSGroupInfo *) * pGroups->count);
new_sorted_groups = (FDFSGroupInfo **)malloc( \
sizeof(FDFSGroupInfo *) * new_size);
if (new_sorted_groups == NULL)
{
tracker_mem_free_groups(new_groups, new_size);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", \
__LINE__, (int)sizeof(FDFSGroupInfo *) * new_size);
return errno != 0 ? errno : ENOMEM;
}
memset(new_sorted_groups, 0, sizeof(FDFSGroupInfo *) * new_size);
memcpy(new_sorted_groups, pGroups->sorted_groups, \
sizeof(FDFSGroupInfo *) * pGroups->count);
old_groups = pGroups->groups;
old_sorted_groups = pGroups->sorted_groups;
pGroups->alloc_size = new_size;
pGroups->groups = new_groups;
pGroups->sorted_groups = new_sorted_groups;
if (bNeedSleep)
{
sleep(1);
}
free(old_groups);
free(old_sorted_groups);
return 0;
}
int tracker_get_group_file_count(FDFSGroupInfo *pGroup)
{
int count;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
count = 0;
ppServerEnd = pGroup->all_servers + pGroup->count;
for (ppServer=pGroup->all_servers; ppServer<ppServerEnd; ppServer++)
{
count += (*ppServer)->stat.success_upload_count - \
(*ppServer)->stat.success_delete_count;
}
return count;
}
int tracker_get_group_success_upload_count(FDFSGroupInfo *pGroup)
{
int count;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
count = 0;
ppServerEnd = pGroup->all_servers + pGroup->count;
for (ppServer=pGroup->all_servers; ppServer<ppServerEnd; ppServer++)
{
count += (*ppServer)->stat.success_upload_count;
}
return count;
}
FDFSStorageDetail *tracker_get_group_sync_src_server(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pDestServer)
{
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
ppServerEnd = pGroup->active_servers + pGroup->active_count;
for (ppServer=pGroup->active_servers; ppServer<ppServerEnd; ppServer++)
{
if (strcmp((*ppServer)->id, pDestServer->id) == 0)
{
continue;
}
return *ppServer;
}
return NULL;
}
static int tracker_mem_realloc_store_servers(FDFSGroupInfo *pGroup, \
const int inc_count, const bool bNeedSleep)
{
int result;
FDFSStorageDetail **old_servers;
FDFSStorageDetail **old_sorted_servers;
FDFSStorageDetail **old_active_servers;
int **old_last_sync_timestamps;
FDFSStorageDetail **new_servers;
FDFSStorageDetail **new_sorted_servers;
FDFSStorageDetail **new_active_servers;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
#ifdef WITH_HTTPD
FDFSStorageDetail **old_http_servers;
FDFSStorageDetail **new_http_servers;
#endif
int **new_last_sync_timestamps;
int old_size;
int new_size;
int err_no;
int i;
new_size = pGroup->alloc_size + inc_count + TRACKER_MEM_ALLOC_ONCE;
new_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * new_size);
if (new_servers == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", \
__LINE__, (int)sizeof(FDFSStorageDetail *) * new_size);
return errno != 0 ? errno : ENOMEM;
}
memset(new_servers, 0, sizeof(FDFSStorageDetail *) * new_size);
ppServerEnd = new_servers + new_size;
for (ppServer=new_servers+pGroup->count; ppServer<ppServerEnd; ppServer++)
{
*ppServer = (FDFSStorageDetail *)malloc( \
sizeof(FDFSStorageDetail));
if (*ppServer == NULL)
{
tracker_mem_free_storages(new_servers, new_size);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail));
return errno != 0 ? errno : ENOMEM;
}
memset(*ppServer, 0, sizeof(FDFSStorageDetail));
}
memcpy(new_servers, pGroup->all_servers, \
sizeof(FDFSStorageDetail *) * pGroup->count);
new_sorted_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * new_size);
if (new_sorted_servers == NULL)
{
free(new_servers);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", \
__LINE__, (int)sizeof(FDFSStorageDetail *) * new_size);
return errno != 0 ? errno : ENOMEM;
}
new_active_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * new_size);
if (new_active_servers == NULL)
{
free(new_servers);
free(new_sorted_servers);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", \
__LINE__, (int)sizeof(FDFSStorageDetail *) * new_size);
return errno != 0 ? errno : ENOMEM;
}
#ifdef WITH_HTTPD
if (g_http_check_interval > 0)
{
new_http_servers = (FDFSStorageDetail **) \
malloc(sizeof(FDFSStorageDetail *) * new_size);
if (new_http_servers == NULL)
{
free(new_servers);
free(new_sorted_servers);
free(new_active_servers);
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail", __LINE__, \
(int)sizeof(FDFSStorageDetail *) * new_size);
return errno != 0 ? errno : ENOMEM;
}
memset(new_http_servers,0,sizeof(FDFSStorageDetail *)*new_size);
memcpy(new_http_servers, pGroup->http_servers, \
sizeof(FDFSStorageDetail *) * pGroup->count);
}
else
{
new_http_servers = NULL;
}
#endif
memset(new_sorted_servers, 0, sizeof(FDFSStorageDetail *) * new_size);
memset(new_active_servers, 0, sizeof(FDFSStorageDetail *) * new_size);
if (pGroup->store_path_count > 0)
{
for (i=pGroup->count; i<new_size; i++)
{
result=tracker_malloc_storage_path_mbs(*(new_servers+i), \
pGroup->store_path_count);
if (result != 0)
{
free(new_servers);
free(new_sorted_servers);
free(new_active_servers);
return result;
}
}
}
memcpy(new_sorted_servers, pGroup->sorted_servers, \
sizeof(FDFSStorageDetail *) * pGroup->count);
memcpy(new_active_servers, pGroup->active_servers, \
sizeof(FDFSStorageDetail *) * pGroup->count);
new_last_sync_timestamps = tracker_malloc_last_sync_timestamps( \
new_size, &err_no);
if (new_last_sync_timestamps == NULL)
{
free(new_servers);
free(new_sorted_servers);
free(new_active_servers);
return err_no;
}
for (i=0; i<pGroup->alloc_size; i++)
{
memcpy(new_last_sync_timestamps[i], \
pGroup->last_sync_timestamps[i], \
(int)sizeof(int) * pGroup->alloc_size);
}
old_size = pGroup->alloc_size;
old_servers = pGroup->all_servers;
old_sorted_servers = pGroup->sorted_servers;
old_active_servers = pGroup->active_servers;
old_last_sync_timestamps = pGroup->last_sync_timestamps;
pGroup->alloc_size = new_size;
pGroup->all_servers = new_servers;
pGroup->sorted_servers = new_sorted_servers;
pGroup->active_servers = new_active_servers;
pGroup->last_sync_timestamps = new_last_sync_timestamps;
tracker_mem_find_store_server(pGroup);
if (g_if_leader_self && g_if_use_trunk_file)
{
tracker_mem_find_trunk_server(pGroup, true);
}
#ifdef WITH_HTTPD
if (g_http_check_interval <= 0)
{
old_http_servers = NULL;
pGroup->http_servers = pGroup->active_servers;
}
else
{
old_http_servers = pGroup->http_servers;
pGroup->http_servers = new_http_servers;
g_http_servers_dirty = true;
}
#endif
if (bNeedSleep)
{
sleep(1);
}
free(old_servers);
free(old_sorted_servers);
free(old_active_servers);
#ifdef WITH_HTTPD
if (old_http_servers != NULL)
{
free(old_http_servers);
}
#endif
tracker_free_last_sync_timestamps(old_last_sync_timestamps, \
old_size);
return 0;
}
static int tracker_mem_cmp_by_group_name(const void *p1, const void *p2)
{
return strcmp((*((FDFSGroupInfo **)p1))->group_name,
(*((FDFSGroupInfo **)p2))->group_name);
}
static int tracker_mem_cmp_by_storage_id(const void *p1, const void *p2)
{
return strcmp((*((FDFSStorageDetail **)p1))->id,
(*((FDFSStorageDetail **)p2))->id);
}
static void tracker_mem_insert_into_sorted_servers( \
FDFSStorageDetail *pTargetServer, \
FDFSStorageDetail **sorted_servers, const int count)
{
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppEnd;
ppEnd = sorted_servers + count;
for (ppServer=ppEnd; ppServer>sorted_servers; ppServer--)
{
if (strcmp(pTargetServer->id, (*(ppServer-1))->id) > 0)
{
break;
}
else
{
*ppServer = *(ppServer-1);
}
}
*ppServer = pTargetServer;
}
static void tracker_mem_insert_into_sorted_groups(FDFSGroups *pGroups, \
FDFSGroupInfo *pTargetGroup)
{
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppEnd;
ppEnd = pGroups->sorted_groups + pGroups->count;
for (ppGroup=ppEnd; ppGroup > pGroups->sorted_groups; ppGroup--)
{
if (strcmp(pTargetGroup->group_name, \
(*(ppGroup-1))->group_name) > 0)
{
*ppGroup = pTargetGroup;
return;
}
else
{
*ppGroup = *(ppGroup-1);
}
}
*ppGroup = pTargetGroup;
}
FDFSGroupInfo *tracker_mem_get_group_ex(FDFSGroups *pGroups, \
const char *group_name)
{
FDFSGroupInfo target_groups;
FDFSGroupInfo *pTargetGroups;
FDFSGroupInfo **ppGroup;
memset(&target_groups, 0, sizeof(target_groups));
strcpy(target_groups.group_name, group_name);
pTargetGroups = &target_groups;
ppGroup = (FDFSGroupInfo **)bsearch(&pTargetGroups, \
pGroups->sorted_groups, \
pGroups->count, sizeof(FDFSGroupInfo *), \
tracker_mem_cmp_by_group_name);
if (ppGroup != NULL)
{
return *ppGroup;
}
else
{
return NULL;
}
}
static int tracker_mem_add_group_ex(FDFSGroups *pGroups, \
TrackerClientInfo *pClientInfo, const char *group_name, \
const bool bNeedSleep, bool *bInserted)
{
FDFSGroupInfo *pGroup;
int result;
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
do
{
result = 0;
*bInserted = false;
pGroup = tracker_mem_get_group_ex(pGroups, group_name);
if (pGroup != NULL)
{
break;
}
if (pGroups->count >= pGroups->alloc_size)
{
result = tracker_mem_realloc_groups(pGroups, bNeedSleep);
if (result != 0)
{
break;
}
}
pGroup = *(pGroups->groups + pGroups->count);
result = tracker_mem_init_group(pGroup);
if (result != 0)
{
break;
}
strcpy(pGroup->group_name, group_name);
tracker_mem_insert_into_sorted_groups(pGroups, pGroup);
pGroups->count++;
if ((pGroups->store_lookup == \
FDFS_STORE_LOOKUP_SPEC_GROUP) && \
(pGroups->pStoreGroup == NULL) && \
(strcmp(pGroups->store_group, \
pGroup->group_name) == 0))
{
pGroups->pStoreGroup = pGroup;
}
*bInserted = true;
} while (0);
if (pthread_mutex_unlock(&mem_thread_lock) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail", \
__LINE__);
}
if (result != 0)
{
return result;
}
pClientInfo->pGroup = pGroup;
return 0;
}
static FDFSStorageDetail *tracker_mem_get_active_storage_by_id( \
FDFSGroupInfo *pGroup, const char *id)
{
FDFSStorageDetail target_storage;
FDFSStorageDetail *pTargetStorage;
FDFSStorageDetail **ppStorageServer;
if (id == NULL)
{
return NULL;
}
memset(&target_storage, 0, sizeof(target_storage));
strcpy(target_storage.id, id);
pTargetStorage = &target_storage;
ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetStorage, \
pGroup->active_servers, \
pGroup->active_count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer != NULL)
{
return *ppStorageServer;
}
else
{
return NULL;
}
}
static FDFSStorageDetail *tracker_mem_get_active_storage_by_ip( \
FDFSGroupInfo *pGroup, const char *ip_addr)
{
FDFSStorageIdInfo *pStorageId;
if (!g_use_storage_id)
{
return tracker_mem_get_active_storage_by_id(pGroup, ip_addr);
}
pStorageId = fdfs_get_storage_id_by_ip(pGroup->group_name, ip_addr);
if (pStorageId == NULL)
{
return NULL;
}
return tracker_mem_get_active_storage_by_id(pGroup, pStorageId->id);
}
#ifdef WITH_HTTPD
static FDFSStorageDetail *tracker_mem_get_active_http_server_by_ip( \
FDFSGroupInfo *pGroup, const char *ip_addr)
{
FDFSStorageDetail target_storage;
FDFSStorageDetail *pTargetStorage;
FDFSStorageDetail **ppStorageServer;
memset(&target_storage, 0, sizeof(target_storage));
if (!g_use_storage_id)
{
// 当IP地址为IPv6时，其storage_id值为IP地址的short code
if (is_ipv6_addr(ip_addr))
{
fdfs_ip_to_shortcode(ip_addr, target_storage.id);
}
else
{
strcpy(target_storage.id, ip_addr);
}
}
else
{
FDFSStorageIdInfo *pStorageId;
pStorageId = fdfs_get_storage_id_by_ip( \
pGroup->group_name, ip_addr);
if (pStorageId == NULL)
{
return NULL;
}
strcpy(target_storage.id, pStorageId->id);
}
pTargetStorage = &target_storage;
ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetStorage, \
pGroup->http_servers, \
pGroup->http_server_count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer != NULL)
{
return *ppStorageServer;
}
else
{
return NULL;
}
}
static FDFSStorageDetail *tracker_mem_get_active_http_server_by_id( \
FDFSGroupInfo *pGroup, const char *storage_id)
{
FDFSStorageDetail target_storage;
FDFSStorageDetail *pTargetStorage;
FDFSStorageDetail **ppStorageServer;
memset(&target_storage, 0, sizeof(target_storage));
strcpy(target_storage.id, storage_id);
pTargetStorage = &target_storage;
ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetStorage, \
pGroup->http_servers, \
pGroup->http_server_count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer != NULL)
{
return *ppStorageServer;
}
else
{
return NULL;
}
}
#endif
FDFSStorageDetail *tracker_mem_get_storage_by_ip(FDFSGroupInfo *pGroup, \
const char *ip_addr)
{
FDFSStorageId storage_id;
if (g_use_storage_id)
{
FDFSStorageIdInfo *pStorageIdInfo;
pStorageIdInfo = fdfs_get_storage_id_by_ip( \
pGroup->group_name, ip_addr);
if (pStorageIdInfo == NULL)
{
return NULL;
}
storage_id.ptr = pStorageIdInfo->id;
}
else
{
// 当IP地址为IPv6时，其storage_id值为IP地址的short code
if (is_ipv6_addr(ip_addr))
{
storage_id.ptr = fdfs_ip_to_shortcode(ip_addr,
storage_id.holder);
}
else
{
storage_id.ptr = (char *)ip_addr;
}
}
return tracker_mem_get_storage(pGroup, storage_id.ptr);
}
FDFSStorageDetail *tracker_mem_get_storage(FDFSGroupInfo *pGroup, \
const char *id)
{
FDFSStorageDetail target_storage;
FDFSStorageDetail *pTargetStorage;
FDFSStorageDetail **ppStorageServer;
memset(&target_storage, 0, sizeof(target_storage));
strcpy(target_storage.id, id);
pTargetStorage = &target_storage;
ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetStorage, \
pGroup->sorted_servers, \
pGroup->count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer != NULL)
{
return *ppStorageServer;
}
else
{
return NULL;
}
}
static void tracker_mem_clear_storage_fields(FDFSStorageDetail *pStorageServer)
{
if (pStorageServer->path_total_mbs != NULL)
{
memset(pStorageServer->path_total_mbs, 0, sizeof(int64_t) \
* pStorageServer->store_path_count);
}
if (pStorageServer->path_free_mbs != NULL)
{
memset(pStorageServer->path_free_mbs, 0, sizeof(int64_t) \
* pStorageServer->store_path_count);
}
pStorageServer->psync_src_server = NULL;
pStorageServer->sync_until_timestamp = 0;
pStorageServer->total_mb = 0;
pStorageServer->free_mb = 0;
pStorageServer->changelog_offset = 0;
pStorageServer->store_path_count = 0;
pStorageServer->subdir_count_per_path = 0;
pStorageServer->upload_priority = 0;
pStorageServer->current_write_path = 0;
memset(&(pStorageServer->stat), 0, sizeof(FDFSStorageStat));
}
static int tracker_mem_remove_group(FDFSGroupInfo **groups, FDFSGroupInfo *pGroup)
{
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppEnd;
FDFSGroupInfo **pp;
ppEnd = groups + g_groups.count;
for (ppGroup=groups; ppGroup<ppEnd; ppGroup++)
{
if (*ppGroup == pGroup)
{
break;
}
}
if (ppGroup == ppEnd)
{
return ENOENT;
}
for (pp=ppGroup + 1; pp<ppEnd; pp++)
{
*(pp - 1) = *pp;
}
return 0;
}
int tracker_mem_delete_group(const char *group_name)
{
FDFSGroupInfo *pGroup;
int result;
pGroup = tracker_mem_get_group(group_name);
if (pGroup == NULL)
{
return ENOENT;
}
if (pGroup->count != 0)
{
return EBUSY;
}
pthread_mutex_lock(&mem_thread_lock);
if (pGroup->count != 0)
{
result = EBUSY;
}
else
{
result = tracker_mem_remove_group(g_groups.groups, pGroup);
if (result == 0)
{
result = tracker_mem_remove_group(g_groups.sorted_groups, pGroup);
}
}
if (result == 0)
{
if (g_groups.pStoreGroup == pGroup)
{
g_groups.pStoreGroup = NULL;
}
g_groups.count--;
}
pthread_mutex_unlock(&mem_thread_lock);
if (result != 0)
{
return result;
}
logDebug("file: "__FILE__", line: %d, " \
"delete empty group: %s", \
__LINE__, group_name);
sleep(1);
free(pGroup);
return tracker_save_groups();
}
int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
{
FDFSStorageDetail *pStorageServer;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppEnd;
pStorageServer = tracker_mem_get_storage(pGroup, id);
if (pStorageServer == NULL || pStorageServer->status == \
FDFS_STORAGE_STATUS_IP_CHANGED)
{
return ENOENT;
}
if (pStorageServer->status == FDFS_STORAGE_STATUS_ONLINE || \
pStorageServer->status == FDFS_STORAGE_STATUS_ACTIVE || \
pStorageServer->status == FDFS_STORAGE_STATUS_RECOVERY)
{
return EBUSY;
}
if (pStorageServer->status == FDFS_STORAGE_STATUS_DELETED)
{
return EALREADY;
}
ppEnd = pGroup->all_servers + pGroup->count;
for (ppServer=pGroup->all_servers; ppServer<ppEnd; ppServer++)
{
if ((*ppServer)->psync_src_server != NULL && \
strcmp((*ppServer)->psync_src_server->id, id) == 0)
{
(*ppServer)->psync_src_server = NULL;
}
}
logDebug("file: "__FILE__", line: %d, "
"delete storage server: %s:%u, group: %s",
__LINE__, pStorageServer->ip_addrs.ips[0].address,
pStorageServer->storage_port, pGroup->group_name);
tracker_mem_clear_storage_fields(pStorageServer);
pStorageServer->status = FDFS_STORAGE_STATUS_DELETED;
pGroup->chg_count++;
tracker_write_to_changelog(pGroup, pStorageServer, NULL);
return 0;
}
int tracker_mem_storage_ip_changed(FDFSGroupInfo *pGroup,
const char *old_storage_ip, const char *new_storage_ip)
{
FDFSStorageDetail *pOldStorageServer;
FDFSStorageDetail *pNewStorageServer;
int result;
bool bInserted;
if (g_use_storage_id)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, do NOT support ip changed adjust " \
"because cluster use server ID instead of " \
"IP address", __LINE__, new_storage_ip);
return EOPNOTSUPP;
}
pOldStorageServer = tracker_mem_get_storage(pGroup, old_storage_ip);
if (pOldStorageServer == NULL || pOldStorageServer->status == \
FDFS_STORAGE_STATUS_DELETED)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, old storage server: %s not exists", \
__LINE__, new_storage_ip, old_storage_ip);
return ENOENT;
}
if (pOldStorageServer->status == FDFS_STORAGE_STATUS_ONLINE || \
pOldStorageServer->status == FDFS_STORAGE_STATUS_ACTIVE || \
pOldStorageServer->status == FDFS_STORAGE_STATUS_RECOVERY)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, old storage server: %s is online", \
__LINE__, new_storage_ip, old_storage_ip);
return EBUSY;
}
if (pOldStorageServer->status == FDFS_STORAGE_STATUS_IP_CHANGED)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, old storage server: %s " \
"'s ip address already changed", \
__LINE__, new_storage_ip, old_storage_ip);
return EALREADY;
}
pNewStorageServer = tracker_mem_get_storage(pGroup, new_storage_ip);
if (!(pNewStorageServer == NULL || pNewStorageServer->status == \
FDFS_STORAGE_STATUS_DELETED))
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, new storage server: %s already exists",\
__LINE__, new_storage_ip, new_storage_ip);
return EEXIST;
}
result = _tracker_mem_add_storage(pGroup, &pNewStorageServer, \
new_storage_ip, new_storage_ip, true, true, &bInserted);
if (result != 0)
{
return result;
}
if (!bInserted)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, new storage server: %s already exists",\
__LINE__, new_storage_ip, new_storage_ip);
return EEXIST;
}
pthread_mutex_lock(&mem_thread_lock);
//exchange old and new storage server
snprintf(pOldStorageServer->id, sizeof(pOldStorageServer->id),
"%s", new_storage_ip);
snprintf(pOldStorageServer->ip_addrs.ips[0].address,
sizeof(pOldStorageServer->ip_addrs.ips[0].address),
"%s", new_storage_ip);
snprintf(pNewStorageServer->id, sizeof(pNewStorageServer->id),
"%s", old_storage_ip);
pNewStorageServer->ip_addrs.count = 1;
snprintf(pNewStorageServer->ip_addrs.ips[0].address,
sizeof(pNewStorageServer->ip_addrs.ips[0].address),
"%s", old_storage_ip);
pNewStorageServer->status = FDFS_STORAGE_STATUS_IP_CHANGED;
pGroup->chg_count++;
//need re-sort
qsort(pGroup->sorted_servers, pGroup->count,
sizeof(FDFSStorageDetail *), tracker_mem_cmp_by_storage_id);
pthread_mutex_unlock(&mem_thread_lock);
tracker_write_to_changelog(pGroup, pNewStorageServer, new_storage_ip);
return tracker_save_sys_files();
}
static int tracker_mem_add_storage(TrackerClientInfo *pClientInfo,
const char *id, const char *ip_addr,
const bool bNeedSleep, const bool bNeedLock, bool *bInserted)
{
int result;
FDFSStorageDetail *pStorageServer;
pStorageServer = NULL;
result = _tracker_mem_add_storage(pClientInfo->pGroup,
&pStorageServer, id, ip_addr, bNeedSleep,
bNeedLock, bInserted);
if (result == 0)
{
pClientInfo->pStorage = pStorageServer;
}
return result;
}
static int tracker_mem_add_storage_from_file(FDFSGroups *pGroups,
const char *data_path, TrackerClientInfo *pClientInfo,
const char *group_name, const char *storage_id, char *ip_addr)
{
int result;
bool bInserted;
if (g_use_storage_id)
{
if (storage_id == NULL || *storage_id == '\0')
{
FDFSStorageIdInfo *idInfo;
idInfo = fdfs_get_storage_id_by_ip(group_name, ip_addr);
if (idInfo == NULL)
{
logError("file: "__FILE__", line: %d, "
"in the file \"%s/%s\", "
"group: %s, item \"%s\" is not found or empty, "
"and storage ip %s not configed in storage_ids.conf",
__LINE__, data_path,
STORAGE_SERVERS_LIST_FILENAME_NEW,
group_name, STORAGE_ITEM_SERVER_ID, ip_addr);
return ENOENT;
}
storage_id = idInfo->id;
}
}
if (ip_addr == NULL)
{
logError("file: "__FILE__", line: %d, "
"in the file \"%s/%s\", "
"group: %s, item \"%s\" is not found",
__LINE__, data_path,
STORAGE_SERVERS_LIST_FILENAME_NEW,
group_name, STORAGE_ITEM_IP_ADDR);
return ENOENT;
}
if (*ip_addr == '\0')
{
logWarning("file: "__FILE__", line: %d, "
"in the file \"%s/%s\", "
"group: %s, item \"%s\" is empty",
__LINE__, data_path,
STORAGE_SERVERS_LIST_FILENAME_NEW,
group_name, STORAGE_ITEM_IP_ADDR);
return ENOENT;
}
memset(pClientInfo, 0, sizeof(TrackerClientInfo));
if ((pClientInfo->pGroup=tracker_mem_get_group_ex(pGroups,
group_name)) == NULL)
{
logError("file: "__FILE__", line: %d, "
"in the file \"%s/%s\", "
"group \"%s\" is not found",
__LINE__, data_path,
STORAGE_SERVERS_LIST_FILENAME_NEW,
group_name);
return errno != 0 ? errno : ENOENT;
}
if ((result=tracker_mem_add_storage(pClientInfo, storage_id,
ip_addr, false, false, &bInserted)) != 0)
{
return result;
}
if (!bInserted)
{
logError("file: "__FILE__", line: %d, "
"in the file \"%s/%s\", "
"storage \"%s\" is duplicate",
__LINE__, data_path,
STORAGE_SERVERS_LIST_FILENAME_NEW, ip_addr);
return EEXIST;
}
return 0;
}
static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
FDFSStorageDetail **ppStorageServer, const char *id,
const char *ip_addr, const bool bNeedSleep,
const bool bNeedLock, bool *bInserted)
{
int result;
FDFSStorageId storage_id;
FDFSStorageIdInfo *pStorageIdInfo;
FDFSMultiIP multi_ip;
if (*ip_addr == '\0')
{
logError("file: "__FILE__", line: %d, " \
"ip address is empty!", __LINE__);
return EINVAL;
}
memset(&multi_ip, 0, sizeof(multi_ip));
if (!g_use_storage_id)
{
multi_ip.count = 1;
multi_ip.index = 0;
strcpy(multi_ip.ips[0].address, ip_addr);
}
if (id != NULL)
{
if (g_use_storage_id)
{
pStorageIdInfo = fdfs_get_storage_by_id(id);
if (pStorageIdInfo == NULL)
{
logError("file: "__FILE__", line: %d, "
"storage id: %s not exist in config file, "
"group_name: %s, storage ip: %s", __LINE__,
id, pGroup->group_name, ip_addr);
return ENOENT;
}
if (strcmp(pStorageIdInfo->group_name, pGroup->group_name) != 0)
{
logError("file: "__FILE__", line: %d, "
"check storage id fail, inconsistent group names, "
"id: %s, storage ip: %s, "
"reported group_name: %s != "
"group name in config file: %s", __LINE__,
pGroup->group_name, id, ip_addr,
pStorageIdInfo->group_name);
return EINVAL;
}
multi_ip = pStorageIdInfo->ip_addrs;
}
storage_id.ptr = (char *)id;
}
else if (g_use_storage_id)
{
pStorageIdInfo = fdfs_get_storage_id_by_ip(
pGroup->group_name, ip_addr);
if (pStorageIdInfo == NULL)
{
logError("file: "__FILE__", line: %d, "
"get storage id info fail, "
"group_name: %s, storage ip: %s not exist in config file",
__LINE__, pGroup->group_name, ip_addr);
return ENOENT;
}
multi_ip = pStorageIdInfo->ip_addrs;
storage_id.ptr = pStorageIdInfo->id;
}
else
{
// 当IP地址为IPv6时，其storage_id值为IP地址的short code
if (is_ipv6_addr(ip_addr))
{
storage_id.ptr = fdfs_ip_to_shortcode(ip_addr, storage_id.holder);
}
else
{
storage_id.ptr = (char *)ip_addr;
}
}
if (bNeedLock && (result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
do
{
result = 0;
*bInserted = false;
*ppStorageServer = tracker_mem_get_storage(pGroup, storage_id.ptr);
if (*ppStorageServer != NULL)
{
if (g_use_storage_id)
{
fdfs_set_multi_ip_index(&(*ppStorageServer)->ip_addrs, ip_addr);
}
if ((*ppStorageServer)->status==FDFS_STORAGE_STATUS_DELETED \
|| (*ppStorageServer)->status==FDFS_STORAGE_STATUS_IP_CHANGED)
{
(*ppStorageServer)->status = FDFS_STORAGE_STATUS_INIT;
}
break;
}
if (pGroup->count >= pGroup->alloc_size)
{
result = tracker_mem_realloc_store_servers(
pGroup, 1, bNeedSleep);
if (result != 0)
{
break;
}
}
*ppStorageServer = *(pGroup->all_servers + pGroup->count);
snprintf((*ppStorageServer)->id, FDFS_STORAGE_ID_MAX_SIZE,
"%s", storage_id.ptr);
(*ppStorageServer)->ip_addrs = multi_ip;
if (g_use_storage_id)
{
fdfs_set_multi_ip_index(&(*ppStorageServer)->ip_addrs, ip_addr);
}
tracker_mem_insert_into_sorted_servers(*ppStorageServer,
pGroup->sorted_servers, pGroup->count);
pGroup->count++;
pGroup->chg_count++;
*bInserted = true;
} while (0);
if (bNeedLock && pthread_mutex_unlock(&mem_thread_lock) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail", \
__LINE__);
}
return result;
}
void tracker_calc_running_times(TrackerRunningStatus *pStatus)
{
pStatus->running_time = g_current_time - g_sf_global_vars.up_time;
if (g_tracker_last_status.last_check_time == 0)
{
pStatus->restart_interval = 0;
}
else
{
pStatus->restart_interval = g_sf_global_vars.up_time -
g_tracker_last_status.last_check_time;
}
#define FDFS_TRIM_TIME(t, i) (t / i) * i
pStatus->running_time = FDFS_TRIM_TIME(pStatus->running_time, \
TRACKER_SYNC_STATUS_FILE_INTERVAL);
pStatus->restart_interval = FDFS_TRIM_TIME(pStatus->restart_interval, \
TRACKER_SYNC_STATUS_FILE_INTERVAL);
}
static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
const int file_index, int fd, int64_t *offset, int64_t *file_size)
{
char out_buff[sizeof(TrackerHeader) + 1 + FDFS_PROTO_PKG_LEN_SIZE];
char in_buff[TRACKER_MAX_PACKAGE_SIZE];
TrackerHeader *pHeader;
char *p;
char *pInBuff;
char *pContent;
int64_t in_bytes;
int64_t write_bytes;
int result;
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
pHeader->cmd = TRACKER_PROTO_CMD_TRACKER_GET_ONE_SYS_FILE;
long2buff(1 + FDFS_PROTO_PKG_LEN_SIZE, pHeader->pkg_len);
p = out_buff + sizeof(TrackerHeader);
*p++ = file_index;
long2buff(*offset, p);
if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%u fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
return (result == ENOENT ? EACCES : result);
}
pInBuff = in_buff;
result = fdfs_recv_response(pTrackerServer, &pInBuff, \
sizeof(in_buff), &in_bytes);
if (result != 0)
{
logError("file: "__FILE__", line: %d, "
"fdfs_recv_response fail, result: %d",
__LINE__, result);
return result;
}
if (in_bytes < FDFS_PROTO_PKG_LEN_SIZE)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%u response data " \
"length: %"PRId64" is invalid, " \
"expect length >= %d.", __LINE__, \
pTrackerServer->ip_addr, pTrackerServer->port, \
in_bytes, FDFS_PROTO_PKG_LEN_SIZE);
return EINVAL;
}
*file_size = buff2long(in_buff);
write_bytes = in_bytes - FDFS_PROTO_PKG_LEN_SIZE;
if (*file_size < 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%u, file size: %"PRId64\
" < 0", __LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, *file_size);
return EINVAL;
}
if (*file_size > 0 && write_bytes == 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%u, file size: %"PRId64\
" > 0, but file content is empty", __LINE__, \
pTrackerServer->ip_addr, pTrackerServer->port, \
*file_size);
return EINVAL;
}
pContent = pInBuff + FDFS_PROTO_PKG_LEN_SIZE;
if (write_bytes > 0 &&
fc_safe_write(fd, pContent, write_bytes) != write_bytes)
{
logError("file: "__FILE__", line: %d, " \
"write to file %s fail, " \
"errno: %d, error info: %s", \
__LINE__, g_tracker_sys_filenames[file_index], \
errno, STRERROR(errno));
return errno != 0 ? errno : EIO;
}
*offset += write_bytes;
return 0;
}
static int tracker_mem_get_one_sys_file(ConnectionInfo *pTrackerServer, \
const int file_index)
{
char full_filename[MAX_PATH_SIZE];
int fd;
int result;
int64_t offset;
int64_t file_size;
snprintf(full_filename, sizeof(full_filename), "%s/data/%s", \
SF_G_BASE_PATH_STR, g_tracker_sys_filenames[file_index]);
fd = open(full_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0)
{
logError("file: "__FILE__", line: %d, " \
"open file %s fail, " \
"errno: %d, error info: %s", \
__LINE__, full_filename, \
errno, STRERROR(errno));
return errno != 0 ? errno : EACCES;
}
SF_FCHOWN_TO_RUNBY_RETURN_ON_ERROR(fd, full_filename);
offset = 0;
file_size = 0;
while (1)
{
result = tracker_mem_get_sys_file_piece(pTrackerServer, \
file_index, fd, &offset, &file_size);
if (result != 0)
{
break;
}
if (offset >= file_size)
{
break;
}
}
close(fd);
return result;
}
static int tracker_mem_get_sys_files(TrackerServerInfo *pTrackerServer)
{
ConnectionInfo *conn;
int result;
int index;
fdfs_server_sock_reset(pTrackerServer);
if ((conn=tracker_connect_server(pTrackerServer, &result)) == NULL)
{
return result;
}
if ((result=tracker_get_sys_files_start(conn)) != 0)
{
tracker_close_connection_ex(conn, true);
return result;
}
for (index=0; index<TRACKER_SYS_FILE_COUNT; index++)
{
result = tracker_mem_get_one_sys_file(conn, index);
if (result != 0)
{
break;
}
}
result = tracker_get_sys_files_end(conn);
tracker_close_connection_ex(conn, result != 0);
return result;
}
static int tracker_mem_cmp_tracker_running_status(const void *p1, const void *p2)
{
TrackerRunningStatus *pStatus1;
TrackerRunningStatus *pStatus2;
int sub;
pStatus1 = (TrackerRunningStatus *)p1;
pStatus2 = (TrackerRunningStatus *)p2;
if (pStatus1->if_leader)
{
return 1;
}
else if (pStatus2->if_leader)
{
return -1;
}
sub = pStatus1->running_time - pStatus2->running_time;
if (sub != 0)
{
return sub;
}
return pStatus2->restart_interval - pStatus1->restart_interval;
}
static int find_my_ip_in_tracker_list()
{
const char *current_ip;
const char *previous_ip;
TrackerServerInfo *pServer;
char buff[256];
previous_ip = NULL;
while ((current_ip=get_next_local_ip(previous_ip)) != NULL)
{
pServer = fdfs_tracker_group_get_server(&g_tracker_servers,
current_ip, SF_G_INNER_PORT);
if (pServer != NULL)
{
if (pServer->count > 1)
{
ConnectionInfo *conn;
ConnectionInfo *end;
end = pServer->connections + pServer->count;
for (conn=pServer->connections; conn<end; conn++)
{
insert_into_local_host_ip(conn->ip_addr);
}
}
return 0;
}
previous_ip = current_ip;
}
logError("file: "__FILE__", line: %d, "
"my ip NOT in tracker server list. %s",
__LINE__, local_host_ip_addrs_to_string(buff, sizeof(buff)));
return ENOENT;
}
static int tracker_mem_first_add_tracker_servers(FDFSStorageJoinBody *pJoinBody)
{
TrackerServerInfo *pLocalTracker;
TrackerServerInfo *pLocalEnd;
TrackerServerInfo *servers;
int tracker_count;
int bytes;
tracker_count = pJoinBody->tracker_count;
bytes = sizeof(TrackerServerInfo) * tracker_count;
servers = (TrackerServerInfo *)malloc(bytes);
if (servers == NULL)
{
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, bytes, errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
memcpy(servers, pJoinBody->tracker_servers, bytes);
pLocalEnd = servers + tracker_count;
for (pLocalTracker=servers; pLocalTracker<pLocalEnd; \
pLocalTracker++)
{
fdfs_server_sock_reset(pLocalTracker);
}
g_tracker_servers.servers = servers;
g_tracker_servers.server_count = tracker_count;
return find_my_ip_in_tracker_list();
}
static int tracker_mem_copy_uniq_tracker_servers(
TrackerServerInfo *pSrcServer,
TrackerServerInfo *pDestServer)
{
ConnectionInfo *conn;
ConnectionInfo *end;
end = pSrcServer->connections + pSrcServer->count;
for (conn=pSrcServer->connections; conn<end; conn++)
{
if (!fdfs_server_contain1(pDestServer, conn))
{
if (pDestServer->count == FDFS_MULTI_IP_MAX_COUNT)
{
logError("file: "__FILE__", line: %d, "
"tracker IPs reach max count: %d",
__LINE__, FDFS_MULTI_IP_MAX_COUNT);
return ENOSPC;
}
pDestServer->connections[pDestServer->count++] = *conn;
}
}
return 0;
}
static int tracker_mem_check_add_tracker_servers(FDFSStorageJoinBody *pJoinBody)
{
TrackerServerInfo *pJoinTracker;
TrackerServerInfo *pJoinEnd;
TrackerServerInfo *pLocalTracker;
TrackerServerInfo *pLocalEnd;
TrackerServerInfo *pNewServer;
TrackerServerInfo *new_servers;
char ip_str_join[256];
char ip_str_before[256];
char ip_str_after[256];
int add_count;
int bytes;
add_count = 0;
pLocalEnd = g_tracker_servers.servers + g_tracker_servers.server_count;
pJoinEnd = pJoinBody->tracker_servers + pJoinBody->tracker_count;
for (pJoinTracker=pJoinBody->tracker_servers;
pJoinTracker<pJoinEnd; pJoinTracker++)
{
for (pLocalTracker=g_tracker_servers.servers;
pLocalTracker<pLocalEnd; pLocalTracker++)
{
if (fdfs_server_equal(pJoinTracker, pLocalTracker))
{
break;
}
if (fdfs_server_contain_ex(pJoinTracker, pLocalTracker))
{
fdfs_server_info_to_string(pJoinTracker,
ip_str_join, sizeof(ip_str_join));
fdfs_server_info_to_string(pLocalTracker,
ip_str_before, sizeof(ip_str_before));
logWarning("file: "__FILE__", line: %d, "
"tracker server ips not consistent, "
"join: %s, local: %s", __LINE__,
ip_str_join, ip_str_before);
if (pJoinTracker->count > pLocalTracker->count)
{
if (tracker_mem_copy_uniq_tracker_servers(pJoinTracker,
pLocalTracker) == 0)
{
fdfs_server_info_to_string(pLocalTracker,
ip_str_after, sizeof(ip_str_after));
logInfo("file: "__FILE__", line: %d, "
"merge tracker server ips, before: %s, "
"after: %s", __LINE__,
ip_str_before, ip_str_after);
}
}
break;
}
}
if (pLocalTracker == pLocalEnd)
{
add_count++;
}
}
if (add_count == 0)
{
return 0;
}
if (g_last_tracker_servers != NULL)
{
logError("file: "__FILE__", line: %d, " \
"last tracker servers does not freed, " \
"should try again!", __LINE__);
return EAGAIN;
}
if (g_tracker_servers.server_count + add_count > FDFS_MAX_TRACKERS)
{
logError("file: "__FILE__", line: %d, "
"too many tracker servers: %d",
__LINE__, g_tracker_servers.server_count + add_count);
return ENOSPC;
}
bytes = sizeof(TrackerServerInfo) * (g_tracker_servers.server_count
+ add_count);
new_servers = (TrackerServerInfo *)malloc(bytes);
if (new_servers == NULL)
{
logError("file: "__FILE__", line: %d, "
"malloc %d bytes fail, "
"errno: %d, error info: %s",
__LINE__, bytes, errno, STRERROR(errno));
return errno != 0 ? errno : ENOMEM;
}
memcpy(new_servers, g_tracker_servers.servers, sizeof(TrackerServerInfo) *
g_tracker_servers.server_count);
pNewServer = new_servers + g_tracker_servers.server_count;
for (pJoinTracker=pJoinBody->tracker_servers;
pJoinTracker<pJoinEnd; pJoinTracker++)
{
for (pLocalTracker=new_servers;
pLocalTracker<pNewServer; pLocalTracker++)
{
if (fdfs_server_contain_ex(pJoinTracker, pLocalTracker))
{
break;
}
}
if (pLocalTracker == pNewServer)
{
memcpy(pNewServer, pJoinTracker,
sizeof(TrackerServerInfo));
fdfs_server_sock_reset(pNewServer);
pNewServer++;
}
}
add_count = (pNewServer - new_servers) - g_tracker_servers.server_count;
g_last_tracker_servers = g_tracker_servers.servers;
g_tracker_servers.servers = new_servers;
g_tracker_servers.server_count += add_count;
logInfo("file: "__FILE__", line: %d, "
"add %d tracker servers, total tracker servers: %d",
__LINE__, add_count, g_tracker_servers.server_count);
return find_my_ip_in_tracker_list();
}
static int tracker_mem_get_tracker_server(FDFSStorageJoinBody *pJoinBody, \
TrackerRunningStatus *pTrackerStatus)
{
TrackerServerInfo *pTrackerServer;
TrackerServerInfo *pTrackerEnd;
TrackerRunningStatus *pStatus;
TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS];
int count;
int result;
int r;
int i;
memset(pTrackerStatus, 0, sizeof(TrackerRunningStatus));
pStatus = trackerStatus;
result = 0;
pTrackerEnd = pJoinBody->tracker_servers + pJoinBody->tracker_count;
for (pTrackerServer=pJoinBody->tracker_servers;
pTrackerServer<pTrackerEnd; pTrackerServer++)
{
if (fdfs_server_contain_local_service(pTrackerServer, SF_G_INNER_PORT))
{
continue;
}
pStatus->pTrackerServer = pTrackerServer;
r = fdfs_get_tracker_status(pTrackerServer, pStatus);
if (r == 0)
{
pStatus++;
}
else if (r != ENOENT)
{
result = r;
}
}
count = pStatus - trackerStatus;
if (count == 0)
{
return result == 0 ? ENOENT : result;
}
if (count > 1)
{
qsort(trackerStatus, count, sizeof(TrackerRunningStatus), \
tracker_mem_cmp_tracker_running_status);
}
for (i=0; i<count; i++)
{
logDebug("file: "__FILE__", line: %d, "
"%s:%u leader: %d, running time: %d, "
"restart interval: %d", __LINE__,
trackerStatus[i].pTrackerServer->connections[0].ip_addr,
trackerStatus[i].pTrackerServer->connections[0].port,
trackerStatus[i].if_leader,
trackerStatus[i].running_time,
trackerStatus[i].restart_interval);
}
//copy the last
memcpy(pTrackerStatus, trackerStatus + (count - 1), \
sizeof(TrackerRunningStatus));
return 0;
}
static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
TrackerRunningStatus *pRunningStatus)
{
int result;
TrackerRunningStatus trackerStatus;
TrackerServerInfo *pTrackerServer;
FDFSGroups newGroups;
FDFSGroups tempGroups;
if (pJoinBody->tracker_count == 0)
{
return 0;
}
result = tracker_mem_get_tracker_server(pJoinBody, &trackerStatus);
if (result != 0)
{
return result == ENOENT ? 0 : result;
}
if (pRunningStatus != NULL)
{
if (tracker_mem_cmp_tracker_running_status(pRunningStatus,
&trackerStatus) >= 0)
{
logDebug("file: "__FILE__", line: %d, "
"%s:%u running time: %d, restart interval: %d, "
"my running time: %d, restart interval: %d, "
"do not need sync system files", __LINE__,
trackerStatus.pTrackerServer->connections[0].ip_addr,
trackerStatus.pTrackerServer->connections[0].port,
trackerStatus.running_time,
trackerStatus.restart_interval,
pRunningStatus->running_time,
pRunningStatus->restart_interval);
return 0;
}
}
pTrackerServer = trackerStatus.pTrackerServer;
result = tracker_mem_get_sys_files(pTrackerServer);
if (result != 0)
{
return result;
}
logInfo("file: "__FILE__", line: %d, "
"sys files loaded from tracker server %s:%u",
__LINE__, pTrackerServer->connections[0].ip_addr,
pTrackerServer->connections[0].port);
memset(&newGroups, 0, sizeof(newGroups));
newGroups.store_lookup = g_groups.store_lookup;
newGroups.store_server = g_groups.store_server;
newGroups.download_server = g_groups.download_server;
newGroups.store_path = g_groups.store_path;
strcpy(newGroups.store_group, g_groups.store_group);
if ((result=tracker_mem_init_groups(&newGroups)) != 0)
{
tracker_mem_destroy_groups(&newGroups, false);
return result;
}
memcpy(&tempGroups, &g_groups, sizeof(FDFSGroups));
memcpy(&g_groups, &newGroups, sizeof(FDFSGroups));
usleep(100000);
tracker_mem_destroy_groups(&tempGroups, false);
tracker_write_status_to_file(NULL);
if (changelog_fd >= 0)
{
close(changelog_fd);
changelog_fd = -1;
}
return tracker_open_changlog_file();
}
int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo,
const char *ip_addr, FDFSStorageJoinBody *pJoinBody,
const bool bNeedSleep)
{
int result;
bool bStorageInserted;
bool bGroupInserted;
FDFSStorageDetail *pStorageServer;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppEnd;
FDFSStorageId storage_id;
tracker_mem_file_lock();
if (need_get_sys_files)
{
if (g_tracker_last_status.last_check_time > 0 && g_sf_global_vars.
up_time - g_tracker_last_status.last_check_time >
2 * TRACKER_SYNC_STATUS_FILE_INTERVAL)
{ /* stop time exceeds 2 * interval */
TrackerRunningStatus runningStatus;
runningStatus.if_leader = false;
tracker_calc_running_times(&runningStatus);
result = tracker_mem_get_sys_files_from_others(\
pJoinBody, &runningStatus);
if (result != 0)
{
tracker_mem_file_unlock();
logError("file: "__FILE__", line: %d, "
"get sys files from other trackers fail, errno: %d",
__LINE__, result);
return EAGAIN;
}
get_sys_files_done = true;
}
need_get_sys_files = false;
}
if ((!get_sys_files_done) && (g_groups.count == 0))
{
if (g_groups.count == 0)
{
if ((result=tracker_mem_get_sys_files_from_others( \
pJoinBody, NULL)) != 0)
{
tracker_mem_file_unlock();
logError("file: "__FILE__", line: %d, "
"get sys files from other trackers fail, errno: %d",
__LINE__, result);
return EAGAIN;
}
get_sys_files_done = true;
}
}
if (g_tracker_servers.servers == NULL)
{
result = tracker_mem_first_add_tracker_servers(pJoinBody);
if (result != 0)
{
tracker_mem_file_unlock();
return result;
}
}
else
{
result = tracker_mem_check_add_tracker_servers(pJoinBody);
if (result != 0)
{
tracker_mem_file_unlock();
return result;
}
}
tracker_mem_file_unlock();
if ((result=tracker_mem_add_group_ex(&g_groups, pClientInfo,
pJoinBody->group_name, bNeedSleep, &bGroupInserted)) != 0)
{
return result;
}
if (bGroupInserted)
{
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
if (g_use_storage_id)
{
FDFSStorageIdInfo *pStorageIdInfo;
if (g_trust_storage_server_id && *(pJoinBody->storage_id) != '\0')
{
pStorageIdInfo = fdfs_get_storage_by_id(pJoinBody->storage_id);
if (pStorageIdInfo == NULL)
{
logError("file: "__FILE__", line: %d, "
"get storage id info fail, storage id: %s",
__LINE__, pJoinBody->storage_id);
return ENOENT;
}
}
else
{
pStorageIdInfo = fdfs_get_storage_id_by_ip(
pClientInfo->pGroup->group_name, ip_addr);
if (pStorageIdInfo == NULL)
{
logError("file: "__FILE__", line: %d, "
"get storage id info fail, group_name: %s, "
"storage ip: %s", __LINE__,
pClientInfo->pGroup->group_name, ip_addr);
return ENOENT;
}
}
storage_id.ptr = pStorageIdInfo->id;
}
else
{
// 当IP地址为IPv6时，其storage_id值为IP地址的short code
if (is_ipv6_addr(ip_addr))
{
storage_id.ptr = fdfs_ip_to_shortcode(ip_addr, storage_id.holder);
}
else
{
storage_id.ptr = (char *)ip_addr;
}
}
if (pClientInfo->pGroup->storage_port == 0)
{
pClientInfo->pGroup->storage_port = pJoinBody->storage_port;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
if (pClientInfo->pGroup->storage_port != \
pJoinBody->storage_port)
{
ppEnd = pClientInfo->pGroup->all_servers + \
pClientInfo->pGroup->count;
for (ppServer=pClientInfo->pGroup->all_servers; \
ppServer<ppEnd; ppServer++)
{
if (strcmp((*ppServer)->id, storage_id.ptr) == 0)
{
(*ppServer)->storage_port = \
pJoinBody->storage_port;
break;
}
}
for (ppServer=pClientInfo->pGroup->all_servers; \
ppServer<ppEnd; ppServer++)
{
if ((*ppServer)->storage_port != \
pJoinBody->storage_port)
{
break;
}
}
if (ppServer == ppEnd) //all servers are same, adjust
{
pClientInfo->pGroup->storage_port = \
pJoinBody->storage_port;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, port %d is not same " \
"in the group \"%s\", group port is %d", \
__LINE__, ip_addr, pJoinBody->storage_port, \
pJoinBody->group_name, \
pClientInfo->pGroup->storage_port);
return EINVAL;
}
}
}
if (pClientInfo->pGroup->storage_http_port == 0)
{
pClientInfo->pGroup->storage_http_port = \
pJoinBody->storage_http_port;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
if (pClientInfo->pGroup->storage_http_port != \
pJoinBody->storage_http_port)
{
ppEnd = pClientInfo->pGroup->all_servers + \
pClientInfo->pGroup->count;
for (ppServer=pClientInfo->pGroup->all_servers; \
ppServer<ppEnd; ppServer++)
{
if (strcmp((*ppServer)->id, storage_id.ptr) == 0)
{
(*ppServer)->storage_http_port = \
pJoinBody->storage_http_port;
break;
}
}
for (ppServer=pClientInfo->pGroup->all_servers; \
ppServer<ppEnd; ppServer++)
{
if ((*ppServer)->storage_http_port != \
pJoinBody->storage_http_port)
{
break;
}
}
if (ppServer == ppEnd) //all servers are same, adjust
{
pClientInfo->pGroup->storage_http_port = \
pJoinBody->storage_http_port;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, http port %d is not same " \
"in the group \"%s\", group http port is %d", \
__LINE__, ip_addr, \
pJoinBody->storage_http_port, \
pJoinBody->group_name, \
pClientInfo->pGroup->storage_http_port);
#ifdef WITH_HTTPD
return EINVAL;
#endif
}
}
}
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
pStorageServer = tracker_mem_get_storage(pClientInfo->pGroup,
storage_id.ptr);
if (pthread_mutex_unlock(&mem_thread_lock) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail", \
__LINE__);
}
if (pStorageServer == NULL)
{
if (!pJoinBody->init_flag)
{
if (pJoinBody->status < 0 || \
pJoinBody->status == FDFS_STORAGE_STATUS_DELETED || \
pJoinBody->status == FDFS_STORAGE_STATUS_IP_CHANGED || \
pJoinBody->status == FDFS_STORAGE_STATUS_NONE)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s:%u, invalid storage " \
"status %d, in the group \"%s\"", \
__LINE__, ip_addr, \
pJoinBody->storage_port, \
pJoinBody->status, \
pJoinBody->group_name);
return EFAULT;
}
}
}
if ((result=tracker_mem_add_storage(pClientInfo, storage_id.ptr,
ip_addr, bNeedSleep, true, &bStorageInserted)) != 0)
{
return result;
}
pStorageServer = pClientInfo->pStorage;
pStorageServer->store_path_count = pJoinBody->store_path_count;
pStorageServer->subdir_count_per_path = pJoinBody->subdir_count_per_path;
pStorageServer->upload_priority = pJoinBody->upload_priority;
pStorageServer->join_time = pJoinBody->join_time;
pStorageServer->up_time = pJoinBody->up_time;
snprintf(pStorageServer->version, sizeof(pStorageServer->version), \
"%s", pJoinBody->version);
snprintf(pStorageServer->domain_name, \
sizeof(pStorageServer->domain_name), \
"%s", pJoinBody->domain_name);
pStorageServer->storage_port = pJoinBody->storage_port;
pStorageServer->storage_http_port = pJoinBody->storage_http_port;
if (pClientInfo->pGroup->store_path_count == 0)
{
pClientInfo->pGroup->store_path_count = \
pJoinBody->store_path_count;
if ((result=tracker_malloc_group_path_mbs( \
pClientInfo->pGroup)) != 0)
{
return result;
}
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
if (pClientInfo->pGroup->store_path_count !=
pJoinBody->store_path_count)
{
ppEnd = pClientInfo->pGroup->all_servers +
pClientInfo->pGroup->count;
for (ppServer=pClientInfo->pGroup->all_servers;
ppServer<ppEnd; ppServer++)
{
if ((*ppServer)->status == FDFS_STORAGE_STATUS_DELETED)
{
continue;
}
if ((*ppServer)->store_path_count !=
pJoinBody->store_path_count)
{
break;
}
}
if (ppServer == ppEnd) //all servers are same, adjust
{
if ((result=tracker_realloc_group_path_mbs(
pClientInfo->pGroup, pJoinBody->
store_path_count)) != 0)
{
return result;
}
if ((result=tracker_save_groups()) != 0)
{
return result;
}
logDebug("file: "__FILE__", line: %d, " \
"all storage server's store_path_count " \
"are same, adjust to %d", \
__LINE__, pJoinBody->store_path_count);
}
else if (pJoinBody->store_path_count < \
pClientInfo->pGroup->store_path_count)
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, store_path_count %d less " \
"than that of the group \"%s\", " \
"the group store_path_count is %d", \
__LINE__, ip_addr, \
pJoinBody->store_path_count, \
pJoinBody->group_name, \
pClientInfo->pGroup->store_path_count);
return EINVAL;
}
}
}
if (pClientInfo->pGroup->subdir_count_per_path == 0)
{
pClientInfo->pGroup->subdir_count_per_path = \
pJoinBody->subdir_count_per_path;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
if (pClientInfo->pGroup->subdir_count_per_path != \
pJoinBody->subdir_count_per_path)
{
ppEnd = pClientInfo->pGroup->all_servers + \
pClientInfo->pGroup->count;
for (ppServer=pClientInfo->pGroup->all_servers; \
ppServer<ppEnd; ppServer++)
{
if ((*ppServer)->subdir_count_per_path != \
pJoinBody->subdir_count_per_path)
{
break;
}
}
if (ppServer == ppEnd) //all servers are same, adjust
{
pClientInfo->pGroup->subdir_count_per_path = \
pJoinBody->subdir_count_per_path;
if ((result=tracker_save_groups()) != 0)
{
return result;
}
}
else
{
logError("file: "__FILE__", line: %d, " \
"client ip: %s, subdir_count_per_path %d is " \
"not same in the group \"%s\", " \
"group subdir_count_per_path is %d", \
__LINE__, ip_addr, \
pJoinBody->subdir_count_per_path, \
pJoinBody->group_name,\
pClientInfo->pGroup->subdir_count_per_path);
return EINVAL;
}
}
}
if (bStorageInserted)
{
if ((!pJoinBody->init_flag) && pJoinBody->status > 0)
{
if (pJoinBody->status == FDFS_STORAGE_STATUS_ACTIVE)
{
pStorageServer->status = FDFS_STORAGE_STATUS_ONLINE;
}
else
{
pStorageServer->status = pJoinBody->status;
}
}
if ((result=tracker_save_sys_files()) != 0)
{
return result;
}
}
if (pStorageServer->status == FDFS_STORAGE_STATUS_OFFLINE || \
pStorageServer->status == FDFS_STORAGE_STATUS_RECOVERY)
{
pStorageServer->status = FDFS_STORAGE_STATUS_ONLINE;
}
else if (pStorageServer->status == FDFS_STORAGE_STATUS_INIT)
{
pStorageServer->changelog_offset = g_changelog_fsize;
}
logDebug("file: "__FILE__", line: %d, " \
"storage server %s::%s join in, remain changelog bytes: " \
"%"PRId64, __LINE__, \
pClientInfo->pGroup->group_name, ip_addr, \
g_changelog_fsize - pStorageServer->changelog_offset);
return 0;
}
int tracker_mem_sync_storages(FDFSGroupInfo *pGroup, \
FDFSStorageBrief *briefServers, const int server_count)
{
int result;
FDFSStorageBrief *pServer;
FDFSStorageBrief *pEnd;
FDFSStorageDetail target_storage;
FDFSStorageDetail *pTargetStorage;
FDFSStorageDetail **ppFound;
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
result = 0;
do
{
memset(&target_storage, 0, sizeof(target_storage));
pEnd = briefServers + server_count;
for (pServer=briefServers; pServer<pEnd; pServer++)
{
pServer->id[FDFS_STORAGE_ID_MAX_SIZE - 1] = '\0';
pServer->ip_addr[IP_ADDRESS_SIZE - 1] = '\0';
if (pServer->status == FDFS_STORAGE_STATUS_NONE)
{
continue;
}
memcpy(target_storage.id, pServer->id,
FDFS_STORAGE_ID_MAX_SIZE);
pTargetStorage = &target_storage;
if ((ppFound=(FDFSStorageDetail **)bsearch(
&pTargetStorage,
pGroup->sorted_servers,
pGroup->count,
sizeof(FDFSStorageDetail *),
tracker_mem_cmp_by_storage_id)) != NULL)
{
if ((*ppFound)->status == pServer->status \
|| (*ppFound)->status == \
FDFS_STORAGE_STATUS_INIT \
|| (*ppFound)->status == \
FDFS_STORAGE_STATUS_ONLINE \
|| (*ppFound)->status == \
FDFS_STORAGE_STATUS_ACTIVE
|| (*ppFound)->status == \
FDFS_STORAGE_STATUS_RECOVERY)
{
continue;
}
logWarning("file: "__FILE__", line: %d, "
"storage server: %s:%u, dest status: %d, "
"my status: %d, should change my status!",
__LINE__, FDFS_CURRENT_IP_ADDR(*ppFound),
(*ppFound)->storage_port,
pServer->status, (*ppFound)->status);
if (pServer->status == \
FDFS_STORAGE_STATUS_DELETED
|| pServer->status == \
FDFS_STORAGE_STATUS_IP_CHANGED)
{
(*ppFound)->status = pServer->status;
pGroup->chg_count++;
continue;
}
if (pServer->status > (*ppFound)->status)
{
(*ppFound)->status = pServer->status;
pGroup->chg_count++;
}
}
else if (pServer->status == FDFS_STORAGE_STATUS_DELETED
|| pServer->status == FDFS_STORAGE_STATUS_IP_CHANGED)
{
//ignore deleted storage server
}
else if (pServer->status == FDFS_STORAGE_STATUS_ACTIVE
|| pServer->status == FDFS_STORAGE_STATUS_ONLINE)
{
//ignore online or active storage server
}
else
{
FDFSStorageDetail *pStorageServer;
bool bInserted;
result = _tracker_mem_add_storage(pGroup,
&pStorageServer, pServer->id,
pServer->ip_addr, true, false,
&bInserted);
if (result == 0 && bInserted)
{
pStorageServer->status = pServer->status;
}
}
}
} while (0);
if (pthread_mutex_unlock(&mem_thread_lock) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail", \
__LINE__);
}
return result;
}
static void tracker_mem_find_store_server(FDFSGroupInfo *pGroup)
{
if (pGroup->active_count == 0)
{
pGroup->pStoreServer = NULL;
return;
}
if (g_groups.store_server == FDFS_STORE_SERVER_FIRST_BY_PRI)
{
FDFSStorageDetail **ppEnd;
FDFSStorageDetail **ppServer;
FDFSStorageDetail *pMinPriServer;
pMinPriServer = *(pGroup->active_servers);
ppEnd = pGroup->active_servers + pGroup->active_count;
for (ppServer=pGroup->active_servers+1; ppServer<ppEnd; \
ppServer++)
{
if ((*ppServer)->upload_priority < \
pMinPriServer->upload_priority)
{
pMinPriServer = *ppServer;
}
}
pGroup->pStoreServer = pMinPriServer;
}
else
{
pGroup->pStoreServer = *(pGroup->active_servers);
}
}
static int _storage_get_trunk_binlog_size(
ConnectionInfo *pStorageServer, int64_t *file_size)
{
char out_buff[sizeof(TrackerHeader)];
char in_buff[8];
TrackerHeader *pHeader;
char *pInBuff;
int64_t in_bytes;
int result;
pHeader = (TrackerHeader *)out_buff;
memset(out_buff, 0, sizeof(out_buff));
pHeader->cmd = STORAGE_PROTO_CMD_TRUNK_GET_BINLOG_SIZE;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"storage server %s:%u, send data fail, " \
"errno: %d, error info: %s.", \
__LINE__, pStorageServer->ip_addr, \
pStorageServer->port, \
result, STRERROR(result));
return result;
}
pInBuff = in_buff;
if ((result=fdfs_recv_response(pStorageServer, \
&pInBuff, sizeof(in_buff), &in_bytes)) != 0)
{
logError("file: "__FILE__", line: %d, "
"fdfs_recv_response fail, result: %d",
__LINE__, result);
return result;
}
if (in_bytes != sizeof(in_buff))
{
logError("file: "__FILE__", line: %d, " \
"storage server %s:%u, recv body length: " \
"%"PRId64" != %d", \
__LINE__, pStorageServer->ip_addr, \
pStorageServer->port, in_bytes, (int)sizeof(in_buff));
return EINVAL;
}
*file_size = buff2long(in_buff);
return 0;
}
static int tracker_mem_get_trunk_binlog_size(
const char *storage_ip, const int port, int64_t *file_size)
{
ConnectionInfo storage_server;
ConnectionInfo *conn;
int result;
*file_size = 0;
strcpy(storage_server.ip_addr, storage_ip);
storage_server.port = port;
storage_server.sock = -1;
if ((conn=tracker_make_connection(&storage_server, &result)) == NULL)
{
return result;
}
result = _storage_get_trunk_binlog_size(conn, file_size);
tracker_close_connection_ex(conn, result != 0);
logDebug("file: "__FILE__", line: %d, " \
"storage %s:%u, trunk binlog file size: %"PRId64, \
__LINE__, storage_server.ip_addr, storage_server.port, \
*file_size);
return result;
}
static int tracker_write_to_trunk_change_log(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pLastTrunkServer)
{
char full_filename[MAX_PATH_SIZE];
char buff[256];
int fd;
int len;
struct tm tm;
time_t current_time;
FDFSStorageDetail *pLastTrunk;
tracker_mem_file_lock();
snprintf(full_filename, sizeof(full_filename), "%s/logs/%s", \
SF_G_BASE_PATH_STR, TRUNK_SERVER_CHANGELOG_FILENAME);
if ((fd=open(full_filename, O_WRONLY | O_CREAT | O_APPEND, 0644)) < 0)
{
tracker_mem_file_unlock();
logError("file: "__FILE__", line: %d, " \
"open \"%s\" fail, errno: %d, error info: %s", \
__LINE__, full_filename, errno, STRERROR(errno));
return errno != 0 ? errno : ENOENT;
}
current_time = g_current_time;
localtime_r(&current_time, &tm);
len = sprintf(buff, "[%04d-%02d-%02d %02d:%02d:%02d] %s ", \
tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, \
tm.tm_hour, tm.tm_min, tm.tm_sec, pGroup->group_name);
pLastTrunk = pLastTrunkServer;
if (pLastTrunk == NULL && *(pGroup->last_trunk_server_id) != '\0')
{
pLastTrunk = tracker_mem_get_storage(pGroup, \
pGroup->last_trunk_server_id);
}
if (g_use_storage_id)
{
if (pLastTrunk == NULL)
{
len += sprintf(buff + len, " %s/%s => ",
*(pGroup->last_trunk_server_id) == '\0' ?
"-" : pGroup->last_trunk_server_id, "-");
}
else
{
len += sprintf(buff + len, " %s/%s => ",
pLastTrunk->id, FDFS_CURRENT_IP_ADDR(pLastTrunk));
}
if (pGroup->pTrunkServer == NULL)
{
len += sprintf(buff + len, " %s/%s\n", "-", "-");
}
else
{
len += sprintf(buff + len, " %s/%s\n",
pGroup->pTrunkServer->id,
FDFS_CURRENT_IP_ADDR(pGroup->pTrunkServer));
}
}
else
{
if (pLastTrunk == NULL)
{
len += sprintf(buff + len, " %s => ",
*(pGroup->last_trunk_server_id) == '\0' ?
"-" : pGroup->last_trunk_server_id);
}
else
{
len += sprintf(buff + len, " %s => ",
FDFS_CURRENT_IP_ADDR(pLastTrunk));
}
if (pGroup->pTrunkServer == NULL)
{
len += sprintf(buff + len, " %s\n", "-");
}
else
{
len += sprintf(buff + len, " %s\n",
FDFS_CURRENT_IP_ADDR(pGroup->pTrunkServer));
}
}
if (fc_safe_write(fd, buff, len) != len)
{
logError("file: "__FILE__", line: %d, " \
"write to file \"%s\" fail, " \
"errno: %d, error info: %s", \
__LINE__, full_filename, \
errno, STRERROR(errno));
}
close(fd);
tracker_mem_file_unlock();
return 0;
}
static int tracker_set_trunk_server_and_log(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pNewTrunkServer)
{
FDFSStorageDetail *pLastTrunkServer;
pLastTrunkServer = pGroup->pTrunkServer;
pGroup->pTrunkServer = pNewTrunkServer;
if (pNewTrunkServer == NULL || strcmp(pNewTrunkServer->id, \
pGroup->last_trunk_server_id) != 0)
{
int result;
result = tracker_write_to_trunk_change_log(pGroup, \
pLastTrunkServer);
if (pNewTrunkServer == NULL)
{
*(pGroup->last_trunk_server_id) = '\0';
}
else
{
strcpy(pGroup->last_trunk_server_id, \
pNewTrunkServer->id);
}
return result;
}
return 0;
}
static int tracker_mem_do_set_trunk_server(FDFSGroupInfo *pGroup,
FDFSStorageDetail *pTrunkServer, const bool save)
{
int result;
if (*(pGroup->last_trunk_server_id) != '\0' &&
strcmp(pTrunkServer->id, pGroup->last_trunk_server_id) != 0)
{
if ((result=fdfs_deal_no_body_cmd_ex(
FDFS_CURRENT_IP_ADDR(pTrunkServer),
pGroup->storage_port,
STORAGE_PROTO_CMD_TRUNK_DELETE_BINLOG_MARKS)) != 0)
{
logError("file: "__FILE__", line: %d, "
"fdfs_deal_no_body_cmd_ex fail, result: %d",
__LINE__, result);
return result;
}
}
tracker_set_trunk_server_and_log(pGroup, pTrunkServer);
pGroup->trunk_chg_count++;
g_trunk_server_chg_count++;
logInfo("file: "__FILE__", line: %d, "
"group: %s, trunk server set to %s(%s:%u)", __LINE__,
pGroup->group_name, pGroup->pTrunkServer->id,
FDFS_CURRENT_IP_ADDR(pGroup->pTrunkServer),
pGroup->storage_port);
if (save)
{
return tracker_save_groups();
}
return 0;
}
static int tracker_mem_find_trunk_server(FDFSGroupInfo *pGroup,
const bool save)
{
FDFSStorageDetail *pStoreServer;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
int result;
int64_t file_size;
int64_t max_file_size;
pStoreServer = pGroup->pStoreServer;
if (pStoreServer == NULL)
{
return ENOENT;
}
result = tracker_mem_get_trunk_binlog_size(
FDFS_CURRENT_IP_ADDR(pStoreServer),
pGroup->storage_port, &max_file_size);
if (result != 0)
{
return result;
}
ppServerEnd = pGroup->active_servers + pGroup->active_count;
for (ppServer=pGroup->active_servers; ppServer<ppServerEnd; ppServer++)
{
if (*ppServer == pStoreServer)
{
continue;
}
result = tracker_mem_get_trunk_binlog_size(
FDFS_CURRENT_IP_ADDR(*ppServer),
pGroup->storage_port, &file_size);
if (result != 0)
{
continue;
}
if (file_size > max_file_size)
{
pStoreServer = *ppServer;
}
}
return tracker_mem_do_set_trunk_server(pGroup, pStoreServer, save);
}
const FDFSStorageDetail *tracker_mem_set_trunk_server( \
FDFSGroupInfo *pGroup, const char *pStroageId, int *result)
{
FDFSStorageDetail *pServer;
FDFSStorageDetail *pTrunkServer;
if (!(g_if_leader_self && g_if_use_trunk_file))
{
*result = EOPNOTSUPP;
return NULL;
}
pTrunkServer = pGroup->pTrunkServer;
if (pStroageId == NULL || *pStroageId == '\0')
{
if (pTrunkServer != NULL && pTrunkServer-> \
status == FDFS_STORAGE_STATUS_ACTIVE)
{
*result = 0;
return pTrunkServer;
}
*result = tracker_mem_find_trunk_server(pGroup, true);
if (*result != 0)
{
return NULL;
}
return pGroup->pTrunkServer;
}
if (pTrunkServer != NULL && pTrunkServer->status == \
FDFS_STORAGE_STATUS_ACTIVE)
{
if (strcmp(pStroageId, pTrunkServer->id) == 0)
{
*result = EALREADY;
}
else
{
*result = EEXIST;
}
return pTrunkServer;
}
pServer = tracker_mem_get_storage(pGroup, pStroageId);
if (pServer == NULL)
{
*result = ENOENT;
return NULL;
}
if (pServer->status != FDFS_STORAGE_STATUS_ACTIVE)
{
*result = ENONET;
return NULL;
}
*result = tracker_mem_do_set_trunk_server(pGroup, \
pServer, true);
return *result == 0 ? pGroup->pTrunkServer : NULL;
}
int tracker_mem_deactive_store_server(FDFSGroupInfo *pGroup,
FDFSStorageDetail *pTargetServer)
{
int result;
FDFSStorageDetail **ppStorageServer;
FDFSStorageDetail **ppEnd;
FDFSStorageDetail **ppServer;
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
ppStorageServer = (FDFSStorageDetail **)bsearch( \
&pTargetServer, \
pGroup->active_servers, \
pGroup->active_count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer != NULL)
{
(*ppStorageServer)->chg_count = 0;
(*ppStorageServer)->trunk_chg_count = 0;
ppEnd = pGroup->active_servers + pGroup->active_count - 1;
for (ppServer=ppStorageServer; ppServer<ppEnd; ppServer++)
{
*ppServer = *(ppServer+1);
}
pGroup->active_count--;
pGroup->chg_count++;
#ifdef WITH_HTTPD
if (g_http_check_interval <= 0)
{
pGroup->http_server_count = pGroup->active_count;
}
#endif
}
tracker_mem_find_store_server(pGroup);
if ((result=pthread_mutex_unlock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
return 0;
}
int tracker_mem_active_store_server(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pTargetServer)
{
int result;
FDFSStorageDetail **ppStorageServer;
if ((pTargetServer->status == FDFS_STORAGE_STATUS_WAIT_SYNC) || \
(pTargetServer->status == FDFS_STORAGE_STATUS_SYNCING) || \
(pTargetServer->status == FDFS_STORAGE_STATUS_IP_CHANGED) || \
(pTargetServer->status == FDFS_STORAGE_STATUS_INIT))
{
return 0;
}
/*
if (pTargetServer->status == FDFS_STORAGE_STATUS_DELETED)
{
logError("file: "__FILE__", line: %d, " \
"storage ip: %s already deleted, you can " \
"restart the tracker servers to reset.", \
__LINE__, pTargetServer->ip_addr);
return EAGAIN;
}
*/
pTargetServer->status = FDFS_STORAGE_STATUS_ACTIVE;
ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetServer, \
pGroup->active_servers, \
pGroup->active_count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer != NULL)
{
return 0;
}
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_lock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetServer, \
pGroup->active_servers, \
pGroup->active_count, \
sizeof(FDFSStorageDetail *), \
tracker_mem_cmp_by_storage_id);
if (ppStorageServer == NULL)
{
tracker_mem_insert_into_sorted_servers( \
pTargetServer, pGroup->active_servers, \
pGroup->active_count);
pGroup->active_count++;
pGroup->chg_count++;
#ifdef WITH_HTTPD
if (g_http_check_interval <= 0)
{
pGroup->http_server_count = pGroup->active_count;
}
#endif
if (g_use_storage_id)
{
logDebug("file: "__FILE__", line: %d, "
"storage server %s::%s(%s) now active",
__LINE__, pGroup->group_name,
pTargetServer->id, FDFS_CURRENT_IP_ADDR(pTargetServer));
}
else
{
logDebug("file: "__FILE__", line: %d, "
"storage server %s::%s now active",
__LINE__, pGroup->group_name,
FDFS_CURRENT_IP_ADDR(pTargetServer));
}
}
tracker_mem_find_store_server(pGroup);
if (g_if_leader_self && g_if_use_trunk_file && \
pGroup->pTrunkServer == NULL)
{
tracker_mem_find_trunk_server(pGroup, true);
}
if ((result=pthread_mutex_unlock(&mem_thread_lock)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"call pthread_mutex_unlock fail, " \
"errno: %d, error info: %s", \
__LINE__, result, STRERROR(result));
return result;
}
return 0;
}
void tracker_mem_find_trunk_servers()
{
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
if (!(g_if_leader_self && g_if_use_trunk_file))
{
return;
}
pthread_mutex_lock(&mem_thread_lock);
ppGroupEnd = g_groups.groups + g_groups.count;
for (ppGroup=g_groups.groups; ppGroup<ppGroupEnd; ppGroup++)
{
if ((*ppGroup)->pTrunkServer == NULL)
{
tracker_mem_find_trunk_server(*ppGroup, true);
}
}
g_trunk_server_chg_count++;
pthread_mutex_unlock(&mem_thread_lock);
}
int tracker_mem_offline_store_server(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pStorage)
{
pStorage->up_time = 0;
if ((pStorage->status == FDFS_STORAGE_STATUS_WAIT_SYNC) || \
(pStorage->status == FDFS_STORAGE_STATUS_SYNCING) || \
(pStorage->status == FDFS_STORAGE_STATUS_INIT) || \
(pStorage->status == FDFS_STORAGE_STATUS_DELETED) || \
(pStorage->status == FDFS_STORAGE_STATUS_IP_CHANGED) || \
(pStorage->status == FDFS_STORAGE_STATUS_RECOVERY))
{
return 0;
}
if (g_use_storage_id)
{
logDebug("file: "__FILE__", line: %d, "
"storage server %s::%s (%s) offline",
__LINE__, pGroup->group_name,
pStorage->id, FDFS_CURRENT_IP_ADDR(pStorage));
}
else
{
logDebug("file: "__FILE__", line: %d, "
"storage server %s::%s offline",
__LINE__, pGroup->group_name,
FDFS_CURRENT_IP_ADDR(pStorage));
}
pStorage->status = FDFS_STORAGE_STATUS_OFFLINE;
return tracker_mem_deactive_store_server(pGroup, pStorage);
}
FDFSStorageDetail *tracker_get_writable_storage(FDFSGroupInfo *pStoreGroup)
{
int write_server_index;
if (g_groups.store_server == FDFS_STORE_SERVER_ROUND_ROBIN)
{
write_server_index = pStoreGroup->current_write_server++;
if (pStoreGroup->current_write_server >= \
pStoreGroup->active_count)
{
pStoreGroup->current_write_server = 0;
}
if (write_server_index >= pStoreGroup->active_count)
{
write_server_index = 0;
}
return *(pStoreGroup->active_servers + write_server_index);
}
else //use the first server
{
return pStoreGroup->pStoreServer;
}
}
int tracker_mem_get_storage_by_filename(const byte cmd,FDFS_DOWNLOAD_TYPE_PARAM\
const char *group_name, const char *filename, const int filename_len, \
FDFSGroupInfo **ppGroup, FDFSStorageDetail **ppStoreServers, \
int *server_count)
{
char szIpAddr[IP_ADDRESS_SIZE];
char storage_id[FDFS_STORAGE_ID_MAX_SIZE];
FDFSStorageDetail *pStoreSrcServer;
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
FDFSStorageDetail *pGroupStoreServer;
int file_timestamp;
int storage_ip;
int read_server_index;
int cmp_res;
struct in_addr ip_addr;
time_t current_time;
bool bNormalFile;
*server_count = 0;
*ppGroup = tracker_mem_get_group(group_name);
if (*ppGroup == NULL)
{
logError("file: "__FILE__", line: %d, " \
"invalid group_name: %s", \
__LINE__, group_name);
return ENOENT;
}
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
if ((*ppGroup)->active_count == 0)
{
return ENOENT;
}
}
else
{
if ((*ppGroup)->http_server_count == 0)
{
return ENOENT;
}
}
#else
if ((*ppGroup)->active_count == 0)
{
return ENOENT;
}
#endif
pGroupStoreServer = (*ppGroup)->pStoreServer;
if (pGroupStoreServer == NULL)
{
return ENOENT;
}
//file generated by version < v1.12
if (filename_len < 32 + (FDFS_FILE_EXT_NAME_MAX_LEN + 1))
{
storage_ip = INADDR_NONE;
*storage_id = '\0';
file_timestamp = 0;
bNormalFile = true;
}
else //file generated by version >= v1.12
{
int64_t file_size;
char name_buff[64];
int decoded_len;
base64_decode_auto(&g_fdfs_base64_context, (char *)filename + \
FDFS_LOGIC_FILE_PATH_LEN, FDFS_FILENAME_BASE64_LENGTH, \
name_buff, &decoded_len);
storage_ip = ntohl(buff2int(name_buff));
file_timestamp = buff2int(name_buff+sizeof(int));
file_size = buff2long(name_buff + sizeof (int) * 2);
if (fdfs_get_server_id_type(storage_ip) == FDFS_ID_TYPE_SERVER_ID)
{
sprintf(storage_id, "%d", storage_ip);
}
else
{
*storage_id = '\0';
}
bNormalFile = !(IS_SLAVE_FILE(filename_len, file_size) || \
IS_APPENDER_FILE(file_size));
}
/*
//logInfo("cmd=%d, bNormalFile=%d, storage_ip=%d, storage_id=%s, "
"file_timestamp=%d\n", cmd, bNormalFile, storage_ip,
storage_id, file_timestamp);
*/
memset(szIpAddr, 0, sizeof(szIpAddr));
if (cmd == TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ONE)
{
if (g_groups.download_server == \
FDFS_DOWNLOAD_SERVER_SOURCE_FIRST)
{
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_storage_by_id(\
*ppGroup, storage_id);
}
else
{
memset(&ip_addr, 0, sizeof(ip_addr));
ip_addr.s_addr = storage_ip;
pStoreSrcServer=tracker_mem_get_active_storage_by_ip( \
*ppGroup, inet_ntop(AF_INET, &ip_addr, \
szIpAddr, sizeof(szIpAddr)));
}
}
else
{
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_http_server_by_id( \
*ppGroup, storage_id);
}
else
{
memset(&ip_addr, 0, sizeof(ip_addr));
ip_addr.s_addr = storage_ip;
pStoreSrcServer=tracker_mem_get_active_http_server_by_ip( \
*ppGroup, inet_ntop(AF_INET, &ip_addr, \
szIpAddr, sizeof(szIpAddr)));
}
}
#else
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_storage_by_id(\
*ppGroup, storage_id);
}
else
{
memset(&ip_addr, 0, sizeof(ip_addr));
ip_addr.s_addr = storage_ip;
pStoreSrcServer=tracker_mem_get_active_storage_by_ip(\
*ppGroup, inet_ntop(AF_INET, &ip_addr, \
szIpAddr, sizeof(szIpAddr)));
}
#endif
if (pStoreSrcServer != NULL)
{
ppStoreServers[(*server_count)++] = \
pStoreSrcServer;
return 0;
}
}
//round robin
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
read_server_index = (*ppGroup)->current_read_server;
if (read_server_index >= (*ppGroup)->active_count)
{
read_server_index = 0;
}
ppStoreServers[(*server_count)++]=*((*ppGroup)->active_servers \
+ read_server_index);
}
else
{
read_server_index = (*ppGroup)->current_http_server;
if (read_server_index >= (*ppGroup)->http_server_count)
{
read_server_index = 0;
}
ppStoreServers[(*server_count)++]=*((*ppGroup)->http_servers \
+ read_server_index);
}
#else
read_server_index = (*ppGroup)->current_read_server;
if (read_server_index >= (*ppGroup)->active_count)
{
read_server_index = 0;
}
ppStoreServers[(*server_count)++]=*((*ppGroup)->active_servers \
+ read_server_index);
#endif
/*
//logInfo("filename=%s, storage server ip=%s, " \
"file_timestamp=%d, last_synced_timestamp=%d\n",
filename, ppStoreServers[0]->ip_addr, file_timestamp, \
(int)ppStoreServers[0]->stat.last_synced_timestamp);
*/
do
{
if (bNormalFile)
{
current_time = g_current_time;
if ((file_timestamp < current_time - \
g_storage_sync_file_max_delay) || \
(ppStoreServers[0]->stat.last_synced_timestamp > \
file_timestamp) || \
(ppStoreServers[0]->stat.last_synced_timestamp + 1 >= \
file_timestamp && current_time - file_timestamp > \
g_storage_sync_file_max_time)\
|| (storage_ip == INADDR_NONE \
&& g_groups.store_server == FDFS_STORE_SERVER_ROUND_ROBIN))
{
break;
}
if (storage_ip == INADDR_NONE)
{
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
ppStoreServers[0] = pGroupStoreServer;
break;
}
else
{
pStoreSrcServer=tracker_mem_get_active_storage_by_id(
*ppGroup, pGroupStoreServer->id);
if (pStoreSrcServer != NULL)
{
ppStoreServers[0] = pStoreSrcServer;
break;
}
}
#else
ppStoreServers[0] = pGroupStoreServer;
break;
#endif
}
}
memset(&ip_addr, 0, sizeof(ip_addr));
if (*storage_id != '\0')
{
cmp_res = strcmp(storage_id, ppStoreServers[0]->id);
}
else
{
ip_addr.s_addr = storage_ip;
inet_ntop(AF_INET, &ip_addr, szIpAddr, sizeof(szIpAddr));
cmp_res = strcmp(szIpAddr, FDFS_CURRENT_IP_ADDR(ppStoreServers[0]));
}
if (cmp_res == 0)
{
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
break;
}
else //http
{
if (*storage_id != '\0')
{
if (tracker_mem_get_active_http_server_by_id(
*ppGroup, storage_id) != NULL)
{
break;
}
}
else if (tracker_mem_get_active_http_server_by_ip(
*ppGroup, szIpAddr) != NULL)
{
break;
}
}
#else
break;
#endif
}
if (g_groups.download_server == \
FDFS_DOWNLOAD_SERVER_ROUND_ROBIN)
{ //avoid search again
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_storage_by_id(
*ppGroup, storage_id);
}
else
{
pStoreSrcServer=tracker_mem_get_active_storage_by_ip(
*ppGroup, szIpAddr);
}
}
else //http
{
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_http_server_by_id(
*ppGroup, storage_id);
}
else
{
pStoreSrcServer=tracker_mem_get_active_http_server_by_ip(
*ppGroup, szIpAddr);
}
}
#else
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_storage_by_id(
*ppGroup, storage_id);
}
else
{
pStoreSrcServer=tracker_mem_get_active_storage_by_ip(
*ppGroup, szIpAddr);
}
#endif
if (pStoreSrcServer != NULL)
{
ppStoreServers[0] = pStoreSrcServer;
break;
}
}
if (g_groups.store_server != \
FDFS_STORE_SERVER_ROUND_ROBIN)
{
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
ppStoreServers[0] = pGroupStoreServer;
}
else //http
{
pStoreSrcServer=tracker_mem_get_active_http_server_by_id(
*ppGroup, pGroupStoreServer->id);
if (pStoreSrcServer != NULL)
{
ppStoreServers[0] = pStoreSrcServer;
}
else
{
ppStoreServers[0] = *((*ppGroup)->http_servers);
}
}
#else
ppStoreServers[0] = pGroupStoreServer;
#endif
break;
}
} while (0);
#ifdef WITH_HTTPD
if (download_type == FDFS_DOWNLOAD_TYPE_TCP)
{
(*ppGroup)->current_read_server++;
if ((*ppGroup)->current_read_server >= (*ppGroup)->active_count)
{
(*ppGroup)->current_read_server = 0;
}
}
else //http
{
(*ppGroup)->current_http_server++;
if ((*ppGroup)->current_http_server >= \
(*ppGroup)->http_server_count)
{
(*ppGroup)->current_http_server = 0;
}
}
#else
(*ppGroup)->current_read_server++;
if ((*ppGroup)->current_read_server >= (*ppGroup)->active_count)
{
(*ppGroup)->current_read_server = 0;
}
#endif
}
else if (cmd == TRACKER_PROTO_CMD_SERVICE_QUERY_UPDATE)
{
if (storage_ip != INADDR_NONE)
{
if (*storage_id != '\0')
{
pStoreSrcServer=tracker_mem_get_active_storage_by_id(\
*ppGroup, storage_id);
}
else
{
memset(&ip_addr, 0, sizeof(ip_addr));
ip_addr.s_addr = storage_ip;
pStoreSrcServer=tracker_mem_get_active_storage_by_ip(\
*ppGroup, inet_ntop(AF_INET, &ip_addr, \
szIpAddr, sizeof(szIpAddr)));
}
if (pStoreSrcServer != NULL)
{
ppStoreServers[(*server_count)++] = \
pStoreSrcServer;
return 0;
}
}
ppStoreServers[0] = tracker_get_writable_storage(*ppGroup);
*server_count = ppStoreServers[0] != NULL ? 1 : 0;
}
else //TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ALL
{
memset(szIpAddr, 0, sizeof(szIpAddr));
if (storage_ip != INADDR_NONE)
{
memset(&ip_addr, 0, sizeof(ip_addr));
ip_addr.s_addr = storage_ip;
inet_ntop(AF_INET, &ip_addr,szIpAddr,sizeof(szIpAddr));
}
if (bNormalFile)
{
current_time = g_current_time;
ppServerEnd = (*ppGroup)->active_servers + \
(*ppGroup)->active_count;
for (ppServer=(*ppGroup)->active_servers; \
ppServer<ppServerEnd; ppServer++)
{
if ((file_timestamp < current_time -
g_storage_sync_file_max_delay) ||
((*ppServer)->stat.last_synced_timestamp >
file_timestamp) ||
((*ppServer)->stat.last_synced_timestamp + 1 >=
file_timestamp && current_time - file_timestamp >
g_storage_sync_file_max_time)
|| (storage_ip == INADDR_NONE
&& g_groups.store_server ==
FDFS_STORE_SERVER_ROUND_ROBIN)
|| strcmp(FDFS_CURRENT_IP_ADDR(*ppServer), szIpAddr) == 0)
{
ppStoreServers[(*server_count)++] = *ppServer;
}
}
}
else
{
if (*storage_id != '\0')
{
pStoreSrcServer = tracker_mem_get_active_storage_by_id( \
*ppGroup, storage_id);
}
else
{
pStoreSrcServer = tracker_mem_get_active_storage_by_ip( \
*ppGroup, szIpAddr);
}
if (pStoreSrcServer != NULL)
{
ppStoreServers[(*server_count)++] = \
pStoreSrcServer;
}
}
if (*server_count == 0)
{
ppStoreServers[(*server_count)++] = pGroupStoreServer;
}
}
return *server_count > 0 ? 0 : ENOENT;
}
int tracker_mem_check_alive(void *arg)
{
FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppServerEnd;
FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd;
FDFSStorageDetail *deactiveServers[FDFS_MAX_SERVERS_EACH_GROUP];
int deactiveCount;
time_t current_time;
current_time = g_current_time;
ppGroupEnd = g_groups.groups + g_groups.count;
for (ppGroup=g_groups.groups; ppGroup<ppGroupEnd; ppGroup++)
{
deactiveCount = 0;
ppServerEnd = (*ppGroup)->active_servers + (*ppGroup)->active_count;
for (ppServer=(*ppGroup)->active_servers; ppServer<ppServerEnd; ppServer++)
{
if (current_time - (*ppServer)->stat.last_heart_beat_time > \
g_check_active_interval)
{
deactiveServers[deactiveCount] = *ppServer;
deactiveCount++;
if (deactiveCount >= FDFS_MAX_SERVERS_EACH_GROUP)
{
break;
}
}
}
if (deactiveCount == 0)
{
continue;
}
ppServerEnd = deactiveServers + deactiveCount;
for (ppServer=deactiveServers; ppServer<ppServerEnd; ppServer++)
{
(*ppServer)->status = FDFS_STORAGE_STATUS_OFFLINE;
tracker_mem_deactive_store_server(*ppGroup, *ppServer);
if (g_use_storage_id)
{
logInfo("file: "__FILE__", line: %d, "
"storage server %s(%s:%u) idle too long, "
"status change to offline!", __LINE__,
(*ppServer)->id, FDFS_CURRENT_IP_ADDR(*ppServer),
(*ppGroup)->storage_port);
}
else
{
logInfo("file: "__FILE__", line: %d, "
"storage server %s:%u idle too long, "
"status change to offline!", __LINE__,
FDFS_CURRENT_IP_ADDR(*ppServer),
(*ppGroup)->storage_port);
}
}
}
if ((!g_if_leader_self) || (!g_if_use_trunk_file))
{
return 0;
}
for (ppGroup=g_groups.groups; ppGroup<ppGroupEnd; ppGroup++)
{
if ((*ppGroup)->pTrunkServer != NULL)
{
int check_trunk_times;
int check_trunk_interval;
int last_beat_interval;
if (current_time - (*ppGroup)->pTrunkServer->up_time <= \
10 * g_check_active_interval)
{
if (g_trunk_init_check_occupying)
{
check_trunk_times = 5;
}
else
{
check_trunk_times = 3;
}
if (g_trunk_init_reload_from_binlog)
{
check_trunk_times *= 2;
}
}
else
{
check_trunk_times = 2;
}
last_beat_interval = current_time - (*ppGroup)-> \
pTrunkServer->stat.last_heart_beat_time;
check_trunk_interval = check_trunk_times * \
g_check_active_interval;
if (last_beat_interval > check_trunk_interval)
{
logInfo("file: "__FILE__", line: %d, "
"trunk server %s(%s:%u) offline because idle "
"time: %d s > threshold: %d s, should "
"re-select trunk server", __LINE__,
(*ppGroup)->pTrunkServer->id,
FDFS_CURRENT_IP_ADDR((*ppGroup)->pTrunkServer),
(*ppGroup)->storage_port, last_beat_interval,
check_trunk_interval);
(*ppGroup)->pTrunkServer = NULL;
tracker_mem_find_trunk_server(*ppGroup, false);
if ((*ppGroup)->pTrunkServer == NULL)
{
tracker_set_trunk_server_and_log(*ppGroup, NULL);
}
(*ppGroup)->trunk_chg_count++;
g_trunk_server_chg_count++;
tracker_save_groups();
}
}
else
{
tracker_mem_find_trunk_server(*ppGroup, true);
}
}
return 0;
}
int tracker_mem_get_storage_index(FDFSGroupInfo *pGroup, \
FDFSStorageDetail *pStorage)
{
FDFSStorageDetail **ppStorage;
FDFSStorageDetail **ppEnd;
ppEnd = pGroup->all_servers + pGroup->count;
for (ppStorage=pGroup->all_servers; ppStorage<ppEnd; ppStorage++)
{
if (*ppStorage == pStorage)
{
return ppStorage - pGroup->all_servers;
}
}
logError("file: "__FILE__", line: %d, "
"get index of storage %s fail!!!",
__LINE__, FDFS_CURRENT_IP_ADDR(pStorage));
return -1;
}
Reference in New Issue View Git Blame Copy Permalink