static int storage_convert_src_server_id()
{
ConnectionInfo *pTrackerServer;
ConnectionInfo *pServerEnd;
ConnectionInfo *pTrackerConn;
ConnectionInfo tracker_server;
int result;
result = ENOENT;
pServerEnd = g_tracker_group.servers + g_tracker_group.server_count;
for (pTrackerServer=g_tracker_group.servers; \
pTrackerServer<pServerEnd; pTrackerServer++)
{
memcpy(&tracker_server, pTrackerServer, \
sizeof(ConnectionInfo));
tracker_server.sock = -1;
if ((pTrackerConn=tracker_connect_server(&tracker_server, \
&result)) == NULL)
{
continue;
}
result = tracker_get_storage_id(pTrackerConn, \
g_group_name, g_sync_src_id, g_sync_src_id);
tracker_disconnect_server_ex(pTrackerConn, \
result != 0 && result != ENOENT);
if (result == 0)
{
return 0;
}
}
return result;
}
int CFDFSClient::fdfs_dowloadfile( BufferInfo* pBuff, const char *group_name, const char* remote_filename)
{
char *file_buff = NULL;
int64_t file_size = 0;
int result = 0;
ConnectionInfo *pTrackerServer = tracker_get_connection();
if (pTrackerServer == NULL)
{
result = (errno != 0 ? errno : ECONNREFUSED);
logErrorEx(&g_log_context, "CFDFSClient::init() tracker_get_connection is failed, result:%d", result);
return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
}
// 查询storage 服务地址
ConnectionInfo storageServer;
ConnectionInfo* pStorageServer;
result = tracker_query_storage_fetch(pTrackerServer, \
&storageServer, group_name, remote_filename);
if (result != 0)
{
logErrorEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() tracker_query_storage_fetch fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
tracker_disconnect_server_ex(pTrackerServer, true);
return FSC_ERROR_CODE_QUERY_STORAGE_FAIL;
}
logDebugEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() storage=%s:%d\n", storageServer.ip_addr, \
storageServer.port);
if ((pStorageServer=tracker_connect_server(&storageServer, \
&result)) == NULL)
{
logErrorEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() \
tracker_connect_server failed, result:%d, storage=%s:%d\n",
result, storageServer.ip_addr, \
storageServer.port);
tracker_disconnect_server_ex(pTrackerServer, true);
return FSC_ERROR_CODE_CONNECT_STORAGE_FAIL;
}
int upload(lua_State *L)
{
char *conf_filename;
char *local_filename;
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
ConnectionInfo *pTrackerServer;
int result;
int store_path_index;
ConnectionInfo storageServer;
char file_id[128];
size_t n;
char response[255];
conf_filename = luaL_checklstring(L, 1, &n);
local_filename = luaL_checklstring(L, 2, &n);
log_init();
g_log_context.log_level = LOG_ERR;
ignore_signal_pipe();
if ((result=fdfs_client_init(conf_filename)) != 0)
{
return result;
}
pTrackerServer = tracker_get_connection();
if (pTrackerServer == NULL)
{
fdfs_client_destroy();
return errno != 0 ? errno : ECONNREFUSED;
}
*group_name = '\0';
if ((result=tracker_query_storage_store(pTrackerServer, \
&storageServer, group_name, &store_path_index)) != 0)
{
fdfs_client_destroy();
return result;
}
result = storage_upload_by_filename1(pTrackerServer, \
&storageServer, store_path_index, \
local_filename, NULL, \
NULL, 0, group_name, file_id);
if (result == 0)
{
sprintf(response, "http://%s/%s\n", storageServer.ip_addr, file_id);
lua_pushstring(L, response);
}
tracker_disconnect_server_ex(pTrackerServer, true);
fdfs_client_destroy();
if (result == 0)
return 1;
return result;
}
int tracker_get_storage_max_status(TrackerServerGroup *pTrackerGroup, \
const char *group_name, const char *ip_addr, \
char *storage_id, int *status)
{
ConnectionInfo *conn;
ConnectionInfo tracker_server;
ConnectionInfo *pServer;
ConnectionInfo *pEnd;
FDFSStorageBrief storage_brief;
int result;
memset(&storage_brief, 0, sizeof(FDFSStorageBrief));
storage_brief.status = -1;
*storage_id = '\0';
*status = -1;
pEnd = pTrackerGroup->servers + pTrackerGroup->server_count;
for (pServer=pTrackerGroup->servers; pServer<pEnd; pServer++)
{
memcpy(&tracker_server, pServer, sizeof(ConnectionInfo));
tracker_server.sock = -1;
if ((conn=tracker_connect_server(&tracker_server, &result)) == NULL)
{
return result;
}
result = tracker_get_storage_status(conn, group_name, \
ip_addr, &storage_brief);
tracker_disconnect_server_ex(conn, result != 0);
if (result != 0)
{
if (result == ENOENT)
{
continue;
}
return result;
}
strcpy(storage_id, storage_brief.id);
if (storage_brief.status > *status)
{
*status = storage_brief.status;
}
}
if (*status == -1)
{
return ENOENT;
}
return 0;
}
int fdfs_deal_no_body_cmd_ex(const char *ip_addr, const int port, const int cmd)
{
ConnectionInfo *conn;
ConnectionInfo server_info;
int result;
strcpy(server_info.ip_addr, ip_addr);
server_info.port = port;
server_info.sock = -1;
if ((conn=tracker_connect_server(&server_info, &result)) == NULL)
{
return result;
}
result = fdfs_deal_no_body_cmd(conn, cmd);
tracker_disconnect_server_ex(conn, result != 0);
return result;
}
int storage_disk_recovery_start(const int store_path_index)
{
ConnectionInfo srcStorage;
ConnectionInfo *pStorageConn;
int result;
char *pBasePath;
pBasePath = g_fdfs_store_paths.paths[store_path_index];
if ((result=recovery_init_mark_file(pBasePath, false)) != 0)
{
return result;
}
if ((result=recovery_init_binlog_file(pBasePath)) != 0)
{
return result;
}
if ((result=recovery_get_src_storage_server(&srcStorage)) != 0)
{
if (result == ENOENT)
{
return storage_disk_recovery_finish(pBasePath);
}
else
{
return result;
}
}
while (g_continue_flag)
{
if (storage_report_storage_status(g_my_server_id_str, \
g_tracker_client_ip, FDFS_STORAGE_STATUS_RECOVERY) == 0)
{
break;
}
}
if (!g_continue_flag)
{
return EINTR;
}
if ((pStorageConn=tracker_connect_server(&srcStorage, &result)) == NULL)
{
return result;
}
result = storage_do_fetch_binlog(pStorageConn, store_path_index);
tracker_disconnect_server_ex(pStorageConn, result != 0);
if (result != 0)
{
return result;
}
//set fetch binlog done
if ((result=recovery_init_mark_file(pBasePath, true)) != 0)
{
return result;
}
if ((result=storage_disk_recovery_split_trunk_binlog( \
store_path_index)) != 0)
{
char markFullFilename[MAX_PATH_SIZE];
unlink(recovery_get_mark_filename(pBasePath, markFullFilename));
return result;
}
return 0;
}
int main(int argc, char *argv[])
{
char *conf_filename;
char *local_filename;
ConnectionInfo *pTrackerServer;
ConnectionInfo *pStorageServer;
int result;
ConnectionInfo storageServer;
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char file_id[256];
char appender_file_id[256];
FDFSMetaData meta_list[32];
int meta_count;
char token[32 + 1];
char file_url[256];
char szDatetime[20];
char szPortPart[16];
int url_len;
time_t ts;
int64_t file_offset;
int64_t file_size = 0;
int store_path_index;
FDFSFileInfo file_info;
int upload_type;
const char *file_ext_name;
struct stat stat_buf;
printf("This is FastDFS client test program v%d.%02d\n" \
"\nCopyright (C) 2008, Happy Fish / YuQing\n" \
"\nFastDFS may be copied only under the terms of the GNU General\n" \
"Public License V3, which may be found in the FastDFS source kit.\n" \
"Please visit the FastDFS Home Page http://www.csource.org/ \n" \
"for more detail.\n\n" \
, g_fdfs_version.major, g_fdfs_version.minor);
if (argc < 3)
{
printf("Usage: %s <config_file> <local_filename> " \
"[FILE | BUFF | CALLBACK]\n", argv[0]);
return 1;
}
log_init();
g_log_context.log_level = LOG_DEBUG;
conf_filename = argv[1];
if ((result=fdfs_client_init(conf_filename)) != 0)
{
return result;
}
pTrackerServer = tracker_get_connection();
if (pTrackerServer == NULL)
{
fdfs_client_destroy();
return errno != 0 ? errno : ECONNREFUSED;
}
local_filename = argv[2];
if (argc == 3)
{
upload_type = FDFS_UPLOAD_BY_FILE;
}
else
{
if (strcmp(argv[3], "BUFF") == 0)
{
upload_type = FDFS_UPLOAD_BY_BUFF;
}
else if (strcmp(argv[3], "CALLBACK") == 0)
{
upload_type = FDFS_UPLOAD_BY_CALLBACK;
}
else
{
upload_type = FDFS_UPLOAD_BY_FILE;
}
}
store_path_index = 0;
*group_name = '\0';
if ((result=tracker_query_storage_store(pTrackerServer, \
&storageServer, group_name, &store_path_index)) != 0)
{
fdfs_client_destroy();
printf("tracker_query_storage fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
return result;
}
printf("group_name=%s, ip_addr=%s, port=%d\n", \
group_name, storageServer.ip_addr, \
storageServer.port);
if ((pStorageServer=tracker_connect_server(&storageServer, \
&result)) == NULL)
{
fdfs_client_destroy();
return result;
}
memset(&meta_list, 0, sizeof(meta_list));
meta_count = 0;
strcpy(meta_list[meta_count].name, "ext_name");
strcpy(meta_list[meta_count].value, "jpg");
meta_count++;
strcpy(meta_list[meta_count].name, "width");
strcpy(meta_list[meta_count].value, "160");
meta_count++;
strcpy(meta_list[meta_count].name, "height");
strcpy(meta_list[meta_count].value, "80");
meta_count++;
strcpy(meta_list[meta_count].name, "file_size");
strcpy(meta_list[meta_count].value, "115120");
meta_count++;
file_ext_name = fdfs_get_file_ext_name(local_filename);
if (upload_type == FDFS_UPLOAD_BY_FILE)
{
if (stat(local_filename, &stat_buf) == 0 && \
S_ISREG(stat_buf.st_mode))
{
file_size = stat_buf.st_size;
result = storage_upload_appender_by_filename1( \
pTrackerServer, pStorageServer, \
store_path_index, local_filename, \
file_ext_name, meta_list, meta_count, \
group_name, file_id);
}
else
{
result = errno != 0 ? errno : ENOENT;
}
printf("storage_upload_appender_by_filename1\n");
}
else if (upload_type == FDFS_UPLOAD_BY_BUFF)
{
char *file_content;
if ((result=getFileContent(local_filename, \
&file_content, &file_size)) == 0)
{
result = storage_upload_appender_by_filebuff1( \
pTrackerServer, pStorageServer, \
store_path_index, file_content, \
file_size, file_ext_name, \
meta_list, meta_count, \
group_name, file_id);
free(file_content);
}
printf("storage_upload_appender_by_filebuff1\n");
}
else
{
if (stat(local_filename, &stat_buf) == 0 && \
S_ISREG(stat_buf.st_mode))
{
file_size = stat_buf.st_size;
result = storage_upload_appender_by_callback1( \
pTrackerServer, pStorageServer, \
store_path_index, uploadFileCallback, \
local_filename, file_size, \
file_ext_name, meta_list, meta_count, \
group_name, file_id);
}
else
{
result = errno != 0 ? errno : ENOENT;
}
printf("storage_upload_appender_by_callback1\n");
}
if (result != 0)
{
printf("upload file fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
tracker_disconnect_server_ex(pStorageServer, true);
fdfs_client_destroy();
return result;
}
if (g_tracker_server_http_port == 80)
{
*szPortPart = '\0';
}
else
{
sprintf(szPortPart, ":%d", g_tracker_server_http_port);
}
url_len = sprintf(file_url, "http://%s%s/%s", \
pTrackerServer->ip_addr, szPortPart, file_id);
if (g_anti_steal_token)
{
ts = time(NULL);
fdfs_http_gen_token(&g_anti_steal_secret_key, file_id, \
ts, token);
sprintf(file_url + url_len, "?token=%s&ts=%d", token, (int)ts);
}
printf("fild_id=%s\n", file_id);
fdfs_get_file_info1(file_id, &file_info);
printf("source ip address: %s\n", file_info.source_ip_addr);
printf("file timestamp=%s\n", formatDatetime(
file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
szDatetime, sizeof(szDatetime)));
printf("file size="INT64_PRINTF_FORMAT"\n", file_info.file_size);
printf("file crc32=%u\n", file_info.crc32);
printf("file url: %s\n", file_url);
strcpy(appender_file_id, file_id);
if (storage_truncate_file1(pTrackerServer, pStorageServer, \
appender_file_id, 0) != 0)
{
printf("truncate file fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
tracker_disconnect_server_ex(pStorageServer, true);
fdfs_client_destroy();
return result;
}
fdfs_get_file_info1(file_id, &file_info);
printf("source ip address: %s\n", file_info.source_ip_addr);
printf("file timestamp=%s\n", formatDatetime(
file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
szDatetime, sizeof(szDatetime)));
printf("file size="INT64_PRINTF_FORMAT"\n", file_info.file_size);
printf("file crc32=%u\n", file_info.crc32);
printf("file url: %s\n", file_url);
if (file_info.file_size != 0)
{
fprintf(stderr, "file size: "INT64_PRINTF_FORMAT \
" != 0!!!", file_info.file_size);
}
//sleep(70);
if (upload_type == FDFS_UPLOAD_BY_FILE)
{
result = storage_append_by_filename1(pTrackerServer, \
pStorageServer, local_filename,
appender_file_id);
printf("storage_append_by_filename\n");
}
else if (upload_type == FDFS_UPLOAD_BY_BUFF)
{
char *file_content;
if ((result=getFileContent(local_filename, \
&file_content, &file_size)) == 0)
{
result = storage_append_by_filebuff1(pTrackerServer, \
pStorageServer, file_content, \
file_size, appender_file_id);
free(file_content);
}
printf("storage_append_by_filebuff1\n");
}
else
{
if (stat(local_filename, &stat_buf) == 0 && \
S_ISREG(stat_buf.st_mode))
{
file_size = stat_buf.st_size;
result = storage_append_by_callback1(pTrackerServer, \
pStorageServer, uploadFileCallback, \
local_filename, file_size, \
appender_file_id);
}
else
{
result = errno != 0 ? errno : ENOENT;
}
printf("storage_append_by_callback1\n");
}
if (result != 0)
{
printf("append file fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
tracker_disconnect_server_ex(pStorageServer, true);
fdfs_client_destroy();
return result;
}
printf("append file successfully.\n");
fdfs_get_file_info1(appender_file_id, &file_info);
printf("source ip address: %s\n", file_info.source_ip_addr);
printf("file timestamp=%s\n", formatDatetime(
file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
szDatetime, sizeof(szDatetime)));
printf("file size="INT64_PRINTF_FORMAT"\n", file_info.file_size);
if (file_info.file_size != file_size)
{
fprintf(stderr, "file size: "INT64_PRINTF_FORMAT \
" != "INT64_PRINTF_FORMAT"!!!", file_info.file_size, \
file_size);
}
file_offset = file_size;
if (upload_type == FDFS_UPLOAD_BY_FILE)
{
result = storage_modify_by_filename1(pTrackerServer, \
pStorageServer, local_filename,
file_offset, appender_file_id);
printf("storage_modify_by_filename\n");
}
else if (upload_type == FDFS_UPLOAD_BY_BUFF)
{
char *file_content;
if ((result=getFileContent(local_filename, \
&file_content, &file_size)) == 0)
{
result = storage_modify_by_filebuff1( \
pTrackerServer, pStorageServer, \
file_content, file_offset, file_size, \
appender_file_id);
free(file_content);
}
printf("storage_modify_by_filebuff1\n");
}
else
{
if (stat(local_filename, &stat_buf) == 0 && \
S_ISREG(stat_buf.st_mode))
{
file_size = stat_buf.st_size;
result = storage_modify_by_callback1( \
pTrackerServer, pStorageServer, \
uploadFileCallback, \
local_filename, file_offset, \
file_size, appender_file_id);
}
else
{
result = errno != 0 ? errno : ENOENT;
}
printf("storage_modify_by_callback1\n");
}
if (result != 0)
{
printf("modify file fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
tracker_disconnect_server_ex(pStorageServer, true);
fdfs_client_destroy();
return result;
}
printf("modify file successfully.\n");
fdfs_get_file_info1(appender_file_id, &file_info);
printf("source ip address: %s\n", file_info.source_ip_addr);
printf("file timestamp=%s\n", formatDatetime(
file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
szDatetime, sizeof(szDatetime)));
printf("file size="INT64_PRINTF_FORMAT"\n", file_info.file_size);
if (file_info.file_size != 2 * file_size)
{
fprintf(stderr, "file size: "INT64_PRINTF_FORMAT \
" != "INT64_PRINTF_FORMAT"!!!", file_info.file_size, \
2 * file_size);
}
tracker_disconnect_server_ex(pStorageServer, true);
tracker_disconnect_server_ex(pTrackerServer, true);
fdfs_client_destroy();
return result;
}
int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
const char *group_name, ConnectionInfo *pStorageServer, \
int *store_path_index)
{
TrackerHeader *pHeader;
ConnectionInfo *conn;
bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char in_buff[sizeof(TrackerHeader) + \
TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
char *pInBuff;
int64_t in_bytes;
int result;
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
memset(pStorageServer, 0, sizeof(ConnectionInfo));
pStorageServer->sock = -1;
pHeader = (TrackerHeader *)out_buff;
memset(out_buff, 0, sizeof(out_buff));
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", group_name);
long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ONE;
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, \
g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
pInBuff = in_buff;
result = fdfs_recv_response(conn, \
&pInBuff, sizeof(in_buff), &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
return result;
}
if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid, " \
"expect length: %d", __LINE__, \
pTrackerServer->ip_addr, pTrackerServer->port, \
in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
return EINVAL;
}
memcpy(pStorageServer->ip_addr, in_buff + \
FDFS_GROUP_NAME_MAX_LEN, IP_ADDRESS_SIZE-1);
pStorageServer->port = (int)buff2long(in_buff + \
FDFS_GROUP_NAME_MAX_LEN + IP_ADDRESS_SIZE - 1);
*store_path_index = *(in_buff + FDFS_GROUP_NAME_MAX_LEN + \
IP_ADDRESS_SIZE - 1 + FDFS_PROTO_PKG_LEN_SIZE);
return 0;
}
int tracker_query_storage_store_list_with_group( \
ConnectionInfo *pTrackerServer, const char *group_name, \
ConnectionInfo *storageServers, const int nMaxServerCount, \
int *storage_count, int *store_path_index)
{
ConnectionInfo *pStorageServer;
ConnectionInfo *pServerEnd;
TrackerHeader *pHeader;
ConnectionInfo *conn;
bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char in_buff[sizeof(TrackerHeader) + FDFS_MAX_SERVERS_EACH_GROUP * \
TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
char returned_group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char *pInBuff;
char *p;
int64_t in_bytes;
int out_len;
int ipPortsLen;
int result;
*storage_count = 0;
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
pHeader = (TrackerHeader *)out_buff;
memset(out_buff, 0, sizeof(out_buff));
if (group_name == NULL || *group_name == '\0')
{
pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ALL;
out_len = 0;
}
else
{
pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ALL;
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", group_name);
out_len = FDFS_GROUP_NAME_MAX_LEN;
}
long2buff(out_len, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(TrackerHeader) + out_len, g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
pInBuff = in_buff;
result = fdfs_recv_response(conn, \
&pInBuff, sizeof(in_buff), &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
return result;
}
if (in_bytes < TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid, " \
"expect length >= %d", __LINE__, \
pTrackerServer->ip_addr, pTrackerServer->port, \
in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
return EINVAL;
}
#define RECORD_LENGTH (IP_ADDRESS_SIZE - 1 + FDFS_PROTO_PKG_LEN_SIZE)
ipPortsLen = in_bytes - (FDFS_GROUP_NAME_MAX_LEN + 1);
if (ipPortsLen % RECORD_LENGTH != 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, in_bytes);
return EINVAL;
}
*storage_count = ipPortsLen / RECORD_LENGTH;
if (nMaxServerCount < *storage_count)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response storage server " \
"count: %d, exceeds max server count: %d!", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, *storage_count, nMaxServerCount);
return ENOSPC;
}
memset(storageServers, 0, sizeof(ConnectionInfo) * nMaxServerCount);
memcpy(returned_group_name, in_buff, FDFS_GROUP_NAME_MAX_LEN);
p = in_buff + FDFS_GROUP_NAME_MAX_LEN;
*(returned_group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
pServerEnd = storageServers + (*storage_count);
for (pStorageServer=storageServers; pStorageServer<pServerEnd; \
pStorageServer++)
{
pStorageServer->sock = -1;
memcpy(pStorageServer->ip_addr, p, IP_ADDRESS_SIZE - 1);
p += IP_ADDRESS_SIZE - 1;
pStorageServer->port = (int)buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
}
*store_path_index = *p;
return 0;
}
int tracker_list_groups(ConnectionInfo *pTrackerServer, \
FDFSGroupStat *group_stats, const int max_groups, \
int *group_count)
{
bool new_connection;
TrackerHeader header;
TrackerGroupStat stats[FDFS_MAX_GROUPS];
char *pInBuff;
ConnectionInfo *conn;
TrackerGroupStat *pSrc;
TrackerGroupStat *pEnd;
FDFSGroupStat *pDest;
int result;
int64_t in_bytes;
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
memset(&header, 0, sizeof(header));
header.cmd = TRACKER_PROTO_CMD_SERVER_LIST_ALL_GROUPS;
header.status = 0;
if ((result=tcpsenddata_nb(conn->sock, &header, \
sizeof(header), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
pInBuff = (char *)stats;
result = fdfs_recv_response(conn, \
&pInBuff, sizeof(stats), &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
*group_count = 0;
return result;
}
if (in_bytes % sizeof(TrackerGroupStat) != 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, in_bytes);
*group_count = 0;
return EINVAL;
}
*group_count = in_bytes / sizeof(TrackerGroupStat);
if (*group_count > max_groups)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d insufficent space, " \
"max group count: %d, expect count: %d", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, max_groups, *group_count);
*group_count = 0;
return ENOSPC;
}
memset(group_stats, 0, sizeof(FDFSGroupStat) * max_groups);
pDest = group_stats;
pEnd = stats + (*group_count);
for (pSrc=stats; pSrc<pEnd; pSrc++)
{
memcpy(pDest->group_name, pSrc->group_name, \
FDFS_GROUP_NAME_MAX_LEN);
pDest->total_mb = buff2long(pSrc->sz_total_mb);
pDest->free_mb = buff2long(pSrc->sz_free_mb);
pDest->trunk_free_mb = buff2long(pSrc->sz_trunk_free_mb);
pDest->count= buff2long(pSrc->sz_count);
pDest->storage_port= buff2long(pSrc->sz_storage_port);
pDest->storage_http_port= buff2long(pSrc->sz_storage_http_port);
pDest->active_count = buff2long(pSrc->sz_active_count);
pDest->current_write_server = buff2long( \
pSrc->sz_current_write_server);
pDest->store_path_count = buff2long( \
pSrc->sz_store_path_count);
pDest->subdir_count_per_path = buff2long( \
pSrc->sz_subdir_count_per_path);
pDest->current_trunk_file_id = buff2long( \
pSrc->sz_current_trunk_file_id);
pDest++;
}
return 0;
}
int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
ConnectionInfo *pStorageServer, const int nMaxServerCount, \
int *server_count, char *group_name, const char *filename)
{
TrackerHeader *pHeader;
ConnectionInfo *pServer;
ConnectionInfo *pServerEnd;
ConnectionInfo *conn;
bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 128];
char in_buff[sizeof(TrackerHeader) + \
TRACKER_QUERY_STORAGE_FETCH_BODY_LEN + \
FDFS_MAX_SERVERS_EACH_GROUP * IP_ADDRESS_SIZE];
char *pInBuff;
int64_t in_bytes;
int result;
int filename_len;
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", group_name);
filename_len = snprintf(out_buff + sizeof(TrackerHeader) + \
FDFS_GROUP_NAME_MAX_LEN, \
sizeof(out_buff) - sizeof(TrackerHeader) - \
FDFS_GROUP_NAME_MAX_LEN, "%s", filename);
long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ALL;
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
filename_len, g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
pInBuff = in_buff;
result = fdfs_recv_response(conn, \
&pInBuff, sizeof(in_buff), &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
return result;
}
if ((in_bytes - TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) % \
(IP_ADDRESS_SIZE - 1) != 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, in_bytes);
return EINVAL;
}
*server_count = 1 + (in_bytes - TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) /
(IP_ADDRESS_SIZE - 1);
if (nMaxServerCount < *server_count)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response storage server " \
"count: %d, exceeds max server count: %d!", __LINE__, \
pTrackerServer->ip_addr, pTrackerServer->port, \
*server_count, nMaxServerCount);
return ENOSPC;
}
memset(pStorageServer, 0, nMaxServerCount * sizeof(ConnectionInfo));
pStorageServer->sock = -1;
memcpy(group_name, pInBuff, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
pInBuff += FDFS_GROUP_NAME_MAX_LEN;
memcpy(pStorageServer->ip_addr, pInBuff, IP_ADDRESS_SIZE - 1);
pInBuff += IP_ADDRESS_SIZE - 1;
pStorageServer->port = (int)buff2long(pInBuff);
pInBuff += FDFS_PROTO_PKG_LEN_SIZE;
pServerEnd = pStorageServer + (*server_count);
for (pServer=pStorageServer+1; pServer<pServerEnd; pServer++)
{
pServer->sock = -1;
pServer->port = pStorageServer->port;
memcpy(pServer->ip_addr, pInBuff, IP_ADDRESS_SIZE - 1);
pInBuff += IP_ADDRESS_SIZE - 1;
}
return 0;
}
int main(int argc, char *argv[])
{
char *conf_filename;
char *local_filename;
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
ConnectionInfo *pTrackerServer;
int result;
int store_path_index;
ConnectionInfo storageServer;
char file_id[128];
if (argc < 3)
{
printf("Usage: %s <config_file> <local_filename>\n", argv[0]);
return 1;
}
log_init();
g_log_context.log_level = LOG_ERR;
ignore_signal_pipe();
conf_filename = argv[1];
if ((result=fdfs_client_init(conf_filename)) != 0)
{
return result;
}
pTrackerServer = tracker_get_connection();
if (pTrackerServer == NULL)
{
fdfs_client_destroy();
return errno != 0 ? errno : ECONNREFUSED;
}
*group_name = '\0';
store_path_index = 0;
if ((result=tracker_query_storage_store(pTrackerServer, \
&storageServer, group_name, &store_path_index)) != 0)
{
fdfs_client_destroy();
fprintf(stderr, "tracker_query_storage fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
return result;
}
local_filename = argv[2];
result = storage_upload_appender_by_filename1(pTrackerServer, \
&storageServer, store_path_index, \
local_filename, NULL, \
NULL, 0, group_name, file_id);
if (result != 0)
{
fprintf(stderr, "upload file fail, " \
"error no: %d, error info: %s\n", \
result, STRERROR(result));
tracker_disconnect_server_ex(pTrackerServer, true);
fdfs_client_destroy();
return result;
}
printf("%s\n", file_id);
tracker_disconnect_server_ex(pTrackerServer, true);
fdfs_client_destroy();
return 0;
}
static int recovery_get_src_storage_server(ConnectionInfo *pSrcStorage)
{
int result;
int storage_count;
ConnectionInfo trackerServer;
ConnectionInfo *pTrackerConn;
FDFSGroupStat groupStat;
FDFSStorageInfo storageStats[FDFS_MAX_SERVERS_EACH_GROUP];
FDFSStorageInfo *pStorageStat;
FDFSStorageInfo *pStorageEnd;
memset(pSrcStorage, 0, sizeof(ConnectionInfo));
pSrcStorage->sock = -1;
logDebug("file: "__FILE__", line: %d, " \
"disk recovery: get source storage server", \
__LINE__);
while (g_continue_flag)
{
result = tracker_get_storage_max_status(&g_tracker_group, \
g_group_name, g_tracker_client_ip, \
g_my_server_id_str, &saved_storage_status);
if (result == ENOENT)
{
logWarning("file: "__FILE__", line: %d, " \
"current storage: %s does not exist " \
"in tracker server", __LINE__, \
g_tracker_client_ip);
return ENOENT;
}
if (result == 0)
{
if (saved_storage_status == FDFS_STORAGE_STATUS_INIT)
{
logInfo("file: "__FILE__", line: %d, " \
"current storage: %s 's status is %d" \
", does not need recovery", __LINE__, \
g_tracker_client_ip, \
saved_storage_status);
return ENOENT;
}
if (saved_storage_status == FDFS_STORAGE_STATUS_IP_CHANGED || \
saved_storage_status == FDFS_STORAGE_STATUS_DELETED)
{
logWarning("file: "__FILE__", line: %d, " \
"current storage: %s 's status is %d" \
", does not need recovery", __LINE__, \
g_tracker_client_ip, saved_storage_status);
return ENOENT;
}
break;
}
sleep(1);
}
while (g_continue_flag)
{
if ((pTrackerConn=tracker_get_connection_r(&trackerServer, \
&result)) == NULL)
{
sleep(5);
continue;
}
result = tracker_list_one_group(pTrackerConn, \
g_group_name, &groupStat);
if (result != 0)
{
tracker_disconnect_server_ex(pTrackerConn, true);
sleep(1);
continue;
}
if (groupStat.count <= 0)
{
logWarning("file: "__FILE__", line: %d, " \
"storage server count: %d in the group <= 0!",\
__LINE__, groupStat.count);
tracker_disconnect_server(pTrackerConn);
sleep(1);
continue;
}
if (groupStat.count == 1)
{
logInfo("file: "__FILE__", line: %d, " \
"storage server count in the group = 1, " \
"does not need recovery", __LINE__);
tracker_disconnect_server(pTrackerConn);
return ENOENT;
}
if (g_fdfs_store_paths.count > groupStat.store_path_count)
{
logInfo("file: "__FILE__", line: %d, " \
"storage store path count: %d > " \
"which of the group: %d, " \
"does not need recovery", __LINE__, \
g_fdfs_store_paths.count, groupStat.store_path_count);
tracker_disconnect_server(pTrackerConn);
return ENOENT;
}
if (groupStat.active_count <= 0)
{
tracker_disconnect_server(pTrackerConn);
sleep(5);
continue;
}
result = tracker_list_servers(pTrackerConn, \
g_group_name, NULL, storageStats, \
FDFS_MAX_SERVERS_EACH_GROUP, &storage_count);
tracker_disconnect_server_ex(pTrackerConn, result != 0);
if (result != 0)
{
sleep(5);
continue;
}
if (storage_count <= 1)
{
logWarning("file: "__FILE__", line: %d, " \
"storage server count: %d in the group <= 1!",\
__LINE__, storage_count);
sleep(5);
continue;
}
pStorageEnd = storageStats + storage_count;
for (pStorageStat=storageStats; pStorageStat<pStorageEnd; \
pStorageStat++)
{
if (strcmp(pStorageStat->id, g_my_server_id_str) == 0)
{
continue;
}
if (pStorageStat->status == FDFS_STORAGE_STATUS_ACTIVE)
{
strcpy(pSrcStorage->ip_addr, \
pStorageStat->ip_addr);
pSrcStorage->port = pStorageStat->storage_port;
break;
}
}
if (pStorageStat < pStorageEnd) //found src storage server
{
break;
}
sleep(5);
}
if (!g_continue_flag)
{
return EINTR;
}
logDebug("file: "__FILE__", line: %d, " \
"disk recovery: get source storage server %s:%d", \
__LINE__, pSrcStorage->ip_addr, pSrcStorage->port);
return 0;
}
int fdfs_get_storage_ids_from_tracker_server(ConnectionInfo *pTrackerServer)
{
#define MAX_REQUEST_LOOP 32
TrackerHeader *pHeader;
ConnectionInfo *conn;
char out_buff[sizeof(TrackerHeader) + sizeof(int)];
char *p;
char *response;
struct data_info {
char *buffer; //for free
char *content;
int length;
} data_list[MAX_REQUEST_LOOP];
int list_count;
int total_count;
int current_count;
int result;
int i;
int start_index;
int64_t in_bytes;
if ((conn=tracker_connect_server(pTrackerServer, &result)) == NULL)
{
return result;
}
memset(data_list, 0, sizeof(data_list));
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
p = out_buff + sizeof(TrackerHeader);
pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_FETCH_STORAGE_IDS;
long2buff(sizeof(int), pHeader->pkg_len);
start_index = 0;
list_count = 0;
result = 0;
while (1)
{
int2buff(start_index, p);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(out_buff), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
response = NULL;
result = fdfs_recv_response(conn, \
&response, 0, &in_bytes);
if (result != 0)
{
logError("file: "__FILE__", line: %d, "
"fdfs_recv_response fail, result: %d",
__LINE__, result);
}
}
if (result != 0)
{
break;
}
if (in_bytes < 2 * sizeof(int))
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d, recv data length: %d "\
"is invalid", __LINE__,
pTrackerServer->ip_addr, \
pTrackerServer->port, (int)in_bytes);
result = EINVAL;
break;
}
total_count = buff2int(response);
current_count = buff2int(response + sizeof(int));
if (total_count <= start_index)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d, total storage " \
"count: %d is invalid, which <= start " \
"index: %d", __LINE__, pTrackerServer->ip_addr,\
pTrackerServer->port, total_count, start_index);
result = EINVAL;
break;
}
if (current_count <= 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d, current storage " \
"count: %d is invalid, which <= 0", \
__LINE__, pTrackerServer->ip_addr,\
pTrackerServer->port, current_count);
result = EINVAL;
break;
}
data_list[list_count].buffer = response;
data_list[list_count].content = response + 2 * sizeof(int);
data_list[list_count].length = in_bytes - 2 * sizeof(int);
list_count++;
/*
//logInfo("list_count: %d, total_count: %d, current_count: %d",
list_count, total_count, current_count);
*/
start_index += current_count;
if (start_index >= total_count)
{
break;
}
if (list_count == MAX_REQUEST_LOOP)
{
logError("file: "__FILE__", line: %d, " \
"response data from tracker " \
"server %s:%d is too large", \
__LINE__, pTrackerServer->ip_addr,\
pTrackerServer->port);
result = ENOSPC;
break;
}
}
tracker_disconnect_server_ex(conn, result != 0);
if (result == 0)
{
do
{
int total_length;
char *content;
total_length = 0;
for (i=0; i<list_count; i++)
{
total_length += data_list[i].length;
}
content = (char *)malloc(total_length + 1);
if (content == NULL)
{
result = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, total_length + 1, \
result, STRERROR(result));
break;
}
p = content;
for (i=0; i<list_count; i++)
{
memcpy(p, data_list[i].content, data_list[i].length);
p += data_list[i].length;
}
*p = '\0';
//logInfo("list_count: %d, storage ids:\n%s", list_count, content);
result = fdfs_load_storage_ids(content, \
"storage-ids-from-tracker");
free(content);
} while (0);
}
for (i=0; i<list_count; i++)
{
free(data_list[i].buffer);
}
return result;
}
int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
const char *group_name, const char *ip_addr, \
char *storage_id)
{
TrackerHeader *pHeader;
ConnectionInfo *conn;
bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
IP_ADDRESS_SIZE];
char *p;
int result;
int ip_len;
int64_t in_bytes;
if (storage_id == NULL)
{
return EINVAL;
}
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
if (ip_addr == NULL)
{
ip_len = 0;
}
else
{
ip_len = strlen(ip_addr);
}
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
p = out_buff + sizeof(TrackerHeader);
snprintf(p, sizeof(out_buff) - sizeof(TrackerHeader), "%s", group_name);
p += FDFS_GROUP_NAME_MAX_LEN;
if (ip_len > 0)
{
memcpy(p, ip_addr, ip_len);
p += ip_len;
}
pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_SERVER_ID;
long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
p - out_buff, g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
result = fdfs_recv_response(conn, \
&storage_id, FDFS_STORAGE_ID_MAX_SIZE, &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
return result;
}
if (in_bytes == 0 || in_bytes >= FDFS_STORAGE_ID_MAX_SIZE)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, in_bytes);
return EINVAL;
}
*(storage_id + in_bytes) = '\0';
return 0;
}
int tracker_set_trunk_server(TrackerServerGroup *pTrackerGroup, \
const char *group_name, const char *storage_id, \
char *new_trunk_server_id)
{
TrackerHeader *pHeader;
ConnectionInfo *conn;
ConnectionInfo *pServer;
ConnectionInfo *pEnd;
ConnectionInfo tracker_server;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
FDFS_STORAGE_ID_MAX_SIZE];
char in_buff[FDFS_STORAGE_ID_MAX_SIZE];
char *pInBuff;
int64_t in_bytes;
int result;
int storage_id_len;
*new_trunk_server_id = '\0';
memset(out_buff, 0, sizeof(out_buff));
memset(in_buff, 0, sizeof(in_buff));
pHeader = (TrackerHeader *)out_buff;
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", group_name);
if (storage_id == NULL)
{
storage_id_len = 0;
}
else
{
storage_id_len = snprintf(out_buff + sizeof(TrackerHeader) + \
FDFS_GROUP_NAME_MAX_LEN, \
sizeof(out_buff) - sizeof(TrackerHeader) - \
FDFS_GROUP_NAME_MAX_LEN, "%s", storage_id);
}
long2buff(FDFS_GROUP_NAME_MAX_LEN + storage_id_len, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVER_SET_TRUNK_SERVER;
result = 0;
pEnd = pTrackerGroup->servers + pTrackerGroup->server_count;
for (pServer=pTrackerGroup->servers; pServer<pEnd; pServer++)
{
memcpy(&tracker_server, pServer, sizeof(ConnectionInfo));
tracker_server.sock = -1;
if ((conn=tracker_connect_server(&tracker_server, &result)) == NULL)
{
continue;
}
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
storage_id_len, g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
tracker_server.ip_addr, tracker_server.port, \
result, STRERROR(result));
tracker_disconnect_server_ex(conn, true);
continue;
}
pInBuff = in_buff;
result = fdfs_recv_response(conn, &pInBuff, \
sizeof(in_buff) - 1, &in_bytes);
tracker_disconnect_server_ex(conn, result != 0);
if (result == 0)
{
strcpy(new_trunk_server_id, in_buff);
return 0;
}
if (result == EOPNOTSUPP)
{
continue;
}
if (result == EALREADY)
{
if (storage_id_len > 0)
{
strcpy(new_trunk_server_id, storage_id);
}
return result;
}
else
{
return result;
}
}
return result;
}
int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
const char *group_name, const char *storage_id)
{
ConnectionInfo *conn;
TrackerHeader *pHeader;
ConnectionInfo tracker_server;
ConnectionInfo *pServer;
ConnectionInfo *pEnd;
FDFSStorageInfo storage_infos[1];
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
FDFS_STORAGE_ID_MAX_SIZE];
char in_buff[1];
char *pInBuff;
int64_t in_bytes;
int result;
int storage_id_len;
int storage_count;
int enoent_count;
enoent_count = 0;
pEnd = pTrackerGroup->servers + pTrackerGroup->server_count;
for (pServer=pTrackerGroup->servers; pServer<pEnd; pServer++)
{
memcpy(&tracker_server, pServer, sizeof(ConnectionInfo));
tracker_server.sock = -1;
if ((conn=tracker_connect_server(&tracker_server, &result)) == NULL)
{
return result;
}
result = tracker_list_servers(conn, group_name, storage_id, \
storage_infos, 1, &storage_count);
tracker_disconnect_server_ex(conn, result != 0 && result != ENOENT);
if (result != 0 && result != ENOENT)
{
return result;
}
if (result == ENOENT || storage_count == 0)
{
enoent_count++;
continue;
}
if (storage_infos[0].status == FDFS_STORAGE_STATUS_ONLINE
|| storage_infos[0].status == FDFS_STORAGE_STATUS_ACTIVE)
{
return EBUSY;
}
}
if (enoent_count == pTrackerGroup->server_count)
{
return ENOENT;
}
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", group_name);
storage_id_len = snprintf(out_buff + sizeof(TrackerHeader) + \
FDFS_GROUP_NAME_MAX_LEN, \
sizeof(out_buff) - sizeof(TrackerHeader) - \
FDFS_GROUP_NAME_MAX_LEN, "%s", storage_id);
long2buff(FDFS_GROUP_NAME_MAX_LEN + storage_id_len, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVER_DELETE_STORAGE;
enoent_count = 0;
result = 0;
for (pServer=pTrackerGroup->servers; pServer<pEnd; pServer++)
{
memcpy(&tracker_server, pServer, sizeof(ConnectionInfo));
tracker_server.sock = -1;
if ((conn=tracker_connect_server(&tracker_server, &result)) == NULL)
{
return result;
}
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
storage_id_len, g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
tracker_server.ip_addr, tracker_server.port, \
result, STRERROR(result));
}
else
{
pInBuff = in_buff;
result = fdfs_recv_response(conn, &pInBuff, 0, &in_bytes);
}
tracker_disconnect_server_ex(conn, result != 0 && result != ENOENT);
if (result != 0)
{
if (result == ENOENT)
{
enoent_count++;
}
else if (result == EALREADY)
{
}
else
{
return result;
}
}
}
if (enoent_count == pTrackerGroup->server_count)
{
return ENOENT;
}
return result == ENOENT ? 0 : result;
}
static int storage_do_recovery(const char *pBasePath, StorageBinLogReader *pReader, \
ConnectionInfo *pSrcStorage)
{
ConnectionInfo *pTrackerServer;
ConnectionInfo *pStorageConn;
FDFSTrunkFullInfo trunk_info;
StorageBinLogRecord record;
int record_length;
int result;
int log_level;
int count;
int store_path_index;
int64_t file_size;
int64_t total_count;
int64_t success_count;
bool bContinueFlag;
char local_filename[MAX_PATH_SIZE];
char src_filename[MAX_PATH_SIZE];
pTrackerServer = g_tracker_group.servers;
count = 0;
total_count = 0;
success_count = 0;
result = 0;
logInfo("file: "__FILE__", line: %d, " \
"disk recovery: recovering files of data path: %s ...", \
__LINE__, pBasePath);
bContinueFlag = true;
while (bContinueFlag)
{
if ((pStorageConn=tracker_connect_server(pSrcStorage, &result)) == NULL)
{
sleep(5);
continue;
}
while (g_continue_flag)
{
result=storage_binlog_read(pReader, &record, &record_length);
if (result != 0)
{
if (result == ENOENT)
{
result = 0;
}
bContinueFlag = false;
break;
}
total_count++;
if (record.op_type == STORAGE_OP_TYPE_SOURCE_CREATE_FILE
|| record.op_type == STORAGE_OP_TYPE_REPLICA_CREATE_FILE)
{
bool bTrunkFile;
if (fdfs_is_trunk_file(record.filename, \
record.filename_len))
{
char *pTrunkPathEnd;
char *pLocalFilename;
bTrunkFile = true;
if (fdfs_decode_trunk_info(record.store_path_index, \
record.true_filename, record.true_filename_len,\
&trunk_info) != 0)
{
pReader->binlog_offset += record_length;
count++;
continue;
}
trunk_get_full_filename(&trunk_info, \
local_filename, sizeof(local_filename));
pTrunkPathEnd = strrchr(record.filename, '/');
pLocalFilename = strrchr(local_filename, '/');
if (pTrunkPathEnd == NULL || pLocalFilename == NULL)
{
pReader->binlog_offset += record_length;
count++;
continue;
}
sprintf(pTrunkPathEnd + 1, "%s", pLocalFilename + 1);
}
else
{
bTrunkFile = false;
sprintf(local_filename, "%s/data/%s", \
g_fdfs_store_paths.paths[record.store_path_index], \
record.true_filename);
}
result = storage_download_file_to_file(pTrackerServer, \
pStorageConn, g_group_name, \
record.filename, local_filename, \
&file_size);
if (result == 0)
{
if (!bTrunkFile)
{
set_file_utimes(local_filename, \
record.timestamp);
}
success_count++;
}
else if (result != ENOENT)
{
break;
}
}
else if (record.op_type == STORAGE_OP_TYPE_SOURCE_CREATE_LINK
|| record.op_type == STORAGE_OP_TYPE_REPLICA_CREATE_LINK)
{
if (record.src_filename_len == 0)
{
logError("file: "__FILE__", line: %d, " \
"invalid binlog line, filename: %s, " \
"expect src filename", __LINE__, \
record.filename);
result = EINVAL;
bContinueFlag = false;
break;
}
if ((result=storage_split_filename_ex(record.filename, \
&record.filename_len, record.true_filename, \
&store_path_index)) != 0)
{
bContinueFlag = false;
break;
}
sprintf(local_filename, "%s/data/%s", \
g_fdfs_store_paths.paths[store_path_index], \
record.true_filename);
if ((result=storage_split_filename_ex( \
record.src_filename, &record.src_filename_len,\
record.true_filename, &store_path_index)) != 0)
{
bContinueFlag = false;
break;
}
sprintf(src_filename, "%s/data/%s", \
g_fdfs_store_paths.paths[store_path_index], \
record.true_filename);
if (symlink(src_filename, local_filename) == 0)
{
success_count++;
}
else
{
result = errno != 0 ? errno : ENOENT;
if (result == ENOENT || result == EEXIST)
{
log_level = LOG_DEBUG;
}
else
{
log_level = LOG_ERR;
}
log_it_ex(&g_log_context, log_level, \
"file: "__FILE__", line: %d, " \
"link file %s to %s fail, " \
"errno: %d, error info: %s", __LINE__,\
src_filename, local_filename, \
result, STRERROR(result));
if (result != ENOENT && result != EEXIST)
{
bContinueFlag = false;
break;
}
}
}
else
{
logError("file: "__FILE__", line: %d, " \
"invalid file op type: %d", \
__LINE__, record.op_type);
result = EINVAL;
bContinueFlag = false;
break;
}
pReader->binlog_offset += record_length;
count++;
if (count == 1000)
{
logDebug("file: "__FILE__", line: %d, " \
"disk recovery: recover path: %s, " \
"file count: %"PRId64 \
", success count: %"PRId64, \
__LINE__, pBasePath, total_count, \
success_count);
recovery_write_to_mark_file(pBasePath, pReader);
count = 0;
}
}
tracker_disconnect_server_ex(pStorageConn, result != 0);
if (count > 0)
{
recovery_write_to_mark_file(pBasePath, pReader);
count = 0;
logInfo("file: "__FILE__", line: %d, " \
"disk recovery: recover path: %s, " \
"file count: %"PRId64 \
", success count: %"PRId64, \
__LINE__, pBasePath, total_count, success_count);
}
else
{
sleep(5);
}
}
if (result == 0)
{
logInfo("file: "__FILE__", line: %d, " \
"disk recovery: recover files of data path: %s done", \
__LINE__, pBasePath);
}
return result;
}
static int do_notify_leader_changed(ConnectionInfo *pTrackerServer, \
ConnectionInfo *pLeader, const char cmd, bool *bConnectFail)
{
char out_buff[sizeof(TrackerHeader) + FDFS_PROTO_IP_PORT_SIZE];
char in_buff[1];
ConnectionInfo *conn;
TrackerHeader *pHeader;
char *pInBuff;
int64_t in_bytes;
int result;
pTrackerServer->sock = -1;
if ((conn=tracker_connect_server(pTrackerServer, &result)) == NULL)
{
*bConnectFail = true;
return result;
}
*bConnectFail = false;
do
{
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
pHeader->cmd = cmd;
sprintf(out_buff + sizeof(TrackerHeader), "%s:%d", \
pLeader->ip_addr, pLeader->port);
long2buff(FDFS_PROTO_IP_PORT_SIZE, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(out_buff), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
result = (result == ENOENT ? EACCES : result);
break;
}
pInBuff = in_buff;
result = fdfs_recv_response(conn, &pInBuff, \
0, &in_bytes);
if (result != 0)
{
break;
}
if (in_bytes != 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid, " \
"expect length: %d.", __LINE__, \
pTrackerServer->ip_addr, pTrackerServer->port, \
in_bytes, 0);
result = EINVAL;
break;
}
} while (0);
if (pTrackerServer->port == g_server_port && \
is_local_host_ip(pTrackerServer->ip_addr))
{
tracker_disconnect_server_ex(conn, true);
}
else
{
tracker_disconnect_server_ex(conn, result != 0);
}
return result;
}
int tracker_list_servers(ConnectionInfo *pTrackerServer, \
const char *szGroupName, const char *szStorageId, \
FDFSStorageInfo *storage_infos, const int max_storages, \
int *storage_count)
{
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
IP_ADDRESS_SIZE];
bool new_connection;
TrackerHeader *pHeader;
ConnectionInfo *conn;
int result;
int name_len;
int id_len;
TrackerStorageStat stats[FDFS_MAX_GROUPS];
char *pInBuff;
TrackerStorageStat *pSrc;
TrackerStorageStat *pEnd;
FDFSStorageStat *pStorageStat;
FDFSStorageInfo *pDest;
FDFSStorageStatBuff *pStatBuff;
int64_t in_bytes;
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
name_len = strlen(szGroupName);
if (name_len > FDFS_GROUP_NAME_MAX_LEN)
{
name_len = FDFS_GROUP_NAME_MAX_LEN;
}
memcpy(out_buff + sizeof(TrackerHeader), szGroupName, name_len);
if (szStorageId == NULL)
{
id_len = 0;
}
else
{
id_len = strlen(szStorageId);
if (id_len >= FDFS_STORAGE_ID_MAX_SIZE)
{
id_len = FDFS_STORAGE_ID_MAX_SIZE - 1;
}
memcpy(out_buff+sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN,\
szStorageId, id_len);
}
long2buff(FDFS_GROUP_NAME_MAX_LEN + id_len, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_STORAGE;
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + id_len, \
g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
pInBuff = (char *)stats;
result = fdfs_recv_response(conn, &pInBuff, \
sizeof(stats), &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
*storage_count = 0;
return result;
}
if (in_bytes % sizeof(TrackerStorageStat) != 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, in_bytes);
*storage_count = 0;
return EINVAL;
}
*storage_count = in_bytes / sizeof(TrackerStorageStat);
if (*storage_count > max_storages)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d insufficent space, " \
"max storage count: %d, expect count: %d", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, max_storages, *storage_count);
*storage_count = 0;
return ENOSPC;
}
memset(storage_infos, 0, sizeof(FDFSStorageInfo) * max_storages);
pDest = storage_infos;
pEnd = stats + (*storage_count);
for (pSrc=stats; pSrc<pEnd; pSrc++)
{
pStatBuff = &(pSrc->stat_buff);
pStorageStat = &(pDest->stat);
pDest->status = pSrc->status;
memcpy(pDest->id, pSrc->id, FDFS_STORAGE_ID_MAX_SIZE - 1);
memcpy(pDest->ip_addr, pSrc->ip_addr, IP_ADDRESS_SIZE - 1);
memcpy(pDest->src_id, pSrc->src_id, \
FDFS_STORAGE_ID_MAX_SIZE - 1);
strcpy(pDest->domain_name, pSrc->domain_name);
strcpy(pDest->version, pSrc->version);
pDest->join_time = buff2long(pSrc->sz_join_time);
pDest->up_time = buff2long(pSrc->sz_up_time);
pDest->total_mb = buff2long(pSrc->sz_total_mb);
pDest->free_mb = buff2long(pSrc->sz_free_mb);
pDest->upload_priority = buff2long(pSrc->sz_upload_priority);
pDest->store_path_count = buff2long(pSrc->sz_store_path_count);
pDest->subdir_count_per_path = buff2long( \
pSrc->sz_subdir_count_per_path);
pDest->storage_port = buff2long(pSrc->sz_storage_port);
pDest->storage_http_port = buff2long(pSrc->sz_storage_http_port);
pDest->current_write_path = buff2long( \
pSrc->sz_current_write_path);
pStorageStat->total_upload_count = buff2long( \
pStatBuff->sz_total_upload_count);
pStorageStat->success_upload_count = buff2long( \
pStatBuff->sz_success_upload_count);
pStorageStat->total_append_count = buff2long( \
pStatBuff->sz_total_append_count);
pStorageStat->success_append_count = buff2long( \
pStatBuff->sz_success_append_count);
pStorageStat->total_modify_count = buff2long( \
pStatBuff->sz_total_modify_count);
pStorageStat->success_modify_count = buff2long( \
pStatBuff->sz_success_modify_count);
pStorageStat->total_truncate_count = buff2long( \
pStatBuff->sz_total_truncate_count);
pStorageStat->success_truncate_count = buff2long( \
pStatBuff->sz_success_truncate_count);
pStorageStat->total_set_meta_count = buff2long( \
pStatBuff->sz_total_set_meta_count);
pStorageStat->success_set_meta_count = buff2long( \
pStatBuff->sz_success_set_meta_count);
pStorageStat->total_delete_count = buff2long( \
pStatBuff->sz_total_delete_count);
pStorageStat->success_delete_count = buff2long( \
pStatBuff->sz_success_delete_count);
pStorageStat->total_download_count = buff2long( \
pStatBuff->sz_total_download_count);
pStorageStat->success_download_count = buff2long( \
pStatBuff->sz_success_download_count);
pStorageStat->total_get_meta_count = buff2long( \
pStatBuff->sz_total_get_meta_count);
pStorageStat->success_get_meta_count = buff2long( \
pStatBuff->sz_success_get_meta_count);
pStorageStat->last_source_update = buff2long( \
pStatBuff->sz_last_source_update);
pStorageStat->last_sync_update = buff2long( \
pStatBuff->sz_last_sync_update);
pStorageStat->last_synced_timestamp = buff2long( \
pStatBuff->sz_last_synced_timestamp);
pStorageStat->total_create_link_count = buff2long( \
pStatBuff->sz_total_create_link_count);
pStorageStat->success_create_link_count = buff2long( \
pStatBuff->sz_success_create_link_count);
pStorageStat->total_delete_link_count = buff2long( \
pStatBuff->sz_total_delete_link_count);
pStorageStat->success_delete_link_count = buff2long( \
pStatBuff->sz_success_delete_link_count);
pStorageStat->total_upload_bytes = buff2long( \
pStatBuff->sz_total_upload_bytes);
pStorageStat->success_upload_bytes = buff2long( \
pStatBuff->sz_success_upload_bytes);
pStorageStat->total_append_bytes = buff2long( \
pStatBuff->sz_total_append_bytes);
pStorageStat->success_append_bytes = buff2long( \
pStatBuff->sz_success_append_bytes);
pStorageStat->total_modify_bytes = buff2long( \
pStatBuff->sz_total_modify_bytes);
pStorageStat->success_modify_bytes = buff2long( \
pStatBuff->sz_success_modify_bytes);
pStorageStat->total_download_bytes = buff2long( \
pStatBuff->sz_total_download_bytes);
pStorageStat->success_download_bytes = buff2long( \
pStatBuff->sz_success_download_bytes);
pStorageStat->total_sync_in_bytes = buff2long( \
pStatBuff->sz_total_sync_in_bytes);
pStorageStat->success_sync_in_bytes = buff2long( \
pStatBuff->sz_success_sync_in_bytes);
pStorageStat->total_sync_out_bytes = buff2long( \
pStatBuff->sz_total_sync_out_bytes);
pStorageStat->success_sync_out_bytes = buff2long( \
pStatBuff->sz_success_sync_out_bytes);
pStorageStat->total_file_open_count = buff2long( \
pStatBuff->sz_total_file_open_count);
pStorageStat->success_file_open_count = buff2long( \
pStatBuff->sz_success_file_open_count);
pStorageStat->total_file_read_count = buff2long( \
pStatBuff->sz_total_file_read_count);
pStorageStat->success_file_read_count = buff2long( \
pStatBuff->sz_success_file_read_count);
pStorageStat->total_file_write_count = buff2long( \
pStatBuff->sz_total_file_write_count);
pStorageStat->success_file_write_count = buff2long( \
pStatBuff->sz_success_file_write_count);
pStorageStat->last_heart_beat_time = buff2long( \
pStatBuff->sz_last_heart_beat_time);
pDest->if_trunk_server = pSrc->if_trunk_server;
pDest++;
}
return 0;
}
int main(int argc, char *argv[])
{
char *conf_filename;
int result;
char *op_type;
char *tracker_server;
int arg_index;
char *group_name;
if (argc < 2)
{
usage(argv);
return 1;
}
tracker_server = NULL;
conf_filename = argv[1];
arg_index = 2;
if (arg_index >= argc)
{
op_type = "list";
}
else
{
int len;
len = strlen(argv[arg_index]);
if (len >= 2 && strncmp(argv[arg_index], "-h", 2) == 0)
{
if (len == 2)
{
arg_index++;
if (arg_index >= argc)
{
usage(argv);
return 1;
}
tracker_server = argv[arg_index++];
}
else
{
tracker_server = argv[arg_index] + 2;
arg_index++;
}
if (arg_index < argc)
{
op_type = argv[arg_index++];
}
else
{
op_type = "list";
}
}
else
{
op_type = argv[arg_index++];
}
}
log_init();
g_log_context.log_level = LOG_DEBUG;
ignore_signal_pipe();
if ((result=fdfs_client_init(conf_filename)) != 0)
{
return result;
}
load_log_level_ex(conf_filename);
if (tracker_server == NULL)
{
if (g_tracker_group.server_count > 1)
{
srand(time(NULL));
rand(); //discard the first
g_tracker_group.server_index = (int)( \
(g_tracker_group.server_count * (double)rand()) \
/ (double)RAND_MAX);
}
}
else
{
int i;
char ip_addr[IP_ADDRESS_SIZE];
*ip_addr = '\0';
if (getIpaddrByName(tracker_server, ip_addr, sizeof(ip_addr)) \
== INADDR_NONE)
{
printf("resolve ip address of tracker server: %s " \
"fail!\n", tracker_server);
return 2;
}
for (i=0; i<g_tracker_group.server_count; i++)
{
if (strcmp(g_tracker_group.servers[i].ip_addr, \
ip_addr) == 0)
{
g_tracker_group.server_index = i;
break;
}
}
if (i == g_tracker_group.server_count)
{
printf("tracker server: %s not exists!\n", tracker_server);
return 2;
}
}
printf("server_count=%d, server_index=%d\n", g_tracker_group.server_count, g_tracker_group.server_index);
pTrackerServer = tracker_get_connection();
if (pTrackerServer == NULL)
{
fdfs_client_destroy();
return errno != 0 ? errno : ECONNREFUSED;
}
printf("\ntracker server is %s:%d\n\n", pTrackerServer->ip_addr, pTrackerServer->port);
if (arg_index < argc)
{
group_name = argv[arg_index++];
}
else
{
group_name = NULL;
}
if (strcmp(op_type, "list") == 0)
{
if (group_name == NULL)
{
result = list_all_groups(NULL);
}
else
{
result = list_all_groups(group_name);
}
}
else if (strcmp(op_type, "delete") == 0)
{
char *storage_id;
if (arg_index >= argc)
{
usage(argv);
return 1;
}
storage_id = argv[arg_index++];
if ((result=tracker_delete_storage(&g_tracker_group, \
group_name, storage_id)) == 0)
{
printf("delete storage server %s::%s success\n", \
group_name, storage_id);
}
else
{
printf("delete storage server %s::%s fail, " \
"error no: %d, error info: %s\n", \
group_name, storage_id, \
result, STRERROR(result));
}
}
else if (strcmp(op_type, "set_trunk_server") == 0)
{
char *storage_id;
char new_trunk_server_id[FDFS_STORAGE_ID_MAX_SIZE];
if (group_name == NULL)
{
usage(argv);
return 1;
}
if (arg_index >= argc)
{
storage_id = "";
}
else
{
storage_id = argv[arg_index++];
}
if ((result=tracker_set_trunk_server(&g_tracker_group, \
group_name, storage_id, new_trunk_server_id)) == 0)
{
printf("set trunk server %s::%s success, " \
"new trunk server: %s\n", group_name, \
storage_id, new_trunk_server_id);
}
else
{
printf("set trunk server %s::%s fail, " \
"error no: %d, error info: %s\n", \
group_name, storage_id, \
result, STRERROR(result));
}
}
else
{
printf("Invalid command %s\n\n", op_type);
usage(argv);
}
tracker_disconnect_server_ex(pTrackerServer, true);
fdfs_client_destroy();
return 0;
}
int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
const char *group_name, FDFSGroupStat *pDest)
{
TrackerHeader *pHeader;
ConnectionInfo *conn;
bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
TrackerGroupStat src;
char *pInBuff;
int result;
int64_t in_bytes;
CHECK_CONNECTION(pTrackerServer, conn, result, new_connection);
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", group_name);
pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_ONE_GROUP;
long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(out_buff), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
pInBuff = (char *)&src;
result = fdfs_recv_response(conn, \
&pInBuff, sizeof(TrackerGroupStat), &in_bytes);
}
if (new_connection)
{
tracker_disconnect_server_ex(conn, result != 0);
}
if (result != 0)
{
return result;
}
if (in_bytes != sizeof(TrackerGroupStat))
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d response data " \
"length: %"PRId64" is invalid", \
__LINE__, pTrackerServer->ip_addr, \
pTrackerServer->port, in_bytes);
return EINVAL;
}
memset(pDest, 0, sizeof(FDFSGroupStat));
memcpy(pDest->group_name, src.group_name, FDFS_GROUP_NAME_MAX_LEN);
pDest->total_mb = buff2long(src.sz_total_mb);
pDest->free_mb = buff2long(src.sz_free_mb);
pDest->trunk_free_mb = buff2long(src.sz_trunk_free_mb);
pDest->count= buff2long(src.sz_count);
pDest->storage_port= buff2long(src.sz_storage_port);
pDest->storage_http_port= buff2long(src.sz_storage_http_port);
pDest->active_count = buff2long(src.sz_active_count);
pDest->current_write_server = buff2long(src.sz_current_write_server);
pDest->store_path_count = buff2long(src.sz_store_path_count);
pDest->subdir_count_per_path = buff2long(src.sz_subdir_count_per_path);
pDest->current_trunk_file_id = buff2long(src.sz_current_trunk_file_id);
return 0;
}
