1 /**
2 * Copyright (C) 2008 Happy Fish / YuQing
3 *
4 * FastDFS may be copied only under the terms of the GNU General
5 * Public License V3, which may be found in the FastDFS source kit.
6 * Please visit the FastDFS Home Page http://www.fastken.com/ for more detail.
7 **/
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <string.h>
13 #include <errno.h>
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include "fdfs_client.h"
17 #include "fdfs_global.h"
18 #include "fastcommon/base64.h"
19 #include "fastcommon/sockopt.h"
20 #include "fastcommon/logger.h"
21 #include "fdfs_http_shared.h"
22
writeToFileCallback(void * arg,const int64_t file_size,const char * data,const int current_size)23 int writeToFileCallback(void *arg, const int64_t file_size, const char *data, \
24 const int current_size)
25 {
26 if (arg == NULL)
27 {
28 return EINVAL;
29 }
30
31 if (fwrite(data, current_size, 1, (FILE *)arg) != 1)
32 {
33 return errno != 0 ? errno : EIO;
34 }
35
36 return 0;
37 }
38
uploadFileCallback(void * arg,const int64_t file_size,int sock)39 int uploadFileCallback(void *arg, const int64_t file_size, int sock)
40 {
41 int64_t total_send_bytes;
42 char *filename;
43
44 if (arg == NULL)
45 {
46 return EINVAL;
47 }
48
49 filename = (char *)arg;
50 return tcpsendfile(sock, filename, file_size, \
51 g_fdfs_network_timeout, &total_send_bytes);
52 }
53
main(int argc,char * argv[])54 int main(int argc, char *argv[])
55 {
56 char *conf_filename;
57 char *local_filename;
58 ConnectionInfo *pTrackerServer;
59 ConnectionInfo *pStorageServer;
60 int result;
61 ConnectionInfo storageServer;
62 char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
63 char remote_filename[256];
64 char appender_filename[256];
65 FDFSMetaData meta_list[32];
66 int meta_count;
67 char token[32 + 1];
68 char file_id[128];
69 char file_url[256];
70 char szDatetime[20];
71 char szPortPart[16];
72 int url_len;
73 time_t ts;
74 int64_t file_offset;
75 int64_t file_size = 0;
76 int store_path_index;
77 FDFSFileInfo file_info;
78 int upload_type;
79 const char *file_ext_name;
80 struct stat stat_buf;
81
82 printf("This is FastDFS client test program v%d.%02d\n" \
83 "\nCopyright (C) 2008, Happy Fish / YuQing\n" \
84 "\nFastDFS may be copied only under the terms of the GNU General\n" \
85 "Public License V3, which may be found in the FastDFS source kit.\n" \
86 "Please visit the FastDFS Home Page http://www.fastken.com/ \n" \
87 "for more detail.\n\n" \
88 , g_fdfs_version.major, g_fdfs_version.minor);
89
90 if (argc < 3)
91 {
92 printf("Usage: %s <config_file> <local_filename> " \
93 "[FILE | BUFF | CALLBACK]\n", argv[0]);
94 return 1;
95 }
96
97 log_init();
98 g_log_context.log_level = LOG_DEBUG;
99
100 conf_filename = argv[1];
101 if ((result=fdfs_client_init(conf_filename)) != 0)
102 {
103 return result;
104 }
105
106 pTrackerServer = tracker_get_connection();
107 if (pTrackerServer == NULL)
108 {
109 fdfs_client_destroy();
110 return errno != 0 ? errno : ECONNREFUSED;
111 }
112
113 local_filename = argv[2];
114 if (argc == 3)
115 {
116 upload_type = FDFS_UPLOAD_BY_FILE;
117 }
118 else
119 {
120 if (strcmp(argv[3], "BUFF") == 0)
121 {
122 upload_type = FDFS_UPLOAD_BY_BUFF;
123 }
124 else if (strcmp(argv[3], "CALLBACK") == 0)
125 {
126 upload_type = FDFS_UPLOAD_BY_CALLBACK;
127 }
128 else
129 {
130 upload_type = FDFS_UPLOAD_BY_FILE;
131 }
132 }
133
134 *group_name = '\0';
135 store_path_index = 0;
136 if ((result=tracker_query_storage_store(pTrackerServer, \
137 &storageServer, group_name, &store_path_index)) != 0)
138 {
139 fdfs_client_destroy();
140 printf("tracker_query_storage fail, " \
141 "error no: %d, error info: %s\n", \
142 result, STRERROR(result));
143 return result;
144 }
145
146 printf("group_name=%s, ip_addr=%s, port=%d\n", \
147 group_name, storageServer.ip_addr, \
148 storageServer.port);
149
150 if ((pStorageServer=tracker_make_connection(&storageServer, \
151 &result)) == NULL)
152 {
153 fdfs_client_destroy();
154 return result;
155 }
156
157 memset(&meta_list, 0, sizeof(meta_list));
158 meta_count = 0;
159 strcpy(meta_list[meta_count].name, "ext_name");
160 strcpy(meta_list[meta_count].value, "jpg");
161 meta_count++;
162 strcpy(meta_list[meta_count].name, "width");
163 strcpy(meta_list[meta_count].value, "160");
164 meta_count++;
165 strcpy(meta_list[meta_count].name, "height");
166 strcpy(meta_list[meta_count].value, "80");
167 meta_count++;
168 strcpy(meta_list[meta_count].name, "file_size");
169 strcpy(meta_list[meta_count].value, "115120");
170 meta_count++;
171
172 file_ext_name = fdfs_get_file_ext_name(local_filename);
173
174 if (upload_type == FDFS_UPLOAD_BY_FILE)
175 {
176 if (stat(local_filename, &stat_buf) == 0 && \
177 S_ISREG(stat_buf.st_mode))
178 {
179 file_size = stat_buf.st_size;
180 result = storage_upload_appender_by_filename ( \
181 pTrackerServer, pStorageServer, \
182 store_path_index, local_filename, \
183 file_ext_name, meta_list, meta_count, \
184 group_name, remote_filename);
185 }
186 else
187 {
188 result = errno != 0 ? errno : ENOENT;
189 }
190
191 printf("storage_upload_appender_by_filename\n");
192 }
193 else if (upload_type == FDFS_UPLOAD_BY_BUFF)
194 {
195 char *file_content;
196 if ((result=getFileContent(local_filename, \
197 &file_content, &file_size)) == 0)
198 {
199 result = storage_upload_appender_by_filebuff( \
200 pTrackerServer, pStorageServer, \
201 store_path_index, file_content, \
202 file_size, file_ext_name, \
203 meta_list, meta_count, \
204 group_name, remote_filename);
205 free(file_content);
206 }
207
208 printf("storage_upload_appender_by_filebuff\n");
209 }
210 else
211 {
212 if (stat(local_filename, &stat_buf) == 0 && \
213 S_ISREG(stat_buf.st_mode))
214 {
215 file_size = stat_buf.st_size;
216 result = storage_upload_appender_by_callback( \
217 pTrackerServer, pStorageServer, \
218 store_path_index, uploadFileCallback, \
219 local_filename, file_size, \
220 file_ext_name, meta_list, meta_count, \
221 group_name, remote_filename);
222 }
223 else
224 {
225 result = errno != 0 ? errno : ENOENT;
226 }
227
228 printf("storage_upload_appender_by_callback\n");
229 }
230
231 if (result != 0)
232 {
233 printf("upload file fail, " \
234 "error no: %d, error info: %s\n", \
235 result, STRERROR(result));
236 tracker_close_connection_ex(pStorageServer, true);
237 fdfs_client_destroy();
238 return result;
239 }
240
241 if (g_tracker_server_http_port == 80)
242 {
243 *szPortPart = '\0';
244 }
245 else
246 {
247 sprintf(szPortPart, ":%d", g_tracker_server_http_port);
248 }
249
250 sprintf(file_id, "%s/%s", group_name, remote_filename);
251 url_len = sprintf(file_url, "http://%s%s/%s", \
252 pTrackerServer->ip_addr, szPortPart, file_id);
253 if (g_anti_steal_token)
254 {
255 ts = time(NULL);
256 fdfs_http_gen_token(&g_anti_steal_secret_key, file_id, \
257 ts, token);
258 sprintf(file_url + url_len, "?token=%s&ts=%d", token, (int)ts);
259 }
260
261 printf("group_name=%s, remote_filename=%s\n", \
262 group_name, remote_filename);
263
264 fdfs_get_file_info(group_name, remote_filename, &file_info);
265 printf("source ip address: %s\n", file_info.source_ip_addr);
266 printf("file timestamp=%s\n", formatDatetime(
267 file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
268 szDatetime, sizeof(szDatetime)));
269 printf("file size=%"PRId64"\n", file_info.file_size);
270 printf("file crc32=%u\n", file_info.crc32);
271 printf("file url: %s\n", file_url);
272
273 //sleep(90);
274 strcpy(appender_filename, remote_filename);
275 if (storage_truncate_file(pTrackerServer, pStorageServer, \
276 group_name, appender_filename, file_size * 2) != 0)
277 {
278 printf("truncate file fail, " \
279 "error no: %d, error info: %s\n", \
280 result, STRERROR(result));
281 tracker_close_connection_ex(pStorageServer, true);
282 fdfs_client_destroy();
283 return result;
284 }
285
286 fdfs_get_file_info(group_name, appender_filename, &file_info);
287 printf("source ip address: %s\n", file_info.source_ip_addr);
288 printf("file timestamp=%s\n", formatDatetime(
289 file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
290 szDatetime, sizeof(szDatetime)));
291 printf("file size=%"PRId64"\n", file_info.file_size);
292 printf("file crc32=%u\n", file_info.crc32);
293 printf("file url: %s\n", file_url);
294 if (file_info.file_size != file_size / 2)
295 {
296 fprintf(stderr, "file size: %"PRId64 \
297 " != %"PRId64"!!!", file_info.file_size, file_size / 2);
298 }
299
300 //sleep(100);
301 if (upload_type == FDFS_UPLOAD_BY_FILE)
302 {
303 result = storage_append_by_filename(pTrackerServer, \
304 pStorageServer, local_filename,
305 group_name, appender_filename);
306
307 printf("storage_append_by_filename\n");
308 }
309 else if (upload_type == FDFS_UPLOAD_BY_BUFF)
310 {
311 char *file_content;
312 if ((result=getFileContent(local_filename, \
313 &file_content, &file_size)) == 0)
314 {
315 result = storage_append_by_filebuff(pTrackerServer, \
316 pStorageServer, file_content, \
317 file_size, group_name, appender_filename);
318 free(file_content);
319 }
320
321 printf("storage_append_by_filebuff\n");
322 }
323 else
324 {
325 if (stat(local_filename, &stat_buf) == 0 && \
326 S_ISREG(stat_buf.st_mode))
327 {
328 file_size = stat_buf.st_size;
329 result = storage_append_by_callback(pTrackerServer, \
330 pStorageServer, uploadFileCallback, \
331 local_filename, file_size, \
332 group_name, appender_filename);
333 }
334 else
335 {
336 result = errno != 0 ? errno : ENOENT;
337 }
338
339 printf("storage_append_by_callback\n");
340 }
341
342 if (result != 0)
343 {
344 printf("append file fail, " \
345 "error no: %d, error info: %s\n", \
346 result, STRERROR(result));
347 tracker_close_connection_ex(pStorageServer, true);
348 fdfs_client_destroy();
349 return result;
350 }
351 printf("append file successfully.\n");
352 fdfs_get_file_info(group_name, remote_filename, &file_info);
353 printf("source ip address: %s\n", file_info.source_ip_addr);
354 printf("file timestamp=%s\n", formatDatetime(
355 file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
356 szDatetime, sizeof(szDatetime)));
357 printf("file size=%"PRId64"\n", file_info.file_size);
358 if (file_info.file_size != file_size + file_size / 2)
359 {
360 fprintf(stderr, "file size: %"PRId64 \
361 " != %"PRId64"!!!", file_info.file_size, \
362 file_size + file_size / 2);
363 }
364
365 file_offset = file_info.file_size;
366 if (upload_type == FDFS_UPLOAD_BY_FILE)
367 {
368 result = storage_modify_by_filename(pTrackerServer, \
369 pStorageServer, local_filename, \
370 file_offset, group_name, \
371 appender_filename);
372
373 printf("storage_modify_by_filename\n");
374 }
375 else if (upload_type == FDFS_UPLOAD_BY_BUFF)
376 {
377 char *file_content;
378 if ((result=getFileContent(local_filename, \
379 &file_content, &file_size)) == 0)
380 {
381 result = storage_modify_by_filebuff(pTrackerServer, \
382 pStorageServer, file_content, \
383 file_offset, file_size, group_name, \
384 appender_filename);
385 free(file_content);
386 }
387
388 printf("storage_modify_by_filebuff\n");
389 }
390 else
391 {
392 if (stat(local_filename, &stat_buf) == 0 && \
393 S_ISREG(stat_buf.st_mode))
394 {
395 file_size = stat_buf.st_size;
396 result = storage_modify_by_callback(pTrackerServer, \
397 pStorageServer, uploadFileCallback, \
398 local_filename, file_offset, \
399 file_size, group_name, appender_filename);
400 }
401 else
402 {
403 result = errno != 0 ? errno : ENOENT;
404 }
405
406 printf("storage_modify_by_callback\n");
407 }
408
409 if (result != 0)
410 {
411 printf("modify file fail, " \
412 "error no: %d, error info: %s\n", \
413 result, STRERROR(result));
414 tracker_close_connection_ex(pStorageServer, true);
415 fdfs_client_destroy();
416 return result;
417 }
418 printf("modify file successfully.\n");
419 fdfs_get_file_info(group_name, remote_filename, &file_info);
420 printf("source ip address: %s\n", file_info.source_ip_addr);
421 printf("file timestamp=%s\n", formatDatetime(
422 file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \
423 szDatetime, sizeof(szDatetime)));
424 printf("file size=%"PRId64"\n", file_info.file_size);
425 if (file_info.file_size != 2 * file_size + file_size / 2)
426 {
427 fprintf(stderr, "file size: %"PRId64 \
428 " != %"PRId64"!!!", file_info.file_size, \
429 2 * file_size + file_size /2);
430 }
431
432 tracker_close_connection_ex(pStorageServer, true);
433 tracker_close_connection_ex(pTrackerServer, true);
434
435 fdfs_client_destroy();
436
437 return result;
438 }
439
440