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