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;
}
