static void sigAlarmHandler(int sig) { ConnectionInfo server; if (bAcceptEndFlag) { return; } logDebug("file: "__FILE__", line: %d, " \ "signal server to quit...", __LINE__); if (*g_bind_addr != '\0') { strcpy(server.ip_addr, g_bind_addr); } else { strcpy(server.ip_addr, "127.0.0.1"); } server.port = g_server_port; server.sock = -1; if (conn_pool_connect_server(&server, g_fdfs_connect_timeout) != 0) { return; } fdfs_quit(&server); conn_pool_disconnect_server(&server); logDebug("file: "__FILE__", line: %d, " \ "signal server to quit done", __LINE__); }
int upload_file(const char *file_buff, const int file_size, char *file_id, char *storage_ip) { int result; TrackerServerInfo *pTrackerServer; TrackerServerInfo storageServer; int store_path_index; pTrackerServer = tracker_get_connection(); if (pTrackerServer == NULL) { return errno != 0 ? errno : ECONNREFUSED; } if ((result=tracker_query_storage_store(pTrackerServer, &storageServer, &store_path_index)) != 0) { fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); return result; } if ((result=tracker_connect_server(&storageServer)) != 0) { fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); return result; } strcpy(storage_ip, storageServer.ip_addr); result = storage_upload_by_filebuff1(pTrackerServer, &storageServer, store_path_index, file_buff, file_size, NULL, NULL, 0, "", file_id); fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); fdfs_quit(&storageServer); tracker_disconnect_server(&storageServer); return result; }
int download_file(const char *file_id, int *file_size, char *storage_ip) { int result; TrackerServerInfo *pTrackerServer; TrackerServerInfo storageServer; int64_t file_bytes; pTrackerServer = tracker_get_connection(); if (pTrackerServer == NULL) { return errno != 0 ? errno : ECONNREFUSED; } if ((result=tracker_query_storage_fetch1(pTrackerServer, &storageServer, file_id)) != 0) { fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); return result; } if ((result=tracker_connect_server(&storageServer)) != 0) { fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); return result; } strcpy(storage_ip, storageServer.ip_addr); result = storage_download_file_ex1(pTrackerServer, &storageServer, file_id, 0, 0, downloadFileCallback, NULL, &file_bytes); *file_size = file_bytes; fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); fdfs_quit(&storageServer); tracker_disconnect_server(&storageServer); return result; }
int delete_file(const char *file_id, char *storage_ip) { int result; TrackerServerInfo *pTrackerServer; TrackerServerInfo storageServer; pTrackerServer = tracker_get_connection(); if (pTrackerServer == NULL) { return errno != 0 ? errno : ECONNREFUSED; } if ((result=tracker_query_storage_update1(pTrackerServer, &storageServer, file_id)) != 0) { fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); return result; } if ((result=tracker_connect_server(&storageServer)) != 0) { fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); return result; } strcpy(storage_ip, storageServer.ip_addr); result = storage_delete_file1(pTrackerServer, &storageServer, file_id); fdfs_quit(pTrackerServer); tracker_disconnect_server(pTrackerServer); fdfs_quit(&storageServer); tracker_disconnect_server(&storageServer); return result; }
int main(int argc, char *argv[]) { char *conf_filename; char *local_filename; TrackerServerInfo *pTrackerServer; int result; char file_id[128]; int64_t file_size; if (argc < 3) { printf("Usage: %s <config_file> <remote file id> " \ "[local filename]\n", argv[0]); return 1; } log_init(); g_log_context.log_level = LOG_ERR; conf_filename = argv[1]; if ((result=fdfs_client_init(conf_filename)) != 0) { return result; } pTrackerServer = tracker_get_connection(); if (pTrackerServer == NULL) { fdfs_client_destroy(); return errno != 0 ? errno : ECONNREFUSED; } snprintf(file_id, sizeof(file_id), "%s", argv[2]); if (argc >= 4) { local_filename = argv[3]; } else { local_filename = strrchr(file_id, '/'); if (local_filename != NULL) { local_filename++; //skip / } else { local_filename = file_id; } } result = storage_download_file_to_file1( \ pTrackerServer, NULL, \ file_id, local_filename, &file_size); if (result != 0) { printf("download file fail, " \ "error no: %d, error info: %s\n", \ result, STRERROR(result)); } fdfs_quit(pTrackerServer); tracker_close_all_connections(); fdfs_client_destroy(); return 0; }
int main(int argc, char *argv[]) { char *conf_filename; char *local_filename; TrackerServerInfo *pTrackerServer; int result; TrackerServerInfo storageServer; char group_name[FDFS_GROUP_NAME_MAX_LEN + 1]; char file_id[256]; char appender_file_id[256]; FDFSMetaData meta_list[32]; int meta_count; char token[32 + 1]; char file_url[256]; char szDatetime[20]; char szPortPart[16]; int url_len; time_t ts; int64_t file_size; int store_path_index; FDFSFileInfo file_info; int upload_type; const char *file_ext_name; printf("This is FastDFS client test program v%d.%02d\n" \ "\nCopyright (C) 2008, Happy Fish / YuQing\n" \ "\nFastDFS may be copied only under the terms of the GNU General\n" \ "Public License V3, which may be found in the FastDFS source kit.\n" \ "Please visit the FastDFS Home Page http://www.csource.org/ \n" \ "for more detail.\n\n" \ , g_fdfs_version.major, g_fdfs_version.minor); if (argc < 3) { printf("Usage: %s <config_file> <local_filename> " \ "[FILE | BUFF | CALLBACK]\n", argv[0]); return 1; } log_init(); g_log_context.log_level = LOG_DEBUG; conf_filename = argv[1]; if ((result=fdfs_client_init(conf_filename)) != 0) { return result; } pTrackerServer = tracker_get_connection(); if (pTrackerServer == NULL) { fdfs_client_destroy(); return errno != 0 ? errno : ECONNREFUSED; } local_filename = argv[2]; if (argc == 3) { upload_type = FDFS_UPLOAD_BY_FILE; } else { if (strcmp(argv[3], "BUFF") == 0) { upload_type = FDFS_UPLOAD_BY_BUFF; } else if (strcmp(argv[3], "CALLBACK") == 0) { upload_type = FDFS_UPLOAD_BY_CALLBACK; } else { upload_type = FDFS_UPLOAD_BY_FILE; } } store_path_index = 0; if ((result=tracker_query_storage_store(pTrackerServer, \ &storageServer, &store_path_index)) != 0) { fdfs_client_destroy(); printf("tracker_query_storage fail, " \ "error no: %d, error info: %s\n", \ result, STRERROR(result)); return result; } printf("group_name=%s, ip_addr=%s, port=%d\n", \ storageServer.group_name, \ storageServer.ip_addr, \ storageServer.port); if ((result=tracker_connect_server(&storageServer)) != 0) { fdfs_client_destroy(); return result; } memset(&meta_list, 0, sizeof(meta_list)); meta_count = 0; strcpy(meta_list[meta_count].name, "ext_name"); strcpy(meta_list[meta_count].value, "jpg"); meta_count++; strcpy(meta_list[meta_count].name, "width"); strcpy(meta_list[meta_count].value, "160"); meta_count++; strcpy(meta_list[meta_count].name, "height"); strcpy(meta_list[meta_count].value, "80"); meta_count++; strcpy(meta_list[meta_count].name, "file_size"); strcpy(meta_list[meta_count].value, "115120"); meta_count++; file_ext_name = fdfs_get_file_ext_name(local_filename); *group_name = '\0'; if (upload_type == FDFS_UPLOAD_BY_FILE) { result = storage_upload_appender_by_filename1(pTrackerServer, \ &storageServer, store_path_index, \ local_filename, file_ext_name, \ meta_list, meta_count, group_name, file_id); printf("storage_upload_appender_by_filename1\n"); } else if (upload_type == FDFS_UPLOAD_BY_BUFF) { char *file_content; if ((result=getFileContent(local_filename, \ &file_content, &file_size)) == 0) { result = storage_upload_appender_by_filebuff1( \ pTrackerServer, &storageServer, \ store_path_index, file_content, \ file_size, file_ext_name, \ meta_list, meta_count, \ group_name, file_id); free(file_content); } printf("storage_upload_appender_by_filebuff1\n"); } else { struct stat stat_buf; if (stat(local_filename, &stat_buf) == 0 && \ S_ISREG(stat_buf.st_mode)) { file_size = stat_buf.st_size; result = storage_upload_appender_by_callback1( \ pTrackerServer, &storageServer, \ store_path_index, uploadFileCallback, \ local_filename, file_size, \ file_ext_name, meta_list, meta_count, \ group_name, file_id); } printf("storage_upload_appender_by_callback1\n"); } if (result != 0) { printf("upload file fail, " \ "error no: %d, error info: %s\n", \ result, STRERROR(result)); fdfs_quit(&storageServer); tracker_disconnect_server(&storageServer); fdfs_client_destroy(); return result; } if (g_tracker_server_http_port == 80) { *szPortPart = '\0'; } else { sprintf(szPortPart, ":%d", g_tracker_server_http_port); } url_len = sprintf(file_url, "http://%s%s/%s", \ pTrackerServer->ip_addr, szPortPart, file_id); if (g_anti_steal_token) { ts = time(NULL); fdfs_http_gen_token(&g_anti_steal_secret_key, file_id, \ ts, token); sprintf(file_url + url_len, "?token=%s&ts=%d", token, (int)ts); } printf("fild_id=%s\n", file_id); fdfs_get_file_info1(file_id, &file_info); printf("source ip address: %s\n", file_info.source_ip_addr); printf("file timestamp=%s\n", formatDatetime( file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \ szDatetime, sizeof(szDatetime))); printf("file size="INT64_PRINTF_FORMAT"\n", file_info.file_size); printf("file crc32=%u\n", file_info.crc32); printf("file url: %s\n", file_url); //sleep(70); strcpy(appender_file_id, file_id); if (upload_type == FDFS_UPLOAD_BY_FILE) { result = storage_append_by_filename1(pTrackerServer, \ &storageServer, local_filename, appender_file_id); printf("storage_append_by_filename\n"); } else if (upload_type == FDFS_UPLOAD_BY_BUFF) { char *file_content; if ((result=getFileContent(local_filename, \ &file_content, &file_size)) == 0) { result = storage_append_by_filebuff1(pTrackerServer, \ &storageServer, file_content, \ file_size, appender_file_id); free(file_content); } printf("storage_append_by_filebuff1\n"); } else { struct stat stat_buf; if (stat(local_filename, &stat_buf) == 0 && \ S_ISREG(stat_buf.st_mode)) { file_size = stat_buf.st_size; result = storage_append_by_callback1(pTrackerServer, \ &storageServer, uploadFileCallback, \ local_filename, file_size, \ appender_file_id); } printf("storage_append_by_callback1\n"); } if (result != 0) { printf("append file fail, " \ "error no: %d, error info: %s\n", \ result, STRERROR(result)); fdfs_quit(&storageServer); tracker_disconnect_server(&storageServer); fdfs_client_destroy(); return result; } printf("append file successfully.\n"); fdfs_get_file_info1(appender_file_id, &file_info); printf("source ip address: %s\n", file_info.source_ip_addr); printf("file timestamp=%s\n", formatDatetime( file_info.create_timestamp, "%Y-%m-%d %H:%M:%S", \ szDatetime, sizeof(szDatetime))); printf("file size="INT64_PRINTF_FORMAT"\n", file_info.file_size); fdfs_quit(&storageServer); tracker_disconnect_server(&storageServer); fdfs_quit(pTrackerServer); tracker_close_all_connections(); fdfs_client_destroy(); return result; }
int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \ IniContext *iniContext, bool * volatile continue_flag, \ const bool client_bind_addr, const char *bind_addr) { ConnectionInfo *pGlobalServer; ConnectionInfo *pTServer; ConnectionInfo *pServerStart; ConnectionInfo *pServerEnd; ConnectionInfo trackerServer; char in_buff[1024]; int result; int leader_index; int i; result = 0; pTServer = &trackerServer; pServerEnd = pTrackerGroup->servers + pTrackerGroup->server_count; leader_index = pTrackerGroup->leader_index; if (leader_index >= 0) { pServerStart = pTrackerGroup->servers + leader_index; } else { pServerStart = pTrackerGroup->servers; } do { for (pGlobalServer=pServerStart; pGlobalServer<pServerEnd; \ pGlobalServer++) { memcpy(pTServer, pGlobalServer, sizeof(ConnectionInfo)); for (i=0; i < 3; i++) { pTServer->sock = socket(AF_INET, SOCK_STREAM, 0); if(pTServer->sock < 0) { result = errno != 0 ? errno : EPERM; logError("file: "__FILE__", line: %d, " \ "socket create failed, errno: %d, " \ "error info: %s.", \ __LINE__, result, STRERROR(result)); sleep(5); break; } if (client_bind_addr && (bind_addr != NULL && \ *bind_addr != '\0')) { socketBind(pTServer->sock, bind_addr, 0); } if (tcpsetnonblockopt(pTServer->sock) != 0) { close(pTServer->sock); pTServer->sock = -1; sleep(1); continue; } if ((result=connectserverbyip_nb(pTServer->sock, \ pTServer->ip_addr, pTServer->port, \ g_fdfs_connect_timeout)) == 0) { break; } close(pTServer->sock); pTServer->sock = -1; sleep(1); } if (pTServer->sock < 0) { logError("file: "__FILE__", line: %d, " \ "connect to tracker server %s:%d fail, " \ "errno: %d, error info: %s", \ __LINE__, pTServer->ip_addr, pTServer->port, \ result, STRERROR(result)); continue; } result = fdfs_do_parameter_req(pTServer, in_buff, \ sizeof(in_buff)); if (result == 0) { result = iniLoadFromBuffer(in_buff, iniContext); close(pTServer->sock); return result; } fdfs_quit(pTServer); close(pTServer->sock); sleep(1); } if (pServerStart != pTrackerGroup->servers) { pServerStart = pTrackerGroup->servers; } } while (*continue_flag); return EINTR; }
static void* trunk_sync_thread_entrance(void* arg) { FDFSStorageBrief *pStorage; TrunkBinLogReader reader; ConnectionInfo storage_server; char local_ip_addr[IP_ADDRESS_SIZE]; int read_result; int sync_result; int conn_result; int result; int previousCode; int nContinuousFail; time_t current_time; time_t last_keep_alive_time; memset(local_ip_addr, 0, sizeof(local_ip_addr)); memset(&reader, 0, sizeof(reader)); reader.mark_fd = -1; reader.binlog_fd = -1; current_time = g_current_time; last_keep_alive_time = 0; pStorage = (FDFSStorageBrief *)arg; strcpy(storage_server.ip_addr, pStorage->ip_addr); storage_server.port = g_server_port; storage_server.sock = -1; logInfo("file: "__FILE__", line: %d, " \ "trunk sync thread to storage server %s:%d started", \ __LINE__, storage_server.ip_addr, storage_server.port); while (g_continue_flag && g_if_trunker_self && \ pStorage->status != FDFS_STORAGE_STATUS_DELETED && \ pStorage->status != FDFS_STORAGE_STATUS_IP_CHANGED && \ pStorage->status != FDFS_STORAGE_STATUS_NONE) { previousCode = 0; nContinuousFail = 0; conn_result = 0; while (g_continue_flag && g_if_trunker_self && \ pStorage->status != FDFS_STORAGE_STATUS_DELETED && \ pStorage->status != FDFS_STORAGE_STATUS_IP_CHANGED && \ pStorage->status != FDFS_STORAGE_STATUS_NONE) { strcpy(storage_server.ip_addr, pStorage->ip_addr); storage_server.sock = \ socket(AF_INET, SOCK_STREAM, 0); if(storage_server.sock < 0) { logCrit("file: "__FILE__", line: %d," \ " socket create fail, " \ "errno: %d, error info: %s. " \ "program exit!", __LINE__, \ errno, STRERROR(errno)); g_continue_flag = false; break; } if (g_client_bind_addr && *g_bind_addr != '\0') { socketBind(storage_server.sock, g_bind_addr, 0); } if (tcpsetnonblockopt(storage_server.sock) != 0) { nContinuousFail++; close(storage_server.sock); storage_server.sock = -1; sleep(1); continue; } if ((conn_result=connectserverbyip_nb(storage_server.sock,\ pStorage->ip_addr, g_server_port, \ g_fdfs_connect_timeout)) == 0) { char szFailPrompt[64]; if (nContinuousFail == 0) { *szFailPrompt = '\0'; } else { sprintf(szFailPrompt, \ ", continuous fail count: %d", \ nContinuousFail); } logInfo("file: "__FILE__", line: %d, " \ "successfully connect to " \ "storage server %s:%d%s", __LINE__, \ pStorage->ip_addr, g_server_port, \ szFailPrompt); nContinuousFail = 0; break; } if (previousCode != conn_result) { logError("file: "__FILE__", line: %d, " \ "connect to storage server %s:%d fail" \ ", errno: %d, error info: %s", \ __LINE__, \ pStorage->ip_addr, g_server_port, \ conn_result, STRERROR(conn_result)); previousCode = conn_result; } nContinuousFail++; close(storage_server.sock); storage_server.sock = -1; if (!g_continue_flag) { break; } sleep(1); } if (nContinuousFail > 0) { logError("file: "__FILE__", line: %d, " \ "connect to storage server %s:%d fail, " \ "try count: %d, errno: %d, error info: %s", \ __LINE__, pStorage->ip_addr, \ g_server_port, nContinuousFail, \ conn_result, STRERROR(conn_result)); } if ((!g_continue_flag) || (!g_if_trunker_self) || \ pStorage->status == FDFS_STORAGE_STATUS_DELETED || \ pStorage->status == FDFS_STORAGE_STATUS_IP_CHANGED || \ pStorage->status == FDFS_STORAGE_STATUS_NONE) { logError("file: "__FILE__", line: %d, break loop." \ "g_continue_flag: %d, g_if_trunker_self: %d, " \ "dest storage status: %d", __LINE__, \ g_continue_flag, g_if_trunker_self, \ pStorage->status); break; } if ((result=trunk_reader_init(pStorage, &reader)) != 0) { logCrit("file: "__FILE__", line: %d, " \ "trunk_reader_init fail, errno=%d, " \ "program exit!", \ __LINE__, result); g_continue_flag = false; break; } getSockIpaddr(storage_server.sock, \ local_ip_addr, IP_ADDRESS_SIZE); insert_into_local_host_ip(local_ip_addr); /* //printf("file: "__FILE__", line: %d, " \ "storage_server.ip_addr=%s, " \ "local_ip_addr: %s\n", \ __LINE__, pStorage->ip_addr, local_ip_addr); */ if (is_local_host_ip(pStorage->ip_addr)) { //can't self sync to self logError("file: "__FILE__", line: %d, " \ "ip_addr %s belong to the local host," \ " trunk sync thread exit.", \ __LINE__, pStorage->ip_addr); fdfs_quit(&storage_server); close(storage_server.sock); break; } if (reader.binlog_offset == 0) { if ((result=fdfs_deal_no_body_cmd(&storage_server, \ STORAGE_PROTO_CMD_TRUNK_TRUNCATE_BINLOG_FILE)) != 0) { logError("file: "__FILE__", line: %d, " "fdfs_deal_no_body_cmd fail, result: %d", __LINE__, result); close(storage_server.sock); trunk_reader_destroy(&reader); sleep(5); continue; } } sync_result = 0; while (g_continue_flag && \ pStorage->status != FDFS_STORAGE_STATUS_DELETED && \ pStorage->status != FDFS_STORAGE_STATUS_IP_CHANGED && \ pStorage->status != FDFS_STORAGE_STATUS_NONE) { read_result = trunk_binlog_preread(&reader); if (read_result == ENOENT) { if (reader.last_binlog_offset != \ reader.binlog_offset) { if (trunk_write_to_mark_file(&reader)!=0) { logCrit("file: "__FILE__", line: %d, " \ "trunk_write_to_mark_file fail, " \ "program exit!", __LINE__); g_continue_flag = false; break; } } current_time = g_current_time; if (current_time - last_keep_alive_time >= \ g_heart_beat_interval) { if (fdfs_active_test(&storage_server)!=0) { break; } last_keep_alive_time = current_time; } if (!g_if_trunker_self) { break; } usleep(g_sync_wait_usec); continue; } if (read_result != 0) { sleep(5); continue; } if ((sync_result=trunk_sync_data(&reader, \ &storage_server)) != 0) { break; } if (g_sync_interval > 0) { usleep(g_sync_interval); } } if (reader.last_binlog_offset != reader.binlog_offset) { if (trunk_write_to_mark_file(&reader) != 0) { logCrit("file: "__FILE__", line: %d, " \ "trunk_write_to_mark_file fail, " \ "program exit!", __LINE__); g_continue_flag = false; break; } } close(storage_server.sock); storage_server.sock = -1; trunk_reader_destroy(&reader); if (!g_continue_flag) { break; } if (!(sync_result == ENOTCONN || sync_result == EIO)) { sleep(1); } } if (storage_server.sock >= 0) { close(storage_server.sock); } trunk_reader_destroy(&reader); trunk_sync_thread_exit(&storage_server); return NULL; }