C++ ccnet_processor_done函数代码示例

static void
receive_commit (CcnetProcessor *processor, char *content, int clen)
{
    USE_PRIV;
    ObjectPack *pack = (ObjectPack *)content;

    if (clen < sizeof(ObjectPack)) {
        g_warning ("[getcommit] invalid object id.\n");
        goto bad;
    }

    g_debug ("[getcommit] recv commit object %s\n", pack->id);
    --priv->pending_objects;

    if (save_commit (pack, clen) < 0) {
        goto bad;
    }

    if (priv->pending_objects == 0) {
        g_debug ("[getcommit] Receive commit completed.\n");
        ccnet_processor_send_update (processor, SC_END, SS_END, NULL, 0);
        ccnet_processor_done (processor, TRUE);
    }

    return;

bad:
    ccnet_processor_send_update (processor, SC_BAD_OBJECT,
                                   SS_BAD_OBJECT, NULL, 0);
    g_warning ("[getcommit] Bad commit object received.\n");
    transfer_task_set_error (((SeafileGetcommitProc *)processor)->tx_task,
                             TASK_ERR_DOWNLOAD_COMMIT);
    ccnet_processor_done (processor, FALSE);
}

static void handle_response (CcnetProcessor *processor,
                             char *code, char *code_msg,
                             char *content, int clen)
{
    SeafileSendcommitV3Proc *proc = (SeafileSendcommitV3Proc *)processor;
    TransferTask *task = proc->tx_task;
    if (task->state != TASK_STATE_NORMAL) {
        ccnet_processor_done (processor, TRUE);
        return;
    }

    switch (processor->state) {
    case INIT:
        if (memcmp (code, SC_OK, 3) == 0) {
            processor->state = SEND_OBJECT;
            send_commits (processor, task->head);
        } else {
            g_warning ("Bad response: %s %s.\n", code, code_msg);
            ccnet_processor_done (processor, FALSE);
        }
        break;
    case SEND_OBJECT:
        if (memcmp (code, SC_ACK, 3) == 0) {
            send_one_commit (processor);
        } else {
            g_warning ("[sendcommit] Bad response in state SEND_OBJECT: %s %s\n",
                       code, code_msg);
            ccnet_processor_done (processor, FALSE);
        }
        break;
    default:
        g_assert (0);
    }
}

static void
process_commit_list (CcnetProcessor *processor, char *content, int clen)
{
    USE_PRIV;
    char *object_id;
    int n_objects;
    int i;

    if (clen % 41 != 1 || content[clen-1] != '\0') {
        g_warning ("[getcommit] Bad commit id list.\n");
        ccnet_processor_send_update (processor, SC_BAD_OL, SS_BAD_OL, NULL, 0);
        transfer_task_set_error (((SeafileGetcommitProc *)processor)->tx_task,
                                 TASK_ERR_DOWNLOAD_COMMIT);
        ccnet_processor_done (processor, FALSE);
        return;
    }

    n_objects = clen/41;

    request_object_batch_begin(priv);

    object_id = content;
    for (i = 0; i < n_objects; ++i) {
        object_id[40] = '\0';
        check_commit (processor, object_id);
        object_id += 41;
    }
    
    request_object_batch_flush (processor, priv);

    if (priv->pending_objects == 0) {
        ccnet_processor_send_update (processor, SC_END, SS_END, NULL, 0);
        ccnet_processor_done (processor, TRUE);
    }
}

static void response_challenge_user(CcnetProcessor *processor, 
                                    char *code, char *code_msg,
                                    char *content, int clen)
{
    unsigned char *buf;
    int decrypt_len;

    if (clen == 0) {
        ccnet_warning("Peer %s(%.8s) send bad format challenge\n",
                      processor->peer->name, processor->peer->id);
        ccnet_processor_send_response (
            processor, SC_BAD_CHALLENGE, SS_BAD_CHALLENGE, NULL, 0);
        ccnet_processor_done(processor, FALSE);
        return;
    }
        
    buf = private_key_decrypt(processor->session->user_privkey,
                   (unsigned char *)content, clen, &decrypt_len);
    if (decrypt_len < 0) {
        ccnet_processor_send_response (
            processor, SC_DECRYPT_ERROR, SS_DECRYPT_ERROR, NULL, 0);
        ccnet_processor_done(processor, FALSE);
    } else
        ccnet_processor_send_response (
            processor, code, "", (char *)buf, decrypt_len);
    g_free(buf);
}

static void
thread_done (void *result)
{
    CcnetProcessor *processor = result;
    USE_PRIV;

    if (processor->delay_shutdown) {
        ccnet_processor_done (processor, FALSE);
        return;
    }

    if (strcmp (priv->rsp_code, SC_OK) == 0) {
        if (priv->has_branch) {
            ccnet_processor_send_response (processor,
                                           SC_OK, SS_OK,
                                           priv->head_id, 41);
        } else
            ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0);
        processor->state = ACCESS_GRANTED;
    } else {
        ccnet_processor_send_response (processor,
                                       priv->rsp_code, priv->rsp_msg,
                                       NULL, 0);
        ccnet_processor_done (processor, FALSE);
    }
}

void
ccnet_service_proxy_invoke_remote (CcnetProcessor *processor,
                                   CcnetPeer *remote,
                                   int argc, char **argv)
{
    CcnetServiceStubProc *stub_proc;
    ServiceProxyPriv *priv = GET_PRIV(processor);

    if (argc < 1) {
        ccnet_processor_send_response (processor, SC_BAD_CMD_FMT,
                                       SS_BAD_CMD_FMT, NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return;
    }
    
    priv->name = proc_name_strjoin_n(" ", argc, argv);

    stub_proc = CCNET_SERVICE_STUB_PROC (
        ccnet_proc_factory_create_master_processor (
            processor->session->proc_factory, "service-stub", remote)
        );
    priv->stub_proc = stub_proc;
    ccnet_service_stub_proc_set_proxy_proc (stub_proc, processor);

    /* Start can fail if the remote end is not connected. */
    if (ccnet_processor_start (CCNET_PROCESSOR(stub_proc), argc, argv) < 0) {
        ccnet_processor_send_response (processor, SC_PROC_DEAD, SS_PROC_DEAD,
                                       NULL, 0);
        ccnet_processor_done (processor, FALSE);
    }
}

static void
process_ack (CcnetProcessor *processor, char *content, int clen)
{
    SeafileSendblockV2Proc *proc = (SeafileSendblockV2Proc *)processor;
    int block_idx;

    if (content[clen-1] != '\0') {
        g_warning ("Bad block ack.\n");
        ccnet_processor_done (processor, FALSE);
        return;
    }

    block_idx = atoi(content);
    if (block_idx < 0 || block_idx >= proc->tx_task->block_list->n_blocks) {
        g_warning ("Bad block index %d.\n", block_idx);
        ccnet_processor_done (processor, FALSE);
        return;
    }

    BitfieldRem (&proc->active, block_idx);
    BitfieldRem (&proc->tx_task->active, block_idx);
    BitfieldAdd (&proc->tx_task->uploaded, block_idx);
    /* g_debug ("[sendlbock] recv ack for block %d\n", block_idx); */
    ++(proc->tx_task->n_uploaded);
}

static void
handle_update (CcnetProcessor *processor,
               char *code, char *code_msg,
               char *content, int clen)
{
    switch (processor->state) {
    case SEND_OBJECTS:
        if (strncmp (code, SC_OBJ_LIST_SEG, 3) == 0) {
            process_object_list_segment (processor, content, clen);
            return;
        } else if (strncmp (code, SC_END, 3) == 0) {
            seaf_debug ("All objects received. Done.\n");
            ccnet_processor_done (processor, TRUE);
            return;
        }
        break;
    default:
        g_return_if_reached ();
    }

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

static void
handle_response (CcnetProcessor *processor,
                 char *code, char *code_msg,
                 char *content, int clen)
{
    SeafileSendfsProc *proc = (SeafileSendfsProc *)processor;
    TransferTask *task = proc->tx_task;

    switch (processor->state) {
    case SEND_ROOT:
        if (strncmp(code, SC_OK, 3) == 0) {
            send_fs_roots (processor);
            return;
        }
        break;
    case SEND_OBJECT:
        if (strncmp(code, SC_GET_OBJECT, 3) == 0) {
            send_fs_objects (processor, content, clen);
            return;
        } else if (strncmp(code, SC_END, 3) == 0) {
            seaf_debug ("Send fs objects end.\n");
            ccnet_processor_done (processor, TRUE);
            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);
}

static int
sync_repo_start (CcnetProcessor *processor, int argc, char **argv)
{
    SeafileSyncRepoProc *proc = (SeafileSyncRepoProc *) processor;

    if (argc != 0) {
        seaf_warning ("[sync-repo] argc should be 0.\n");
        ccnet_processor_done (processor, FALSE);
        return 0;
    }

    if (!proc->task) {
        seaf_warning ("[sync-repo] Error: not provide info task.\n");
        ccnet_processor_done (processor, FALSE);
        return 0;
    }

    char buf[256];

    /* Use a virutal "fetch_head" branch that works both on client and server. */
    snprintf (buf, 256, "remote %s seafile-sync-repo-slave %s %s",
              processor->peer_id, proc->task->info->repo_id, "fetch_head");
    
    ccnet_processor_send_request (processor, buf);

    return 0;
}

static int
start (CcnetProcessor *processor, int argc, char **argv)
{
    char *session_token;
    USE_PRIV;

    if (argc != 1) {
        ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return -1;
    }

    session_token = argv[0];
    if (seaf_token_manager_verify_token (seaf->token_mgr,
                                         processor->peer_id,
                                         session_token, NULL) == 0) {
        ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0);
        processor->state = RECV_ROOT;
        priv->dir_queue = g_queue_new ();
        register_async_io (processor);
        return 0;
    } else {
        ccnet_processor_send_response (processor, 
                                       SC_ACCESS_DENIED, SS_ACCESS_DENIED,
                                       NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return -1;
    }
}

static void
commit_write_cb (OSAsyncResult *res, void *data)
{
    CcnetProcessor *processor = data;
    TransferTask *task = ((SeafileGetcommitV3Proc *)processor)->tx_task;
    SeafCommit *commit;

    if (!res->success) {
        seaf_warning ("Failed to write commit %.8s.\n", res->obj_id);
        transfer_task_set_error (task, TASK_ERR_DOWNLOAD_COMMIT);
        ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return;
    }

    commit = seaf_commit_from_data (res->obj_id, res->data, res->len);
    if (!commit) {
        seaf_warning ("[getcommit] Bad commit object received.\n");
        transfer_task_set_error (task, TASK_ERR_DOWNLOAD_COMMIT);
        ccnet_processor_send_update (processor, SC_BAD_OBJECT, SS_BAD_OBJECT,
                                     NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return;
    }

    if (strcmp (commit->root_id, EMPTY_SHA1) != 0)
        object_list_insert (task->fs_roots, commit->root_id);
    seaf_commit_unref (commit);

    ccnet_processor_done (processor, TRUE);
}

static void 
computation_finished (CcnetProcessor *processor,
                      int status,
                      char *message)
{
    USE_PRIV;

    g_ptr_array_free (priv->block_ids, TRUE);
    priv->block_ids = NULL;

    g_message ("Finished computing size of repo %s.\n", priv->repo_id);

    /* Store repo size into database.
     */
    if (seaf_monitor_set_repo_size (singleton_monitor, 
                                    priv->repo_id, 
                                    priv->repo_size,
                                    priv->is_accurate,
                                    priv->head) < 0) {
        ccnet_processor_send_response (processor,
                                       SC_DB_ERROR, SS_DB_ERROR,
                                       NULL, 0);
        ccnet_processor_done (processor, FALSE);
    }

    ccnet_processor_send_response (processor, SC_FINISHED, SS_FINISHED, NULL, 0);
    ccnet_processor_done (processor, TRUE);
}

static int
start (CcnetProcessor *processor, int argc, char **argv)
{
    USE_PRIV;

    if (argc != 2 || strlen(argv[0]) != 36 || strlen(argv[1]) != 40) {
        ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return -1;
    }

    if (seaf_monitor_is_repo_size_uptodate (singleton_monitor,
                                            argv[0], argv[1])) {
        g_message ("repo size %s is up-to-date.\n", argv[0]);
        ccnet_processor_send_response (processor, SC_FINISHED, SS_FINISHED, NULL, 0);
        ccnet_processor_done (processor, TRUE);
        return 0;
    }

    memcpy (priv->repo_id, argv[0], 41);
    memcpy (priv->head, argv[1], 41);
    priv->block_ids = g_ptr_array_new_with_free_func (g_free);
    priv->is_accurate = 1;

    ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0);

    return 0;
}

static void 
thread_done (void *result)
{
    CcnetProcessor *processor = result;
    USE_PRIV;

    if (processor->delay_shutdown) {
        ccnet_processor_done (processor, FALSE);
        return;
    }

    if (strcmp (priv->rsp_code, SC_OK) == 0) {
        /* Repo is updated, trigger repo size computation. */
        if (seaf->monitor_id != NULL &&
            (strcmp (seaf->monitor_id, seaf->session->base.id) == 0 ||
             ccnet_peer_is_ready (seaf->ccnetrpc_client, seaf->monitor_id)))
        {
            monitor_compute_repo_size_async_wrapper (seaf->monitor_id, 
                                                     priv->repo_id,
                                                     compute_callback,
                                                     NULL);
        }

        ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0);
        ccnet_processor_done (processor, TRUE);
    } else {
        ccnet_processor_send_response (processor,
                                       priv->rsp_code, priv->rsp_msg,
                                       NULL, 0);
        ccnet_processor_done (processor, FALSE);
    }
}