void do_send_task(int fd, t_task_base *base, t_pfs_sig_head *h)
{
struct conn *curcon = &acon[fd];
curcon->send_len = 0;
char obuf[2048] = {0x0};
pfs_cs_peer *peer = (pfs_cs_peer *) curcon->user;
peer->hbtime = time(NULL);
uint8_t tmp_status = FILE_SYNC_DST_2_SRC;
if (base->fsize == 0 || base->retry)
{
if (get_localfile_stat(base) != LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_ERROR, "filename[%s] get_localfile_stat ERROR %m!\n", base->filename);
tmp_status = FILE_SYNC_DST_2_SRC_E_OPENFILE;
}
}
if (tmp_status == FILE_SYNC_DST_2_SRC)
{
t_pfs_tasklist *task = NULL;
if (pfs_get_task(&task, TASK_Q_HOME))
{
LOG(pfs_data_log, LOG_ERROR, "filename[%s] do_newtask ERROR!\n", base->filename);
tmp_status = FILE_SYNC_DST_2_SRC_E_MALLOC;
}
else
{
memset(&(task->task), 0, sizeof(task->task));
t_task_sub *sub = &(task->task.sub);
memset(sub, 0, sizeof(t_task_sub));
ip2str(sub->peerip, peer->ip);
sub->processlen = base->fsize;
sub->starttime = time(NULL);
sub->oper_type = OPER_GET_RSP;
sub->need_sync = TASK_SRC_NOSYNC;
memcpy(&(task->task.base), base, sizeof(t_task_base));
int lfd = -1;
if (open_localfile_4_read(base, &lfd) != LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_ERROR, "fd[%d] err open [%s] %m close it\n", fd, base->filename);
tmp_status = FILE_SYNC_DST_2_SRC_E_OPENFILE;
task->task.base.overstatus = OVER_E_OPEN_SRCFILE;
pfs_set_task(task, TASK_Q_FIN);
}
else
{
task->task.base.overstatus = OVER_UNKNOWN;
pfs_set_task(task, TASK_Q_SEND);
peer->sendtask = task;
set_client_fd(fd, lfd, 0, sub->processlen);
peer->sock_stat = SENDFILEING;
}
}
}
int n = create_sig_msg(CMD_GET_FILE_RSP, tmp_status, (t_pfs_sig_body *)base, obuf, sizeof(t_task_base));
set_client_data(fd, obuf, n);
peer->headlen = n;
}
int do_recv_task(int fd, t_pfs_sig_head *h, t_task_base *base)
{
struct conn *curcon = &acon[fd];
pfs_cs_peer *peer = (pfs_cs_peer *) curcon->user;
if (peer->sock_stat != PREPARE_RECVFILE)
{
LOG(pfs_data_log, LOG_ERROR, "fd[%d] status not recv [%x] file [%s]\n", fd, peer->sock_stat, base->filename);
return RECV_CLOSE;
}
t_pfs_tasklist *task0 = peer->recvtask;
t_task_base *base0 = &(task0->task.base);
t_task_sub *sub0 = &(task0->task.sub);
if (h->status != FILE_SYNC_DST_2_SRC)
{
LOG(pfs_data_log, LOG_ERROR, "fd[%d] status err file [%s][%x]\n", fd, base->filename, h->status);
peer->sock_stat = IDLE;
task0->task.base.overstatus = OVER_E_OPEN_SRCFILE;
pfs_set_task(task0, TASK_Q_FIN);
peer->recvtask = NULL;
return RECV_CLOSE;
}
if (memcmp(base0->filemd5, base->filemd5, sizeof(base0->filemd5)))
{
memcpy(base0, base, sizeof(t_task_base));
sub0->processlen = base->fsize;
}
if (peer->local_in_fd > 0)
close(peer->local_in_fd);
if (open_tmp_localfile_4_write(base0, &(peer->local_in_fd)) != LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_ERROR, "fd[%d] file [%s] open file err %m\n", fd, base->filename);
if (peer->recvtask)
{
base0->overstatus = OVER_E_OPEN_DSTFILE;
pfs_set_task(peer->recvtask, TASK_Q_CLEAN);
peer->recvtask = NULL;
}
return RECV_CLOSE;
}
else
{
peer->sock_stat = RECVFILEING;
LOG(pfs_data_log, LOG_NORMAL, "fd[%d] file [%s]prepare recv\n", fd, base->filename);
}
return RECV_ADD_EPOLLIN;
}
void check_task()
{
t_pfs_tasklist *task = NULL;
int ret = 0;
while (1)
{
ret = pfs_get_task(&task, TASK_Q_WAIT_TMP);
if (ret != GET_TASK_Q_OK)
{
LOG(pfs_data_log, LOG_TRACE, "pfs_get_task get notihng %d\n", ret);
break;
}
pfs_set_task(task, TASK_Q_WAIT);
}
while (1)
{
ret = pfs_get_task(&task, TASK_Q_SYNC_DIR_TMP);
if (ret != GET_TASK_Q_OK)
{
LOG(pfs_data_log, LOG_TRACE, "pfs_get_task get notihng %d\n", ret);
break;
}
pfs_set_task(task, TASK_Q_SYNC_DIR);
}
uint16_t once_run = 0;
while (1)
{
once_run++;
if (once_run >= g_config.max_task_run_once)
return;
ret = pfs_get_task(&task, TASK_Q_WAIT);
if (ret != GET_TASK_Q_OK)
{
LOG(pfs_data_log, LOG_TRACE, "pfs_get_task get notihng %d\n", ret);
ret = pfs_get_task(&task, TASK_Q_SYNC_DIR);
if (ret != GET_TASK_Q_OK)
return ;
else
LOG(pfs_data_log, LOG_DEBUG, "Process TASK_Q_SYNC_DIR!\n");
}
t_task_sub *sub = &(task->task.sub);
t_task_base *base = &(task->task.base);
LOG(pfs_data_log, LOG_DEBUG, "%s be get from wait queue!\n", base->filename);
if (base->retry > g_config.retry)
{
LOG(pfs_data_log, LOG_DEBUG, "%s too many try!\n", base->filename, base->retry, g_config.retry);
base->overstatus = OVER_TOO_MANY_TRY;
pfs_set_task(task, TASK_Q_FIN);
continue;
}
if (base->fsize > 0 && check_localfile_md5(base, VIDEOFILE) == LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_DEBUG, "%s check md5 ok!\n", base->filename);
base->overstatus = OVER_OK;
pfs_set_task(task, TASK_Q_FIN);
continue;
}
pfs_cs_peer *peer = NULL;
find_ip_stat(str2ip(sub->peerip), &peer, CON_ACTIVE, IDLE);
if (sub->oper_type != OPER_GET_REQ && OPER_FROM_POSS != sub->oper_type)
{
LOG(pfs_data_log, LOG_ERROR, "%s:%d ERROR oper_type %d %s!\n", ID, LN, sub->oper_type, base->filename);
base->overstatus = OVER_E_TYPE;
pfs_set_task(task, TASK_Q_FIN);
continue;
}
LOG(pfs_data_log, LOG_DEBUG, "%s is prepare OPER_GET_REQ from %s\n", base->filename, sub->peerip);
if(check_disk_space(base) != DISK_OK)
{
LOG(pfs_data_log, LOG_DEBUG, "%s:%d filename[%s] DISK NOT ENOUGH SPACE!\n", ID, LN, base->filename);
if (DISK_SPACE_TOO_SMALL == check_disk_space(base))
{
if (sub->need_sync == TASK_SYNC_ISDIR)
pfs_set_task(task, TASK_Q_SYNC_DIR_TMP);
else
pfs_set_task(task, TASK_Q_WAIT_TMP);
}
else
{
base->overstatus = OVER_DISK_ERR;
pfs_set_task(task, TASK_Q_FIN);
}
continue;
}
if (peer == NULL)
{
int count = get_ip_connect_count(str2ip(sub->peerip));
if (count > g_config.max_data_connects)
{
LOG(pfs_data_log, LOG_DEBUG, "ip %s too many connect %d max %d\n", sub->peerip, count, g_config.max_data_connects);
if (sub->need_sync == TASK_SYNC_ISDIR)
pfs_set_task(task, TASK_Q_SYNC_DIR_TMP);
else
pfs_set_task(task, TASK_Q_WAIT_TMP);
continue;
}
active_connect(sub->peerip);
char *peerhost = sub->peerip;
if (find_ip_stat(str2ip(peerhost), &peer, CON_ACTIVE, IDLE) != 0)
{
LOG(pfs_data_log, LOG_DEBUG, "%s be hung up because find_ip_stat error!\n", base->filename);
if (sub->need_sync == TASK_SYNC_ISDIR)
pfs_set_task(task, TASK_Q_SYNC_DIR_TMP);
else
pfs_set_task(task, TASK_Q_WAIT_TMP);
continue;
}
}
if (g_config.pfs_test)
{
LOG(pfs_data_log, LOG_NORMAL, "pfs run in test %s\n", base->filename);
base->overstatus = OVER_OK;
pfs_set_task(task, TASK_Q_FIN);
continue;
}
t_pfs_sig_head h;
t_pfs_sig_body b;
sub->lastlen = 0;
h.bodylen = sizeof(t_task_base);
memcpy(b.body, base, sizeof(t_task_base));
h.cmdid = CMD_GET_FILE_REQ;
h.status = FILE_SYNC_DST_2_SRC;
active_send(peer, &h, &b);
peer->sock_stat = PREPARE_RECVFILE;
LOG(pfs_data_log, LOG_DEBUG, "fd[%d:%s] %s send get a file sock_stat [%s]!\n", peer->fd, sub->peerip, base->filename, sock_stat_cmd[peer->sock_stat]);
pfs_set_task(task, TASK_Q_RECV);
peer->recvtask = task;
}
}
int do_push_task(int fd, t_pfs_sig_head *h, t_task_base *base)
{
struct conn *curcon = &acon[fd];
pfs_cs_peer *peer = (pfs_cs_peer *) curcon->user;
peer->sock_stat = PREPARE_RECVFILE;
t_pfs_tasklist *task = NULL;
if (pfs_get_task(&task, TASK_Q_HOME))
{
LOG(pfs_data_log, LOG_ERROR, "filename[%s] do_push_task ERROR!\n", base->filename);
create_push_rsp_err("get task home error!", fd);
return RECV_ADD_EPOLLOUT;
}
if (base->type != TASK_DELFILE)
{
if (h->status == 0)
get_local_filename(base);
LOG(pfs_data_log, LOG_NORMAL, "filename[%s] do_push_task path by upload!\n", base->filename);
}
else
LOG(pfs_data_log, LOG_NORMAL, "filename[%s] be delete!\n", base->filename);
memset(&(task->task), 0, sizeof(task->task));
t_task_sub *sub = &(task->task.sub);
memset(sub, 0, sizeof(t_task_sub));
ip2str(sub->peerip, peer->ip);
sub->processlen = base->fsize;
sub->starttime = time(NULL);
sub->oper_type = OPER_PUT_REQ;
sub->need_sync = TASK_SOURCE;
t_task_base *base0 = &(task->task.base);
memcpy(base0, base, sizeof(t_task_base));
base0->starttime = time(NULL);
peer->recvtask = task;
if (base->type == TASK_DELFILE)
{
delete_localfile(base);
base0->overstatus = OVER_OK;
pfs_set_task(peer->recvtask, TASK_Q_FIN);
peer->recvtask = NULL;
create_push_rsp(task, fd);
return RECV_SEND;
}
if (peer->local_in_fd > 0)
close(peer->local_in_fd);
if (open_tmp_localfile_4_write(base0, &(peer->local_in_fd)) != LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_ERROR, "fd[%d] file [%s] open file err %m\n", fd, base->filename);
if (peer->recvtask)
{
base0->overstatus = OVER_E_OPEN_DSTFILE;
pfs_set_task(peer->recvtask, TASK_Q_CLEAN);
peer->recvtask = NULL;
}
create_push_rsp_err("open remote file err", fd);
return RECV_ADD_EPOLLOUT;
}
else
{
peer->sock_stat = RECVFILEING;
LOG(pfs_data_log, LOG_NORMAL, "fd[%d] file [%s] prepare recv\n", fd, base->filename);
}
return RECV_ADD_EPOLLIN;
}
