int
seaf_sync_manager_start (SeafSyncManager *mgr)
{
add_repo_relays ();
mgr->priv->check_sync_timer = ccnet_timer_new (
check_sync_pulse, mgr, CHECK_SYNC_INTERVAL);
mgr->priv->check_commit_timer = ccnet_timer_new (
auto_commit_pulse, mgr, CHECK_COMMIT_INTERVAL);
ccnet_proc_factory_register_processor (mgr->seaf->session->proc_factory,
"seafile-sync-repo",
SEAFILE_TYPE_SYNC_REPO_PROC);
ccnet_proc_factory_register_processor (mgr->seaf->session->proc_factory,
"seafile-notifysync",
SEAFILE_TYPE_NOTIFYSYNC_PROC);
ccnet_proc_factory_register_processor (mgr->seaf->session->proc_factory,
"seafile-get-repo-email-token",
SEAFILE_TYPE_GETREPOEMAILTOKEN_PROC);
g_signal_connect (seaf, "repo-fetched",
(GCallback)on_repo_fetched, mgr);
g_signal_connect (seaf, "repo-uploaded",
(GCallback)on_repo_uploaded, mgr);
return 0;
}
void
ccnet_conn_listen_init (CcnetConnManager *manager)
{
evutil_socket_t socket;
CcnetSession *session = manager->session;
if (session->base.public_port == 0) {
ccnet_message ("Do not listen for incoming peers\n");
return;
}
socket = ccnet_net_bind_tcp (session->base.public_port, 1);
if (socket >= 0) {
ccnet_message ("Opened port %d to listen for "
"incoming peer connections\n", session->base.public_port);
manager->bind_socket = socket;
listen (manager->bind_socket, 5);
} else {
ccnet_error ("Couldn't open port %d to listen for "
"incoming peer connections (errno %d - %s)",
session->base.public_port, errno, strerror(errno) );
exit (1);
}
manager->listen_timer = ccnet_timer_new (listen_pulse, manager,
LISTEN_INTERVAL);
}
int
seaf_web_at_manager_start (SeafWebAccessTokenManager *mgr)
{
ccnet_timer_new (clean_pulse, mgr, CLEANING_INTERVAL_MSEC);
return 0;
}
static void reset_timeout(CcnetProcessor *processor)
{
if (processor->retry_timer)
ccnet_timer_free(&processor->retry_timer);
processor->retry_timer = ccnet_timer_new ((TimerCB)timeout_cb, processor,
KEEPALIVE_INTERVAL);
}
int
seaf_passwd_manager_start (SeafPasswdManager *mgr)
{
mgr->priv->reap_timer = ccnet_timer_new (reap_expired_passwd,
mgr, REAP_INTERVAL * 1000);
return 1;
}
int
seaf_clone_manager_start (SeafCloneManager *mgr)
{
mgr->check_timer = ccnet_timer_new (check_connect_pulse, mgr,
CHECK_CONNECT_INTERVAL * 1000);
return 0;
}
int
seaf_mq_manager_start (SeafMqManager *mgr)
{
SeafMqManagerPriv *priv = mgr->priv;
priv->timer = ccnet_timer_new (heartbeat_pulse, mgr,
HEARTBEAT_INTERVAL * 1000);
return 0;
}
void
ccnet_conn_manager_start (CcnetConnManager *manager)
{
#ifdef CCNET_SERVER
ccnet_conn_listen_init (manager);
#endif
manager->reconnect_timer = ccnet_timer_new (reconnect_pulse, manager,
RECONNECT_PERIOD_MSEC);
}
int
size_scheduler_start (SizeScheduler *scheduler)
{
scheduler->priv->sched_timer = ccnet_timer_new (schedule_pulse,
scheduler,
SCHEDULER_INTV);
return 0;
}
int
scheduler_init (Scheduler *scheduler)
{
scheduler->priv->repo_size_job_queue = g_queue_new ();
scheduler->priv->sched_timer = ccnet_timer_new (schedule_pulse,
scheduler,
SCHEDULER_INTV);
return 0;
}
static void
schedule_shutdown (CcnetPeer *peer)
{
if (peer->shutdown_scheduled)
return;
g_object_ref (peer);
ccnet_timer_new ((TimerCB)shutdown_peer, peer, 1);
peer->shutdown_scheduled = 1;
}
void
ccnet_session_start (CcnetSession *session)
{
ccnet_proc_factory_start (session->proc_factory);
ccnet_message_manager_start (session->msg_mgr);
ccnet_session_start_network (session);
if (session->base.net_status == NET_STATUS_DOWN) {
ccnet_timer_new ((TimerCB)restart_network, session, 10000);
}
ccnet_peer_manager_start (session->peer_mgr);
}
int
seaf_clone_manager_start (SeafCloneManager *mgr)
{
mgr->check_timer = ccnet_timer_new (check_connect_pulse, mgr,
CHECK_CONNECT_INTERVAL * 1000);
char *sql = "SELECT * FROM CloneTasks";
if (sqlite_foreach_selected_row (mgr->db, sql, restart_task, mgr) < 0)
return -1;
g_signal_connect (seaf, "repo-fetched",
(GCallback)on_repo_fetched, mgr);
return 0;
}
int
scheduler_init (Scheduler *scheduler)
{
if (create_repo_stat_tables (scheduler->seaf) < 0) {
g_warning ("[scheduler] failed to create stat tables.\n");
return -1;
}
scheduler->priv->repo_size_job_queue = g_queue_new ();
scheduler->priv->sched_timer = ccnet_timer_new (schedule_pulse,
scheduler,
SCHEDULER_INTV);
return 0;
}
static void
handle_update (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen)
{
switch (processor->state) {
case RECV_ROOT:
if (strncmp(code, SC_ROOT, 3) == 0) {
queue_fs_roots (processor, content, clen);
} else if (strncmp(code, SC_ROOT_END, 3) == 0) {
/* change state to FETCH_OBJECT */
process_fsroot_list (processor);
processor->timer = ccnet_timer_new (
(TimerCB)check_end_condition, processor, CHECK_INTERVAL);
processor->state = FETCH_OBJECT;
} else {
seaf_warning ("Bad update: %s %s\n", code, code_msg);
ccnet_processor_send_response (processor,
SC_BAD_UPDATE_CODE, SS_BAD_UPDATE_CODE,
NULL, 0);
ccnet_processor_done (processor, FALSE);
}
break;
case FETCH_OBJECT:
if (strncmp(code, SC_OBJ_SEG, 3) == 0) {
recv_fs_object_seg (processor, content, clen);
} else if (strncmp(code, SC_OBJ_SEG_END, 3) == 0) {
recv_fs_object_seg (processor, content, clen);
process_fs_object_seg (processor);
} else if (strncmp(code, SC_OBJECT, 3) == 0) {
recv_fs_object (processor, content, clen);
} else {
seaf_warning ("Bad update: %s %s\n", code, code_msg);
ccnet_processor_send_response (processor,
SC_BAD_UPDATE_CODE, SS_BAD_UPDATE_CODE,
NULL, 0);
ccnet_processor_done (processor, FALSE);
}
break;
default:
g_return_if_reached ();
}
}
int
seaf_repo_manager_init_merge_scheduler ()
{
scheduler = g_new0 (MergeScheduler, 1);
if (!scheduler)
return -1;
pthread_mutex_init (&scheduler->q_lock, NULL);
scheduler->queue = g_queue_new ();
scheduler->running = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
scheduler->tpool = ccnet_job_manager_new (MAX_RUNNING_TASKS);
scheduler->timer = ccnet_timer_new (schedule_merge_tasks,
scheduler,
SCHEDULE_INTERVAL);
return 0;
}
static void
handle_response (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen)
{
SeafileGetfsProc *proc = (SeafileGetfsProc *)processor;
TransferTask *task = proc->tx_task;
switch (processor->state) {
case REQUEST_SENT:
if (strncmp(code, SC_OK, 3) == 0) {
load_fsroot_list (processor);
processor->timer = ccnet_timer_new (
(TimerCB)check_object, processor, CHECK_INTERVAL);
processor->state = FETCH_OBJECT;
return;
}
break;
case FETCH_OBJECT:
if (strncmp(code, SC_OBJ_SEG, 3) == 0) {
recv_fs_object_seg (processor, content, clen);
return;
} else if (strncmp(code, SC_OBJ_SEG_END, 3) == 0) {
recv_fs_object_seg (processor, content, clen);
process_fs_object_seg (processor);
return;
} else if (strncmp(code, SC_OBJECT, 3) == 0) {
recv_fs_object (processor, content, clen);
return;
}
break;
default:
g_assert (0);
}
g_warning ("Bad response: %s %s.\n", code, code_msg);
if (memcmp (code, SC_ACCESS_DENIED, 3) == 0)
transfer_task_set_error (task, TASK_ERR_ACCESS_DENIED);
ccnet_processor_done (processor, FALSE);
}
