FastDFS分布式文件系统点滴记录5 -- upload上传机制剖析2

首先分析下 tracker ， tracker_service.c 3137行：int tracker_deal_task(struct fast_task_info *pTask)

对TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE命令的处理是

1. case TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE:
   
2.             result = tracker_deal_service_query_storage( \
   
3.                     pTask, pHeader->cmd);
   
4.             break;

我们进入 tracker_deal_service_query_storage， tracker_service.c 1955行：

1. static int tracker_deal_service_query_storage( \
   
2.         struct fast_task_info *pTask, char cmd)

这个函数比较长，由于里面包含了负载均衡相关的逻辑判断，我们暂时关注点只分析cmd为TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE，涉及到负载均衡的部分，之后其他文章会单独分析。

tracker_service.c 2184行： 

1.     if (cmd == TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ONE
   
2.      || cmd == TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE)
   
3.     {
   
4.         pStorageServer = tracker_get_writable_storage(pStoreGroup);
   
5.         if (pStorageServer == NULL)
   
6.         {
   
7.             pTask->length = sizeof(TrackerHeader);
   
8.             return ENOENT;
   
9.         }
   
10.     }
    
11.     else //query store server list, use the first to check
    
12.     {
    
13.         pStorageServer = *(pStoreGroup->active_servers);
    
14.     }

代码分析：

1.通过负载均衡, 获得可利用的pStoreGroup 结构；

2. 调用tracker_get_writable_storage ，找到合适的pStorageServer

tracker_service.c 2199行：

1. write_path_index = pStorageServer->current_write_path;
   
2.     if (write_path_index >= pStoreGroup->store_path_count)
   
3.     {
   
4.         write_path_index = 0;
   
5.     }
   
6. 
   
7.     avg_reserved_mb = g_storage_reserved_mb / \
   
8.              pStoreGroup->store_path_count;
   
9.     if (pStorageServer->path_free_mbs[write_path_index] <= avg_reserved_mb)
   
10.     {
    
11.         int i;
    
12.         for (i=0; i<pStoreGroup->store_path_count; i++)
    
13.         {
    
14.             if (pStorageServer->path_free_mbs[i] > avg_reserved_mb)
    
15.             {
    
16.                 pStorageServer->current_write_path = i;
    
17.                 write_path_index = i;
    
18.                 break;
    
19.             }
    
20.         }
    
21. 
    
22.         if (i == pStoreGroup->store_path_count)
    
23.         {
    
24.             if (!g_if_use_trunk_file)
    
25.             {
    
26.                 pTask->length = sizeof(TrackerHeader);
    
27.                 return ENOSPC;
    
28.             }
    
29. 
    
30.             for (i=write_path_index; i<pStoreGroup-> \
    
31.                 store_path_count; i++)
    
32.             {
    
33.                 if (pStorageServer->path_free_mbs[i] + \
    
34.                  pStoreGroup->trunk_free_mb > avg_reserved_mb)
    
35.                 {
    
36.                     pStorageServer->current_write_path = i;
    
37.                     write_path_index = i;
    
38.                     break;
    
39.                 }
    
40.             }
    
41.             if ( i == pStoreGroup->store_path_count)
    
42.             {
    
43.                 for (i=0; i<write_path_index; i++)
    
44.                 {
    
45.                 if (pStorageServer->path_free_mbs[i] + \
    
46.                  pStoreGroup->trunk_free_mb > avg_reserved_mb)
    
47.                 {
    
48.                     pStorageServer->current_write_path = i;
    
49.                     write_path_index = i;
    
50.                     break;
    
51.                 }
    
52.                 }
    
53. 
    
54.                 if (i == write_path_index)
    
55.                 {
    
56.                     pTask->length = sizeof(TrackerHeader);
    
57.                     return ENOSPC;
    
58.                 }
    
59.             }
    
60.         }
    
61.     }
    
62. 
    
63.     if (g_groups.store_path == FDFS_STORE_PATH_ROUND_ROBIN)
    
64.     {
    
65.         pStorageServer->current_write_path++;
    
66.         if (pStorageServer->current_write_path >= \
    
67.                 pStoreGroup->store_path_count)
    
68.         {
    
69.             pStorageServer->current_write_path = 0;
    
70.         }
    
71.     }
    
72. 
    
73.     /*
    
74.     //printf("pStoreGroup->current_write_server: %d, " \
    
75.     "pStoreGroup->active_count=%d\n", \
    
76.     pStoreGroup->current_write_server, \
    
77.     pStoreGroup->active_count);
    
78.     */
    
79. 
    
80.     p = pTask->data + sizeof(TrackerHeader);
    
81.     memcpy(p, pStoreGroup->group_name, FDFS_GROUP_NAME_MAX_LEN);
    
82.     p += FDFS_GROUP_NAME_MAX_LEN;
    
83. 
    
84.     if (cmd == TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ALL
    
85.      || cmd == TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ALL)
    
86.     {
    
87.         int active_count;
    
88.         FDFSStorageDetail **ppServer;
    
89.         FDFSStorageDetail **ppEnd;
    
90. 
    
91.         active_count = pStoreGroup->active_count;
    
92.         if (active_count == 0)
    
93.         {
    
94.             pTask->length = sizeof(TrackerHeader);
    
95.             return ENOENT;
    
96.         }
    
97. 
    
98.         ppEnd = pStoreGroup->active_servers + active_count;
    
99.         for (ppServer=pStoreGroup->active_servers; ppServer<ppEnd; \
    
100.             ppServer++)
     
101.         {
     
102.             memcpy(p, (*ppServer)->ip_addr, IP_ADDRESS_SIZE - 1);
     
103.             p += IP_ADDRESS_SIZE - 1;
     
104. 
     
105.             long2buff(pStoreGroup->storage_port, p);
     
106.             p += FDFS_PROTO_PKG_LEN_SIZE;
     
107.         }
     
108.     }
     
109.     else
     
110.     {
     
111.         memcpy(p, pStorageServer->ip_addr, IP_ADDRESS_SIZE - 1);
     
112.         p += IP_ADDRESS_SIZE - 1;
     
113. 
     
114.         long2buff(pStoreGroup->storage_port, p);
     
115.         p += FDFS_PROTO_PKG_LEN_SIZE;
     
116.     }
     
117. 
     
118.     *p++ = (char)write_path_index;
     
119. 
     
120.     pTask->length = p - pTask->data;
     
121. 
     
122.     return 0;

代码分析：

1. 根据配置的条件，查找合适的write_path_index，

2. 将找到的storage server 信息，group_name、ip_addr、storage_port 拼接到响应包里面。

最后， tracker_service.c 3287行 ：

1.     pHeader = (TrackerHeader *)pTask->data;
   
2.     pHeader->status = result;
   
3.     pHeader->cmd = TRACKER_PROTO_CMD_RESP;
   
4.     long2buff(pTask->length - sizeof(TrackerHeader), pHeader->pkg_len);
   
5. 
   
6.     send_add_event(pTask);

会将应答包通过socket 发送至客户端。

至此，client 与 tracker 的请求storage server 的过程结束。这里只是对TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE 命令进行分析。其余获取store 的命令和它类似，读者可以自行分析。

欢迎感兴趣的朋友一起交流研究，提出意见。

FastDFS技术交流群：164684842