Пример #1
0
static void
read_done_cb (OSAsyncResult *res, void *cb_data)
{
    CcnetProcessor *processor = cb_data;
    USE_PRIV;

    if (!res->success) {
        g_warning ("[putcommit] Failed to read %s.\n", res->obj_id);
        goto bad;
    }

    send_commit (processor, res->obj_id, res->data, res->len);

    seaf_debug ("Send commit %.8s.\n", res->obj_id);

    /* Send next commit. */
    if (priv->id_list != NULL)
        read_and_send_commit (processor);
    else {
        ccnet_processor_send_response (processor, SC_END, SS_END, NULL, 0);
        ccnet_processor_done (processor, TRUE);
    }

    return;

bad:
    ccnet_processor_send_response (processor, SC_NOT_FOUND, SS_NOT_FOUND,
                                   NULL, 0);
    ccnet_processor_done (processor, FALSE);
}
Пример #2
0
static void handle_response (CcnetProcessor *processor,
                             char *code, char *code_msg,
                             char *content, int clen)
{
    SeafileSendcommitV4Proc *proc = (SeafileSendcommitV4Proc *)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_commit (processor, task->head);
            return;
        }
        break;
    case SEND_OBJECT:
        if (memcmp (code, SC_ACK, 3) == 0) {
            ccnet_processor_done (processor, TRUE);
            return;
        }
        break;
    default:
        g_return_if_reached ();
    }

    seaf_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);
}
Пример #3
0
static void
send_commits (CcnetProcessor *processor, char *content, int clen)
{
    char *object_id;
    int n_objects;
    int i;

    if (clen % 41 != 1 || content[clen-1] != '\0') {
        g_warning ("[putcommit] Bad fs object list.\n");
        ccnet_processor_send_response (processor, SC_BAD_OL, SS_BAD_OL, NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return;
    }

    n_objects = clen/41;
    g_debug ("[putcommit] send commit objects %d:\n%s", n_objects, content);

    object_id = content;
    for (i = 0; i < n_objects; ++i) {
        object_id[40] = '\0';
        g_debug ("[putcommit] send commit object #%d:%s\n", i, object_id);
        if (send_commit (processor, object_id) == FALSE)
            return;

        object_id += 41;
    }
}
Пример #4
0
bool XYVirtualKeyboard::enter_clicked()
{
    if (letterLabel->text().isEmpty())
    {
        return false;
    }

    emit send_commit(letterLabel->text());
    clear_history();

    return true;
}
Пример #5
0
void s4pp_flush (s4pp_ctx_t *ctx, s4pp_done_fn done)
{
  if (ctx->state != S4PP_BUFFERING)
    done (ctx, true);
  else
  {
    ctx->done = done;
    if (ctx->waiting_for_sent)
      ctx->want_commit_on_sent = true;
    else
      send_commit (ctx);
  }
}
Пример #6
0
bool s4pp_on_sent (s4pp_ctx_t *ctx)
{
  ctx->err = S4PP_OK; // clear earlier errors
  ctx->waiting_for_sent = false;
  if (ctx->want_commit_on_sent)
  {
    ctx->want_commit_on_sent = false;
    send_commit (ctx);
  }
  else
    progress_work (ctx);
  return_res;
}
Пример #7
0
static void
send_one_commit (CcnetProcessor *processor)
{
    USE_PRIV;
    char *commit_id;

    if (!priv->id_list) {
        ccnet_processor_send_update (processor, SC_END, SS_END, NULL, 0);
        ccnet_processor_done (processor, TRUE);
        return;
    }

    commit_id = priv->id_list->data;
    priv->id_list = g_list_delete_link (priv->id_list, priv->id_list);

    send_commit (processor, commit_id);

    g_free (commit_id);
}
Пример #8
0
static gboolean
traverse_commit (SeafCommit *commit, void *data, gboolean *stop)
{
    CcnetProcessor *processor = data;
    TransferTask *task = ((SeafileSendcommitV2Proc *)processor)->tx_task;
    USE_PRIV;

    if (priv->end_commit_id[0] != 0 &&
        strcmp (priv->end_commit_id, commit->commit_id) == 0) {
        *stop = TRUE;
        return TRUE;
    }

    send_commit (processor, commit->commit_id);

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

    return TRUE;
}
Пример #9
0
static void
send_commits (CcnetProcessor *processor, char *content, int clen)
{
    char *object_id;
    int n_objects;
    int i;

    if (clen % 41 != 1 || content[clen-1] != '\0') {
        seaf_warning ("Bad fs object list.\n");
        ccnet_processor_send_update (processor, SC_BAD_OL, SS_BAD_OL, NULL, 0);
        ccnet_processor_done (processor, FALSE);
        return;
    }

    n_objects = clen/41;

    object_id = content;
    for (i = 0; i < n_objects; ++i) {
        object_id[40] = '\0';
        if (send_commit (processor, object_id) == FALSE)
            return;
        object_id += 41;
    }
}
Пример #10
0
static void progress_work (s4pp_ctx_t *ctx)
{
  switch (ctx->state)
  {
    case S4PP_INIT:
    case S4PP_CONNECT: // if connect failed, we need to retry the connect
      if (!ctx->conn && !ctx->fatal)
      {
        ctx->conn = ctx->io->connect (ctx->server);
        ctx->state = S4PP_CONNECT;
      }
      break;
    case S4PP_HELLO:
      break; // waiting for hello, nothing to do
    case S4PP_AUTHED:
      if (!ctx->next)
        break; // nothing to do, leave the session alone
      if (!prepare_begin_seq (ctx))
        break;
      // else fall-through
    case S4PP_BUFFERING:
      while (ctx->state == S4PP_BUFFERING && process_out_buffer (ctx, false))
      {
        bool sig = false;
        if (ctx->seq.n_sent >= ctx->seq.n_max)
          sig = true;
        else
        {
          s4pp_sample_t sample;
          if (ctx->next (ctx, &sample))
          {
            unsigned idx;
            if (!prepare_dict_entry (ctx, sample.name, &idx))
              break;
            prepare_sample_entry (ctx, &sample, idx);
          }
          else
		  {
			ctx->next = NULL; // mark end of this batch
		    if (ctx->done)
              sig = true;
			else
		      break;
		  }
        }
        if (sig)
          send_commit (ctx);
      }
      break;
    case S4PP_COMMITTING: // waiting for OK/NOK
      // we might only have buffered the SIG: in the overflow area, so
      // ensure we flush it out in that case.
      if (ctx->outbuf.used)
          process_out_buffer (ctx, true);
      break;
    case S4PP_ERRORED:
    default:
      // We have work to do, but something went wrong, so reconnect if possible
      if (ctx->conn)
        ctx->io->disconnect (ctx->conn);
      ctx->conn = NULL;
      ctx->err = S4PP_OK;
      if (!ctx->fatal)
      {
        ctx->conn = ctx->io->connect (ctx->server);
        ctx->state = S4PP_CONNECT;
      }
      else
        ctx->state = S4PP_ERRORED;
      break;
  }
}