int refs_delete_ref(struct ref_store *refs, const char *msg, const char *refname, const unsigned char *old_sha1, unsigned int flags) { struct ref_transaction *transaction; struct strbuf err = STRBUF_INIT; if (ref_type(refname) == REF_TYPE_PSEUDOREF) { assert(refs == get_main_ref_store()); return delete_pseudoref(refname, old_sha1); } transaction = ref_store_transaction_begin(refs, &err); if (!transaction || ref_transaction_delete(transaction, refname, old_sha1, flags, msg, &err) || ref_transaction_commit(transaction, &err)) { error("%s", err.buf); ref_transaction_free(transaction); strbuf_release(&err); return 1; } ref_transaction_free(transaction); strbuf_release(&err); return 0; }
static int packed_delete_refs(struct ref_store *ref_store, const char *msg, struct string_list *refnames, unsigned int flags) { struct packed_ref_store *refs = packed_downcast(ref_store, REF_STORE_WRITE, "delete_refs"); struct strbuf err = STRBUF_INIT; struct ref_transaction *transaction; struct string_list_item *item; int ret; (void)refs; /* We need the check above, but don't use the variable */ if (!refnames->nr) return 0; /* * Since we don't check the references' old_oids, the * individual updates can't fail, so we can pack all of the * updates into a single transaction. */ transaction = ref_store_transaction_begin(ref_store, &err); if (!transaction) return -1; for_each_string_list_item(item, refnames) { if (ref_transaction_delete(transaction, item->string, NULL, flags, msg, &err)) { warning(_("could not delete reference %s: %s"), item->string, err.buf); strbuf_reset(&err); } } ret = ref_transaction_commit(transaction, &err); if (ret) { if (refnames->nr == 1) error(_("could not delete reference %s: %s"), refnames->items[0].string, err.buf); else error(_("could not delete references: %s"), err.buf); } ref_transaction_free(transaction); strbuf_release(&err); return ret; }
int refs_update_ref(struct ref_store *refs, const char *msg, const char *refname, const unsigned char *new_sha1, const unsigned char *old_sha1, unsigned int flags, enum action_on_err onerr) { struct ref_transaction *t = NULL; struct strbuf err = STRBUF_INIT; int ret = 0; if (ref_type(refname) == REF_TYPE_PSEUDOREF) { assert(refs == get_main_ref_store()); ret = write_pseudoref(refname, new_sha1, old_sha1, &err); } else { t = ref_store_transaction_begin(refs, &err); if (!t || ref_transaction_update(t, refname, new_sha1, old_sha1, flags, msg, &err) || ref_transaction_commit(t, &err)) { ret = 1; ref_transaction_free(t); } } if (ret) { const char *str = "update_ref failed for ref '%s': %s"; switch (onerr) { case UPDATE_REFS_MSG_ON_ERR: error(str, refname, err.buf); break; case UPDATE_REFS_DIE_ON_ERR: die(str, refname, err.buf); break; case UPDATE_REFS_QUIET_ON_ERR: break; } strbuf_release(&err); return 1; } strbuf_release(&err); if (t) ref_transaction_free(t); return 0; }
struct ref_transaction *ref_transaction_begin(struct strbuf *err) { return ref_store_transaction_begin(get_main_ref_store(), err); }