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

storage server get ip from tracker

multi_ipaddr
YuQing 2019-10-12 19:15:58 +08:00
parent ba527d41bb
commit 5695965470
4 changed files with 172 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
storage/storage_ip_changed_dealer.c
View File

@ -117,6 +117,107 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
}
}
static int storage_get_my_ip_from_tracker(ConnectionInfo *conn,
char *ip_addrs, const int buff_size)
{
char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
TrackerHeader *pHeader;
int result;
int64_t in_bytes;
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_MY_IP;
strcpy(out_buff + sizeof(TrackerHeader), g_group_name);
if((result=tcpsenddata_nb(conn->sock, out_buff,
sizeof(out_buff), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, "
"tracker server %s:%d, send data fail, "
"errno: %d, error info: %s.",
__LINE__, conn->ip_addr, conn->port,
result, STRERROR(result));
return result;
}
if ((result=fdfs_recv_response(conn, &ip_addrs,
buff_size - 1, &in_bytes)) != 0)
{
logError("file: "__FILE__", line: %d, "
"tracker server %s:%d, recv response fail, "
"errno: %d, error info: %s.",
__LINE__, conn->ip_addr, conn->port,
result, STRERROR(result));
return result;
}
*(ip_addrs + in_bytes) = '\0';
return 0;
}
static int storage_set_tracker_client_ips(ConnectionInfo *conn)
{
char my_ip_addrs[256];
char error_info[256];
FDFSMultiIP multi_ip;
int result;
int i;
if ((result=storage_get_my_ip_from_tracker(conn, my_ip_addrs,
sizeof(my_ip_addrs))) != 0)
{
return result;
}
if ((result=fdfs_parse_multi_ips_ex(my_ip_addrs, &multi_ip,
error_info, sizeof(error_info), false)) != 0)
{
return result;
}
for (i = 0; i < multi_ip.count; i++)
{
result = storage_insert_ip_addr_to_multi_ips(&g_tracker_client_ip,
multi_ip.ips[i], multi_ip.count);
if (result == 0)
{
if ((result=fdfs_check_and_format_ips(&g_tracker_client_ip,
error_info, sizeof(error_info))) != 0)
{
logCrit("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%d, "
"my ip: %s not valid, error info: %s. "
"program exit!", __LINE__,
conn->ip_addr, conn->port,
multi_ip.ips[i], error_info);
return result;
}
insert_into_local_host_ip(multi_ip.ips[i]);
}
else if (result != EEXIST)
{
char ip_str[256];
fdfs_multi_ips_to_string(&g_tracker_client_ip,
ip_str, sizeof(ip_str));
logError("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%d, "
"my ip: %s not consistent with client ips: %s "
"of other tracker client. program exit!", __LINE__,
conn->ip_addr, conn->port,
multi_ip.ips[i], ip_str);
return result;
}
}
return 0;
}
int storage_get_my_tracker_client_ip()
{
TrackerServerInfo *pGlobalServer;
@ -137,7 +238,7 @@ int storage_get_my_tracker_client_ip()
while (success_count == 0 && g_continue_flag)
{
for (pGlobalServer=g_tracker_group.servers; pGlobalServer<pTServerEnd; \
for (pGlobalServer=g_tracker_group.servers; pGlobalServer<pTServerEnd;
pGlobalServer++)
{
memcpy(pTServer, pGlobalServer, sizeof(TrackerServerInfo));
@ -166,27 +267,15 @@ int storage_get_my_tracker_client_ip()
continue;
}
getSockIpaddr(conn->sock, tracker_client_ip, IP_ADDRESS_SIZE);
result = storage_insert_ip_addr_to_multi_ips(&g_tracker_client_ip,
tracker_client_ip, 1);
if (!(result == 0 || result == EEXIST))
if ((result=storage_set_tracker_client_ips(conn)) != 0)
{
char ip_str[256];
fdfs_multi_ips_to_string(&g_tracker_client_ip,
ip_str, sizeof(ip_str));
logError("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%d, "
"my ip: %s not consistent with client ips: %s "
"of other tracker client.", __LINE__,
conn->ip_addr, conn->port,
tracker_client_ip, ip_str);
close(conn->sock);
return EINVAL;
return result;
}
getSockIpaddr(conn->sock, tracker_client_ip, IP_ADDRESS_SIZE);
insert_into_local_host_ip(tracker_client_ip);
fdfs_quit(conn);
close(conn->sock);
success_count++;

35
storage/tracker_client_thread.c
View File

@ -199,7 +199,6 @@ static void *tracker_report_thread_entrance(void *arg)
TrackerServerInfo *pTrackerServer;
char my_server_id[FDFS_STORAGE_ID_MAX_SIZE];
char tracker_client_ip[IP_ADDRESS_SIZE];
char ip_str[256];
char szFailPrompt[256];
bool sync_old_done;
int stat_chg_sync_count;
@ -296,41 +295,7 @@ static void *tracker_report_thread_entrance(void *arg)
previousCode = 0;
nContinuousFail = 0;
result = storage_insert_ip_addr_to_multi_ips(&g_tracker_client_ip,
tracker_client_ip, ips_limit);
if (!(result == 0 || result == EEXIST))
{
fdfs_multi_ips_to_string(&g_tracker_client_ip,
ip_str, sizeof(ip_str));
logCrit("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%d, "
"my ip: %s not consistent with client ips: %s "
"of other tracker client. program exit!", __LINE__,
conn->ip_addr, conn->port,
tracker_client_ip, ip_str);
g_continue_flag = false;
break;
}
if (result == 0)
{
if (fdfs_check_and_format_ips(&g_tracker_client_ip,
szFailPrompt, sizeof(szFailPrompt)) != 0)
{
logCrit("file: "__FILE__", line: %d, "
"as a client of tracker server %s:%d, "
"my ip: %s not valid, error info: %s. "
"program exit!", __LINE__,
conn->ip_addr, conn->port,
tracker_client_ip, szFailPrompt);
g_continue_flag = false;
break;
}
insert_into_local_host_ip(tracker_client_ip);
}
/*
//printf("file: "__FILE__", line: %d, " \

1
tracker/tracker_proto.h
View File

@ -34,6 +34,7 @@
#define TRACKER_PROTO_CMD_STORAGE_FETCH_TRUNK_FID 72 //storage get current trunk file id
#define TRACKER_PROTO_CMD_STORAGE_GET_STATUS 71 //get storage status from tracker
#define TRACKER_PROTO_CMD_STORAGE_GET_SERVER_ID 70 //get storage server id from tracker
#define TRACKER_PROTO_CMD_STORAGE_GET_MY_IP 60 //get storage server ip from tracker
#define TRACKER_PROTO_CMD_STORAGE_FETCH_STORAGE_IDS 69 //get all storage ids from tracker
#define TRACKER_PROTO_CMD_STORAGE_GET_GROUP_NAME 109 //get storage group name from tracker

62
tracker/tracker_service.c
View File

@ -1133,6 +1133,65 @@ static int tracker_deal_get_storage_id(struct fast_task_info *pTask)
return 0;
}
static int tracker_deal_get_my_ip(struct fast_task_info *pTask)
{
char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
int nPkgLen;
int body_len;
nPkgLen = pTask->length - sizeof(TrackerHeader);
if (nPkgLen != FDFS_GROUP_NAME_MAX_LEN)
{
logError("file: "__FILE__", line: %d, "
"cmd=%d, client ip addr: %s, "
"package size %d is not correct, "
"expect length: %d", __LINE__,
TRACKER_PROTO_CMD_STORAGE_GET_MY_IP,
pTask->client_ip, nPkgLen, FDFS_GROUP_NAME_MAX_LEN);
pTask->length = sizeof(TrackerHeader);
return EINVAL;
}
memcpy(group_name, pTask->data + sizeof(TrackerHeader),
FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
if (g_use_storage_id)
{
FDFSStorageIdInfo *pFDFSStorageIdInfo;
pFDFSStorageIdInfo = fdfs_get_storage_id_by_ip(group_name,
pTask->client_ip);
if (pFDFSStorageIdInfo == NULL)
{
logWarning("file: "__FILE__", line: %d, "
"cmd=%d, client ip addr: %s, "
"group_name: %s, storage ip not exist "
"in storage_ids.conf", __LINE__,
TRACKER_PROTO_CMD_STORAGE_GET_MY_IP,
pTask->client_ip, group_name);
body_len = strlen(pTask->client_ip);
memcpy(pTask->data + sizeof(TrackerHeader),
pTask->client_ip, body_len);
}
else
{
body_len = fdfs_multi_ips_to_string(
&pFDFSStorageIdInfo->ip_addrs,
pTask->data + sizeof(TrackerHeader),
pTask->size - sizeof(TrackerHeader));
}
}
else
{
body_len = strlen(pTask->client_ip);
memcpy(pTask->data + sizeof(TrackerHeader),
pTask->client_ip, body_len);
}
pTask->length = sizeof(TrackerHeader) + body_len;
return 0;
}
static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask)
{
char ip_addr[IP_ADDRESS_SIZE];
@ -3799,6 +3858,9 @@ int tracker_deal_task(struct fast_task_info *pTask)
case TRACKER_PROTO_CMD_STORAGE_GET_SERVER_ID:
result = tracker_deal_get_storage_id(pTask);
break;
case TRACKER_PROTO_CMD_STORAGE_GET_MY_IP:
result = tracker_deal_get_my_ip(pTask);
break;
case TRACKER_PROTO_CMD_STORAGE_GET_GROUP_NAME:
result = tracker_deal_get_storage_group_name(pTask);
break;