devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c/c++ fast_dfs上传、下载图片

作者：我家小花儿 | 2024-06-22 03:43:23

赞

踩

dfs上传

首先安装libfastcommon

1、git clone https://github.com/happyfish100/libfastcommon.git

安装fastdfs

2、cd libfastcommon && ./make.sh && ./make.sh install

3、git clone https://github.com/happyfish100/fastdfs.git

4、cd  fastdfs && ./make.sh && ./make.sh install

在fastdfs/client里面有c操作fastdfs的一些示例文件，这里我用的是fdfs_upload_file.c

到以下就是我的测试工程了，如果你没有fastdfs的服务的话就在安装好fastdfs后 cd /etc/fdfs

sudo cp client.conf.sample client.conf

将base_path=/home/yuqing/fastdfs 改为你机器一个存在的目录,该目录用来存放fastdfs客户端的日志，没有的话可以自己先把目录建好

将tracker_server=192.168.2.33:22122 改为你要访问的地址

sudo cp storage.conf.sample storage.conf

将base_path=/home/yuqing/fastdfs 改为你机器上一个存在的目录，这个目录是用来存放上传的文件的

sudo cp tracker.conf.sample tracker.conf

将base_path=/home/yuqing/fastdfs 改为你机器一个存在的目录，没有的话可以自己先把目录建好

fdfs_trackerd /etc/fdfs/tracker.conf start启动tracker服务

fdfs_storaged /etc/fdfs/storage.conf start启动storage服务

5、下面就是我的测试工程了

  1. #ifndef MY_FDFS_CLIENT_H
  2. #define MY_FDFS_CLIENT_H
  3.  
  4. #include "fdfs_client.h"
  5. #include "fdfs_global.h"
  6. #include "base64.h"
  7. #include "sockopt.h"
  8. #include "logger.h"
  9. #include <string>
  10. #define TEST
  11. using namespace std;
  12.  
  13. //错误码
  14. enum FSC_CODE
  15. {
  16.     FSC_ERROR_CODE_NONE = 0,				//没有错误
  17.     FSC_ERROR_CODE_INIT_FAILED,				//初始化失败
  18.  
  19.     FSC_ERROR_CODE_PARAM_INVAILD,			//参数无效
  20.  
  21.     FSC_ERROR_CODE_CONNECT_TRACKER_FAIL,    //连接失败
  22.     FSC_ERROR_CODE_QUERY_STORAGE_FAIL,		//查询storage地址失败
  23.     FSC_ERROR_CODE_CONNECT_STORAGE_FAIL,	//连接storage失败
  24.  
  25.     FSC_ERROR_CODE_DOWNLAOD_FILE_FAIL,		//下载文件失败
  26.     FSC_ERROR_CODE_DELETE_FILE_FAIL,		//删除文件失败
  27. };
  28.  
  29. class CFDFSClient
  30. {
  31. public:
  32. 	CFDFSClient(void);
  33. 	~CFDFSClient(void);
  34.  
  35. public:
  36. 	
  37. 	// 初始化客户端
  38.     //
  39.     //功能：初始化fastdfs
  40.     //参数：
  41.     //      const char* sConfig IN FastDFS配置文件路劲 比如:/etc/fdfs/client.conf
  42.     //		int nLogLevel 日志等级 采用的是unix 日志等级
  43.     //  0: LOG_EMERG
  44.     //	1: LOG_ALERT
  45.     //	2: LOG_CRIT
  46.     //	3: LOG_ERR
  47.     //	4: LOG_WARNING
  48.     //	5: LOG_NOTICE
  49.     //	6: LOG_INFO
  50.     //	7: LOG_DEBUG
  51.  
  52.     //返回：int& anError OUT 错误信息
  53.  
  54.     //备注：
  55.     //      注意初始化时，必须保证conf文件中base_path目录存在
  56.     //		比如 base_path=/fastdfs/tracker, 需要保证/fastdfs/tracker存在，
  57.     //		不存在 需创建mkdir /fastdfs/tracker
  58.     //
  59. 	int init(const char* sFDFSConfig, int nLogLevel);
  60.  
  61. 	// 下载文件
  62.     //
  63.     //功能：下载文件
  64.     //参数：
  65.     //      BufferInfo* pBuff OUT 返回的文件信息，文件大小，以及内存大小
  66.     //      const char *group_name IN 存储组名
  67.     //      const char* remote_filename IN 存储名
  68.     //      比如：group2/M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250.png
  69.     //		group_name:group2
  70.     //		remote_filename: M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250.png
  71.  
  72.     // 返回：0:成功 否则失败。
  73.     //
  74. 	int fdfs_dowloadfile(BufferInfo* pBuff, const char *group_name, const char* remote_filename);
  75. 	
  76. 	// 上传
  77.     //
  78.     //功能：上传文件
  79.     //参数：
  80.     //      char *file_content IN 文件内容
  81.     //      const char *file_ext_name IN 文件扩展名
  82.     //		int file_size IN 文件大小
  83.     //		int& name_size	OUT 返回的文件名大小
  84.     //      char* remote_file_name OUT 返回的文件名
  85.     //      比如：group2/M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250.png
  86.  
  87.     // 返回：0:成功 否则失败。
  88.     //
  89. 	int fdfs_uploadfile( const char *file_content, const char *file_ext_name, int file_size, 
  90.         int& name_size, char* &remote_file_name);
  91.     
  92.     // slave上传
  93.     //
  94.     //功能：从文件上传
  95.     //参数：
  96.     //      char *file_content IN 文件内容
  97.     //      const char *master_filename IN 主文件名 存在服务端文件名
  98.     //      比如：M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250
  99.     //      const char *prefix_name IN 从前缀名 比如200*200
  100.     //      const char *file_ext_name IN 文件扩展名
  101.     //		int file_size IN 文件大小
  102.     //		int& name_size	OUT 返回的文件名大小
  103.     //      char* remote_file_name OUT 返回的文件名
  104.     //      比如：group2/M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250.png
  105.  
  106.     // 返回：0:成功 否则失败。
  107.     //
  108.     int fdfs_slave_uploadfile( const char *file_content, const char *master_filename,
  109.                                const char *prefix_name, const char *file_ext_name, 
  110.                                int file_size, int& name_size, char*& remote_file_name );
  111.  
  112. 	// 删除
  113.     //
  114.     //功能：删除文件
  115.     //参数：
  116.     //      const char *group_name IN 存储组名
  117.     //      const char* remote_filename IN 存储名
  118.     //      比如：group2/M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250.png
  119.     //		group_name:group2
  120.     //		remote_filename: M00/00/00/CgEIzVRhnJWAZfVkAAAsFwWtoVg250.png
  121.  
  122.     // 返回：0:成功 否则失败。
  123.     //
  124. 	int fdfs_deletefile(const char *group_name, const char* remote_filename);
  125.  
  126. 	// 所有组信息
  127.     //
  128.     //功能：获取所有组信息
  129.     //参数：
  130.     //      BufferInfo* group_info OUT 所有组信息
  131.  
  132.     // 返回：0:成功 否则失败。
  133.     //
  134.  
  135. #ifndef TEST
  136.     int list_all_groups(BufferInfo* group_info);
  137.  
  138. 	// 指定组信息
  139.     //
  140.     //功能：获取指定组信息
  141.     //参数：
  142.     //		const char* group_name IN 组名 如：group1
  143.     //      BufferInfo* group_info OUT 所有组信息
  144.  
  145.     // 返回：0:成功 否则失败。
  146.     //
  147. 	int list_one_group(const char* group_name, BufferInfo *group_info);
  148.  
  149. 	// storage信息
  150.     //
  151.     //功能：获取storage信息
  152.     //参数：
  153.     //		const char* group_name IN 组名 如：group1
  154.     //		const char* storage_id IN 组名 如：storage ip
  155.     //      BufferInfo* storages_info OUT 存储信息
  156.  
  157.     // 返回：0:成功 否则失败。
  158.     //
  159. 	int list_storages(const char* group_name, 
  160. 		const char* storage_id, 
  161. 		BufferInfo* storages_info);
  162. #endif
  163.  
  164. private:
  165. 	void re_fastfds_client_init();
  166.  
  167. 	int fastfdfs_client_init(const char* sFDFSConfig);
  168.  
  169. private:
  170. 	ConnectionInfo *m_pTrackerServer;
  171. 	BufferInfo m_RecvBufferInfo;
  172. 	char* m_pRemoteFileName;
  173. 	string m_strConfigPath;
  174. 	int	m_nLevelLog;
  175. };
  176.  
  177. #endif
  178.  
  1. #include "FDFSClient.h"
  2. #ifndef TEST
  3. #include "json/json.h"
  4. #endif
  5.  
  6. #define  MAX_REMOTE_FILE_NAME_SIZE 100
  7.  
  8. CFDFSClient::CFDFSClient(void)
  9. {
  10. 	m_pTrackerServer = NULL;
  11. 	//m_RecvBufferInfo = {0};
  12. 	memset(&m_RecvBufferInfo,0,sizeof(m_RecvBufferInfo));
  13. 	m_pRemoteFileName = NULL;
  14. }
  15.  
  16. CFDFSClient::~CFDFSClient(void)
  17. {
  18. 	fdfs_client_destroy();
  19.  
  20. 	log_destroy();
  21. 	
  22. 	if (m_RecvBufferInfo.buff != NULL)
  23. 	{
  24. 		free(m_RecvBufferInfo.buff);
  25. 	}
  26.  
  27. 	if (m_pRemoteFileName != NULL)
  28. 	{
  29. 		free(m_pRemoteFileName);
  30. 	}
  31. }
  32.  
  33. int CFDFSClient::init( const char* sFDFSConfig, int nLogLevel)
  34. {
  35. 	// 初始化日志
  36.     log_init(); 
  37.     g_log_context.log_level = nLogLevel;
  38.  
  39. 	m_strConfigPath = sFDFSConfig;
  40. 	m_nLevelLog = nLogLevel;
  41.  
  42. 	// 初始化fastfds客户端
  43. 	int result = 0;
  44. 	result = fastfdfs_client_init(sFDFSConfig);
  45.  
  46.     m_pRemoteFileName = (char*)malloc(MAX_REMOTE_FILE_NAME_SIZE * sizeof(char));
  47. 	memset(m_pRemoteFileName, 0, MAX_REMOTE_FILE_NAME_SIZE - 1);
  48. 	return result;
  49. }
  50.  
  51. int CFDFSClient::fastfdfs_client_init(const char* sFDFSConfig)
  52. {
  53. 	int result = 0;
  54. 	if ((result=fdfs_client_init(m_strConfigPath.c_str())) != 0)
  55. 	{
  56. 		logErrorEx(&g_log_context, "CFDFSClient::init() fdfs_client_init is failed, result:%d", result);
  57. 		return FSC_ERROR_CODE_INIT_FAILED;
  58. 	}
  59.  
  60. 	return result;
  61. }
  62.  
  63. int CFDFSClient::fdfs_dowloadfile( BufferInfo* pBuff, const char *group_name, const char* remote_filename)
  64. {
  65. 	char *file_buff = NULL;
  66.     int64_t file_size = 0;
  67.     int result = 0;
  68.     
  69.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  70. 	if (pTrackerServer == NULL)
  71. 	{
  72. 		result = (errno != 0 ? errno : ECONNREFUSED);
  73. 		logErrorEx(&g_log_context, "CFDFSClient::init() tracker_get_connection is failed, result:%d", result);
  74.  
  75. 		return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  76. 	}
  77.  
  78.     // 查询storage 服务地址
  79. 	ConnectionInfo storageServer;
  80. 	ConnectionInfo* pStorageServer;
  81.     result = tracker_query_storage_fetch(pTrackerServer, \
  82. 		&storageServer, group_name, remote_filename);
  83.     if (result != 0)
  84. 	{
  85. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() tracker_query_storage_fetch fail, " \
  86. 			"error no: %d, error info: %s\n", \
  87. 			result, STRERROR(result));
  88.             
  89.         tracker_disconnect_server_ex(pTrackerServer, true);
  90.  
  91. 		return FSC_ERROR_CODE_QUERY_STORAGE_FAIL;
  92. 	}
  93.  
  94. 	logDebugEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() storage=%s:%d\n", storageServer.ip_addr, \
  95. 		storageServer.port);
  96.  
  97. 	if ((pStorageServer=tracker_connect_server(&storageServer, \
  98. 		&result)) == NULL)
  99. 	{
  100. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() \
  101. 			tracker_connect_server failed, result:%d, storage=%s:%d\n", 
  102. 			result, storageServer.ip_addr, \
  103. 			storageServer.port);
  104.         
  105.         tracker_disconnect_server_ex(pTrackerServer, true);
  106.  
  107. 		return FSC_ERROR_CODE_CONNECT_STORAGE_FAIL;
  108.     }
  109.  
  110.     if ((result=storage_download_file_to_buff( \
  111. 		pTrackerServer, pStorageServer, \
  112. 		group_name, remote_filename, \
  113. 		&file_buff, &file_size)) == 0)
  114. 	{
  115.         buffer_memcpy(&m_RecvBufferInfo, file_buff, file_size);
  116. 		*pBuff = m_RecvBufferInfo;
  117. 		free(file_buff);
  118. 	}
  119.  
  120.     if (result != 0)
  121. 	{
  122. 		const char* strMsg = STRERROR(result);
  123. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_dowloadfile() download file fail, " \
  124. 					"group:%s, remote;%s, error no: %d, error info: %s\n", \
  125. 					group_name, remote_filename, result, strMsg);
  126. 		result = FSC_ERROR_CODE_DOWNLAOD_FILE_FAIL;
  127. 	}
  128.  
  129.     tracker_disconnect_server_ex(pStorageServer, true);
  130.     tracker_disconnect_server_ex(pTrackerServer, true);
  131.     
  132.     return  result;
  133. }
  134.  
  135. int CFDFSClient::fdfs_uploadfile(const char *file_content, const char *file_ext_name, int file_size,
  136.                                  int& name_size, char *&remote_file_name)
  137. {
  138.     int result = 0;
  139.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  140. 	if (pTrackerServer == NULL)
  141. 	{
  142. 		result = (errno != 0 ? errno : ECONNREFUSED);
  143. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_uploadfile() tracker_get_connection is failed, result:%d", result);
  144.  
  145. 		return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  146. 	}
  147.     
  148. 	char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
  149. 	char remote_filename[256];
  150.  
  151. 	int store_path_index;
  152. 	ConnectionInfo storageServer;
  153. 	ConnectionInfo* pStorageServer;
  154. 	if ((result=tracker_query_storage_store(pTrackerServer, \
  155. 		&storageServer, group_name, &store_path_index)) != 0)
  156. 	{
  157.         tracker_disconnect_server_ex(pTrackerServer, true);
  158.  
  159. 		logErrorEx(&g_log_context, "tracker_query_storage fail, " \
  160. 			"error no: %d, error info: %s\n", \
  161. 			result, STRERROR(result));
  162. 		return result;
  163. 	}
  164.  
  165. 	if ((pStorageServer=tracker_connect_server(&storageServer, \
  166. 		&result)) == NULL)
  167. 	{
  168. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_uploadfile() \
  169. 								   tracker_connect_server failed, result:%d, storage=%s:%d\n", 
  170. 								   result, storageServer.ip_addr, \
  171. 								   storageServer.port);
  172.         tracker_disconnect_server_ex(pTrackerServer, true);
  173.  
  174. 		return result;
  175. 	}
  176.  
  177. 	result = storage_upload_by_filebuff(pTrackerServer, \
  178. 		pStorageServer, store_path_index, \
  179. 		file_content, file_size, file_ext_name, \
  180. 		NULL, 0, \
  181. 		group_name, remote_filename);
  182. 	if (result != 0)
  183. 	{
  184. 		const char* strMsg = STRERROR(result);
  185. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_uploadfile() upload file fail, " \
  186. 			"group:%s, remote;%s, error no: %d, error info: %s\n", \
  187. 			group_name, remote_filename, result, strMsg);
  188. 	}
  189.     else{
  190.         int nNameSize = snprintf(m_pRemoteFileName,MAX_REMOTE_FILE_NAME_SIZE-1, "%s/%s", group_name, remote_filename);
  191.         remote_file_name = m_pRemoteFileName;
  192.         name_size = nNameSize;
  193.     }
  194.     
  195.     tracker_disconnect_server_ex(pStorageServer, true);
  196.     tracker_disconnect_server_ex(pTrackerServer, true);
  197.  
  198.     return result;
  199. }
  200.  
  201. int CFDFSClient::fdfs_slave_uploadfile( const char *file_content, const char *master_filename,
  202.                                         const char *prefix_name, const char *file_ext_name, 
  203.                                         int file_size, int& name_size, char*& remote_file_name)
  204. {
  205.     int result = 0;
  206.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  207. 	if (pTrackerServer == NULL)
  208. 	{
  209. 		result = (errno != 0 ? errno : ECONNREFUSED);
  210. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_slave_uploadfile() tracker_get_connection is failed, result:%d", result);
  211.  
  212. 		return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  213. 	}
  214.     
  215. 	char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
  216. 	char remote_filename[256];
  217.  
  218. 	int store_path_index;
  219. 	ConnectionInfo storageServer;
  220. 	ConnectionInfo* pStorageServer;
  221. 	if ((result=tracker_query_storage_store(pTrackerServer, \
  222. 		&storageServer, group_name, &store_path_index)) != 0)
  223. 	{
  224.         tracker_disconnect_server_ex(pTrackerServer, true);
  225.  
  226. 		logErrorEx(&g_log_context, "tracker_query_storage fail, " \
  227. 			"error no: %d, error info: %s\n", \
  228. 			result, STRERROR(result));
  229. 		return result;
  230. 	}
  231.  
  232. 	if ((pStorageServer=tracker_connect_server(&storageServer, \
  233. 		&result)) == NULL)
  234. 	{
  235. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_slave_uploadfile() \
  236. 								   tracker_connect_server failed, result:%d, storage=%s:%d\n", 
  237. 								   result, storageServer.ip_addr, \
  238. 								   storageServer.port);
  239.         tracker_disconnect_server_ex(pTrackerServer, true);
  240.  
  241. 		return result;
  242. 	}
  243.  
  244. 	result = storage_upload_slave_by_filebuff(pTrackerServer, \
  245. 		pStorageServer, file_content, file_size, \
  246.         master_filename, prefix_name, file_ext_name, \
  247. 		NULL, 0, \
  248. 		group_name, remote_filename);
  249. 	
  250. 	//logErrorEx(&g_log_context, "master_filename:%s, prefix_name:%s, file_ext_name:%s, group_name:%s, remote_filename:%s\n", 
  251. 	//	master_filename, prefix_name, file_ext_name, group_name, remote_filename);
  252. 	
  253. 	if (result != 0)
  254. 	{
  255. 		const char* strMsg = STRERROR(result);
  256. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_slave_uploadfile() upload file fail, " \
  257. 			"group:%s, remote;%s, error no: %d, error info: %s\n", \
  258. 			group_name, remote_filename, result, strMsg);
  259. 	}
  260.     else{
  261.         int nNameSize = snprintf(m_pRemoteFileName,MAX_REMOTE_FILE_NAME_SIZE-1, "%s/%s", group_name, remote_filename);
  262.         remote_file_name = m_pRemoteFileName;
  263.         name_size = nNameSize;
  264.     }
  265.     
  266.     tracker_disconnect_server_ex(pStorageServer, true);
  267.     tracker_disconnect_server_ex(pTrackerServer, true);
  268.  
  269.     return result;
  270. }
  271.  
  272.  
  273. int CFDFSClient::fdfs_deletefile( const char *group_name, const char* remote_filename )
  274. {
  275. 	int result = 0;
  276.  
  277.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  278. 	if (pTrackerServer == NULL)
  279. 	{
  280. 		fdfs_client_destroy();
  281. 		result = (errno != 0 ? errno : ECONNREFUSED);
  282. 		logErrorEx(&g_log_context, "CFDFSClient::init() tracker_get_connection is failed, result:%d", result);
  283.  
  284. 		return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  285. 	}
  286.     
  287. 	// 查询storage 服务地址
  288. 	ConnectionInfo storageServer;
  289. 	ConnectionInfo* pStorageServer;
  290. 	result = tracker_query_storage_update(pTrackerServer, \
  291. 		&storageServer, group_name, remote_filename);
  292. 	if (result != 0)
  293. 	{
  294. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_deletefile() tracker_query_storage_fetch fail, " \
  295. 			"error no: %d, error info: %s\n", \
  296. 			result, STRERROR(result));  
  297.         
  298.         tracker_disconnect_server_ex(pTrackerServer, true);
  299.  
  300. 		return FSC_ERROR_CODE_QUERY_STORAGE_FAIL;
  301. 	}
  302.  
  303. 	logDebugEx(&g_log_context, "CFDFSClient::fdfs_deletefile() storage=%s:%d\n", storageServer.ip_addr, \
  304. 		storageServer.port);
  305.  
  306. 	if ((pStorageServer=tracker_connect_server(&storageServer, \
  307. 		&result)) == NULL)
  308. 	{
  309. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_deletefile() \
  310. 								   tracker_connect_server failed, result:%d, storage=%s:%d\n", 
  311. 								   result, storageServer.ip_addr, \
  312. 								   storageServer.port);
  313.         tracker_disconnect_server_ex(pTrackerServer, true);
  314.  
  315. 		return FSC_ERROR_CODE_CONNECT_STORAGE_FAIL;
  316. 	}
  317.  
  318. 	// 删除操作
  319. 	result=storage_delete_file(pTrackerServer, NULL, group_name, remote_filename);
  320. 	if (result != 0)
  321. 	{
  322. 		const char* strMsg = STRERROR(result);
  323. 		logErrorEx(&g_log_context, "CFDFSClient::fdfs_deletefile() delete file fail, " \
  324. 			"group:%s, remote;%s, error no: %d, error info: %s\n", \
  325. 			group_name, remote_filename, result, strMsg);
  326.  
  327. 		result = FSC_ERROR_CODE_DELETE_FILE_FAIL;
  328. 	}
  329.  
  330. 	tracker_disconnect_server_ex(pStorageServer, true);
  331.     tracker_disconnect_server_ex(pTrackerServer, true);
  332.     
  333. 	return  result;
  334. }
  335. #ifndef TEST
  336. int CFDFSClient::list_all_groups(BufferInfo* group_info)
  337. {
  338. 	int result = 0;
  339.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  340.     if (pTrackerServer == NULL)
  341.     {
  342.         fdfs_client_destroy();
  343.         result = (errno != 0 ? errno : ECONNREFUSED);
  344.         logErrorEx(&g_log_context, "CFDFSClient::init() tracker_get_connection is failed, result:%d", result);
  345.  
  346.         return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  347.     }
  348.  
  349.     int group_count;
  350.     FDFSGroupStat group_stats[FDFS_MAX_GROUPS];
  351.     result = tracker_list_groups(pTrackerServer, \
  352.         group_stats, FDFS_MAX_GROUPS, \
  353.         &group_count);
  354.     if (result != 0)
  355.     {
  356.         tracker_disconnect_server_ex(pTrackerServer, true);
  357.  
  358.         const char* strMsg = STRERROR(result);
  359.         logErrorEx(&g_log_context, "CFDFSClient::list_all_groups() get  list_all_groups fail, " \
  360.             "error no: %d, error info: %s\n", \
  361.             result, strMsg);
  362.  
  363.         return result;
  364.     }
  365.  
  366.     Json::Value GroupsValue;
  367.     Json::Value Info;
  368.     FDFSGroupStat *pGroupStat;
  369.     FDFSGroupStat *pGroupEnd;
  370.     pGroupEnd = group_stats + group_count;
  371.     for (pGroupStat=group_stats; pGroupStat<pGroupEnd; \
  372.      pGroupStat++)
  373.     {
  374.         Info["group_name"] = pGroupStat->group_name;
  375.         Info["total_mb"] = (long long)pGroupStat->total_mb;
  376.         Info["free_mb"] = (long long)pGroupStat->free_mb;
  377.         Info["trunk_free_mb"] = (long long)pGroupStat->trunk_free_mb;
  378.         Info["server_count"] = pGroupStat->count;
  379.         Info["storage_port"] = pGroupStat->storage_port;
  380.         Info["active_count"] = pGroupStat->active_count;
  381.         Info["current_write_server"] = pGroupStat->current_write_server;
  382.         Info["subdir_count_per_path"] = pGroupStat->subdir_count_per_path;
  383.         Info["current_trunk_file_id"] = pGroupStat->current_trunk_file_id;
  384.  
  385.         GroupsValue.append(Info);
  386.     }
  387.     std::string strGroupsInfo = GroupsValue.toStyledString();
  388.     buffer_memcpy(&m_RecvBufferInfo, strGroupsInfo.c_str(), strGroupsInfo.length());
  389.     *group_info = m_RecvBufferInfo;
  390.    
  391.     tracker_disconnect_server_ex(pTrackerServer, true);
  392.  
  393. 	return result;
  394. }
  395.  
  396. int CFDFSClient::list_one_group(const char* group_name, BufferInfo* group_info)
  397. {
  398. 	int result;
  399. 	FDFSGroupStat group_stat;
  400.     
  401.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  402. 	if (pTrackerServer == NULL)
  403. 	{
  404. 		fdfs_client_destroy();
  405. 		result = (errno != 0 ? errno : ECONNREFUSED);
  406. 		logErrorEx(&g_log_context, "CFDFSClient::init() tracker_get_connection is failed, result:%d", result);
  407.  
  408. 		return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  409. 	}
  410.  
  411. 	result = tracker_list_one_group(pTrackerServer, group_name, &group_stat);
  412. 	if (result != 0)
  413. 	{
  414.         tracker_disconnect_server_ex(pTrackerServer, true);
  415.  
  416. 		const char* strMsg = STRERROR(result);
  417. 		logErrorEx(&g_log_context, "CFDFSClient::list_one_group() get list_one_group fail, " \
  418. 			"error no: %d, error info: %s\n", \
  419. 			result, strMsg);
  420.  
  421. 		return result;
  422. 	}
  423.  
  424. 	Json::Value GroupsValue;
  425. 	GroupsValue["group_name"] = group_stat.group_name;
  426. 	GroupsValue["total_mb"] = (long long)group_stat.total_mb;
  427. 	GroupsValue["free_mb"] = (long long)group_stat.free_mb;
  428. 	GroupsValue["trunk_free_mb"] = (long long)group_stat.trunk_free_mb;
  429. 	GroupsValue["server_count"] = group_stat.count;
  430. 	GroupsValue["storage_port"] = group_stat.storage_port;
  431. 	GroupsValue["active_count"] = group_stat.active_count;
  432. 	GroupsValue["current_write_server"] = group_stat.current_write_server;
  433. 	GroupsValue["subdir_count_per_path"] = group_stat.subdir_count_per_path;
  434. 	GroupsValue["current_trunk_file_id"] = group_stat.current_trunk_file_id;
  435.  
  436. 	std::string strGroupsInfo = GroupsValue.toStyledString();
  437. 	buffer_memcpy(&m_RecvBufferInfo, strGroupsInfo.c_str(), strGroupsInfo.length());
  438. 	*group_info = m_RecvBufferInfo;
  439.         
  440.     tracker_disconnect_server_ex(pTrackerServer, true);
  441.  
  442. 	return result;
  443. }
  444.  
  445. int CFDFSClient::list_storages(const char* group_name, 
  446. 							   const char* storage_id, 
  447. 							   BufferInfo* storages_info)
  448. {
  449. 	int result;
  450. 	int storage_count;
  451. 	FDFSStorageInfo storage_infos[FDFS_MAX_SERVERS_EACH_GROUP];
  452. 	FDFSStorageInfo *pStorage;
  453. 	FDFSStorageInfo *pStorageEnd;
  454. 	FDFSStorageStat *pStorageStat;
  455.  
  456.     ConnectionInfo *pTrackerServer = tracker_get_connection();
  457. 	if (pTrackerServer == NULL)
  458. 	{
  459. 		fdfs_client_destroy();
  460. 		result = (errno != 0 ? errno : ECONNREFUSED);
  461. 		logErrorEx(&g_log_context, "CFDFSClient::init() tracker_get_connection is failed, result:%d", result);
  462.  
  463. 		return FSC_ERROR_CODE_CONNECT_TRACKER_FAIL;
  464. 	}
  465.     
  466. 	result = tracker_list_servers(pTrackerServer, \
  467. 		group_name, storage_id, \
  468. 		storage_infos, FDFS_MAX_SERVERS_EACH_GROUP, \
  469. 		&storage_count);
  470. 	if (result != 0)
  471. 	{
  472.         tracker_disconnect_server_ex(pTrackerServer, true);
  473.  
  474. 		const char* strMsg = STRERROR(result);
  475. 		logErrorEx(&g_log_context, "CFDFSClient::list_storages() get list_storages fail, " \
  476. 			"error no: %d, error info: %s\n", \
  477. 			result, strMsg);
  478.  
  479. 		return result;
  480. 	}
  481.  
  482. 	Json::Value StoragesValue;
  483. 	Json::Value Info;
  484. 	char szJoinTime[32];
  485. 	char szUpTime[32];
  486. 	char szLastHeartBeatTime[32];
  487. 	char szSrcUpdTime[32];
  488. 	char szSyncUpdTime[32];
  489. 	char szSyncedTimestamp[32];
  490. 	pStorageEnd = storage_infos + storage_count;
  491. 	for (pStorage=storage_infos; pStorage<pStorageEnd; \
  492. 		pStorage++)
  493. 	{
  494. 		Info["status"] = pStorage->status;
  495. 		Info["id"] = pStorage->id;
  496. 		Info["ip_addr"] = pStorage->ip_addr;
  497. 		Info["version"] = pStorage->version;
  498. 		Info["src_id"] = pStorage->src_id;
  499. 		Info["domain_name"] = pStorage->domain_name;
  500. 		Info["total_mb"] = pStorage->total_mb;
  501. 		Info["free_mb"] = pStorage->free_mb;
  502. 		Info["upload_priority"] = pStorage->upload_priority;
  503.  
  504. 		formatDatetime(pStorage->join_time, \
  505. 			"%Y-%m-%d %H:%M:%S", \
  506. 			szJoinTime, sizeof(szJoinTime)), \
  507. 		Info["join_time"] = szJoinTime;
  508.  
  509. 		formatDatetime(pStorage->up_time, \
  510. 		"%Y-%m-%d %H:%M:%S", \
  511. 		szUpTime, sizeof(szUpTime)), \
  512. 		Info["up_time"] = szUpTime;
  513.  
  514. 		Info["store_path_count"] = pStorage->store_path_count;	
  515. 		Info["subdir_count_per_path"] = pStorage->subdir_count_per_path;	
  516. 		Info["storage_port"] = pStorage->storage_port;	
  517. 		Info["current_write_path"] = pStorage->current_write_path;	
  518.  
  519. 		// 统计数据
  520. 		pStorageStat = &(pStorage->stat);
  521. 		Info["total_upload_count"] = (long long)pStorageStat->total_upload_count;	
  522. 		Info["success_upload_count"] = (long long)pStorageStat->success_upload_count;	
  523. 		Info["total_delete_count"] = (long long)pStorageStat->total_delete_count;	
  524. 		Info["success_delete_count"] = (long long)pStorageStat->success_delete_count;	
  525. 		Info["total_download_count"] = (long long)pStorageStat->total_download_count;	
  526. 		Info["success_download_count"] = (long long)pStorageStat->success_download_count;	
  527.  
  528. 		Info["total_upload_bytes"] = (long long)pStorageStat->total_upload_bytes;	
  529. 		Info["success_upload_bytes"] = (long long)pStorageStat->success_upload_bytes;
  530. 		Info["total_download_bytes"] = (long long)pStorageStat->total_download_bytes;	
  531. 		Info["success_download_bytes"] = (long long)pStorageStat->success_download_bytes;
  532. 		Info["total_sync_in_bytes"] = (long long)pStorageStat->total_sync_in_bytes;	
  533. 		Info["success_sync_in_bytes"] = (long long)pStorageStat->success_sync_in_bytes;
  534. 		Info["total_sync_out_bytes"] = (long long)pStorageStat->total_sync_out_bytes;	
  535. 		Info["success_sync_out_bytes"] = (long long)pStorageStat->success_sync_out_bytes;
  536.  
  537. 		Info["total_file_open_count"] = (long long)pStorageStat->total_file_open_count;	
  538. 		Info["success_file_open_count"] = (long long)pStorageStat->success_file_open_count;
  539. 		Info["total_file_read_count"] = (long long)pStorageStat->total_file_read_count;	
  540. 		Info["success_file_read_count"] = (long long)pStorageStat->success_file_read_count;
  541. 		Info["total_file_write_count"] = (long long)pStorageStat->total_file_write_count;	
  542. 		Info["success_file_write_count"] =(long long) pStorageStat->success_file_write_count;
  543.  
  544. 		formatDatetime(pStorageStat->last_heart_beat_time, \
  545. 			"%Y-%m-%d %H:%M:%S", \
  546. 			szLastHeartBeatTime, sizeof(szLastHeartBeatTime)), \
  547. 		Info["last_heart_beat_time"] = szLastHeartBeatTime;
  548.  
  549. 		formatDatetime(pStorageStat->last_source_update, \
  550. 		"%Y-%m-%d %H:%M:%S", \
  551. 		szSrcUpdTime, sizeof(szSrcUpdTime)), \
  552. 		Info["last_source_update"] = szSrcUpdTime;
  553.  
  554. 		formatDatetime(pStorageStat->last_sync_update, \
  555. 		"%Y-%m-%d %H:%M:%S", \
  556. 		szSyncUpdTime, sizeof(szSyncUpdTime)), \
  557. 		Info["last_sync_update"] = szSyncUpdTime;
  558.  
  559. 		formatDatetime(pStorageStat->last_synced_timestamp, \
  560. 		"%Y-%m-%d %H:%M:%S", \
  561. 		szSyncedTimestamp, sizeof(szSyncedTimestamp));
  562. 		Info["last_synced_timestamp"] = szSyncedTimestamp;
  563.  
  564. 		StoragesValue.append(Info);
  565. 	}
  566.  
  567. 	std::string strStorageInfo = StoragesValue.toStyledString();
  568. 	buffer_memcpy(&m_RecvBufferInfo, strStorageInfo.c_str(), strStorageInfo.length());
  569. 	*storages_info = m_RecvBufferInfo;
  570.     
  571.     tracker_disconnect_server_ex(pTrackerServer, true);
  572.  
  573. 	return result;
  574. }
  575. #endif
  1. #include <iostream>
  2. #include <fstream>
  3. #include <memory>
  4. #include "FDFSClient.h"
  5.  
  6. void ShowError(const std::string &msg, int code){
  7.     if(code == 0) return;
  8.     std::cout << msg << ":" << code << std::endl;
  9.     ::exit(-1);
  10. }
  11.  
  12. int main()
  13. {
  14.     std::ifstream file_stream("desktop_test.png", std::ios::in | std::ios::binary);
  15.     file_stream.seekg(0, std::ios_base::end);
  16.     int file_size = file_stream.tellg();
  17.     file_stream.seekg(0, std::ios_base::beg);
  18.  
  19.     std::shared_ptr<char> buffer(new char[file_size]);
  20.     file_stream.read(buffer.get(), file_size);
  21.  
  22.     char *remote_file_name = nullptr;
  23.     int remote_name_size = 0;
  24.     CFDFSClient fdfs_client;
  25.     ShowError("client_init", fdfs_client.init("client.conf",6));
  26.     ShowError("upload_file",fdfs_client.fdfs_uploadfile(buffer.get(),"png", file_size, remote_name_size, remote_file_name));
  27.     std::cout << "remote file name: " << remote_file_name << std::endl;
  28.     return 0;
  29. }

 cmake配置如下

  1. cmake_minimum_required(VERSION 2.8)
  2.  
  3. project(fdfs_client)
  4. add_compile_options(-std=c++17 -fpermissive)
  5. INCLUDE_DIRECTORIES(/usr/include/fastcommon /usr/include/fastdfs)
  6. LINK_DIRECTORIES(/home/whl/Documents/qtproject/fdfs_client/json/lib)
  7. find_package(spdlog REQUIRED)
  8. aux_source_directory(. Client_Sources)
  9. add_executable(${PROJECT_NAME} ${Client_Sources})
  10. target_link_libraries(${PROJECT_NAME} spdlog::spdlog_header_only fdfsclient fastcommon)

有个json编译没过，我将它注释了，影响不大。如果上传成功，就会返回一个这样的地址

group1/M00/29/6A/wKgCKF0YUmKAVdsAAAm9c5z7Go4983.png

在浏览器中就可以访问了(需要配置nginx)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/745249
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号