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

log square quoted IPv6 address

master
YuQing 2024-03-06 15:35:19 +08:00
parent ff2aef1735
commit 422c63cc54
24 changed files with 1201 additions and 1045 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
HISTORY
View File

@ -1,6 +1,8 @@
Version 6.12.1 2024-02-26 Version 6.12.1 2024-03-06
* adapt to libserverframe 1.2.3 * adapt to libserverframe 1.2.3
* bugfixed: notify_leader_changed support IPv6 correctly
* log square quoted IPv6 address
Version 6.12.0 2024-02-12 Version 6.12.0 2024-02-12
* bugfixed: parse ip and port use parseAddress instead of splitEx * bugfixed: parse ip and port use parseAddress instead of splitEx

7
client/client_func.c
View File

@ -137,11 +137,12 @@ static int copy_tracker_servers(TrackerServerGroup *pTrackerGroup,
/* /*
{ {
TrackerServerInfo *pServer; TrackerServerInfo *pServer;
for (pServer=pTrackerGroup->servers; pServer<pTrackerGroup->servers+ \ char formatted_ip[FORMATTED_IP_SIZE];
for (pServer=pTrackerGroup->servers; pServer<pTrackerGroup->servers+
pTrackerGroup->server_count; pServer++) pTrackerGroup->server_count; pServer++)
{ {
//printf("server=%s:%u\n", \ format_ip_address(pServer->connections[0].ip_addr, formatted_ip);
pServer->ip_addr, pServer->port); printf("server=%s:%u\n", formatted_ip, pServer->connections[0].port);
} }
} }
*/ */

9
client/fdfs_monitor.c
View File

@ -35,12 +35,13 @@ static void usage(char *argv[])
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
char formatted_ip[FORMATTED_IP_SIZE];
char *conf_filename; char *conf_filename;
int result;
char *op_type; char *op_type;
char *group_name;
char *tracker_server; char *tracker_server;
int arg_index; int arg_index;
char *group_name; int result;
if (argc < 2) if (argc < 2)
{ {
@ -155,7 +156,9 @@ int main(int argc, char *argv[])
fdfs_client_destroy(); fdfs_client_destroy();
return errno != 0 ? errno : ECONNREFUSED; return errno != 0 ? errno : ECONNREFUSED;
} }
printf("\ntracker server is %s:%u\n\n", pTrackerServer->ip_addr, pTrackerServer->port); format_ip_address(pTrackerServer->ip_addr, formatted_ip);
printf("\ntracker server is %s:%u\n\n", formatted_ip,
pTrackerServer->port);
if (arg_index < argc) if (arg_index < argc)
{ {

21
client/fdfs_test.c
View File

@ -66,6 +66,7 @@ int main(int argc, char *argv[])
int meta_count; int meta_count;
int i; int i;
FDFSMetaData *pMetaList; FDFSMetaData *pMetaList;
char formatted_ip[FORMATTED_IP_SIZE];
char token[32 + 1]; char token[32 + 1];
char file_id[128]; char file_id[128];
char file_url[256]; char file_url[256];
@ -460,8 +461,9 @@ g_fdfs_version.patch);
printf("server list (%d):\n", server_count); printf("server list (%d):\n", server_count);
for (i=0; i<server_count; i++) for (i=0; i<server_count; i++)
{ {
printf("\t%s:%u\n", \ format_ip_address(storageServers[i].
storageServers[i].ip_addr, \ ip_addr, formatted_ip);
printf("\t%s:%u\n", formatted_ip,
storageServers[i].port); storageServers[i].port);
} }
printf("\n"); printf("\n");
@ -488,8 +490,8 @@ g_fdfs_version.patch);
return result; return result;
} }
printf("storage=%s:%u\n", storageServer.ip_addr, \ format_ip_address(storageServer.ip_addr, formatted_ip);
storageServer.port); printf("storage=%s:%u\n", formatted_ip, storageServer.port);
if ((pStorageServer=tracker_make_connection(&storageServer, \ if ((pStorageServer=tracker_make_connection(&storageServer, \
&result)) == NULL) &result)) == NULL)
@ -670,15 +672,17 @@ g_fdfs_version.patch);
/* for test only */ /* for test only */
if ((result=fdfs_active_test(pTrackerServer)) != 0) if ((result=fdfs_active_test(pTrackerServer)) != 0)
{ {
printf("active_test to tracker server %s:%u fail, errno: %d\n", \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
pTrackerServer->ip_addr, pTrackerServer->port, result); printf("active_test to tracker server %s:%u fail, errno: %d\n",
formatted_ip, pTrackerServer->port, result);
} }
/* for test only */ /* for test only */
if ((result=fdfs_active_test(pStorageServer)) != 0) if ((result=fdfs_active_test(pStorageServer)) != 0)
{ {
printf("active_test to storage server %s:%u fail, errno: %d\n", \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
pStorageServer->ip_addr, pStorageServer->port, result); printf("active_test to storage server %s:%u fail, errno: %d\n",
formatted_ip, pStorageServer->port, result);
} }
tracker_close_connection_ex(pStorageServer, true); tracker_close_connection_ex(pStorageServer, true);
@ -688,4 +692,3 @@ g_fdfs_version.patch);
return result; return result;
} }

20
client/fdfs_test1.c
View File

@ -63,6 +63,7 @@ int main(int argc, char *argv[])
int meta_count; int meta_count;
int i; int i;
FDFSMetaData *pMetaList; FDFSMetaData *pMetaList;
char formatted_ip[FORMATTED_IP_SIZE];
char token[32 + 1]; char token[32 + 1];
char file_id[128]; char file_id[128];
char master_file_id[128]; char master_file_id[128];
@ -432,8 +433,9 @@ g_fdfs_version.patch);
printf("server list (%d):\n", server_count); printf("server list (%d):\n", server_count);
for (i=0; i<server_count; i++) for (i=0; i<server_count; i++)
{ {
printf("\t%s:%u\n", \ format_ip_address(storageServers[i].
storageServers[i].ip_addr, \ ip_addr, formatted_ip);
printf("\t%s:%u\n", formatted_ip,
storageServers[i].port); storageServers[i].port);
} }
printf("\n"); printf("\n");
@ -455,8 +457,8 @@ g_fdfs_version.patch);
return result; return result;
} }
printf("storage=%s:%u\n", storageServer.ip_addr, \ format_ip_address(storageServer.ip_addr, formatted_ip);
storageServer.port); printf("storage=%s:%u\n", formatted_ip, storageServer.port);
if ((pStorageServer=tracker_make_connection(&storageServer, \ if ((pStorageServer=tracker_make_connection(&storageServer, \
&result)) == NULL) &result)) == NULL)
@ -637,15 +639,17 @@ g_fdfs_version.patch);
/* for test only */ /* for test only */
if ((result=fdfs_active_test(pTrackerServer)) != 0) if ((result=fdfs_active_test(pTrackerServer)) != 0)
{ {
printf("active_test to tracker server %s:%u fail, errno: %d\n", \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
pTrackerServer->ip_addr, pTrackerServer->port, result); printf("active_test to tracker server %s:%u fail, errno: %d\n",
formatted_ip, pTrackerServer->port, result);
} }
/* for test only */ /* for test only */
if ((result=fdfs_active_test(pStorageServer)) != 0) if ((result=fdfs_active_test(pStorageServer)) != 0)
{ {
printf("active_test to storage server %s:%u fail, errno: %d\n", \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
pStorageServer->ip_addr, pStorageServer->port, result); printf("active_test to storage server %s:%u fail, errno: %d\n",
formatted_ip, pStorageServer->port, result);
} }
tracker_close_connection_ex(pStorageServer, true); tracker_close_connection_ex(pStorageServer, true);

303
client/storage_client.c
View File

@ -309,6 +309,7 @@ int storage_get_metadata(ConnectionInfo *pTrackerServer, \
int result; int result;
ConnectionInfo storageServer; ConnectionInfo storageServer;
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
char formatted_ip[FORMATTED_IP_SIZE];
int64_t in_bytes; int64_t in_bytes;
int filename_len; int filename_len;
char *file_buff; char *file_buff;
@ -346,15 +347,15 @@ int storage_get_metadata(ConnectionInfo *pTrackerServer, \
long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_GET_METADATA; pHeader->cmd = STORAGE_PROTO_CMD_GET_METADATA;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
filename_len, SF_G_NETWORK_TIMEOUT)) != 0) filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -410,6 +411,7 @@ int storage_query_file_info_ex(ConnectionInfo *pTrackerServer, \
ConnectionInfo storageServer; ConnectionInfo storageServer;
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
char in_buff[3 * FDFS_PROTO_PKG_LEN_SIZE + IP_ADDRESS_SIZE]; char in_buff[3 * FDFS_PROTO_PKG_LEN_SIZE + IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char buff[64]; char buff[64];
int64_t in_bytes; int64_t in_bytes;
int filename_len; int filename_len;
@ -446,15 +448,15 @@ int storage_query_file_info_ex(ConnectionInfo *pTrackerServer, \
pHeader->cmd = STORAGE_PROTO_CMD_QUERY_FILE_INFO; pHeader->cmd = STORAGE_PROTO_CMD_QUERY_FILE_INFO;
pHeader->status = bSilence ? ENOENT : 0; pHeader->status = bSilence ? ENOENT : 0;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
filename_len, SF_G_NETWORK_TIMEOUT)) != 0) filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -471,11 +473,11 @@ int storage_query_file_info_ex(ConnectionInfo *pTrackerServer, \
if (in_bytes != sizeof(in_buff)) if (in_bytes != sizeof(in_buff))
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"recv data from storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"recv bytes: %"PRId64" != %d", __LINE__, \ "recv data from storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "recv bytes: %"PRId64" != %d", __LINE__, formatted_ip,
in_bytes, (int)sizeof(in_buff)); pStorageServer->port, in_bytes, (int)sizeof(in_buff));
result = EINVAL; result = EINVAL;
} }
@ -543,6 +545,7 @@ int storage_delete_file(ConnectionInfo *pTrackerServer, \
int result; int result;
ConnectionInfo storageServer; ConnectionInfo storageServer;
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
char *pBuff; char *pBuff;
int64_t in_bytes; int64_t in_bytes;
@ -576,15 +579,15 @@ int storage_delete_file(ConnectionInfo *pTrackerServer, \
long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_DELETE_FILE; pHeader->cmd = STORAGE_PROTO_CMD_DELETE_FILE;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
filename_len, SF_G_NETWORK_TIMEOUT)) != 0) filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -632,6 +635,7 @@ int storage_do_download_file_ex(ConnectionInfo *pTrackerServer, \
int result; int result;
ConnectionInfo storageServer; ConnectionInfo storageServer;
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int out_bytes; int out_bytes;
int64_t in_bytes; int64_t in_bytes;
@ -666,21 +670,21 @@ int storage_do_download_file_ex(ConnectionInfo *pTrackerServer, \
p += 8; p += 8;
snprintf(p, sizeof(out_buff) - (p - out_buff), "%s", group_name); snprintf(p, sizeof(out_buff) - (p - out_buff), "%s", group_name);
p += FDFS_GROUP_NAME_MAX_LEN; p += FDFS_GROUP_NAME_MAX_LEN;
filename_len = snprintf(p, sizeof(out_buff) - (p - out_buff), \ filename_len = snprintf(p, sizeof(out_buff) -
"%s", remote_filename); (p - out_buff), "%s", remote_filename);
p += filename_len; p += filename_len;
out_bytes = p - out_buff; out_bytes = p - out_buff;
long2buff(out_bytes - sizeof(TrackerHeader), pHeader->pkg_len); long2buff(out_bytes - sizeof(TrackerHeader), pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_DOWNLOAD_FILE; pHeader->cmd = STORAGE_PROTO_CMD_DOWNLOAD_FILE;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
out_bytes, SF_G_NETWORK_TIMEOUT)) != 0) out_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -744,15 +748,14 @@ int storage_do_download_file_ex(ConnectionInfo *pTrackerServer, \
recv_bytes = remain_bytes; recv_bytes = remain_bytes;
} }
if ((result=tcprecvdata_nb(pStorageServer->sock, buff, \ if ((result=tcprecvdata_nb(pStorageServer->sock, buff,
recv_bytes, SF_G_NETWORK_TIMEOUT)) != 0) recv_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"recv data from storage server " \ logError("file: "__FILE__", line: %d, "
"%s:%u fail, " \ "recv data from storage server %s:%u fail, "
"errno: %d, error info: %s", __LINE__, \ "errno: %d, error info: %s", __LINE__,
pStorageServer->ip_addr, \ formatted_ip, pStorageServer->port,
pStorageServer->port, \
result, STRERROR(result)); result, STRERROR(result));
break; break;
} }
@ -917,6 +920,7 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
int64_t in_bytes; int64_t in_bytes;
int64_t total_send_bytes; int64_t total_send_bytes;
char in_buff[128]; char in_buff[128];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
ConnectionInfo storageServer; ConnectionInfo storageServer;
bool new_connection; bool new_connection;
@ -966,8 +970,9 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
*group_name = '\0'; *group_name = '\0';
/* /*
format_ip_address(pStorageServer->ip_addr, formatted_ip);
//logInfo("upload to storage %s:%u\n", \ //logInfo("upload to storage %s:%u\n", \
pStorageServer->ip_addr, pStorageServer->port); formatted_ip, pStorageServer->port);
*/ */
do do
@ -1033,14 +1038,14 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
pHeader->cmd = cmd; pHeader->cmd = cmd;
pHeader->status = 0; pHeader->status = 0;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -1055,15 +1060,15 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
} }
else if (upload_type == FDFS_UPLOAD_BY_BUFF) else if (upload_type == FDFS_UPLOAD_BY_BUFF)
{ {
if ((result=tcpsenddata_nb(pStorageServer->sock, \ if ((result=tcpsenddata_nb(pStorageServer->sock,
(char *)file_buff, file_size, \ (char *)file_buff, file_size,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
} }
@ -1089,12 +1094,11 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN) if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "storage server %s:%u response data length: %"PRId64" "
"should > %d", __LINE__, \ "is invalid, should > %d", __LINE__, formatted_ip,
pStorageServer->ip_addr, pStorageServer->port, \ pStorageServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
in_bytes, FDFS_GROUP_NAME_MAX_LEN);
result = EINVAL; result = EINVAL;
break; break;
} }
@ -1254,6 +1258,7 @@ int storage_set_metadata(ConnectionInfo *pTrackerServer, \
ConnectionInfo storageServer; ConnectionInfo storageServer;
char out_buff[sizeof(TrackerHeader)+2*FDFS_PROTO_PKG_LEN_SIZE+\ char out_buff[sizeof(TrackerHeader)+2*FDFS_PROTO_PKG_LEN_SIZE+\
FDFS_GROUP_NAME_MAX_LEN+128]; FDFS_GROUP_NAME_MAX_LEN+128];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
int64_t in_bytes; int64_t in_bytes;
char *pBuff; char *pBuff;
@ -1310,30 +1315,29 @@ int storage_set_metadata(ConnectionInfo *pTrackerServer, \
p += filename_len; p += filename_len;
pHeader = (TrackerHeader *)out_buff; pHeader = (TrackerHeader *)out_buff;
long2buff((int)(p - (out_buff + sizeof(TrackerHeader))) + \ long2buff((int)(p - (out_buff + sizeof(TrackerHeader))) +
meta_bytes, pHeader->pkg_len); meta_bytes, pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_SET_METADATA; pHeader->cmd = STORAGE_PROTO_CMD_SET_METADATA;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
if (meta_bytes > 0 && (result=tcpsenddata_nb(pStorageServer->sock, \ if (meta_bytes > 0 && (result=tcpsenddata_nb(pStorageServer->sock,
meta_buff, meta_bytes, SF_G_NETWORK_TIMEOUT)) != 0) meta_buff, meta_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -1434,6 +1438,7 @@ int storage_client_create_link(ConnectionInfo *pTrackerServer, \
FDFS_GROUP_NAME_MAX_LEN + FDFS_FILE_PREFIX_MAX_LEN + \ FDFS_GROUP_NAME_MAX_LEN + FDFS_FILE_PREFIX_MAX_LEN + \
FDFS_FILE_EXT_NAME_MAX_LEN + 256]; FDFS_FILE_EXT_NAME_MAX_LEN + 256];
char in_buff[128]; char in_buff[128];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int group_name_len; int group_name_len;
int master_filename_len; int master_filename_len;
@ -1531,11 +1536,11 @@ int storage_client_create_link(ConnectionInfo *pTrackerServer, \
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -1551,12 +1556,11 @@ int storage_client_create_link(ConnectionInfo *pTrackerServer, \
if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN) if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "storage server %s:%u response data length: %"PRId64" "
"should > %d", __LINE__, \ "is invalid, should > %d", __LINE__, formatted_ip,
pStorageServer->ip_addr, pStorageServer->port, \ pStorageServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
in_bytes, FDFS_GROUP_NAME_MAX_LEN);
result = EINVAL; result = EINVAL;
break; break;
} }
@ -1785,6 +1789,7 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
TrackerHeader *pHeader; TrackerHeader *pHeader;
int result; int result;
char out_buff[512]; char out_buff[512];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int64_t in_bytes; int64_t in_bytes;
int64_t total_send_bytes; int64_t total_send_bytes;
@ -1802,8 +1807,9 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
} }
/* /*
format_ip_address(pStorageServer->ip_addr, formatted_ip);
//printf("upload to storage %s:%u\n", \ //printf("upload to storage %s:%u\n", \
pStorageServer->ip_addr, pStorageServer->port); formatted_ip, pStorageServer->port);
*/ */
do do
@ -1819,19 +1825,19 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
memcpy(p, appender_filename, appender_filename_len); memcpy(p, appender_filename, appender_filename_len);
p += appender_filename_len; p += appender_filename_len;
long2buff((p - out_buff) + file_size - sizeof(TrackerHeader), \ long2buff((p - out_buff) + file_size - sizeof(TrackerHeader),
pHeader->pkg_len); pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_APPEND_FILE; pHeader->cmd = STORAGE_PROTO_CMD_APPEND_FILE;
pHeader->status = 0; pHeader->status = 0;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -1846,15 +1852,15 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
} }
else if (upload_type == FDFS_UPLOAD_BY_BUFF) else if (upload_type == FDFS_UPLOAD_BY_BUFF)
{ {
if ((result=tcpsenddata_nb(pStorageServer->sock, \ if ((result=tcpsenddata_nb(pStorageServer->sock,
(char *)file_buff, file_size, \ (char *)file_buff, file_size,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
} }
@ -1878,10 +1884,10 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
if (in_bytes != 0) if (in_bytes != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "storage server %s:%u response data length: %"PRId64" "
"should == 0", __LINE__, pStorageServer->ip_addr, \ "is invalid, should == 0", __LINE__, formatted_ip,
pStorageServer->port, in_bytes); pStorageServer->port, in_bytes);
result = EINVAL; result = EINVAL;
break; break;
@ -1914,6 +1920,7 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
TrackerHeader *pHeader; TrackerHeader *pHeader;
int result; int result;
char out_buff[512]; char out_buff[512];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int64_t in_bytes; int64_t in_bytes;
int64_t total_send_bytes; int64_t total_send_bytes;
@ -1930,8 +1937,9 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
} }
/* /*
format_ip_address(pStorageServer->ip_addr, formatted_ip);
//printf("upload to storage %s:%u\n", \ //printf("upload to storage %s:%u\n", \
pStorageServer->ip_addr, pStorageServer->port); formatted_ip, pStorageServer->port);
*/ */
do do
@ -1950,42 +1958,41 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
memcpy(p, appender_filename, appender_filename_len); memcpy(p, appender_filename, appender_filename_len);
p += appender_filename_len; p += appender_filename_len;
long2buff((p - out_buff) + file_size - sizeof(TrackerHeader), \ long2buff((p - out_buff) + file_size - sizeof(TrackerHeader),
pHeader->pkg_len); pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_MODIFY_FILE; pHeader->cmd = STORAGE_PROTO_CMD_MODIFY_FILE;
pHeader->status = 0; pHeader->status = 0;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
if (upload_type == FDFS_UPLOAD_BY_FILE) if (upload_type == FDFS_UPLOAD_BY_FILE)
{ {
if ((result=tcpsendfile(pStorageServer->sock, file_buff, \ if ((result=tcpsendfile(pStorageServer->sock, file_buff,
file_size, SF_G_NETWORK_TIMEOUT, \ file_size, SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0)
&total_send_bytes)) != 0)
{ {
break; break;
} }
} }
else if (upload_type == FDFS_UPLOAD_BY_BUFF) else if (upload_type == FDFS_UPLOAD_BY_BUFF)
{ {
if ((result=tcpsenddata_nb(pStorageServer->sock, \ if ((result=tcpsenddata_nb(pStorageServer->sock,
(char *)file_buff, file_size, \ (char *)file_buff, file_size,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
} }
@ -2009,10 +2016,10 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
if (in_bytes != 0) if (in_bytes != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "storage server %s:%u response data length: %"PRId64" "
"should == 0", __LINE__, pStorageServer->ip_addr, \ "is invalid, should == 0", __LINE__, formatted_ip,
pStorageServer->port, in_bytes); pStorageServer->port, in_bytes);
result = EINVAL; result = EINVAL;
break; break;
@ -2382,6 +2389,7 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
TrackerHeader *pHeader; TrackerHeader *pHeader;
int result; int result;
char out_buff[512]; char out_buff[512];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int64_t in_bytes; int64_t in_bytes;
ConnectionInfo storageServer; ConnectionInfo storageServer;
@ -2397,8 +2405,9 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
} }
/* /*
format_ip_address(pStorageServer->ip_addr, formatted_ip);
//printf("upload to storage %s:%u\n", \ //printf("upload to storage %s:%u\n", \
pStorageServer->ip_addr, pStorageServer->port); formatted_ip, pStorageServer->port);
*/ */
do do
@ -2414,19 +2423,19 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
memcpy(p, appender_filename, appender_filename_len); memcpy(p, appender_filename, appender_filename_len);
p += appender_filename_len; p += appender_filename_len;
long2buff((p - out_buff) - sizeof(TrackerHeader), \ long2buff((p - out_buff) - sizeof(TrackerHeader),
pHeader->pkg_len); pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_TRUNCATE_FILE; pHeader->cmd = STORAGE_PROTO_CMD_TRUNCATE_FILE;
pHeader->status = 0; pHeader->status = 0;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, "
pStorageServer->ip_addr, pStorageServer->port, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
break; break;
} }
@ -2440,10 +2449,10 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
if (in_bytes != 0) if (in_bytes != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "storage server %s:%u response data length: %"PRId64" "
"should == 0", __LINE__, pStorageServer->ip_addr, \ "is invalid, should == 0", __LINE__, formatted_ip,
pStorageServer->port, in_bytes); pStorageServer->port, in_bytes);
result = EINVAL; result = EINVAL;
break; break;
@ -2467,6 +2476,7 @@ int storage_regenerate_appender_filename(ConnectionInfo *pTrackerServer,
int result; int result;
char out_buff[512]; char out_buff[512];
char in_buff[256]; char in_buff[256];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
@ -2498,11 +2508,11 @@ int storage_regenerate_appender_filename(ConnectionInfo *pTrackerServer,
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(pStorageServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to storage server %s:%u fail, " "send data to storage server %s:%u fail, "
"errno: %d, error info: %s", __LINE__, "errno: %d, error info: %s", __LINE__, formatted_ip,
pStorageServer->ip_addr, pStorageServer->port, pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -2518,12 +2528,11 @@ int storage_regenerate_appender_filename(ConnectionInfo *pTrackerServer,
if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN) if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN)
{ {
format_ip_address(pStorageServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"storage server %s:%u response data " "storage server %s:%u response data length: %"PRId64" "
"length: %"PRId64" is invalid, " "is invalid, should > %d", __LINE__, formatted_ip,
"should > %d", __LINE__, pStorageServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
pStorageServer->ip_addr, pStorageServer->port,
in_bytes, FDFS_GROUP_NAME_MAX_LEN);
result = EINVAL; result = EINVAL;
break; break;
} }

309
client/tracker_client.c
View File

@ -249,6 +249,7 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
{ {
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
IP_ADDRESS_SIZE]; IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
bool new_connection; bool new_connection;
TrackerHeader *pHeader; TrackerHeader *pHeader;
ConnectionInfo *conn; ConnectionInfo *conn;
@ -293,16 +294,15 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
long2buff(FDFS_GROUP_NAME_MAX_LEN + id_len, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + id_len, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_STORAGE; pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_STORAGE;
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + id_len, \ sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + id_len,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, errno: %d, "
pTrackerServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -330,10 +330,10 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
if (in_bytes % sizeof(TrackerStorageStat) != 0) if (in_bytes % sizeof(TrackerStorageStat) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data length: %"PRId64
__LINE__, pTrackerServer->ip_addr, \ " is invalid", __LINE__, formatted_ip,
pTrackerServer->port, in_bytes); pTrackerServer->port, in_bytes);
*storage_count = 0; *storage_count = 0;
return EINVAL; return EINVAL;
@ -342,11 +342,12 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
*storage_count = in_bytes / sizeof(TrackerStorageStat); *storage_count = in_bytes / sizeof(TrackerStorageStat);
if (*storage_count > max_storages) if (*storage_count > max_storages)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u insufficent space, " \ logError("file: "__FILE__", line: %d, "
"max storage count: %d, expect count: %d", \ "tracker server %s:%u insufficent space, "
__LINE__, pTrackerServer->ip_addr, \ "max storage count: %d, expect count: %d",
pTrackerServer->port, max_storages, *storage_count); __LINE__, formatted_ip, pTrackerServer->port,
max_storages, *storage_count);
*storage_count = 0; *storage_count = 0;
return ENOSPC; return ENOSPC;
} }
@ -484,6 +485,7 @@ int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
ConnectionInfo *conn; ConnectionInfo *conn;
bool new_connection; bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerGroupStat src; TrackerGroupStat src;
char *pInBuff; char *pInBuff;
int result; int result;
@ -497,15 +499,14 @@ int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
sizeof(TrackerHeader), "%s", group_name); sizeof(TrackerHeader), "%s", group_name);
pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_ONE_GROUP; pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_ONE_GROUP;
long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, errno: %d, "
pTrackerServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -532,10 +533,10 @@ int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
if (in_bytes != sizeof(TrackerGroupStat)) if (in_bytes != sizeof(TrackerGroupStat))
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data length: %"PRId64" "
__LINE__, pTrackerServer->ip_addr, \ "is invalid", __LINE__, formatted_ip,
pTrackerServer->port, in_bytes); pTrackerServer->port, in_bytes);
return EINVAL; return EINVAL;
} }
@ -569,6 +570,7 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
TrackerGroupStat *pSrc; TrackerGroupStat *pSrc;
TrackerGroupStat *pEnd; TrackerGroupStat *pEnd;
FDFSGroupStat *pDest; FDFSGroupStat *pDest;
char formatted_ip[FORMATTED_IP_SIZE];
int result; int result;
int64_t in_bytes; int64_t in_bytes;
@ -577,15 +579,14 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
memset(&header, 0, sizeof(header)); memset(&header, 0, sizeof(header));
header.cmd = TRACKER_PROTO_CMD_SERVER_LIST_ALL_GROUPS; header.cmd = TRACKER_PROTO_CMD_SERVER_LIST_ALL_GROUPS;
header.status = 0; header.status = 0;
if ((result=tcpsenddata_nb(conn->sock, &header, \ if ((result=tcpsenddata_nb(conn->sock, &header,
sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, errno: %d, "
pTrackerServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -613,10 +614,10 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
if (in_bytes % sizeof(TrackerGroupStat) != 0) if (in_bytes % sizeof(TrackerGroupStat) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data length: %"PRId64" "
__LINE__, pTrackerServer->ip_addr, \ "is invalid", __LINE__, formatted_ip,
pTrackerServer->port, in_bytes); pTrackerServer->port, in_bytes);
*group_count = 0; *group_count = 0;
return EINVAL; return EINVAL;
@ -625,11 +626,12 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
*group_count = in_bytes / sizeof(TrackerGroupStat); *group_count = in_bytes / sizeof(TrackerGroupStat);
if (*group_count > max_groups) if (*group_count > max_groups)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u insufficent space, " \ logError("file: "__FILE__", line: %d, "
"max group count: %d, expect count: %d", \ "tracker server %s:%u insufficent space, "
__LINE__, pTrackerServer->ip_addr, \ "max group count: %d, expect count: %d",
pTrackerServer->port, max_groups, *group_count); __LINE__, formatted_ip, pTrackerServer->port,
max_groups, *group_count);
*group_count = 0; *group_count = 0;
return ENOSPC; return ENOSPC;
} }
@ -672,6 +674,7 @@ int tracker_do_query_storage(ConnectionInfo *pTrackerServer, \
bool new_connection; bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 128]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 128];
char in_buff[sizeof(TrackerHeader) + TRACKER_QUERY_STORAGE_FETCH_BODY_LEN]; char in_buff[sizeof(TrackerHeader) + TRACKER_QUERY_STORAGE_FETCH_BODY_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
int result; int result;
@ -693,16 +696,15 @@ int tracker_do_query_storage(ConnectionInfo *pTrackerServer, \
long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
pHeader->cmd = cmd; pHeader->cmd = cmd;
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
filename_len, SF_G_NETWORK_TIMEOUT)) != 0) filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, errno: %d, "
pTrackerServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -729,12 +731,11 @@ int tracker_do_query_storage(ConnectionInfo *pTrackerServer, \
if (in_bytes != TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) if (in_bytes != TRACKER_QUERY_STORAGE_FETCH_BODY_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "tracker server %s:%u response data length: %"PRId64" "
"expect length: %d", __LINE__, \ "is invalid, expect length: %d", __LINE__,
pTrackerServer->ip_addr, \ formatted_ip, pTrackerServer->port, in_bytes,
pTrackerServer->port, in_bytes, \
TRACKER_QUERY_STORAGE_FETCH_BODY_LEN); TRACKER_QUERY_STORAGE_FETCH_BODY_LEN);
return EINVAL; return EINVAL;
} }
@ -759,6 +760,7 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
char in_buff[sizeof(TrackerHeader) + \ char in_buff[sizeof(TrackerHeader) + \
TRACKER_QUERY_STORAGE_FETCH_BODY_LEN + \ TRACKER_QUERY_STORAGE_FETCH_BODY_LEN + \
FDFS_MAX_SERVERS_EACH_GROUP * IP_ADDRESS_SIZE]; FDFS_MAX_SERVERS_EACH_GROUP * IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
int result; int result;
@ -781,12 +783,11 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
filename_len, SF_G_NETWORK_TIMEOUT)) != 0) filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -814,10 +815,10 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
if ((in_bytes - TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) % \ if ((in_bytes - TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) % \
(IP_ADDRESS_SIZE - 1) != 0) (IP_ADDRESS_SIZE - 1) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data length: %"PRId64" "
__LINE__, pTrackerServer->ip_addr, \ "is invalid", __LINE__, formatted_ip,
pTrackerServer->port, in_bytes); pTrackerServer->port, in_bytes);
return EINVAL; return EINVAL;
} }
@ -826,10 +827,11 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
(IP_ADDRESS_SIZE - 1); (IP_ADDRESS_SIZE - 1);
if (nMaxServerCount < *server_count) if (nMaxServerCount < *server_count)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response storage server " \ logError("file: "__FILE__", line: %d, "
"count: %d, exceeds max server count: %d!", __LINE__, \ "tracker server %s:%u response storage server "
pTrackerServer->ip_addr, pTrackerServer->port, \ "count: %d, exceeds max server count: %d!", __LINE__,
formatted_ip, pTrackerServer->port,
*server_count, nMaxServerCount); *server_count, nMaxServerCount);
return ENOSPC; return ENOSPC;
} }
@ -864,6 +866,7 @@ int tracker_query_storage_store_without_group(ConnectionInfo *pTrackerServer,
TrackerHeader header; TrackerHeader header;
char in_buff[sizeof(TrackerHeader) + \ char in_buff[sizeof(TrackerHeader) + \
TRACKER_QUERY_STORAGE_STORE_BODY_LEN]; TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
bool new_connection; bool new_connection;
ConnectionInfo *conn; ConnectionInfo *conn;
char *pInBuff; char *pInBuff;
@ -880,12 +883,11 @@ int tracker_query_storage_store_without_group(ConnectionInfo *pTrackerServer,
if ((result=tcpsenddata_nb(conn->sock, &header, \ if ((result=tcpsenddata_nb(conn->sock, &header, \
sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -912,12 +914,12 @@ int tracker_query_storage_store_without_group(ConnectionInfo *pTrackerServer,
if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN) if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "tracker server %s:%u response data length: %"PRId64" "
"expect length: %d", __LINE__, \ "is invalid, expect length: %d", __LINE__,
pTrackerServer->ip_addr, pTrackerServer->port, \ formatted_ip, pTrackerServer->port, in_bytes,
in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN); TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
return EINVAL; return EINVAL;
} }
@ -943,6 +945,7 @@ int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char in_buff[sizeof(TrackerHeader) + \ char in_buff[sizeof(TrackerHeader) + \
TRACKER_QUERY_STORAGE_STORE_BODY_LEN]; TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
int result; int result;
@ -959,16 +962,15 @@ int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ONE; pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ONE;
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, \ sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -995,11 +997,11 @@ int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN) if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "tracker server %s:%u response data "
"expect length: %d", __LINE__, \ "length: %"PRId64" is invalid, expect length: %d",
pTrackerServer->ip_addr, pTrackerServer->port, \ __LINE__, formatted_ip, pTrackerServer->port,
in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN); in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
return EINVAL; return EINVAL;
} }
@ -1027,6 +1029,7 @@ int tracker_query_storage_store_list_with_group( \
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char in_buff[sizeof(TrackerHeader) + FDFS_MAX_SERVERS_EACH_GROUP * \ char in_buff[sizeof(TrackerHeader) + FDFS_MAX_SERVERS_EACH_GROUP * \
TRACKER_QUERY_STORAGE_STORE_BODY_LEN]; TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
char returned_group_name[FDFS_GROUP_NAME_MAX_LEN + 1]; char returned_group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
char *pInBuff; char *pInBuff;
char *p; char *p;
@ -1055,15 +1058,14 @@ int tracker_query_storage_store_list_with_group( \
} }
long2buff(out_len, pHeader->pkg_len); long2buff(out_len, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(TrackerHeader) + out_len, SF_G_NETWORK_TIMEOUT)) != 0) sizeof(TrackerHeader) + out_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -1090,11 +1092,11 @@ int tracker_query_storage_store_list_with_group( \
if (in_bytes < TRACKER_QUERY_STORAGE_STORE_BODY_LEN) if (in_bytes < TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "tracker server %s:%u response data "
"expect length >= %d", __LINE__, \ "length: %"PRId64" is invalid, expect length >= %d",
pTrackerServer->ip_addr, pTrackerServer->port, \ __LINE__, formatted_ip, pTrackerServer->port,
in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN); in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
return EINVAL; return EINVAL;
} }
@ -1104,22 +1106,23 @@ int tracker_query_storage_store_list_with_group( \
ipPortsLen = in_bytes - (FDFS_GROUP_NAME_MAX_LEN + 1); ipPortsLen = in_bytes - (FDFS_GROUP_NAME_MAX_LEN + 1);
if (ipPortsLen % RECORD_LENGTH != 0) if (ipPortsLen % RECORD_LENGTH != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data "
__LINE__, pTrackerServer->ip_addr, \ "length: %"PRId64" is invalid", __LINE__,
pTrackerServer->port, in_bytes); formatted_ip, pTrackerServer->port, in_bytes);
return EINVAL; return EINVAL;
} }
*storage_count = ipPortsLen / RECORD_LENGTH; *storage_count = ipPortsLen / RECORD_LENGTH;
if (nMaxServerCount < *storage_count) if (nMaxServerCount < *storage_count)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response storage server " \ logError("file: "__FILE__", line: %d, "
"count: %d, exceeds max server count: %d!", \ "tracker server %s:%u response storage server "
__LINE__, pTrackerServer->ip_addr, \ "count: %d, exceeds max server count: %d!",
pTrackerServer->port, *storage_count, nMaxServerCount); __LINE__, formatted_ip, pTrackerServer->port,
*storage_count, nMaxServerCount);
return ENOSPC; return ENOSPC;
} }
@ -1157,6 +1160,7 @@ int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
FDFSStorageInfo storage_infos[1]; FDFSStorageInfo storage_infos[1];
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
FDFS_STORAGE_ID_MAX_SIZE]; FDFS_STORAGE_ID_MAX_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
@ -1228,11 +1232,11 @@ int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
storage_id_len, SF_G_NETWORK_TIMEOUT)) != 0) storage_id_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to tracker server %s:%u fail, " "send data to tracker server %s:%u fail, "
"errno: %d, error info: %s", __LINE__, "errno: %d, error info: %s", __LINE__, formatted_ip,
conn->ip_addr, conn->port, conn->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -1280,6 +1284,7 @@ int tracker_delete_group(TrackerServerGroup *pTrackerGroup, \
TrackerServerInfo *pServer; TrackerServerInfo *pServer;
TrackerServerInfo *pEnd; TrackerServerInfo *pEnd;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
@ -1308,11 +1313,11 @@ int tracker_delete_group(TrackerServerGroup *pTrackerGroup, \
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to tracker server %s:%u fail, " "send data to tracker server %s:%u fail, "
"errno: %d, error info: %s", __LINE__, "errno: %d, error info: %s", __LINE__, formatted_ip,
conn->ip_addr, conn->port, conn->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -1343,6 +1348,7 @@ int tracker_set_trunk_server(TrackerServerGroup *pTrackerGroup, \
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
FDFS_STORAGE_ID_MAX_SIZE]; FDFS_STORAGE_ID_MAX_SIZE];
char in_buff[FDFS_STORAGE_ID_MAX_SIZE]; char in_buff[FDFS_STORAGE_ID_MAX_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
int result; int result;
@ -1380,15 +1386,15 @@ int tracker_set_trunk_server(TrackerServerGroup *pTrackerGroup, \
continue; continue;
} }
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
storage_id_len, SF_G_NETWORK_TIMEOUT)) != 0) storage_id_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to tracker server %s:%u fail, " "send data to tracker server %s:%u fail, "
"errno: %d, error info: %s", __LINE__, "errno: %d, error info: %s", __LINE__, formatted_ip,
conn->ip_addr, conn->port, conn->port, result, STRERROR(result));
result, STRERROR(result));
tracker_close_connection_ex(conn, true); tracker_close_connection_ex(conn, true);
continue; continue;
@ -1438,6 +1444,7 @@ int tracker_get_storage_status(ConnectionInfo *pTrackerServer,
bool new_connection; bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
IP_ADDRESS_SIZE]; IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
char *p; char *p;
int result; int result;
@ -1467,15 +1474,14 @@ int tracker_get_storage_status(ConnectionInfo *pTrackerServer,
} }
pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_STATUS; pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_STATUS;
long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -1502,11 +1508,11 @@ int tracker_get_storage_status(ConnectionInfo *pTrackerServer,
if (in_bytes != sizeof(FDFSStorageBrief)) if (in_bytes != sizeof(FDFSStorageBrief))
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data "
__LINE__, pTrackerServer->ip_addr, \ "length: %"PRId64" is invalid", __LINE__,
pTrackerServer->port, in_bytes); formatted_ip, pTrackerServer->port, in_bytes);
return EINVAL; return EINVAL;
} }
@ -1522,6 +1528,7 @@ int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
bool new_connection; bool new_connection;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
IP_ADDRESS_SIZE]; IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int result; int result;
int ip_len; int ip_len;
@ -1555,15 +1562,14 @@ int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
} }
pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_SERVER_ID; pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_SERVER_ID;
long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
} }
else else
{ {
@ -1589,10 +1595,10 @@ int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
if (in_bytes == 0 || in_bytes >= FDFS_STORAGE_ID_MAX_SIZE) if (in_bytes == 0 || in_bytes >= FDFS_STORAGE_ID_MAX_SIZE)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid", \ "tracker server %s:%u response data length: %"PRId64" "
__LINE__, pTrackerServer->ip_addr, \ "is invalid", __LINE__, formatted_ip,
pTrackerServer->port, in_bytes); pTrackerServer->port, in_bytes);
return EINVAL; return EINVAL;
} }
@ -1654,4 +1660,3 @@ int tracker_get_storage_max_status(TrackerServerGroup *pTrackerGroup, \
return 0; return 0;
} }

2
make.sh
View File

@ -6,7 +6,7 @@ TARGET_SYSTEMD_PATH=$DESTDIR/usr/lib/systemd/system
WITH_LINUX_SERVICE=1 WITH_LINUX_SERVICE=1
DEBUG_FLAG=0 DEBUG_FLAG=1
export CC=gcc export CC=gcc
CFLAGS='-Wall' CFLAGS='-Wall'

36
storage/storage_disk_recovery.c
View File

@ -119,6 +119,7 @@ static int storage_do_fetch_binlog(ConnectionInfo *pSrcStorage, \
{ {
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 1]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 1];
char full_binlog_filename[MAX_PATH_SIZE]; char full_binlog_filename[MAX_PATH_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader *pHeader; TrackerHeader *pHeader;
char *pBasePath; char *pBasePath;
int64_t in_bytes; int64_t in_bytes;
@ -142,10 +143,11 @@ static int storage_do_fetch_binlog(ConnectionInfo *pSrcStorage, \
if((result=tcpsenddata_nb(pSrcStorage->sock, out_buff, if((result=tcpsenddata_nb(pSrcStorage->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(pSrcStorage->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"storage server %s:%u, send data fail, " "storage server %s:%u, send data fail, "
"errno: %d, error info: %s.", "errno: %d, error info: %s.", __LINE__,
__LINE__, pSrcStorage->ip_addr, pSrcStorage->port, formatted_ip, pSrcStorage->port,
result, STRERROR(result)); result, STRERROR(result));
return result; return result;
} }
@ -170,17 +172,19 @@ static int storage_do_fetch_binlog(ConnectionInfo *pSrcStorage, \
if ((result=tcprecvfile(pSrcStorage->sock, full_binlog_filename, if ((result=tcprecvfile(pSrcStorage->sock, full_binlog_filename,
in_bytes, 0, network_timeout, &file_bytes)) != 0) in_bytes, 0, network_timeout, &file_bytes)) != 0)
{ {
format_ip_address(pSrcStorage->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"storage server %s:%u, tcprecvfile fail, " "storage server %s:%u, tcprecvfile fail, "
"errno: %d, error info: %s.", "errno: %d, error info: %s.", __LINE__,
__LINE__, pSrcStorage->ip_addr, pSrcStorage->port, formatted_ip, pSrcStorage->port,
result, STRERROR(result)); result, STRERROR(result));
return result; return result;
} }
format_ip_address(pSrcStorage->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"recovery binlog from %s:%u, file size: %"PRId64, __LINE__, "recovery binlog from %s:%u, file size: %"PRId64, __LINE__,
pSrcStorage->ip_addr, pSrcStorage->port, file_bytes); formatted_ip, pSrcStorage->port, file_bytes);
return 0; return 0;
} }
@ -196,6 +200,7 @@ static int recovery_get_src_storage_server(ConnectionInfo *pSrcStorage)
FDFSGroupStat groupStat; FDFSGroupStat groupStat;
FDFSStorageInfo storageStats[FDFS_MAX_SERVERS_EACH_GROUP]; FDFSStorageInfo storageStats[FDFS_MAX_SERVERS_EACH_GROUP];
FDFSStorageInfo *pStorageStat; FDFSStorageInfo *pStorageStat;
char formatted_ip[FORMATTED_IP_SIZE];
bool found; bool found;
memset(pSrcStorage, 0, sizeof(ConnectionInfo)); memset(pSrcStorage, 0, sizeof(ConnectionInfo));
@ -356,9 +361,12 @@ static int recovery_get_src_storage_server(ConnectionInfo *pSrcStorage)
return EINTR; return EINTR;
} }
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
format_ip_address(pSrcStorage->ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"disk recovery: get source storage server %s:%u", "disk recovery: get source storage server %s:%u",
__LINE__, pSrcStorage->ip_addr, pSrcStorage->port); __LINE__, formatted_ip, pSrcStorage->port);
}
return 0; return 0;
} }
@ -721,6 +729,7 @@ static int storage_do_recovery(RecoveryThreadData *pThreadData,
bool bContinueFlag; bool bContinueFlag;
char local_filename[MAX_PATH_SIZE]; char local_filename[MAX_PATH_SIZE];
char src_filename[MAX_PATH_SIZE]; char src_filename[MAX_PATH_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
pTrackerServer = tracker_get_connection_r(&trackerServer, &result); pTrackerServer = tracker_get_connection_r(&trackerServer, &result);
if (pTrackerServer == NULL) if (pTrackerServer == NULL)
@ -737,10 +746,11 @@ static int storage_do_recovery(RecoveryThreadData *pThreadData,
noent_count = 0; noent_count = 0;
result = 0; result = 0;
format_ip_address(pSrcStorage->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"disk recovery thread #%d, src storage server %s:%u, " "disk recovery thread #%d, src storage server %s:%u, "
"recovering files of data path: %s ...", __LINE__, "recovering files of data path: %s ...", __LINE__,
pThreadData->thread_index, pSrcStorage->ip_addr, pThreadData->thread_index, formatted_ip,
pSrcStorage->port, pThreadData->base_path); pSrcStorage->port, pThreadData->base_path);
bContinueFlag = true; bContinueFlag = true;
@ -924,10 +934,11 @@ static int storage_do_recovery(RecoveryThreadData *pThreadData,
if (pThreadData->done) if (pThreadData->done)
{ {
format_ip_address(pSrcStorage->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"disk recovery thread #%d, src storage server %s:%u, " "disk recovery thread #%d, src storage server %s:%u, "
"recover files of data path: %s done", __LINE__, "recover files of data path: %s done", __LINE__,
pThreadData->thread_index, pSrcStorage->ip_addr, pThreadData->thread_index, formatted_ip,
pSrcStorage->port, pThreadData->base_path); pSrcStorage->port, pThreadData->base_path);
} }
@ -1700,10 +1711,11 @@ static int storage_disk_recovery_split_trunk_binlog(const int store_path_index)
int storage_disk_recovery_prepare(const int store_path_index) int storage_disk_recovery_prepare(const int store_path_index)
{ {
char formatted_ip[FORMATTED_IP_SIZE];
ConnectionInfo srcStorage; ConnectionInfo srcStorage;
ConnectionInfo *pStorageConn; ConnectionInfo *pStorageConn;
int result;
char *pBasePath; char *pBasePath;
int result;
pBasePath = g_fdfs_store_paths.paths[store_path_index].path; pBasePath = g_fdfs_store_paths.paths[store_path_index].path;
if ((result=recovery_init_flag_file(pBasePath, false, -1)) != 0) if ((result=recovery_init_flag_file(pBasePath, false, -1)) != 0)
@ -1748,9 +1760,10 @@ int storage_disk_recovery_prepare(const int store_path_index)
return result; return result;
} }
format_ip_address(pStorageConn->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"try to fetch binlog from %s:%u ...", __LINE__, "try to fetch binlog from %s:%u ...", __LINE__,
pStorageConn->ip_addr, pStorageConn->port); formatted_ip, pStorageConn->port);
result = storage_do_fetch_binlog(pStorageConn, store_path_index); result = storage_do_fetch_binlog(pStorageConn, store_path_index);
tracker_close_connection_ex(pStorageConn, true); tracker_close_connection_ex(pStorageConn, true);
@ -1759,9 +1772,10 @@ int storage_disk_recovery_prepare(const int store_path_index)
return result; return result;
} }
format_ip_address(pStorageConn->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"fetch binlog from %s:%u successfully.", __LINE__, "fetch binlog from %s:%u successfully.", __LINE__,
pStorageConn->ip_addr, pStorageConn->port); formatted_ip, pStorageConn->port);
if ((result=storage_disk_recovery_split_trunk_binlog( if ((result=storage_disk_recovery_split_trunk_binlog(
store_path_index)) != 0) store_path_index)) != 0)

20
storage/storage_dump.c
View File

@ -32,6 +32,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
char reserved_space_str[32]; char reserved_space_str[32];
char tracker_client_ip_str[256]; char tracker_client_ip_str[256];
char last_storage_ip_str[256]; char last_storage_ip_str[256];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
int total_len; int total_len;
int i; int i;
@ -40,6 +41,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
tracker_client_ip_str, sizeof(tracker_client_ip_str)); tracker_client_ip_str, sizeof(tracker_client_ip_str));
fdfs_multi_ips_to_string(&g_last_storage_ip, fdfs_multi_ips_to_string(&g_last_storage_ip,
last_storage_ip_str, sizeof(last_storage_ip_str)); last_storage_ip_str, sizeof(last_storage_ip_str));
format_ip_address(g_trunk_server.connections[0].ip_addr, formatted_ip);
total_len = snprintf(buff, buffSize, total_len = snprintf(buff, buffSize,
"SF_G_CONNECT_TIMEOUT=%ds\n" "SF_G_CONNECT_TIMEOUT=%ds\n"
@ -49,7 +51,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
"SF_G_CONTINUE_FLAG=%d\n" "SF_G_CONTINUE_FLAG=%d\n"
"g_schedule_flag=%d\n" "g_schedule_flag=%d\n"
"SF_G_INNER_PORT=%d\n" "SF_G_INNER_PORT=%d\n"
"g_max_connections=%d\n" "SF_G_MAX_CONNECTIONS=%d\n"
"g_storage_thread_count=%d\n" "g_storage_thread_count=%d\n"
"g_group_name=%s\n" "g_group_name=%s\n"
"g_subdir_count_per_path=%d\n" "g_subdir_count_per_path=%d\n"
@ -143,7 +145,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
, g_fdfs_version.patch, SF_G_CONTINUE_FLAG , g_fdfs_version.patch, SF_G_CONTINUE_FLAG
, g_schedule_flag , g_schedule_flag
, SF_G_INNER_PORT , SF_G_INNER_PORT
, g_sf_global_vars.max_connections , SF_G_MAX_CONNECTIONS
, SF_G_ALIVE_THREAD_COUNT , SF_G_ALIVE_THREAD_COUNT
, g_group_name , g_group_name
, g_subdir_count_per_path , g_subdir_count_per_path
@ -208,18 +210,18 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
, g_slot_min_size , g_slot_min_size
, g_trunk_file_size , g_trunk_file_size
, g_store_path_mode , g_store_path_mode
, fdfs_storage_reserved_space_to_string( \ , fdfs_storage_reserved_space_to_string(
&g_storage_reserved_space, reserved_space_str) \ &g_storage_reserved_space, reserved_space_str)
, g_avg_storage_reserved_mb , g_avg_storage_reserved_mb
, g_store_path_index , g_store_path_index
, g_current_trunk_file_id , g_current_trunk_file_id
, g_trunk_sync_thread_count , g_trunk_sync_thread_count
, g_trunk_server.connections[0].ip_addr , formatted_ip
, g_trunk_server.connections[0].port , g_trunk_server.connections[0].port
, g_trunk_total_free_space , g_trunk_total_free_space
, g_use_connection_pool , g_use_connection_pool
, g_connection_pool_max_idle_time , g_connection_pool_max_idle_time
, g_use_connection_pool ? conn_pool_get_connection_count( \ , g_use_connection_pool ? conn_pool_get_connection_count(
&g_connection_pool) : 0 &g_connection_pool) : 0
#ifdef WITH_HTTPD #ifdef WITH_HTTPD
, g_http_params.disabled , g_http_params.disabled
@ -272,6 +274,7 @@ static int fdfs_dump_tracker_servers(char *buff, const int buffSize)
int total_len; int total_len;
TrackerServerInfo *pTrackerServer; TrackerServerInfo *pTrackerServer;
TrackerServerInfo *pTrackerEnd; TrackerServerInfo *pTrackerEnd;
char formatted_ip[FORMATTED_IP_SIZE];
total_len = snprintf(buff, buffSize, \ total_len = snprintf(buff, buffSize, \
"\ng_tracker_group.server_count=%d, " \ "\ng_tracker_group.server_count=%d, " \
@ -287,11 +290,12 @@ static int fdfs_dump_tracker_servers(char *buff, const int buffSize)
for (pTrackerServer=g_tracker_group.servers; \ for (pTrackerServer=g_tracker_group.servers; \
pTrackerServer<pTrackerEnd; pTrackerServer++) pTrackerServer<pTrackerEnd; pTrackerServer++)
{ {
format_ip_address(pTrackerServer->connections[0].
ip_addr, formatted_ip);
total_len += snprintf(buff + total_len, buffSize - total_len, total_len += snprintf(buff + total_len, buffSize - total_len,
"\t%d. tracker server=%s:%u\n", "\t%d. tracker server=%s:%u\n",
(int)(pTrackerServer - g_tracker_group.servers) + 1, (int)(pTrackerServer - g_tracker_group.servers) + 1,
pTrackerServer->connections[0].ip_addr, formatted_ip, pTrackerServer->connections[0].port);
pTrackerServer->connections[0].port);
} }
return total_len; return total_len;

59
storage/storage_func.c
View File

@ -141,6 +141,7 @@ static int storage_check_and_make_data_dirs();
static int storage_do_get_group_name(ConnectionInfo *pTrackerServer) static int storage_do_get_group_name(ConnectionInfo *pTrackerServer)
{ {
char out_buff[sizeof(TrackerHeader) + 4]; char out_buff[sizeof(TrackerHeader) + 4];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader *pHeader; TrackerHeader *pHeader;
char *pInBuff; char *pInBuff;
int64_t in_bytes; int64_t in_bytes;
@ -154,12 +155,11 @@ static int storage_do_get_group_name(ConnectionInfo *pTrackerServer)
if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u, send data fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s.", \ "tracker server %s:%u, send data fail, errno: %d, "
__LINE__, pTrackerServer->ip_addr, \ "error info: %s.", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
@ -175,11 +175,11 @@ static int storage_do_get_group_name(ConnectionInfo *pTrackerServer)
if (in_bytes != FDFS_GROUP_NAME_MAX_LEN) if (in_bytes != FDFS_GROUP_NAME_MAX_LEN)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u, recv body length: " \ logError("file: "__FILE__", line: %d, "
"%"PRId64" != %d", \ "tracker server %s:%u, recv body length: %"PRId64" != %d",
__LINE__, pTrackerServer->ip_addr, \ __LINE__, formatted_ip, pTrackerServer->port,
pTrackerServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN); in_bytes, FDFS_GROUP_NAME_MAX_LEN);
return EINVAL; return EINVAL;
} }
@ -1410,6 +1410,7 @@ static int storage_check_tracker_ipaddr(const char *filename)
TrackerServerInfo *pEnd; TrackerServerInfo *pEnd;
ConnectionInfo *conn; ConnectionInfo *conn;
ConnectionInfo *conn_end; ConnectionInfo *conn_end;
char formatted_ip[FORMATTED_IP_SIZE];
pEnd = g_tracker_group.servers + g_tracker_group.server_count; pEnd = g_tracker_group.servers + g_tracker_group.server_count;
for (pServer=g_tracker_group.servers; pServer<pEnd; pServer++) for (pServer=g_tracker_group.servers; pServer<pEnd; pServer++)
@ -1417,13 +1418,13 @@ static int storage_check_tracker_ipaddr(const char *filename)
conn_end = pServer->connections + pServer->count; conn_end = pServer->connections + pServer->count;
for (conn=pServer->connections; conn<conn_end; conn++) for (conn=pServer->connections; conn<conn_end; conn++)
{ {
//logInfo("server=%s:%u\n", conn->ip_addr, conn->port); if (is_loopback_ip(conn->ip_addr))
if (strcmp(conn->ip_addr, "127.0.0.1") == 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"conf file \"%s\", tracker: \"%s:%u\" is invalid, " "conf file \"%s\", tracker: \"%s:%u\" is invalid, "
"tracker server ip can't be 127.0.0.1", "tracker server ip can't be loopback address",
__LINE__, filename, conn->ip_addr, conn->port); __LINE__, filename, formatted_ip, conn->port);
return EINVAL; return EINVAL;
} }
} }
@ -2256,6 +2257,7 @@ static int storage_get_my_ip_from_tracker(ConnectionInfo *conn,
char *ip_addrs, const int buff_size) char *ip_addrs, const int buff_size)
{ {
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader *pHeader; TrackerHeader *pHeader;
int result; int result;
int64_t in_bytes; int64_t in_bytes;
@ -2269,21 +2271,21 @@ static int storage_get_my_ip_from_tracker(ConnectionInfo *conn,
if((result=tcpsenddata_nb(conn->sock, out_buff, if((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, send data fail, " "tracker server %s:%u, send data fail, errno: %d, "
"errno: %d, error info: %s.", "error info: %s.", __LINE__, formatted_ip,
__LINE__, conn->ip_addr, conn->port, conn->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
if ((result=fdfs_recv_response(conn, &ip_addrs, if ((result=fdfs_recv_response(conn, &ip_addrs,
buff_size - 1, &in_bytes)) != 0) buff_size - 1, &in_bytes)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, recv response fail, " "tracker server %s:%u, recv response fail, errno: %d, "
"errno: %d, error info: %s.", "error info: %s.", __LINE__, formatted_ip, conn->port,
__LINE__, conn->ip_addr, conn->port,
result, STRERROR(result)); result, STRERROR(result));
return result; return result;
} }
@ -2297,6 +2299,7 @@ int storage_set_tracker_client_ips(ConnectionInfo *conn,
{ {
char my_ip_addrs[256]; char my_ip_addrs[256];
char error_info[256]; char error_info[256];
char formatted_ip[FORMATTED_IP_SIZE];
FDFSMultiIP multi_ip; FDFSMultiIP multi_ip;
int result; int result;
int i; int i;
@ -2327,13 +2330,12 @@ int storage_set_tracker_client_ips(ConnectionInfo *conn,
if ((result=fdfs_check_and_format_ips(&g_tracker_client_ip, if ((result=fdfs_check_and_format_ips(&g_tracker_client_ip,
error_info, sizeof(error_info))) != 0) error_info, sizeof(error_info))) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logCrit("file: "__FILE__", line: %d, " logCrit("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%u, " "as a client of tracker server %s:%u, "
"my ip: %s not valid, error info: %s. " "my ip: %s not valid, error info: %s. "
"program exit!", __LINE__, "program exit!", __LINE__, formatted_ip,
conn->ip_addr, conn->port, conn->port, multi_ip.ips[i].address, error_info);
multi_ip.ips[i].address, error_info);
return result; return result;
} }
@ -2345,11 +2347,12 @@ int storage_set_tracker_client_ips(ConnectionInfo *conn,
fdfs_multi_ips_to_string(&g_tracker_client_ip, fdfs_multi_ips_to_string(&g_tracker_client_ip,
ip_str, sizeof(ip_str)); ip_str, sizeof(ip_str));
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%u, " "as a client of tracker server %s:%u, "
"my ip: %s not consistent with client ips: %s " "my ip: %s not consistent with client ips: %s "
"of other tracker client. program exit!", __LINE__, "of other tracker client. program exit!",
conn->ip_addr, conn->port, __LINE__, formatted_ip, conn->port,
multi_ip.ips[i].address, ip_str); multi_ip.ips[i].address, ip_str);
return result; return result;

55
storage/storage_ip_changed_dealer.c
View File

@ -32,6 +32,7 @@ static int storage_do_changelog_req(ConnectionInfo *pTrackerServer)
{ {
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
FDFS_STORAGE_ID_MAX_SIZE]; FDFS_STORAGE_ID_MAX_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader *pHeader; TrackerHeader *pHeader;
int result; int result;
@ -44,15 +45,14 @@ static int storage_do_changelog_req(ConnectionInfo *pTrackerServer)
strcpy(out_buff + sizeof(TrackerHeader), g_group_name); strcpy(out_buff + sizeof(TrackerHeader), g_group_name);
strcpy(out_buff + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, strcpy(out_buff + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
g_my_server_id_str); g_my_server_id_str);
if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \ if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u, send data fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s.", \ "tracker server %s:%u, send data fail, "
__LINE__, pTrackerServer->ip_addr, \ "errno: %d, error info: %s.", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
@ -64,6 +64,7 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \ char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
2 * IP_ADDRESS_SIZE]; 2 * IP_ADDRESS_SIZE];
char in_buff[1]; char in_buff[1];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
TrackerHeader *pHeader; TrackerHeader *pHeader;
int result; int result;
@ -83,10 +84,10 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \ if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u, send data fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "tracker server %s:%u, send data fail, "
__LINE__, pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, result, STRERROR(result)); pTrackerServer->port, result, STRERROR(result));
return result; return result;
} }
@ -108,12 +109,12 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
} }
else else
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, recv data fail or " "tracker server %s:%u, recv data fail or "
"response status != 0, " "response status != 0, errno: %d, error info: %s",
"errno: %d, error info: %s", __LINE__, formatted_ip, pTrackerServer->port,
__LINE__, pTrackerServer->ip_addr, result, STRERROR(result));
pTrackerServer->port, result, STRERROR(result));
return result == EBUSY ? 0 : result; return result == EBUSY ? 0 : result;
} }
} }
@ -126,6 +127,7 @@ int storage_get_my_tracker_client_ip()
TrackerServerInfo trackerServer; TrackerServerInfo trackerServer;
ConnectionInfo *conn; ConnectionInfo *conn;
char tracker_client_ip[IP_ADDRESS_SIZE]; char tracker_client_ip[IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
int success_count; int success_count;
int result; int result;
int i; int i;
@ -159,12 +161,11 @@ int storage_get_my_tracker_client_ip()
if (conn == NULL) if (conn == NULL)
{ {
format_ip_address(pTServer->connections[0].ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to tracker server %s:%u fail, " "connect to tracker server %s:%u fail, "
"errno: %d, error info: %s", "errno: %d, error info: %s", __LINE__, formatted_ip,
__LINE__, pTServer->connections[0].ip_addr, pTServer->connections[0].port, result, STRERROR(result));
pTServer->connections[0].port,
result, STRERROR(result));
continue; continue;
} }
@ -199,6 +200,7 @@ static int storage_report_storage_ip_addr()
TrackerServerInfo *pTServer; TrackerServerInfo *pTServer;
TrackerServerInfo *pTServerEnd; TrackerServerInfo *pTServerEnd;
TrackerServerInfo trackerServer; TrackerServerInfo trackerServer;
char formatted_ip[FORMATTED_IP_SIZE];
ConnectionInfo *conn; ConnectionInfo *conn;
int success_count; int success_count;
int result; int result;
@ -248,12 +250,11 @@ static int storage_report_storage_ip_addr()
if (conn == NULL) if (conn == NULL)
{ {
format_ip_address(pTServer->connections[0].ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to tracker server %s:%u fail, " "connect to tracker server %s:%u fail, "
"errno: %d, error info: %s", "errno: %d, error info: %s", __LINE__, formatted_ip,
__LINE__, pTServer->connections[0].ip_addr, pTServer->connections[0].port, result, STRERROR(result));
pTServer->connections[0].port,
result, STRERROR(result));
continue; continue;
} }
@ -286,6 +287,7 @@ int storage_changelog_req()
TrackerServerInfo *pTServer; TrackerServerInfo *pTServer;
TrackerServerInfo *pTServerEnd; TrackerServerInfo *pTServerEnd;
TrackerServerInfo trackerServer; TrackerServerInfo trackerServer;
char formatted_ip[FORMATTED_IP_SIZE];
ConnectionInfo *conn; ConnectionInfo *conn;
int success_count; int success_count;
int result; int result;
@ -319,12 +321,11 @@ int storage_changelog_req()
if (conn == NULL) if (conn == NULL)
{ {
format_ip_address(pTServer->connections[0].ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to tracker server %s:%u fail, " "connect to tracker server %s:%u fail, "
"errno: %d, error info: %s", "errno: %d, error info: %s", __LINE__, formatted_ip,
__LINE__, pTServer->connections[0].ip_addr, pTServer->connections[0].port, result, STRERROR(result));
pTServer->connections[0].port,
result, STRERROR(result));
continue; continue;
} }

182
storage/storage_sync.c
View File

@ -96,6 +96,7 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
char *pBuff; char *pBuff;
char full_filename[MAX_PATH_SIZE]; char full_filename[MAX_PATH_SIZE];
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
struct stat stat_buf; struct stat stat_buf;
FDFSTrunkFullInfo trunkInfo; FDFSTrunkFullInfo trunkInfo;
@ -145,26 +146,26 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
{ {
if (file_info.file_size == stat_buf.st_size) if (file_info.file_size == stat_buf.st_size)
{ {
logDebug("file: "__FILE__", line: %d, " \ if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
"sync data file, logic file: %s " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"on dest server %s:%u already exists, "\ logDebug("file: "__FILE__", line: %d, "
"and same as mine, ignore it", \ "sync data file, logic file: %s "
__LINE__, pRecord->filename, \ "on dest server %s:%u already exists, "
pStorageServer->ip_addr, \ "and same as mine, ignore it", __LINE__,
pRecord->filename, formatted_ip,
pStorageServer->port); pStorageServer->port);
}
need_sync_file = false; need_sync_file = false;
} }
else else
{ {
logWarning("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"sync data file, logic file: %s " \ logWarning("file: "__FILE__", line: %d, "
"on dest server %s:%u already exists, "\ "sync data file, logic file: %s "
"but file size: %"PRId64 \ "on dest server %s:%u already exists, "
" not same as mine: %"PRId64 \ "but file size: %"PRId64" not same as mine: %"PRId64
", need re-sync it", __LINE__, \ ", need re-sync it", __LINE__, pRecord->filename,
pRecord->filename, pStorageServer->ip_addr,\ formatted_ip, pStorageServer->port, file_info.file_size,
pStorageServer->port, \
file_info.file_size, \
(int64_t)stat_buf.st_size); (int64_t)stat_buf.st_size);
proto_cmd = STORAGE_PROTO_CMD_SYNC_UPDATE_FILE; proto_cmd = STORAGE_PROTO_CMD_SYNC_UPDATE_FILE;
@ -227,16 +228,14 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
memcpy(p, pRecord->filename, pRecord->filename_len); memcpy(p, pRecord->filename, pRecord->filename_len);
p += pRecord->filename_len; p += pRecord->filename_len;
if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"sync data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "sync data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -245,13 +244,11 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
full_filename, file_offset, stat_buf.st_size, \ full_filename, file_offset, stat_buf.st_size, \
SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0)) SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0))
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"sync data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "sync data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -276,13 +273,13 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
if (result == EEXIST) if (result == EEXIST)
{ {
if (need_sync_file && pRecord->op_type == \ if (need_sync_file && pRecord->op_type ==
STORAGE_OP_TYPE_SOURCE_CREATE_FILE) STORAGE_OP_TYPE_SOURCE_CREATE_FILE)
{ {
logWarning("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server ip: %s:%u, data file: %s " \ logWarning("file: "__FILE__", line: %d, "
"already exists, maybe some mistake?", \ "storage server ip: %s:%u, data file: %s already exists, "
__LINE__, pStorageServer->ip_addr, \ "maybe some mistake?", __LINE__, formatted_ip,
pStorageServer->port, pRecord->filename); pStorageServer->port, pRecord->filename);
} }
@ -320,6 +317,7 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
char *fields[SYNC_MODIFY_FIELD_COUNT]; char *fields[SYNC_MODIFY_FIELD_COUNT];
char full_filename[MAX_PATH_SIZE]; char full_filename[MAX_PATH_SIZE];
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
struct stat stat_buf; struct stat stat_buf;
int64_t in_bytes; int64_t in_bytes;
@ -427,13 +425,11 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"sync data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "sync data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -441,13 +437,11 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
full_filename, start_offset, modify_length, \ full_filename, start_offset, modify_length, \
SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0) SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"sync data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "sync data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -491,6 +485,7 @@ static int storage_sync_truncate_file(ConnectionInfo *pStorageServer, \
char *fields[SYNC_TRUNCATE_FIELD_COUNT]; char *fields[SYNC_TRUNCATE_FIELD_COUNT];
char full_filename[MAX_PATH_SIZE]; char full_filename[MAX_PATH_SIZE];
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
struct stat stat_buf; struct stat stat_buf;
int64_t in_bytes; int64_t in_bytes;
@ -589,16 +584,14 @@ static int storage_sync_truncate_file(ConnectionInfo *pStorageServer, \
memcpy(p, pRecord->filename, pRecord->filename_len); memcpy(p, pRecord->filename, pRecord->filename_len);
p += pRecord->filename_len; p += pRecord->filename_len;
if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0) p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"sync data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "sync data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
break; break;
} }
@ -627,6 +620,7 @@ static int storage_sync_delete_file(ConnectionInfo *pStorageServer, \
{ {
TrackerHeader *pHeader; TrackerHeader *pHeader;
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256]; char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
char formatted_ip[FORMATTED_IP_SIZE];
struct stat stat_buf; struct stat stat_buf;
FDFSTrunkFullInfo trunkInfo; FDFSTrunkFullInfo trunkInfo;
FDFSTrunkHeader trunkHeader; FDFSTrunkHeader trunkHeader;
@ -666,12 +660,11 @@ static int storage_sync_delete_file(ConnectionInfo *pStorageServer, \
sizeof(TrackerHeader) + 4 + FDFS_GROUP_NAME_MAX_LEN + \ sizeof(TrackerHeader) + 4 + FDFS_GROUP_NAME_MAX_LEN + \
pRecord->filename_len, SF_G_NETWORK_TIMEOUT)) != 0) pRecord->filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("FILE: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("FILE: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "send data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
@ -702,6 +695,7 @@ static int storage_report_my_server_id(ConnectionInfo *pStorageServer)
int result; int result;
TrackerHeader *pHeader; TrackerHeader *pHeader;
char out_buff[sizeof(TrackerHeader) + FDFS_STORAGE_ID_MAX_SIZE]; char out_buff[sizeof(TrackerHeader) + FDFS_STORAGE_ID_MAX_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
char *pBuff; char *pBuff;
int64_t in_bytes; int64_t in_bytes;
@ -716,12 +710,11 @@ static int storage_report_my_server_id(ConnectionInfo *pStorageServer)
sizeof(TrackerHeader) + FDFS_STORAGE_ID_MAX_SIZE, \ sizeof(TrackerHeader) + FDFS_STORAGE_ID_MAX_SIZE, \
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("FILE: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("FILE: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "send data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
@ -751,6 +744,7 @@ static int storage_sync_link_file(ConnectionInfo *pStorageServer, \
int result; int result;
char out_buff[sizeof(TrackerHeader) + 2 * FDFS_PROTO_PKG_LEN_SIZE + \ char out_buff[sizeof(TrackerHeader) + 2 * FDFS_PROTO_PKG_LEN_SIZE + \
4 + FDFS_GROUP_NAME_MAX_LEN + 256]; 4 + FDFS_GROUP_NAME_MAX_LEN + 256];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
FDFSTrunkFullInfo trunkInfo; FDFSTrunkFullInfo trunkInfo;
FDFSTrunkHeader trunkHeader; FDFSTrunkHeader trunkHeader;
@ -937,16 +931,15 @@ static int storage_sync_link_file(ConnectionInfo *pStorageServer, \
long2buff(out_body_len, pHeader->pkg_len); long2buff(out_body_len, pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_SYNC_CREATE_LINK; pHeader->cmd = STORAGE_PROTO_CMD_SYNC_CREATE_LINK;
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
sizeof(TrackerHeader) + out_body_len, \ sizeof(TrackerHeader) + out_body_len,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("FILE: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("FILE: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "send data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorageServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pStorageServer->port, \ pStorageServer->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
@ -984,6 +977,7 @@ static int storage_sync_rename_file(ConnectionInfo *pStorageServer,
int result; int result;
char out_buff[sizeof(TrackerHeader) + 2 * FDFS_PROTO_PKG_LEN_SIZE + char out_buff[sizeof(TrackerHeader) + 2 * FDFS_PROTO_PKG_LEN_SIZE +
4 + FDFS_GROUP_NAME_MAX_LEN + 256]; 4 + FDFS_GROUP_NAME_MAX_LEN + 256];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
int out_body_len; int out_body_len;
int64_t in_bytes; int64_t in_bytes;
@ -1049,10 +1043,10 @@ static int storage_sync_rename_file(ConnectionInfo *pStorageServer,
sizeof(TrackerHeader) + out_body_len, sizeof(TrackerHeader) + out_body_len,
SF_G_NETWORK_TIMEOUT)) != 0) SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(pStorageServer->ip_addr, formatted_ip);
logError("FILE: "__FILE__", line: %d, " logError("FILE: "__FILE__", line: %d, "
"send data to storage server %s:%u fail, " "send data to storage server %s:%u fail, errno: %d, "
"errno: %d, error info: %s", "error info: %s", __LINE__, formatted_ip,
__LINE__, pStorageServer->ip_addr,
pStorageServer->port, result, STRERROR(result)); pStorageServer->port, result, STRERROR(result));
return result; return result;
} }
@ -1069,10 +1063,13 @@ static int storage_sync_rename_file(ConnectionInfo *pStorageServer,
} }
else if (result == EEXIST) else if (result == EEXIST)
{ {
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
format_ip_address(pStorageServer->ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"storage server ip: %s:%u, data file: %s " "storage server ip: %s:%u, data file: %s "
"already exists", __LINE__, pStorageServer->ip_addr, "already exists", __LINE__, formatted_ip,
pStorageServer->port, pRecord->filename); pStorageServer->port, pRecord->filename);
}
return 0; return 0;
} }
else else
@ -1997,6 +1994,7 @@ int storage_report_storage_status(const char *storage_id, \
TrackerServerInfo *pGlobalServer; TrackerServerInfo *pGlobalServer;
TrackerServerInfo *pTServer; TrackerServerInfo *pTServer;
TrackerServerInfo *pTServerEnd; TrackerServerInfo *pTServerEnd;
char formatted_ip[FORMATTED_IP_SIZE];
ConnectionInfo *conn; ConnectionInfo *conn;
int result; int result;
int report_count; int report_count;
@ -2063,12 +2061,12 @@ int storage_report_storage_status(const char *storage_id, \
if (conn == NULL) if (conn == NULL)
{ {
format_ip_address(pTServer->connections[0].
ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to tracker server %s:%u fail, " "connect to tracker server %s:%u fail, errno: %d, "
"errno: %d, error info: %s", "error info: %s", __LINE__, formatted_ip, pTServer->
__LINE__, pTServer->connections[0].ip_addr, connections[0].port, result, STRERROR(result));
pTServer->connections[0].port,
result, STRERROR(result));
continue; continue;
} }
@ -2861,6 +2859,7 @@ static void storage_sync_thread_exit(ConnectionInfo *pStorage)
int i; int i;
int thread_count; int thread_count;
pthread_t tid; pthread_t tid;
char formatted_ip[FORMATTED_IP_SIZE];
if ((result=pthread_mutex_lock(&sync_thread_lock)) != 0) if ((result=pthread_mutex_lock(&sync_thread_lock)) != 0)
{ {
@ -2896,9 +2895,12 @@ static void storage_sync_thread_exit(ConnectionInfo *pStorage)
__LINE__, result, STRERROR(result)); __LINE__, result, STRERROR(result));
} }
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
format_ip_address(pStorage->ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"sync thread to storage server %s:%u exit", "sync thread to storage server %s:%u exit",
__LINE__, pStorage->ip_addr, pStorage->port); __LINE__, formatted_ip, pStorage->port);
}
} }
static void* storage_sync_thread_entrance(void* arg) static void* storage_sync_thread_entrance(void* arg)
@ -2908,6 +2910,7 @@ static void* storage_sync_thread_entrance(void* arg)
StorageBinLogRecord record; StorageBinLogRecord record;
ConnectionInfo storage_server; ConnectionInfo storage_server;
char local_ip_addr[IP_ADDRESS_SIZE]; char local_ip_addr[IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
int read_result; int read_result;
int sync_result; int sync_result;
int result; int result;
@ -2954,9 +2957,12 @@ static void* storage_sync_thread_entrance(void* arg)
start_time = 0; start_time = 0;
end_time = 0; end_time = 0;
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
format_ip_address(storage_server.ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"sync thread to storage server %s:%u started", "sync thread to storage server %s:%u started",
__LINE__, storage_server.ip_addr, storage_server.port); __LINE__, formatted_ip, storage_server.port);
}
while (SF_G_CONTINUE_FLAG && \ while (SF_G_CONTINUE_FLAG && \
pStorage->status != FDFS_STORAGE_STATUS_DELETED && \ pStorage->status != FDFS_STORAGE_STATUS_DELETED && \

11
storage/storage_sync_func.c
View File

@ -40,6 +40,7 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
FDFSMultiIP ip_addrs; FDFSMultiIP ip_addrs;
FDFSMultiIP *multi_ip; FDFSMultiIP *multi_ip;
const char *bind_addr; const char *bind_addr;
char formatted_ip[FORMATTED_IP_SIZE];
multi_ip = NULL; multi_ip = NULL;
if (g_use_storage_id) if (g_use_storage_id)
@ -118,10 +119,12 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
", continuous fail count: %d", ", continuous fail count: %d",
nContinuousFail); nContinuousFail);
} }
format_ip_address(conn->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"successfully connect to " "successfully connect to "
"storage server %s:%u%s", __LINE__, "storage server %s:%u%s", __LINE__,
conn->ip_addr, SF_G_INNER_PORT, szFailPrompt); formatted_ip, SF_G_INNER_PORT, szFailPrompt);
nContinuousFail = 0; nContinuousFail = 0;
break; break;
} }
@ -129,10 +132,11 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
nContinuousFail++; nContinuousFail++;
if (previousCodes[i] != conn_results[i]) if (previousCodes[i] != conn_results[i])
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to storage server %s:%u fail, " "connect to storage server %s:%u fail, "
"errno: %d, error info: %s", "errno: %d, error info: %s",
__LINE__, conn->ip_addr, SF_G_INNER_PORT, __LINE__, formatted_ip, SF_G_INNER_PORT,
conn_results[i], STRERROR(conn_results[i])); conn_results[i], STRERROR(conn_results[i]));
previousCodes[i] = conn_results[i]; previousCodes[i] = conn_results[i];
} }
@ -155,10 +159,11 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
avg_fails = (nContinuousFail + ip_addrs.count - 1) / ip_addrs.count; avg_fails = (nContinuousFail + ip_addrs.count - 1) / ip_addrs.count;
for (i=0; i<ip_addrs.count; i++) for (i=0; i<ip_addrs.count; i++)
{ {
format_ip_address(ip_addrs.ips[i].address, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to storage server %s:%u fail, " "connect to storage server %s:%u fail, "
"try count: %d, errno: %d, error info: %s", "try count: %d, errno: %d, error info: %s",
__LINE__, ip_addrs.ips[i].address, SF_G_INNER_PORT, avg_fails, __LINE__, formatted_ip, SF_G_INNER_PORT, avg_fails,
conn_results[i], STRERROR(conn_results[i])); conn_results[i], STRERROR(conn_results[i]));
} }
} }

587
storage/tracker_client_thread.c
View File

File diff suppressed because it is too large Load Diff

57
storage/trunk_mgr/trunk_client.c
View File

@ -35,6 +35,7 @@ static int trunk_client_trunk_do_alloc_space(ConnectionInfo *pTrunkServer, \
char *p; char *p;
int result; int result;
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 5]; char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 5];
char formatted_ip[FORMATTED_IP_SIZE];
FDFSTrunkInfoBuff trunkBuff; FDFSTrunkInfoBuff trunkBuff;
int64_t in_bytes; int64_t in_bytes;
@ -50,15 +51,14 @@ static int trunk_client_trunk_do_alloc_space(ConnectionInfo *pTrunkServer, \
long2buff(FDFS_GROUP_NAME_MAX_LEN + 5, pHeader->pkg_len); long2buff(FDFS_GROUP_NAME_MAX_LEN + 5, pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_TRUNK_ALLOC_SPACE; pHeader->cmd = STORAGE_PROTO_CMD_TRUNK_ALLOC_SPACE;
if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrunkServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, errno: %d, "
pTrunkServer->ip_addr, pTrunkServer->port, \ "error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pTrunkServer->port, result, STRERROR(result));
return result; return result;
} }
@ -74,11 +74,12 @@ static int trunk_client_trunk_do_alloc_space(ConnectionInfo *pTrunkServer, \
if (in_bytes != sizeof(FDFSTrunkInfoBuff)) if (in_bytes != sizeof(FDFSTrunkInfoBuff))
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrunkServer->ip_addr, formatted_ip);
"storage server %s:%u, recv body length: %d invalid, " \ logError("file: "__FILE__", line: %d, "
"expect body length: %d", __LINE__, \ "storage server %s:%u, recv body length: %d invalid, "
pTrunkServer->ip_addr, pTrunkServer->port, \ "expect body length: %d", __LINE__, formatted_ip,
(int)in_bytes, (int)sizeof(FDFSTrunkInfoBuff)); pTrunkServer->port, (int)in_bytes,
(int)sizeof(FDFSTrunkInfoBuff));
return EINVAL; return EINVAL;
} }
@ -97,6 +98,7 @@ static int trunk_client_connect_trunk_server(TrackerServerInfo *trunk_server,
ConnectionInfo **conn, const char *prompt) ConnectionInfo **conn, const char *prompt)
{ {
int result; int result;
char formatted_ip[FORMATTED_IP_SIZE];
if (g_trunk_server.count == 0) if (g_trunk_server.count == 0)
{ {
@ -108,10 +110,11 @@ static int trunk_client_connect_trunk_server(TrackerServerInfo *trunk_server,
memcpy(trunk_server, &g_trunk_server, sizeof(TrackerServerInfo)); memcpy(trunk_server, &g_trunk_server, sizeof(TrackerServerInfo));
if ((*conn=tracker_connect_server(trunk_server, &result)) == NULL) if ((*conn=tracker_connect_server(trunk_server, &result)) == NULL)
{ {
format_ip_address(trunk_server->connections[0].
ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"%s because connect to trunk " "%s because connect to trunk server %s:%u fail, "
"server %s:%u fail, errno: %d", __LINE__, "errno: %d", __LINE__, prompt, formatted_ip,
prompt, trunk_server->connections[0].ip_addr,
trunk_server->connections[0].port, result); trunk_server->connections[0].port, result);
return result; return result;
} }
@ -167,6 +170,7 @@ static int trunk_client_trunk_confirm_or_free(ConnectionInfo *pTrunkServer,\
int result; int result;
char out_buff[sizeof(TrackerHeader) \ char out_buff[sizeof(TrackerHeader) \
+ STORAGE_TRUNK_ALLOC_CONFIRM_REQ_BODY_LEN]; + STORAGE_TRUNK_ALLOC_CONFIRM_REQ_BODY_LEN];
char formatted_ip[FORMATTED_IP_SIZE];
pHeader = (TrackerHeader *)out_buff; pHeader = (TrackerHeader *)out_buff;
pTrunkBuff = (FDFSTrunkInfoBuff *)(out_buff + sizeof(TrackerHeader) \ pTrunkBuff = (FDFSTrunkInfoBuff *)(out_buff + sizeof(TrackerHeader) \
@ -185,15 +189,14 @@ static int trunk_client_trunk_confirm_or_free(ConnectionInfo *pTrunkServer,\
int2buff(pTrunkInfo->file.offset, pTrunkBuff->offset); int2buff(pTrunkInfo->file.offset, pTrunkBuff->offset);
int2buff(pTrunkInfo->file.size, pTrunkBuff->size); int2buff(pTrunkInfo->file.size, pTrunkBuff->size);
if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrunkServer->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to storage server %s:%u fail, errno: %d, "
pTrunkServer->ip_addr, pTrunkServer->port, \ "error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pTrunkServer->port, result, STRERROR(result));
return result; return result;
} }
@ -207,11 +210,11 @@ static int trunk_client_trunk_confirm_or_free(ConnectionInfo *pTrunkServer,\
if (in_bytes != 0) if (in_bytes != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrunkServer->ip_addr, formatted_ip);
"storage server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "storage server %s:%u response data length: "
"should == 0", __LINE__, pTrunkServer->ip_addr, \ "%"PRId64" is invalid, should == 0", __LINE__,
pTrunkServer->port, in_bytes); formatted_ip, pTrunkServer->port, in_bytes);
return EINVAL; return EINVAL;
} }

35
storage/trunk_mgr/trunk_sync.c
View File

@ -1953,6 +1953,7 @@ static void trunk_sync_thread_exit(TrunkSyncThreadInfo *thread_data,
const int port) const int port)
{ {
int result; int result;
char formatted_ip[FORMATTED_IP_SIZE];
if ((result=pthread_mutex_lock(&trunk_sync_thread_lock)) != 0) if ((result=pthread_mutex_lock(&trunk_sync_thread_lock)) != 0)
{ {
@ -1973,9 +1974,10 @@ static void trunk_sync_thread_exit(TrunkSyncThreadInfo *thread_data,
__LINE__, result, STRERROR(result)); __LINE__, result, STRERROR(result));
} }
format_ip_address(thread_data->pStorage->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"trunk sync thread to storage server %s:%u exit", "trunk sync thread to storage server %s:%u exit",
__LINE__, thread_data->pStorage->ip_addr, port); __LINE__, formatted_ip, port);
} }
static int trunk_sync_data(TrunkBinLogReader *pReader, \ static int trunk_sync_data(TrunkBinLogReader *pReader, \
@ -1985,6 +1987,7 @@ static int trunk_sync_data(TrunkBinLogReader *pReader, \
char *p; char *p;
int result; int result;
TrackerHeader header; TrackerHeader header;
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
char *pBuff; char *pBuff;
int64_t in_bytes; int64_t in_bytes;
@ -2009,25 +2012,25 @@ static int trunk_sync_data(TrunkBinLogReader *pReader, \
memset(&header, 0, sizeof(header)); memset(&header, 0, sizeof(header));
long2buff(length, header.pkg_len); long2buff(length, header.pkg_len);
header.cmd = STORAGE_PROTO_CMD_TRUNK_SYNC_BINLOG; header.cmd = STORAGE_PROTO_CMD_TRUNK_SYNC_BINLOG;
if ((result=tcpsenddata_nb(pStorage->sock, &header, \ if ((result=tcpsenddata_nb(pStorage->sock, &header,
sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("FILE: "__FILE__", line: %d, " \ format_ip_address(pStorage->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("FILE: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "send data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorage->ip_addr, pStorage->port, \ "error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorage->port, result, STRERROR(result));
return result; return result;
} }
if ((result=tcpsenddata_nb(pStorage->sock, pReader->binlog_buff.buffer,\ if ((result=tcpsenddata_nb(pStorage->sock, pReader->binlog_buff.buffer,
length, SF_G_NETWORK_TIMEOUT)) != 0) length, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("FILE: "__FILE__", line: %d, " \ format_ip_address(pStorage->ip_addr, formatted_ip);
"send data to storage server %s:%u fail, " \ logError("FILE: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "send data to storage server %s:%u fail, errno: %d, "
__LINE__, pStorage->ip_addr, pStorage->port, \ "error info: %s", __LINE__, formatted_ip,
result, STRERROR(result)); pStorage->port, result, STRERROR(result));
return result; return result;
} }
@ -2057,6 +2060,7 @@ static void *trunk_sync_thread_entrance(void* arg)
TrunkBinLogReader reader; TrunkBinLogReader reader;
ConnectionInfo storage_server; ConnectionInfo storage_server;
char local_ip_addr[IP_ADDRESS_SIZE]; char local_ip_addr[IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
int read_result; int read_result;
int sync_result; int sync_result;
int result; int result;
@ -2085,9 +2089,10 @@ static void *trunk_sync_thread_entrance(void* arg)
storage_server.port = SF_G_INNER_PORT; storage_server.port = SF_G_INNER_PORT;
storage_server.sock = -1; storage_server.sock = -1;
logInfo("file: "__FILE__", line: %d, " \ format_ip_address(storage_server.ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, "
"trunk sync thread to storage server %s:%u started", "trunk sync thread to storage server %s:%u started",
__LINE__, storage_server.ip_addr, storage_server.port); __LINE__, formatted_ip, storage_server.port);
while (SF_G_CONTINUE_FLAG && g_if_trunker_self && \ while (SF_G_CONTINUE_FLAG && g_if_trunker_self && \
pStorage->status != FDFS_STORAGE_STATUS_DELETED && \ pStorage->status != FDFS_STORAGE_STATUS_DELETED && \

20
tracker/fdfs_server_id_func.c
View File

@ -567,6 +567,7 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
TrackerHeader *pHeader; TrackerHeader *pHeader;
ConnectionInfo *conn; ConnectionInfo *conn;
char out_buff[sizeof(TrackerHeader) + sizeof(FDFSFetchStorageIdsBody)]; char out_buff[sizeof(TrackerHeader) + sizeof(FDFSFetchStorageIdsBody)];
char formatted_ip[FORMATTED_IP_SIZE];
char *p; char *p;
char *response; char *response;
struct data_info { struct data_info {
@ -603,10 +604,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
if ((result=tcpsenddata_nb(conn->sock, out_buff, if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to tracker server %s:%u fail, " "send data to tracker server %s:%u fail, "
"errno: %d, error info: %s", __LINE__, "errno: %d, error info: %s", __LINE__,
conn->ip_addr, conn->port, formatted_ip, conn->port,
result, STRERROR(result)); result, STRERROR(result));
} }
else else
@ -628,9 +630,10 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
if (in_bytes < 2 * sizeof(int)) if (in_bytes < 2 * sizeof(int))
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, recv data length: %d " "tracker server %s:%u, recv data length: %d "
"is invalid", __LINE__, conn->ip_addr, "is invalid", __LINE__, formatted_ip,
conn->port, (int)in_bytes); conn->port, (int)in_bytes);
result = EINVAL; result = EINVAL;
break; break;
@ -640,10 +643,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
current_count = buff2int(response + sizeof(int)); current_count = buff2int(response + sizeof(int));
if (total_count <= start_index) if (total_count <= start_index)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, total storage " "tracker server %s:%u, total storage "
"count: %d is invalid, which <= start " "count: %d is invalid, which <= start "
"index: %d", __LINE__, conn->ip_addr, "index: %d", __LINE__, formatted_ip,
conn->port, total_count, start_index); conn->port, total_count, start_index);
result = EINVAL; result = EINVAL;
break; break;
@ -651,10 +655,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
if (current_count <= 0) if (current_count <= 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, current storage " "tracker server %s:%u, current storage "
"count: %d is invalid, which <= 0", __LINE__, "count: %d is invalid, which <= 0", __LINE__,
conn->ip_addr, conn->port, current_count); formatted_ip, conn->port, current_count);
result = EINVAL; result = EINVAL;
break; break;
} }
@ -677,10 +682,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
if (list_count == MAX_REQUEST_LOOP) if (list_count == MAX_REQUEST_LOOP)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"response data from tracker " "response data from tracker server "
"server %s:%u is too large", "%s:%u is too large", __LINE__,
__LINE__, conn->ip_addr, conn->port); formatted_ip, conn->port);
result = ENOSPC; result = ENOSPC;
break; break;
} }

2
tracker/fdfs_shared_func.c
View File

@ -570,7 +570,7 @@ int fdfs_server_info_to_string_ex(const TrackerServerInfo *pServer,
{ {
*(buff + len++) = ']'; *(buff + len++) = ']';
} }
len += snprintf(buff + len, buffSize - len, ":%d", port); len += snprintf(buff + len, buffSize - len, ":%u", port);
return len; return len;
} }

9
tracker/tracker_dump.c
View File

@ -298,7 +298,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
"SF_G_CONTINUE_FLAG=%d\n" "SF_G_CONTINUE_FLAG=%d\n"
"g_schedule_flag=%d\n" "g_schedule_flag=%d\n"
"SF_G_INNER_PORT=%d\n" "SF_G_INNER_PORT=%d\n"
"g_max_connections=%d\n" "SF_G_MAX_CONNECTIONS=%d\n"
"g_tracker_thread_count=%d\n" "g_tracker_thread_count=%d\n"
"g_sync_log_buff_interval=%ds\n" "g_sync_log_buff_interval=%ds\n"
"g_check_active_interval=%ds\n" "g_check_active_interval=%ds\n"
@ -352,7 +352,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
, g_fdfs_version.patch, SF_G_CONTINUE_FLAG , g_fdfs_version.patch, SF_G_CONTINUE_FLAG
, g_schedule_flag , g_schedule_flag
, SF_G_INNER_PORT , SF_G_INNER_PORT
, g_sf_global_vars.max_connections , SF_G_MAX_CONNECTIONS
, g_sf_context.thread_count , g_sf_context.thread_count
, g_sf_global_vars.error_log.sync_log_buff_interval , g_sf_global_vars.error_log.sync_log_buff_interval
, g_check_active_interval , g_check_active_interval
@ -444,9 +444,8 @@ static int fdfs_dump_tracker_servers(char *buff, const int buffSize)
fdfs_server_info_to_string(pTrackerServer, ip_str, sizeof(ip_str)); fdfs_server_info_to_string(pTrackerServer, ip_str, sizeof(ip_str));
total_len += snprintf(buff + total_len, buffSize - total_len, total_len += snprintf(buff + total_len, buffSize - total_len,
"\t%d. tracker server=%s:%u\n", \ "\t%d. tracker server=%s\n", (int)(pTrackerServer -
(int)(pTrackerServer - g_tracker_servers.servers) + 1, \ g_tracker_servers.servers) + 1, ip_str);
ip_str, pTrackerServer->connections[0].port);
} }
return total_len; return total_len;

144
tracker/tracker_mem.c
View File

@ -1787,6 +1787,7 @@ int tracker_save_storages()
char trueFilename[MAX_PATH_SIZE]; char trueFilename[MAX_PATH_SIZE];
char buff[4096]; char buff[4096];
char id_buff[128]; char id_buff[128];
char formatted_ip[FORMATTED_IP_SIZE];
int fd; int fd;
int len; int len;
FDFSGroupInfo **ppGroup; FDFSGroupInfo **ppGroup;
@ -1838,6 +1839,7 @@ int tracker_save_storages()
} }
count++; count++;
format_ip_address(FDFS_CURRENT_IP_ADDR(pStorage), formatted_ip);
len = sprintf(buff, \ len = sprintf(buff, \
"# storage %s:%u\n" \ "# storage %s:%u\n" \
"[%s"STORAGE_SECTION_NO_FORMAT"]\n" \ "[%s"STORAGE_SECTION_NO_FORMAT"]\n" \
@ -1894,8 +1896,7 @@ int tracker_save_storages()
"\t%s=%d\n" \ "\t%s=%d\n" \
"\t%s=%d\n" \ "\t%s=%d\n" \
"\t%s=%"PRId64"\n\n", \ "\t%s=%"PRId64"\n\n", \
FDFS_CURRENT_IP_ADDR(pStorage), \ formatted_ip, pStorage->storage_port, \
pStorage->storage_port, \
STORAGE_SECTION_NAME_PREFIX, count, id_buff, \ STORAGE_SECTION_NAME_PREFIX, count, id_buff, \
STORAGE_ITEM_GROUP_NAME, \ STORAGE_ITEM_GROUP_NAME, \
(*ppGroup)->group_name, \ (*ppGroup)->group_name, \
@ -3415,6 +3416,7 @@ int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
FDFSStorageDetail *pStorageServer; FDFSStorageDetail *pStorageServer;
FDFSStorageDetail **ppServer; FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppEnd; FDFSStorageDetail **ppEnd;
char formatted_ip[FORMATTED_IP_SIZE];
pStorageServer = tracker_mem_get_storage(pGroup, id); pStorageServer = tracker_mem_get_storage(pGroup, id);
if (pStorageServer == NULL || pStorageServer->status == \ if (pStorageServer == NULL || pStorageServer->status == \
@ -3445,10 +3447,14 @@ int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
} }
} }
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
format_ip_address(pStorageServer->ip_addrs.
ips[0].address, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"delete storage server: %s:%u, group: %s", "delete storage server: %s:%u, group: %s", __LINE__,
__LINE__, pStorageServer->ip_addrs.ips[0].address, formatted_ip, pStorageServer->storage_port,
pStorageServer->storage_port, pGroup->group_name); pGroup->group_name);
}
tracker_mem_clear_storage_fields(pStorageServer); tracker_mem_clear_storage_fields(pStorageServer);
@ -3840,6 +3846,7 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
{ {
char out_buff[sizeof(TrackerHeader) + 1 + FDFS_PROTO_PKG_LEN_SIZE]; char out_buff[sizeof(TrackerHeader) + 1 + FDFS_PROTO_PKG_LEN_SIZE];
char in_buff[TRACKER_MAX_PACKAGE_SIZE]; char in_buff[TRACKER_MAX_PACKAGE_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader *pHeader; TrackerHeader *pHeader;
char *p; char *p;
char *pInBuff; char *pInBuff;
@ -3859,13 +3866,12 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"send data to tracker server %s:%u fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", __LINE__, \ "send data to tracker server %s:%u fail, "
pTrackerServer->ip_addr, \ "errno: %d, error info: %s", __LINE__,
pTrackerServer->port, \ formatted_ip, pTrackerServer->port,
result, STRERROR(result)); result, STRERROR(result));
return (result == ENOENT ? EACCES : result); return (result == ENOENT ? EACCES : result);
} }
@ -3882,11 +3888,12 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
if (in_bytes < FDFS_PROTO_PKG_LEN_SIZE) if (in_bytes < FDFS_PROTO_PKG_LEN_SIZE)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u response data " \ logError("file: "__FILE__", line: %d, "
"length: %"PRId64" is invalid, " \ "tracker server %s:%u response data "
"expect length >= %d.", __LINE__, \ "length: %"PRId64" is invalid, "
pTrackerServer->ip_addr, pTrackerServer->port, \ "expect length >= %d.", __LINE__,
formatted_ip, pTrackerServer->port,
in_bytes, FDFS_PROTO_PKG_LEN_SIZE); in_bytes, FDFS_PROTO_PKG_LEN_SIZE);
return EINVAL; return EINVAL;
} }
@ -3896,20 +3903,21 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
if (*file_size < 0) if (*file_size < 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u, file size: %"PRId64\ logError("file: "__FILE__", line: %d, "
" < 0", __LINE__, pTrackerServer->ip_addr, \ "tracker server %s:%u, file size: %"PRId64
" < 0", __LINE__, formatted_ip,
pTrackerServer->port, *file_size); pTrackerServer->port, *file_size);
return EINVAL; return EINVAL;
} }
if (*file_size > 0 && write_bytes == 0) if (*file_size > 0 && write_bytes == 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server %s:%u, file size: %"PRId64\ logError("file: "__FILE__", line: %d, "
" > 0, but file content is empty", __LINE__, \ "tracker server %s:%u, file size: %"PRId64
pTrackerServer->ip_addr, pTrackerServer->port, \ " > 0, but file content is empty", __LINE__,
*file_size); formatted_ip, pTrackerServer->port, *file_size);
return EINVAL; return EINVAL;
} }
@ -4268,6 +4276,7 @@ static int tracker_mem_get_tracker_server(FDFSStorageJoinBody *pJoinBody, \
TrackerServerInfo *pTrackerEnd; TrackerServerInfo *pTrackerEnd;
TrackerRunningStatus *pStatus; TrackerRunningStatus *pStatus;
TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS]; TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS];
char formatted_ip[FORMATTED_IP_SIZE];
int count; int count;
int result; int result;
int r; int r;
@ -4309,17 +4318,20 @@ static int tracker_mem_get_tracker_server(FDFSStorageJoinBody *pJoinBody, \
tracker_mem_cmp_tracker_running_status); tracker_mem_cmp_tracker_running_status);
} }
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
for (i=0; i<count; i++) for (i=0; i<count; i++)
{ {
format_ip_address(trackerStatus[i].pTrackerServer->
connections[0].ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"%s:%u leader: %d, running time: %d, " "%s:%u leader: %d, running time: %d, "
"restart interval: %d", __LINE__, "restart interval: %d", __LINE__, formatted_ip,
trackerStatus[i].pTrackerServer->connections[0].ip_addr,
trackerStatus[i].pTrackerServer->connections[0].port, trackerStatus[i].pTrackerServer->connections[0].port,
trackerStatus[i].if_leader, trackerStatus[i].if_leader,
trackerStatus[i].running_time, trackerStatus[i].running_time,
trackerStatus[i].restart_interval); trackerStatus[i].restart_interval);
} }
}
//copy the last //copy the last
memcpy(pTrackerStatus, trackerStatus + (count - 1), \ memcpy(pTrackerStatus, trackerStatus + (count - 1), \
@ -4335,6 +4347,7 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
TrackerServerInfo *pTrackerServer; TrackerServerInfo *pTrackerServer;
FDFSGroups newGroups; FDFSGroups newGroups;
FDFSGroups tempGroups; FDFSGroups tempGroups;
char formatted_ip[FORMATTED_IP_SIZE];
if (pJoinBody->tracker_count == 0) if (pJoinBody->tracker_count == 0)
{ {
@ -4352,11 +4365,12 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
if (tracker_mem_cmp_tracker_running_status(pRunningStatus, if (tracker_mem_cmp_tracker_running_status(pRunningStatus,
&trackerStatus) >= 0) &trackerStatus) >= 0)
{ {
format_ip_address(trackerStatus.pTrackerServer->
connections[0].ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, " logDebug("file: "__FILE__", line: %d, "
"%s:%u running time: %d, restart interval: %d, " "%s:%u running time: %d, restart interval: %d, "
"my running time: %d, restart interval: %d, " "my running time: %d, restart interval: %d, "
"do not need sync system files", __LINE__, "do not need sync system files", __LINE__, formatted_ip,
trackerStatus.pTrackerServer->connections[0].ip_addr,
trackerStatus.pTrackerServer->connections[0].port, trackerStatus.pTrackerServer->connections[0].port,
trackerStatus.running_time, trackerStatus.running_time,
trackerStatus.restart_interval, trackerStatus.restart_interval,
@ -4374,10 +4388,10 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
return result; return result;
} }
format_ip_address(pTrackerServer->connections[0].ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"sys files loaded from tracker server %s:%u", "sys files loaded from tracker server %s:%u", __LINE__,
__LINE__, pTrackerServer->connections[0].ip_addr, formatted_ip, pTrackerServer->connections[0].port);
pTrackerServer->connections[0].port);
memset(&newGroups, 0, sizeof(newGroups)); memset(&newGroups, 0, sizeof(newGroups));
newGroups.store_lookup = g_groups.store_lookup; newGroups.store_lookup = g_groups.store_lookup;
@ -4419,6 +4433,7 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo,
FDFSStorageDetail **ppServer; FDFSStorageDetail **ppServer;
FDFSStorageDetail **ppEnd; FDFSStorageDetail **ppEnd;
FDFSStorageId storage_id; FDFSStorageId storage_id;
char formatted_ip[FORMATTED_IP_SIZE];
tracker_mem_file_lock(); tracker_mem_file_lock();
@ -4689,12 +4704,13 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo,
pJoinBody->status == FDFS_STORAGE_STATUS_IP_CHANGED || \ pJoinBody->status == FDFS_STORAGE_STATUS_IP_CHANGED || \
pJoinBody->status == FDFS_STORAGE_STATUS_NONE) pJoinBody->status == FDFS_STORAGE_STATUS_NONE)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(ip_addr, formatted_ip);
"client ip: %s:%u, invalid storage " \ logError("file: "__FILE__", line: %d, "
"status %d, in the group \"%s\"", \ "client ip: %s:%u, invalid storage "
__LINE__, ip_addr, \ "status %d, in the group \"%s\"",
pJoinBody->storage_port, \ __LINE__, formatted_ip,
pJoinBody->status, \ pJoinBody->storage_port,
pJoinBody->status,
pJoinBody->group_name); pJoinBody->group_name);
return EFAULT; return EFAULT;
} }
@ -4891,6 +4907,7 @@ int tracker_mem_sync_storages(FDFSGroupInfo *pGroup, \
FDFSStorageDetail target_storage; FDFSStorageDetail target_storage;
FDFSStorageDetail *pTargetStorage; FDFSStorageDetail *pTargetStorage;
FDFSStorageDetail **ppFound; FDFSStorageDetail **ppFound;
char formatted_ip[FORMATTED_IP_SIZE];
if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0) if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
{ {
@ -4938,11 +4955,12 @@ int tracker_mem_sync_storages(FDFSGroupInfo *pGroup, \
continue; continue;
} }
format_ip_address(FDFS_CURRENT_IP_ADDR(*ppFound),
formatted_ip);
logWarning("file: "__FILE__", line: %d, " logWarning("file: "__FILE__", line: %d, "
"storage server: %s:%u, dest status: %d, " "storage server: %s:%u, dest status: %d, "
"my status: %d, should change my status!", "my status: %d, should change my status!",
__LINE__, FDFS_CURRENT_IP_ADDR(*ppFound), __LINE__, formatted_ip, (*ppFound)->storage_port,
(*ppFound)->storage_port,
pServer->status, (*ppFound)->status); pServer->status, (*ppFound)->status);
if (pServer->status == \ if (pServer->status == \
@ -5036,6 +5054,7 @@ static int _storage_get_trunk_binlog_size(
ConnectionInfo *pStorageServer, int64_t *file_size) ConnectionInfo *pStorageServer, int64_t *file_size)
{ {
char out_buff[sizeof(TrackerHeader)]; char out_buff[sizeof(TrackerHeader)];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[8]; char in_buff[8];
TrackerHeader *pHeader; TrackerHeader *pHeader;
char *pInBuff; char *pInBuff;
@ -5048,11 +5067,11 @@ static int _storage_get_trunk_binlog_size(
if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \ if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u, send data fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s.", \ "storage server %s:%u, send data fail, "
__LINE__, pStorageServer->ip_addr, \ "errno: %d, error info: %s.", __LINE__,
pStorageServer->port, \ formatted_ip, pStorageServer->port,
result, STRERROR(result)); result, STRERROR(result));
return result; return result;
} }
@ -5069,10 +5088,10 @@ static int _storage_get_trunk_binlog_size(
if (in_bytes != sizeof(in_buff)) if (in_bytes != sizeof(in_buff))
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pStorageServer->ip_addr, formatted_ip);
"storage server %s:%u, recv body length: " \ logError("file: "__FILE__", line: %d, "
"%"PRId64" != %d", \ "storage server %s:%u, recv body length: "
__LINE__, pStorageServer->ip_addr, \ "%"PRId64" != %d", __LINE__, formatted_ip,
pStorageServer->port, in_bytes, (int)sizeof(in_buff)); pStorageServer->port, in_bytes, (int)sizeof(in_buff));
return EINVAL; return EINVAL;
} }
@ -5086,6 +5105,7 @@ static int tracker_mem_get_trunk_binlog_size(
{ {
ConnectionInfo storage_server; ConnectionInfo storage_server;
ConnectionInfo *conn; ConnectionInfo *conn;
char formatted_ip[FORMATTED_IP_SIZE];
int result; int result;
*file_size = 0; *file_size = 0;
@ -5100,11 +5120,13 @@ static int tracker_mem_get_trunk_binlog_size(
result = _storage_get_trunk_binlog_size(conn, file_size); result = _storage_get_trunk_binlog_size(conn, file_size);
tracker_close_connection_ex(conn, result != 0); tracker_close_connection_ex(conn, result != 0);
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
format_ip_address(storage_server.ip_addr, formatted_ip);
logDebug("file: "__FILE__", line: %d, "
"storage %s:%u, trunk binlog file size: %"PRId64,
__LINE__, formatted_ip, storage_server.port, *file_size);
}
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; return result;
} }
@ -5240,6 +5262,7 @@ static int tracker_set_trunk_server_and_log(FDFSGroupInfo *pGroup, \
static int tracker_mem_do_set_trunk_server(FDFSGroupInfo *pGroup, static int tracker_mem_do_set_trunk_server(FDFSGroupInfo *pGroup,
FDFSStorageDetail *pTrunkServer, const bool save) FDFSStorageDetail *pTrunkServer, const bool save)
{ {
char formatted_ip[FORMATTED_IP_SIZE];
int result; int result;
if (*(pGroup->last_trunk_server_id) != '\0' && if (*(pGroup->last_trunk_server_id) != '\0' &&
@ -5261,11 +5284,12 @@ static int tracker_mem_do_set_trunk_server(FDFSGroupInfo *pGroup,
pGroup->trunk_chg_count++; pGroup->trunk_chg_count++;
g_trunk_server_chg_count++; g_trunk_server_chg_count++;
format_ip_address(FDFS_CURRENT_IP_ADDR(pGroup->
pTrunkServer), formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"group: %s, trunk server set to %s(%s:%u)", __LINE__, "group: %s, trunk server set to %s(%s:%u)", __LINE__,
pGroup->group_name, pGroup->pTrunkServer->id, pGroup->group_name, pGroup->pTrunkServer->id,
FDFS_CURRENT_IP_ADDR(pGroup->pTrunkServer), formatted_ip, pGroup->storage_port);
pGroup->storage_port);
if (save) if (save)
{ {
return tracker_save_groups(); return tracker_save_groups();
@ -6108,6 +6132,7 @@ int tracker_mem_check_alive(void *arg)
FDFSGroupInfo **ppGroup; FDFSGroupInfo **ppGroup;
FDFSGroupInfo **ppGroupEnd; FDFSGroupInfo **ppGroupEnd;
FDFSStorageDetail *deactiveServers[FDFS_MAX_SERVERS_EACH_GROUP]; FDFSStorageDetail *deactiveServers[FDFS_MAX_SERVERS_EACH_GROUP];
char formatted_ip[FORMATTED_IP_SIZE];
int deactiveCount; int deactiveCount;
time_t current_time; time_t current_time;
@ -6139,6 +6164,7 @@ int tracker_mem_check_alive(void *arg)
ppServerEnd = deactiveServers + deactiveCount; ppServerEnd = deactiveServers + deactiveCount;
for (ppServer=deactiveServers; ppServer<ppServerEnd; ppServer++) for (ppServer=deactiveServers; ppServer<ppServerEnd; ppServer++)
{ {
format_ip_address(FDFS_CURRENT_IP_ADDR(*ppServer), formatted_ip);
(*ppServer)->status = FDFS_STORAGE_STATUS_OFFLINE; (*ppServer)->status = FDFS_STORAGE_STATUS_OFFLINE;
tracker_mem_deactive_store_server(*ppGroup, *ppServer); tracker_mem_deactive_store_server(*ppGroup, *ppServer);
if (g_use_storage_id) if (g_use_storage_id)
@ -6146,7 +6172,7 @@ int tracker_mem_check_alive(void *arg)
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"storage server %s(%s:%u) idle too long, " "storage server %s(%s:%u) idle too long, "
"status change to offline!", __LINE__, "status change to offline!", __LINE__,
(*ppServer)->id, FDFS_CURRENT_IP_ADDR(*ppServer), (*ppServer)->id, formatted_ip,
(*ppGroup)->storage_port); (*ppGroup)->storage_port);
} }
else else
@ -6154,8 +6180,7 @@ int tracker_mem_check_alive(void *arg)
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"storage server %s:%u idle too long, " "storage server %s:%u idle too long, "
"status change to offline!", __LINE__, "status change to offline!", __LINE__,
FDFS_CURRENT_IP_ADDR(*ppServer), formatted_ip, (*ppGroup)->storage_port);
(*ppGroup)->storage_port);
} }
} }
} }
@ -6201,12 +6226,13 @@ int tracker_mem_check_alive(void *arg)
g_check_active_interval; g_check_active_interval;
if (last_beat_interval > check_trunk_interval) if (last_beat_interval > check_trunk_interval)
{ {
format_ip_address(FDFS_CURRENT_IP_ADDR((*ppGroup)->
pTrunkServer), formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"trunk server %s(%s:%u) offline because idle " "trunk server %s(%s:%u) offline because idle "
"time: %d s > threshold: %d s, should " "time: %d s > threshold: %d s, should "
"re-select trunk server", __LINE__, "re-select trunk server", __LINE__,
(*ppGroup)->pTrunkServer->id, (*ppGroup)->pTrunkServer->id, formatted_ip,
FDFS_CURRENT_IP_ADDR((*ppGroup)->pTrunkServer),
(*ppGroup)->storage_port, last_beat_interval, (*ppGroup)->storage_port, last_beat_interval,
check_trunk_interval); check_trunk_interval);

95
tracker/tracker_proto.c
View File

@ -43,16 +43,16 @@ int fdfs_recv_header_ex(ConnectionInfo *pTrackerServer,
const int network_timeout, int64_t *in_bytes) const int network_timeout, int64_t *in_bytes)
{ {
TrackerHeader resp; TrackerHeader resp;
char formatted_ip[FORMATTED_IP_SIZE];
int result; int result;
if ((result=tcprecvdata_nb(pTrackerServer->sock, &resp, if ((result=tcprecvdata_nb(pTrackerServer->sock, &resp,
sizeof(resp), network_timeout)) != 0) sizeof(resp), network_timeout)) != 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"server: %s:%u, recv data fail, " "server: %s:%u, recv data fail, errno: %d, error info: %s",
"errno: %d, error info: %s", __LINE__, formatted_ip, pTrackerServer->port,
__LINE__, pTrackerServer->ip_addr,
pTrackerServer->port,
result, STRERROR(result)); result, STRERROR(result));
*in_bytes = 0; *in_bytes = 0;
return result; return result;
@ -60,10 +60,10 @@ int fdfs_recv_header_ex(ConnectionInfo *pTrackerServer,
if (resp.status != 0) if (resp.status != 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"server: %s:%u, response status %d != 0", "server: %s:%u, response status %d != 0", __LINE__,
__LINE__, pTrackerServer->ip_addr, formatted_ip, pTrackerServer->port, resp.status);
pTrackerServer->port, resp.status);
*in_bytes = 0; *in_bytes = 0;
return resp.status; return resp.status;
@ -72,11 +72,10 @@ int fdfs_recv_header_ex(ConnectionInfo *pTrackerServer,
*in_bytes = buff2long(resp.pkg_len); *in_bytes = buff2long(resp.pkg_len);
if (*in_bytes < 0) if (*in_bytes < 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"server: %s:%u, recv package size " "server: %s:%u, recv package size %"PRId64" is not correct",
"%"PRId64" is not correct", __LINE__, formatted_ip, pTrackerServer->port, *in_bytes);
__LINE__, pTrackerServer->ip_addr,
pTrackerServer->port, *in_bytes);
*in_bytes = 0; *in_bytes = 0;
return EINVAL; return EINVAL;
} }
@ -90,6 +89,7 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
{ {
int result; int result;
bool bMalloced; bool bMalloced;
char formatted_ip[FORMATTED_IP_SIZE];
result = fdfs_recv_header(pTrackerServer, in_bytes); result = fdfs_recv_header(pTrackerServer, in_bytes);
if (result != 0) if (result != 0)
@ -121,11 +121,11 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
{ {
if (*in_bytes > buff_size) if (*in_bytes > buff_size)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"server: %s:%u, recv body bytes: " \ logError("file: "__FILE__", line: %d, "
"%"PRId64" exceed max: %d", \ "server: %s:%u, recv body bytes: %"PRId64" exceed "
__LINE__, pTrackerServer->ip_addr, \ "max: %d", __LINE__, formatted_ip, pTrackerServer->port,
pTrackerServer->port, *in_bytes, buff_size); *in_bytes, buff_size);
*in_bytes = 0; *in_bytes = 0;
return ENOSPC; return ENOSPC;
} }
@ -133,15 +133,14 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
bMalloced = false; bMalloced = false;
} }
if ((result=tcprecvdata_nb(pTrackerServer->sock, *buff, \ if ((result=tcprecvdata_nb(pTrackerServer->sock, *buff,
*in_bytes, SF_G_NETWORK_TIMEOUT)) != 0) *in_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server: %s:%u, recv data fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "tracker server: %s:%u, recv data fail, errno: %d, "
__LINE__, pTrackerServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
*in_bytes = 0; *in_bytes = 0;
if (bMalloced) if (bMalloced)
{ {
@ -157,20 +156,20 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
int fdfs_quit(ConnectionInfo *pTrackerServer) int fdfs_quit(ConnectionInfo *pTrackerServer)
{ {
TrackerHeader header; TrackerHeader header;
char formatted_ip[FORMATTED_IP_SIZE];
int result; int result;
memset(&header, 0, sizeof(header)); memset(&header, 0, sizeof(header));
header.cmd = FDFS_PROTO_CMD_QUIT; header.cmd = FDFS_PROTO_CMD_QUIT;
result = tcpsenddata_nb(pTrackerServer->sock, &header, \ result = tcpsenddata_nb(pTrackerServer->sock, &header,
sizeof(header), SF_G_NETWORK_TIMEOUT); sizeof(header), SF_G_NETWORK_TIMEOUT);
if(result != 0) if(result != 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(pTrackerServer->ip_addr, formatted_ip);
"tracker server: %s:%u, send data fail, " \ logError("file: "__FILE__", line: %d, "
"errno: %d, error info: %s", \ "tracker server: %s:%u, send data fail, errno: %d, "
__LINE__, pTrackerServer->ip_addr, \ "error info: %s", __LINE__, formatted_ip,
pTrackerServer->port, \ pTrackerServer->port, result, STRERROR(result));
result, STRERROR(result));
return result; return result;
} }
@ -596,6 +595,7 @@ static int fdfs_do_parameter_req(ConnectionInfo *pTrackerServer,
char *buff, const int buff_size) char *buff, const int buff_size)
{ {
char out_buff[sizeof(TrackerHeader)]; char out_buff[sizeof(TrackerHeader)];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader *pHeader; TrackerHeader *pHeader;
int64_t in_bytes; int64_t in_bytes;
int result; int result;
@ -606,10 +606,11 @@ static int fdfs_do_parameter_req(ConnectionInfo *pTrackerServer,
if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff,
sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, send data fail, " "tracker server %s:%u, send data fail, "
"errno: %d, error info: %s.", __LINE__, "errno: %d, error info: %s", __LINE__,
pTrackerServer->ip_addr, pTrackerServer->port, formatted_ip, pTrackerServer->port,
result, STRERROR(result)); result, STRERROR(result));
return result; return result;
} }
@ -622,10 +623,11 @@ static int fdfs_do_parameter_req(ConnectionInfo *pTrackerServer,
if (in_bytes >= buff_size) if (in_bytes >= buff_size)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"server: %s:%u, recv body bytes: " "server: %s:%u, recv body bytes: "
"%"PRId64" exceed max: %d", __LINE__, "%"PRId64" exceed max: %d", __LINE__,
pTrackerServer->ip_addr, pTrackerServer->port, formatted_ip, pTrackerServer->port,
in_bytes, buff_size); in_bytes, buff_size);
return ENOSPC; return ENOSPC;
} }
@ -646,6 +648,7 @@ int fdfs_get_ini_context_from_tracker_ex(TrackerServerGroup *pTrackerGroup,
TrackerServerInfo *pTServer; TrackerServerInfo *pTServer;
TrackerServerInfo trackerServer; TrackerServerInfo trackerServer;
char in_buff[1024]; char in_buff[1024];
char formatted_ip[FORMATTED_IP_SIZE];
int result; int result;
int leader_index; int leader_index;
int i; int i;
@ -698,11 +701,13 @@ int fdfs_get_ini_context_from_tracker_ex(TrackerServerGroup *pTrackerGroup,
if (conn == NULL) if (conn == NULL)
{ {
format_ip_address(pTServer->connections[0].
ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"connect to server %s:%u fail, errno: %d, " "connect to server %s:%u fail, errno: %d, "
"error info: %s", __LINE__, pTServer->connections[0]. "error info: %s", __LINE__, formatted_ip,
ip_addr, pTServer->connections[0].port, pTServer->connections[0].port, result,
result, STRERROR(result)); STRERROR(result));
continue; continue;
} }
@ -715,9 +720,10 @@ int fdfs_get_ini_context_from_tracker_ex(TrackerServerGroup *pTrackerGroup,
return result; return result;
} }
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"get parameters from tracker server %s:%u fail", "get parameters from tracker server %s:%u fail",
__LINE__, conn->ip_addr, conn->port); __LINE__, formatted_ip, conn->port);
close(conn->sock); close(conn->sock);
sleep(1); sleep(1);
} }
@ -735,6 +741,7 @@ int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
TrackerRunningStatus *pStatus) TrackerRunningStatus *pStatus)
{ {
char in_buff[1 + 2 * FDFS_PROTO_PKG_LEN_SIZE]; char in_buff[1 + 2 * FDFS_PROTO_PKG_LEN_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
TrackerHeader header; TrackerHeader header;
char *pInBuff; char *pInBuff;
ConnectionInfo *conn; ConnectionInfo *conn;
@ -754,10 +761,10 @@ int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
if ((result=tcpsenddata_nb(conn->sock, &header, if ((result=tcpsenddata_nb(conn->sock, &header,
sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to tracker server %s:%u fail, " "send data to tracker server %s:%u fail, errno: %d, "
"errno: %d, error info: %s", __LINE__, "error info: %s", __LINE__, formatted_ip, conn->port,
conn->ip_addr, conn->port,
result, STRERROR(result)); result, STRERROR(result));
result = (result == ENOENT ? EACCES : result); result = (result == ENOENT ? EACCES : result);
@ -774,11 +781,11 @@ int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
if (in_bytes != sizeof(in_buff)) if (in_bytes != sizeof(in_buff))
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u response data " "tracker server %s:%u response data length: "
"length: %"PRId64" is invalid, " "%"PRId64" is invalid, expect length: %d",
"expect length: %d.", __LINE__, __LINE__, formatted_ip, conn->port,
conn->ip_addr, conn->port,
in_bytes, (int)sizeof(in_buff)); in_bytes, (int)sizeof(in_buff));
result = EINVAL; result = EINVAL;
break; break;

78
tracker/tracker_relationship.c
View File

@ -40,6 +40,7 @@ static int fdfs_ping_leader(ConnectionInfo *pTrackerServer)
int64_t in_bytes; int64_t in_bytes;
char in_buff[(FDFS_GROUP_NAME_MAX_LEN + FDFS_STORAGE_ID_MAX_SIZE) * \ char in_buff[(FDFS_GROUP_NAME_MAX_LEN + FDFS_STORAGE_ID_MAX_SIZE) * \
FDFS_MAX_GROUPS]; FDFS_MAX_GROUPS];
char formatted_ip[FORMATTED_IP_SIZE];
char *pInBuff; char *pInBuff;
char *p; char *p;
char *pEnd; char *pEnd;
@ -49,26 +50,26 @@ static int fdfs_ping_leader(ConnectionInfo *pTrackerServer)
memset(&header, 0, sizeof(header)); memset(&header, 0, sizeof(header));
header.cmd = TRACKER_PROTO_CMD_TRACKER_PING_LEADER; header.cmd = TRACKER_PROTO_CMD_TRACKER_PING_LEADER;
result = tcpsenddata_nb(pTrackerServer->sock, &header, \ result = tcpsenddata_nb(pTrackerServer->sock, &header,
sizeof(header), SF_G_NETWORK_TIMEOUT); sizeof(header), SF_G_NETWORK_TIMEOUT);
if(result != 0) if(result != 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, send data fail, " "tracker server %s:%u, send data fail, errno: %d, "
"errno: %d, error info: %s", "error info: %s", __LINE__, formatted_ip,
__LINE__, pTrackerServer->ip_addr,
pTrackerServer->port, result, STRERROR(result)); pTrackerServer->port, result, STRERROR(result));
return result; return result;
} }
pInBuff = in_buff; pInBuff = in_buff;
if ((result=fdfs_recv_response(pTrackerServer, &pInBuff, \ if ((result=fdfs_recv_response(pTrackerServer, &pInBuff,
sizeof(in_buff), &in_bytes)) != 0) sizeof(in_buff), &in_bytes)) != 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"fdfs_recv_response from %s:%u fail, result: %d", "fdfs_recv_response from %s:%u fail, result: %d",
__LINE__, pTrackerServer->ip_addr, __LINE__, formatted_ip, pTrackerServer->port, result);
pTrackerServer->port, result);
return result; return result;
} }
@ -79,9 +80,10 @@ static int fdfs_ping_leader(ConnectionInfo *pTrackerServer)
else if (in_bytes % (FDFS_GROUP_NAME_MAX_LEN + \ else if (in_bytes % (FDFS_GROUP_NAME_MAX_LEN + \
FDFS_STORAGE_ID_MAX_SIZE) != 0) FDFS_STORAGE_ID_MAX_SIZE) != 0)
{ {
format_ip_address(pTrackerServer->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u, invalid body length: " "tracker server %s:%u, invalid body length: "
"%"PRId64, __LINE__, pTrackerServer->ip_addr, "%"PRId64, __LINE__, formatted_ip,
pTrackerServer->port, in_bytes); pTrackerServer->port, in_bytes);
return EINVAL; return EINVAL;
} }
@ -198,6 +200,7 @@ static int relationship_get_tracker_leader(TrackerRunningStatus *pTrackerStatus)
TrackerServerInfo *pTrackerEnd; TrackerServerInfo *pTrackerEnd;
TrackerRunningStatus *pStatus; TrackerRunningStatus *pStatus;
TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS]; TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS];
char formatted_ip[FORMATTED_IP_SIZE];
int count; int count;
int result; int result;
int r; int r;
@ -235,17 +238,20 @@ static int relationship_get_tracker_leader(TrackerRunningStatus *pTrackerStatus)
qsort(trackerStatus, count, sizeof(TrackerRunningStatus), \ qsort(trackerStatus, count, sizeof(TrackerRunningStatus), \
relationship_cmp_tracker_status); relationship_cmp_tracker_status);
if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
for (i=0; i<count; i++) for (i=0; i<count; i++)
{ {
logDebug("file: "__FILE__", line: %d, " \ format_ip_address(trackerStatus[i].pTrackerServer->
"%s:%u if_leader: %d, running time: %d, " \ connections->ip_addr, formatted_ip);
"restart interval: %d", __LINE__, \ logDebug("file: "__FILE__", line: %d, "
trackerStatus[i].pTrackerServer->connections->ip_addr, \ "%s:%u if_leader: %d, running time: %d, "
trackerStatus[i].pTrackerServer->connections->port, \ "restart interval: %d", __LINE__, formatted_ip,
trackerStatus[i].if_leader, \ trackerStatus[i].pTrackerServer->connections->port,
trackerStatus[i].running_time, \ trackerStatus[i].if_leader,
trackerStatus[i].running_time,
trackerStatus[i].restart_interval); trackerStatus[i].restart_interval);
} }
}
memcpy(pTrackerStatus, trackerStatus + (count - 1), \ memcpy(pTrackerStatus, trackerStatus + (count - 1), \
sizeof(TrackerRunningStatus)); sizeof(TrackerRunningStatus));
@ -256,6 +262,7 @@ static int do_notify_leader_changed(TrackerServerInfo *pTrackerServer, \
ConnectionInfo *pLeader, const char cmd, bool *bConnectFail) ConnectionInfo *pLeader, const char cmd, bool *bConnectFail)
{ {
char out_buff[sizeof(TrackerHeader) + FDFS_PROTO_IP_PORT_SIZE]; char out_buff[sizeof(TrackerHeader) + FDFS_PROTO_IP_PORT_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
char in_buff[1]; char in_buff[1];
ConnectionInfo *conn; ConnectionInfo *conn;
TrackerHeader *pHeader; TrackerHeader *pHeader;
@ -276,39 +283,41 @@ static int do_notify_leader_changed(TrackerServerInfo *pTrackerServer, \
memset(out_buff, 0, sizeof(out_buff)); memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff; pHeader = (TrackerHeader *)out_buff;
pHeader->cmd = cmd; pHeader->cmd = cmd;
sprintf(out_buff + sizeof(TrackerHeader), "%s:%u", \ format_ip_port(pLeader->ip_addr, pLeader->port,
pLeader->ip_addr, pLeader->port); out_buff + sizeof(TrackerHeader));
long2buff(FDFS_PROTO_IP_PORT_SIZE, pHeader->pkg_len); long2buff(FDFS_PROTO_IP_PORT_SIZE, pHeader->pkg_len);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \ if ((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0) sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"send data to tracker server %s:%u fail, " "send data to tracker server %s:%u fail, errno: %d, "
"errno: %d, error info: %s", __LINE__, "error info: %s", __LINE__, formatted_ip, conn->port,
conn->ip_addr, conn->port, result, STRERROR(result)); result, STRERROR(result));
result = (result == ENOENT ? EACCES : result); result = (result == ENOENT ? EACCES : result);
break; break;
} }
pInBuff = in_buff; pInBuff = in_buff;
result = fdfs_recv_response(conn, &pInBuff, \ result = fdfs_recv_response(conn, &pInBuff, 0, &in_bytes);
0, &in_bytes);
if (result != 0) if (result != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"fdfs_recv_response from tracker server %s:%u fail, " "fdfs_recv_response from tracker server %s:%u fail, "
"result: %d", __LINE__, conn->ip_addr, conn->port, result); "result: %d", __LINE__, formatted_ip, conn->port, result);
break; break;
} }
if (in_bytes != 0) if (in_bytes != 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"tracker server %s:%u response data " "tracker server %s:%u response data "
"length: %"PRId64" is invalid, " "length: %"PRId64" is invalid, "
"expect length: %d.", __LINE__, "expect length: %d.", __LINE__,
conn->ip_addr, conn->port, in_bytes, 0); formatted_ip, conn->port, in_bytes, 0);
result = EINVAL; result = EINVAL;
break; break;
} }
@ -330,6 +339,8 @@ static int do_notify_leader_changed(TrackerServerInfo *pTrackerServer, \
void relationship_set_tracker_leader(const int server_index, void relationship_set_tracker_leader(const int server_index,
ConnectionInfo *pLeader, const bool leader_self) ConnectionInfo *pLeader, const bool leader_self)
{ {
char formatted_ip[FORMATTED_IP_SIZE];
g_tracker_servers.leader_index = server_index; g_tracker_servers.leader_index = server_index;
g_next_leader_index = -1; g_next_leader_index = -1;
@ -340,9 +351,10 @@ void relationship_set_tracker_leader(const int server_index,
} }
else else
{ {
format_ip_address(pLeader->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"the tracker leader is %s:%u", __LINE__, "the tracker leader is %s:%u", __LINE__,
pLeader->ip_addr, pLeader->port); formatted_ip, pLeader->port);
} }
} }
@ -458,6 +470,7 @@ static int relationship_select_leader()
int result; int result;
TrackerRunningStatus trackerStatus; TrackerRunningStatus trackerStatus;
ConnectionInfo *conn; ConnectionInfo *conn;
char formatted_ip[FORMATTED_IP_SIZE];
if (g_tracker_servers.server_count <= 0) if (g_tracker_servers.server_count <= 0)
{ {
@ -482,9 +495,10 @@ static int relationship_select_leader()
return result; return result;
} }
format_ip_address(conn->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"I am the new tracker leader %s:%u", "I am the new tracker leader %s:%u",
__LINE__, conn->ip_addr, conn->port); __LINE__, formatted_ip, conn->port);
tracker_mem_find_trunk_servers(); tracker_mem_find_trunk_servers();
} }
@ -509,15 +523,17 @@ static int relationship_select_leader()
if (g_tracker_servers.leader_index >= 0) if (g_tracker_servers.leader_index >= 0)
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"the tracker leader %s:%u", __LINE__, "the tracker leader %s:%u", __LINE__,
conn->ip_addr, conn->port); formatted_ip, conn->port);
} }
else else
{ {
format_ip_address(conn->ip_addr, formatted_ip);
logInfo("file: "__FILE__", line: %d, " logInfo("file: "__FILE__", line: %d, "
"waiting for the candidate tracker leader %s:%u notify ...", "waiting for the candidate tracker leader %s:%u notify ...",
__LINE__, conn->ip_addr, conn->port); __LINE__, formatted_ip, conn->port);
return ENOENT; return ENOENT;
} }
} }
@ -560,6 +576,7 @@ static void *relationship_thread_entrance(void* arg)
int fail_count; int fail_count;
int sleep_seconds; int sleep_seconds;
char formatted_ip[FORMATTED_IP_SIZE];
#ifdef OS_LINUX #ifdef OS_LINUX
{ {
@ -607,8 +624,9 @@ static void *relationship_thread_entrance(void* arg)
{ {
pLeader = g_tracker_servers.servers pLeader = g_tracker_servers.servers
[leader_index].connections; [leader_index].connections;
format_ip_address(pLeader->ip_addr, formatted_ip);
sprintf(leader_str, "leader %s:%u", sprintf(leader_str, "leader %s:%u",
pLeader->ip_addr, pLeader->port); formatted_ip, pLeader->port);
} }
++fail_count; ++fail_count;

45
tracker/tracker_service.c
View File

@ -645,6 +645,7 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
char *pIpAndPort; char *pIpAndPort;
char *ipAndPort[2]; char *ipAndPort[2];
ConnectionInfo leader; ConnectionInfo leader;
char formatted_ip[FORMATTED_IP_SIZE];
int server_index; int server_index;
if (pTask->recv.ptr->length - sizeof(TrackerHeader) != if (pTask->recv.ptr->length - sizeof(TrackerHeader) !=
@ -675,14 +676,15 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
pTask->send.ptr->length = sizeof(TrackerHeader); pTask->send.ptr->length = sizeof(TrackerHeader);
strcpy(leader.ip_addr, ipAndPort[0]); strcpy(leader.ip_addr, ipAndPort[0]);
leader.port = atoi(ipAndPort[1]); leader.port = atoi(ipAndPort[1]);
server_index = fdfs_get_tracker_leader_index_ex(&g_tracker_servers, \ server_index = fdfs_get_tracker_leader_index_ex(&g_tracker_servers,
leader.ip_addr, leader.port); leader.ip_addr, leader.port);
if (server_index < 0) if (server_index < 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(leader.ip_addr, formatted_ip);
"client ip: %s, leader %s:%u not exist", \ logError("file: "__FILE__", line: %d, "
__LINE__, pTask->client_ip, \ "client ip: %s, leader %s:%u not exist",
leader.ip_addr, leader.port); __LINE__, pTask->client_ip,
formatted_ip, leader.port);
return ENOENT; return ENOENT;
} }
@ -693,11 +695,11 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
g_tracker_servers.leader_index = -1; g_tracker_servers.leader_index = -1;
g_tracker_leader_chg_count++; g_tracker_leader_chg_count++;
logError("file: "__FILE__", line: %d, " \ format_ip_address(leader.ip_addr, formatted_ip);
"client ip: %s, two leaders occur, " \ logError("file: "__FILE__", line: %d, "
"new leader is %s:%u", \ "client ip: %s, two leaders occur, new leader "
__LINE__, pTask->client_ip, \ "is %s:%u", __LINE__, pTask->client_ip,
leader.ip_addr, leader.port); formatted_ip, leader.port);
return EINVAL; return EINVAL;
} }
@ -710,6 +712,7 @@ static int tracker_deal_commit_next_leader(struct fast_task_info *pTask)
char *pIpAndPort; char *pIpAndPort;
char *ipAndPort[2]; char *ipAndPort[2];
ConnectionInfo leader; ConnectionInfo leader;
char formatted_ip[FORMATTED_IP_SIZE];
int server_index; int server_index;
bool leader_self; bool leader_self;
@ -745,18 +748,20 @@ static int tracker_deal_commit_next_leader(struct fast_task_info *pTask)
leader.ip_addr, leader.port); leader.ip_addr, leader.port);
if (server_index < 0) if (server_index < 0)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(leader.ip_addr, formatted_ip);
"client ip: %s, leader %s:%u not exist", \ logError("file: "__FILE__", line: %d, "
__LINE__, pTask->client_ip, \ "client ip: %s, leader %s:%u not exist",
leader.ip_addr, leader.port); __LINE__, pTask->client_ip,
formatted_ip, leader.port);
return ENOENT; return ENOENT;
} }
if (server_index != g_next_leader_index) if (server_index != g_next_leader_index)
{ {
logError("file: "__FILE__", line: %d, " \ format_ip_address(leader.ip_addr, formatted_ip);
"client ip: %s, can't commit leader %s:%u", \ logError("file: "__FILE__", line: %d, "
__LINE__, pTask->client_ip, \ "client ip: %s, can't commit leader %s:%u",
leader.ip_addr, leader.port); __LINE__, pTask->client_ip,
formatted_ip, leader.port);
return EINVAL; return EINVAL;
} }
@ -984,6 +989,7 @@ static int tracker_deal_get_my_ip(struct fast_task_info *pTask)
static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask) static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask)
{ {
char ip_addr[IP_ADDRESS_SIZE]; char ip_addr[IP_ADDRESS_SIZE];
char formatted_ip[FORMATTED_IP_SIZE];
FDFSStorageIdInfo *pFDFSStorageIdInfo; FDFSStorageIdInfo *pFDFSStorageIdInfo;
char *pPort; char *pPort;
int port; int port;
@ -1038,9 +1044,10 @@ static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask)
pFDFSStorageIdInfo = fdfs_get_storage_id_by_ip_port(ip_addr, port); pFDFSStorageIdInfo = fdfs_get_storage_id_by_ip_port(ip_addr, port);
if (pFDFSStorageIdInfo == NULL) if (pFDFSStorageIdInfo == NULL)
{ {
format_ip_address(ip_addr, formatted_ip);
logError("file: "__FILE__", line: %d, " logError("file: "__FILE__", line: %d, "
"client ip: %s, can't get group name for storage %s:%u", "client ip: %s, can't get group name for storage %s:%u",
__LINE__, pTask->client_ip, ip_addr, port); __LINE__, pTask->client_ip, formatted_ip, port);
pTask->send.ptr->length = sizeof(TrackerHeader); pTask->send.ptr->length = sizeof(TrackerHeader);
return ENOENT; return ENOENT;
} }