void OS_make_pipe (Tchannel * readerp, Tchannel * writerp) { HFILE hread; HFILE hwrite; STD_API_CALL (dos_create_pipe, ((&hread), (&hwrite), 4096)); transaction_begin (); OS2_handle_close_on_abort (hwrite); (*readerp) = (OS2_make_channel (hread, CHANNEL_READ)); transaction_commit (); transaction_begin (); OS_channel_close_on_abort (*readerp); (*writerp) = (OS2_make_channel (hwrite, CHANNEL_WRITE)); transaction_commit (); }
static void handle_mget_put(tcp_client* c, struct evbuffer* buffer) { int rv, i, n; int ksize, vsize; char k[MAX_TRANSACTION_SIZE]; char v[MAX_TRANSACTION_SIZE]; val* tmp; struct evbuffer* b = evbuffer_copy(buffer); transaction_set_get_cb(c->t, on_mget_put, c); evbuffer_remove(b, &n, sizeof(int)); for (i = 0; i < n; i++) { evbuffer_remove(b, &ksize, sizeof(int)); evbuffer_remove(b, k, ksize); evbuffer_remove(b, &vsize, sizeof(int)); evbuffer_remove(b, v, vsize); tmp = execute_get(c->t, k, ksize); if (tmp == NULL) { evbuffer_free(b); return; } val_free(tmp); execute_put(c->t, k, ksize, v, vsize); } evbuffer_free(b); evbuffer_drain(buffer, evbuffer_get_length(buffer)); rv = transaction_commit(c->t, c->id, on_commit); if (rv < 0) { transaction_clear(c->t); send_result(c->buffer_ev, -1); return; } evtimer_add(&c->timeout_ev, &commit_timeout); }
transition_result_t handle_data_end(context_t *context) { switch (transaction_commit(&context->transaction)) { case TRANSACTION_DONE: break; case TRANSACTION_WAIT: context->is_wait_transition = 1; return TRANSITION_WAIT; default: return TRANSITION_ERROR; } context->is_wait_transition = 0; if (buffer_shift_read_after(&context->in_message, CRLF, sizeof(CRLF) - 1) < 0) { return TRANSITION_ERROR; } if (buffer_space(&context->in_message) == 0) { buffer_drop_read(&context->in_message); } if (BUFFER_TAILQ_PUSH_BACK_STRING(&context->out_message_queue, "250 Ok" CRLF) < 0) { return TRANSITION_ERROR; } log_write(context->log, "[%s] commit transaction, file saved: %s", context->uuid, context->transaction.__data_filename); return TRANSITION_SUCCEED; }
Tchannel OS_open_append_file (const char * filename) { Tchannel channel = (open_file (filename, FILE_NORMAL, (OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW), CHANNEL_WRITE)); transaction_begin (); OS_channel_close_on_abort (channel); (void) set_file_pointer (channel, FILE_END, 0); transaction_commit (); return (channel); }
static void handle_commit(tcp_client* c, struct evbuffer* b) { int rv = transaction_remote_count(c->t); if (transaction_read_only(c->t)) { send_result(c->buffer_ev, rv); transaction_clear(c->t); return; } rv = transaction_commit(c->t, c->id, on_commit); if (rv < 0) { transaction_clear(c->t); send_result(c->buffer_ev, -1); } evtimer_add(&c->timeout_ev, &commit_timeout); }
static void handle_mput(tcp_client* c, struct evbuffer* b) { int rv, i, n; int ksize, vsize; char k[MAX_TRANSACTION_SIZE]; char v[MAX_TRANSACTION_SIZE]; evbuffer_remove(b, &n, sizeof(int)); for (i = 0; i < n; i++) { evbuffer_remove(b, &ksize, sizeof(int)); evbuffer_remove(b, k, ksize); evbuffer_remove(b, &vsize, sizeof(int)); evbuffer_remove(b, v, vsize); execute_put(c->t, k, ksize, v, vsize); } rv = transaction_commit(c->t, c->id, on_commit); if (rv < 0) { transaction_clear(c->t); send_result(c->buffer_ev, -1); return; } evtimer_add(&c->timeout_ev, &commit_timeout); }
int walker_fetch(struct walker *walker, int targets, char **target, const char **write_ref, const char *write_ref_log_details) { struct strbuf refname = STRBUF_INIT; struct strbuf err = STRBUF_INIT; struct transaction *transaction = NULL; unsigned char *sha1 = xmalloc(targets * 20); char *msg = NULL; int i, ret = -1; save_commit_buffer = 0; if (write_ref) { transaction = transaction_begin(&err); if (!transaction) { error("%s", err.buf); goto done; } } if (!walker->get_recover) { for_each_ref(mark_complete, NULL); commit_list_sort_by_date(&complete); } for (i = 0; i < targets; i++) { if (interpret_target(walker, target[i], &sha1[20 * i])) { error("Could not interpret response from server '%s' as something to pull", target[i]); goto done; } if (process(walker, lookup_unknown_object(&sha1[20 * i]))) goto done; } if (loop(walker)) goto done; if (!write_ref) { ret = 0; goto done; } if (write_ref_log_details) { msg = xstrfmt("fetch from %s", write_ref_log_details); } else { msg = NULL; } for (i = 0; i < targets; i++) { if (!write_ref[i]) continue; strbuf_reset(&refname); strbuf_addf(&refname, "refs/%s", write_ref[i]); if (transaction_update_ref(transaction, refname.buf, &sha1[20 * i], NULL, 0, 0, msg ? msg : "fetch (unknown)", &err)) { error("%s", err.buf); goto done; } } if (transaction_commit(transaction, &err)) { error("%s", err.buf); goto done; } ret = 0; done: transaction_free(transaction); free(msg); free(sha1); strbuf_release(&err); strbuf_release(&refname); return ret; }
void create_branch(const char *head, const char *name, const char *start_name, int force, int reflog, int clobber_head, int quiet, enum branch_track track) { struct commit *commit; unsigned char sha1[20]; char *real_ref, msg[PATH_MAX + 20]; struct strbuf ref = STRBUF_INIT; int forcing = 0; int dont_change_ref = 0; int explicit_tracking = 0; if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE) explicit_tracking = 1; if (validate_new_branchname(name, &ref, force, track == BRANCH_TRACK_OVERRIDE || clobber_head)) { if (!force) dont_change_ref = 1; else forcing = 1; } real_ref = NULL; if (get_sha1(start_name, sha1)) { if (explicit_tracking) { if (advice_set_upstream_failure) { error(_(upstream_missing), start_name); advise(_(upstream_advice)); exit(1); } die(_(upstream_missing), start_name); } die(_("Not a valid object name: '%s'."), start_name); } switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) { case 0: /* Not branching from any existing branch */ if (explicit_tracking) die(_(upstream_not_branch), start_name); break; case 1: /* Unique completion -- good, only if it is a real branch */ if (!starts_with(real_ref, "refs/heads/") && validate_remote_tracking_branch(real_ref)) { if (explicit_tracking) die(_(upstream_not_branch), start_name); else real_ref = NULL; } break; default: die(_("Ambiguous object name: '%s'."), start_name); break; } if ((commit = lookup_commit_reference(sha1)) == NULL) die(_("Not a valid branch point: '%s'."), start_name); hashcpy(sha1, commit->object.sha1); if (forcing) snprintf(msg, sizeof msg, "branch: Reset to %s", start_name); else if (!dont_change_ref) snprintf(msg, sizeof msg, "branch: Created from %s", start_name); if (reflog) log_all_ref_updates = 1; if (!dont_change_ref) { struct transaction *transaction; struct strbuf err = STRBUF_INIT; transaction = transaction_begin(&err); if (!transaction || transaction_update_ref(transaction, ref.buf, sha1, null_sha1, 0, !forcing, msg, &err) || transaction_commit(transaction, &err)) die("%s", err.buf); transaction_free(transaction); } if (real_ref && track) setup_tracking(ref.buf + 11, real_ref, track, quiet); strbuf_release(&ref); free(real_ref); }