src/transaction.c - third_party/libgit2 - Git at Google

 /*
  * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */

 #include "common.h"
 #include "repository.h"
 #include "strmap.h"
 #include "refdb.h"
 #include "pool.h"
 #include "reflog.h"
 #include "signature.h"
 #include "config.h"

 #include "git2/transaction.h"
 #include "git2/signature.h"
 #include "git2/sys/refs.h"
 #include "git2/sys/refdb_backend.h"

 typedef enum {
 	TRANSACTION_NONE,
 	TRANSACTION_REFS,
 	TRANSACTION_CONFIG,
 } transaction_t;

 typedef struct {
 	const char *name;
 	void *payload;

 	git_ref_t ref_type;
 	union {
 		git_oid id;
 		char *symbolic;
 	} target;
 	git_reflog *reflog;

 	const char *message;
 	git_signature *sig;

 	unsigned int committed :1,
 		remove :1;
 } transaction_node;

 struct git_transaction {
 	transaction_t type;
 	git_repository *repo;
 	git_refdb *db;
 	git_config *cfg;

 	git_strmap *locks;
 	git_pool pool;
 };

 int git_transaction_config_new(git_transaction **out, git_config *cfg)
 {
 	git_transaction *tx;
 	assert(out && cfg);

 	tx = git__calloc(1, sizeof(git_transaction));
 	GITERR_CHECK_ALLOC(tx);

 	tx->type = TRANSACTION_CONFIG;
 	tx->cfg = cfg;
 	*out = tx;
 	return 0;
 }

 int git_transaction_new(git_transaction **out, git_repository *repo)
 {
 	int error;
 	git_pool pool;
 	git_transaction *tx = NULL;

 	assert(out && repo);

 	git_pool_init(&pool, 1);

 	tx = git_pool_mallocz(&pool, sizeof(git_transaction));
 	if (!tx) {
 		error = -1;
 		goto on_error;
 	}

 	if ((error = git_strmap_alloc(&tx->locks)) < 0) {
 		error = -1;
 		goto on_error;
 	}

 	if ((error = git_repository_refdb(&tx->db, repo)) < 0)
 		goto on_error;

 	tx->type = TRANSACTION_REFS;
 	memcpy(&tx->pool, &pool, sizeof(git_pool));
 	tx->repo = repo;
 	*out = tx;
 	return 0;

 on_error:
 	git_pool_clear(&pool);
 	return error;
 }

 int git_transaction_lock_ref(git_transaction *tx, const char *refname)
 {
 	int error;
 	transaction_node *node;

 	assert(tx && refname);

 	node = git_pool_mallocz(&tx->pool, sizeof(transaction_node));
 	GITERR_CHECK_ALLOC(node);

 	node->name = git_pool_strdup(&tx->pool, refname);
 	GITERR_CHECK_ALLOC(node->name);

 	if ((error = git_refdb_lock(&node->payload, tx->db, refname)) < 0)
 		return error;

 	git_strmap_insert(tx->locks, node->name, node, &error);
 	if (error < 0)
 		goto cleanup;

 	return 0;

 cleanup:
 	git_refdb_unlock(tx->db, node->payload, false, false, NULL, NULL, NULL);

 	return error;
 }

 static int find_locked(transaction_node **out, git_transaction *tx, const char *refname)
 {
 	git_strmap_iter pos;
 	transaction_node *node;

 	pos = git_strmap_lookup_index(tx->locks, refname);
 	if (!git_strmap_valid_index(tx->locks, pos)) {
 		giterr_set(GITERR_REFERENCE, "the specified reference is not locked");
 		return GIT_ENOTFOUND;
 	}

 	node = git_strmap_value_at(tx->locks, pos);

 	*out = node;
 	return 0;
 }

 static int copy_common(transaction_node *node, git_transaction *tx, const git_signature *sig, const char *msg)
 {
 	if (sig && git_signature__pdup(&node->sig, sig, &tx->pool) < 0)
 		return -1;

 	if (!node->sig) {
 		git_signature *tmp;
 		int error;

 		if (git_reference__log_signature(&tmp, tx->repo) < 0)
 			return -1;

 		/* make sure the sig we use is in our pool */
 		error = git_signature__pdup(&node->sig, tmp, &tx->pool);
 		git_signature_free(tmp);
 		if (error < 0)
 			return error;
 	}

 	if (msg) {
 		node->message = git_pool_strdup(&tx->pool, msg);
 		GITERR_CHECK_ALLOC(node->message);
 	}

 	return 0;
 }

 int git_transaction_set_target(git_transaction *tx, const char *refname, const git_oid *target, const git_signature *sig, const char *msg)
 {
 	int error;
 	transaction_node *node;

 	assert(tx && refname && target);

 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;

 	if ((error = copy_common(node, tx, sig, msg)) < 0)
 		return error;

 	git_oid_cpy(&node->target.id, target);
 	node->ref_type = GIT_REF_OID;

 	return 0;
 }

 int git_transaction_set_symbolic_target(git_transaction *tx, const char *refname, const char *target, const git_signature *sig, const char *msg)
 {
 	int error;
 	transaction_node *node;

 	assert(tx && refname && target);

 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;

 	if ((error = copy_common(node, tx, sig, msg)) < 0)
 		return error;

 	node->target.symbolic = git_pool_strdup(&tx->pool, target);
 	GITERR_CHECK_ALLOC(node->target.symbolic);
 	node->ref_type = GIT_REF_SYMBOLIC;

 	return 0;
 }

 int git_transaction_remove(git_transaction *tx, const char *refname)
 {
 	int error;
 	transaction_node *node;

 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;

 	node->remove = true;
 	node->ref_type = GIT_REF_OID; /* the id will be ignored */

 	return 0;
 }

 static int dup_reflog(git_reflog **out, const git_reflog *in, git_pool *pool)
 {
 	git_reflog *reflog;
 	git_reflog_entry *entries;
 	size_t len, i;

 	reflog = git_pool_mallocz(pool, sizeof(git_reflog));
 	GITERR_CHECK_ALLOC(reflog);

 	reflog->ref_name = git_pool_strdup(pool, in->ref_name);
 	GITERR_CHECK_ALLOC(reflog->ref_name);

 	len = in->entries.length;
 	reflog->entries.length = len;
 	reflog->entries.contents = git_pool_mallocz(pool, len * sizeof(void *));
 	GITERR_CHECK_ALLOC(reflog->entries.contents);

 	entries = git_pool_mallocz(pool, len * sizeof(git_reflog_entry));
 	GITERR_CHECK_ALLOC(entries);

 	for (i = 0; i < len; i++) {
 		const git_reflog_entry *src;
 		git_reflog_entry *tgt;

 		tgt = &entries[i];
 		reflog->entries.contents[i] = tgt;

 		src = git_vector_get(&in->entries, i);
 		git_oid_cpy(&tgt->oid_old, &src->oid_old);
 		git_oid_cpy(&tgt->oid_cur, &src->oid_cur);

 		tgt->msg = git_pool_strdup(pool, src->msg);
 		GITERR_CHECK_ALLOC(tgt->msg);

 		if (git_signature__pdup(&tgt->committer, src->committer, pool) < 0)
 			return -1;
 	}


 	*out = reflog;
 	return 0;
 }

 int git_transaction_set_reflog(git_transaction *tx, const char *refname, const git_reflog *reflog)
 {
 	int error;
 	transaction_node *node;

 	assert(tx && refname && reflog);

 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;

 	if ((error = dup_reflog(&node->reflog, reflog, &tx->pool)) < 0)
 		return error;

 	return 0;
 }

 static int update_target(git_refdb *db, transaction_node *node)
 {
 	git_reference *ref;
 	int error, update_reflog;

 	if (node->ref_type == GIT_REF_OID) {
 		ref = git_reference__alloc(node->name, &node->target.id, NULL);
 	} else if (node->ref_type == GIT_REF_SYMBOLIC) {
 		ref = git_reference__alloc_symbolic(node->name, node->target.symbolic);
 	} else {
 		abort();
 	}

 	GITERR_CHECK_ALLOC(ref);
 	update_reflog = node->reflog == NULL;

 	if (node->remove) {
 		error =  git_refdb_unlock(db, node->payload, 2, false, ref, NULL, NULL);
 	} else if (node->ref_type == GIT_REF_OID) {
 		error = git_refdb_unlock(db, node->payload, true, update_reflog, ref, node->sig, node->message);
 	} else if (node->ref_type == GIT_REF_SYMBOLIC) {
 		error = git_refdb_unlock(db, node->payload, true, update_reflog, ref, node->sig, node->message);
 	} else {
 		abort();
 	}

 	git_reference_free(ref);
 	node->committed = true;

 	return error;
 }

 int git_transaction_commit(git_transaction *tx)
 {
 	transaction_node *node;
 	int error = 0;

 	assert(tx);

 	if (tx->type == TRANSACTION_CONFIG) {
 		error = git_config_unlock(tx->cfg, true);
 		tx->cfg = NULL;

 		return error;
 	}

 	git_strmap_foreach_value(tx->locks, node, {
 		if (node->reflog) {
 			if ((error = tx->db->backend->reflog_write(tx->db->backend, node->reflog)) < 0)
 				return error;
 		}

 		if (node->ref_type != GIT_REF_INVALID) {
 			if ((error = update_target(tx->db, node)) < 0)
 				return error;
 		}
 	});

 	return 0;
 }

 void git_transaction_free(git_transaction *tx)
 {
 	transaction_node *node;
 	git_pool pool;

 	assert(tx);

 	if (tx->type == TRANSACTION_CONFIG) {
 		if (tx->cfg) {
 			git_config_unlock(tx->cfg, false);
 			git_config_free(tx->cfg);
 		}

 		git__free(tx);
 		return;
 	}

 	/* start by unlocking the ones we've left hanging, if any */
 	git_strmap_foreach_value(tx->locks, node, {
 		if (node->committed)
 			continue;

 		git_refdb_unlock(tx->db, node->payload, false, false, NULL, NULL, NULL);
 	});

 	git_refdb_free(tx->db);
 	git_strmap_free(tx->locks);

 	/* tx is inside the pool, so we need to extract the data */
 	memcpy(&pool, &tx->pool, sizeof(git_pool));
 	git_pool_clear(&pool);
 }
	/*
	* Copyright (C) the libgit2 contributors. All rights reserved.
	*
	* This file is part of libgit2, distributed under the GNU GPL v2 with
	* a Linking Exception. For full terms see the included COPYING file.
	*/

	#include "common.h"
	#include "repository.h"
	#include "strmap.h"
	#include "refdb.h"
	#include "pool.h"
	#include "reflog.h"
	#include "signature.h"
	#include "config.h"

	#include "git2/transaction.h"
	#include "git2/signature.h"
	#include "git2/sys/refs.h"
	#include "git2/sys/refdb_backend.h"

	typedef enum {
	TRANSACTION_NONE,
	TRANSACTION_REFS,
	TRANSACTION_CONFIG,
	} transaction_t;

	typedef struct {
	const char *name;
	void *payload;

	git_ref_t ref_type;
	union {
	git_oid id;
	char *symbolic;
	} target;
	git_reflog *reflog;

	const char *message;
	git_signature *sig;

	unsigned int committed :1,
	remove :1;
	} transaction_node;

	struct git_transaction {
	transaction_t type;
	git_repository *repo;
	git_refdb *db;
	git_config *cfg;

	git_strmap *locks;
	git_pool pool;
	};

	int git_transaction_config_new(git_transaction *out, git_config cfg)
	{
	git_transaction *tx;
	assert(out && cfg);

	tx = git__calloc(1, sizeof(git_transaction));
	GITERR_CHECK_ALLOC(tx);

	tx->type = TRANSACTION_CONFIG;
	tx->cfg = cfg;
	*out = tx;
	return 0;
	}

	int git_transaction_new(git_transaction *out, git_repository repo)
	{
	int error;
	git_pool pool;
	git_transaction *tx = NULL;

	assert(out && repo);

	git_pool_init(&pool, 1);

	tx = git_pool_mallocz(&pool, sizeof(git_transaction));
	if (!tx) {
	error = -1;
	goto on_error;
	}

	if ((error = git_strmap_alloc(&tx->locks)) < 0) {
	error = -1;
	goto on_error;
	}

	if ((error = git_repository_refdb(&tx->db, repo)) < 0)
	goto on_error;

	tx->type = TRANSACTION_REFS;
	memcpy(&tx->pool, &pool, sizeof(git_pool));
	tx->repo = repo;
	*out = tx;
	return 0;

	on_error:
	git_pool_clear(&pool);
	return error;
	}

	int git_transaction_lock_ref(git_transaction tx, const char refname)
	{
	int error;
	transaction_node *node;

	assert(tx && refname);

	node = git_pool_mallocz(&tx->pool, sizeof(transaction_node));
	GITERR_CHECK_ALLOC(node);

	node->name = git_pool_strdup(&tx->pool, refname);
	GITERR_CHECK_ALLOC(node->name);

	if ((error = git_refdb_lock(&node->payload, tx->db, refname)) < 0)
	return error;

	git_strmap_insert(tx->locks, node->name, node, &error);
	if (error < 0)
	goto cleanup;

	return 0;

	cleanup:
	git_refdb_unlock(tx->db, node->payload, false, false, NULL, NULL, NULL);

	return error;
	}

	static int find_locked(transaction_node *out, git_transaction tx, const char *refname)
	{
	git_strmap_iter pos;
	transaction_node *node;

	pos = git_strmap_lookup_index(tx->locks, refname);
	if (!git_strmap_valid_index(tx->locks, pos)) {
	giterr_set(GITERR_REFERENCE, "the specified reference is not locked");
	return GIT_ENOTFOUND;
	}

	node = git_strmap_value_at(tx->locks, pos);

	*out = node;
	return 0;
	}

	static int copy_common(transaction_node node, git_transaction tx, const git_signature sig, const char msg)
	{
	if (sig && git_signature__pdup(&node->sig, sig, &tx->pool) < 0)
	return -1;

	if (!node->sig) {
	git_signature *tmp;
	int error;

	if (git_reference__log_signature(&tmp, tx->repo) < 0)
	return -1;

	/* make sure the sig we use is in our pool */
	error = git_signature__pdup(&node->sig, tmp, &tx->pool);
	git_signature_free(tmp);
	if (error < 0)
	return error;
	}

	if (msg) {
	node->message = git_pool_strdup(&tx->pool, msg);
	GITERR_CHECK_ALLOC(node->message);
	}

	return 0;
	}

	int git_transaction_set_target(git_transaction tx, const char refname, const git_oid target, const git_signature sig, const char *msg)
	{
	int error;
	transaction_node *node;

	assert(tx && refname && target);

	if ((error = find_locked(&node, tx, refname)) < 0)
	return error;

	if ((error = copy_common(node, tx, sig, msg)) < 0)
	return error;

	git_oid_cpy(&node->target.id, target);
	node->ref_type = GIT_REF_OID;

	return 0;
	}

	int git_transaction_set_symbolic_target(git_transaction tx, const char refname, const char target, const git_signature sig, const char *msg)
	{
	int error;
	transaction_node *node;

	assert(tx && refname && target);

	if ((error = find_locked(&node, tx, refname)) < 0)
	return error;

	if ((error = copy_common(node, tx, sig, msg)) < 0)
	return error;

	node->target.symbolic = git_pool_strdup(&tx->pool, target);
	GITERR_CHECK_ALLOC(node->target.symbolic);
	node->ref_type = GIT_REF_SYMBOLIC;

	return 0;
	}

	int git_transaction_remove(git_transaction tx, const char refname)
	{
	int error;
	transaction_node *node;

	if ((error = find_locked(&node, tx, refname)) < 0)
	return error;

	node->remove = true;
	node->ref_type = GIT_REF_OID; /* the id will be ignored */

	return 0;
	}

	static int dup_reflog(git_reflog *out, const git_reflog in, git_pool *pool)
	{
	git_reflog *reflog;
	git_reflog_entry *entries;
	size_t len, i;

	reflog = git_pool_mallocz(pool, sizeof(git_reflog));
	GITERR_CHECK_ALLOC(reflog);

	reflog->ref_name = git_pool_strdup(pool, in->ref_name);
	GITERR_CHECK_ALLOC(reflog->ref_name);

	len = in->entries.length;
	reflog->entries.length = len;
	reflog->entries.contents = git_pool_mallocz(pool, len * sizeof(void *));
	GITERR_CHECK_ALLOC(reflog->entries.contents);

	entries = git_pool_mallocz(pool, len * sizeof(git_reflog_entry));
	GITERR_CHECK_ALLOC(entries);

	for (i = 0; i < len; i++) {
	const git_reflog_entry *src;
	git_reflog_entry *tgt;

	tgt = &entries[i];
	reflog->entries.contents[i] = tgt;

	src = git_vector_get(&in->entries, i);
	git_oid_cpy(&tgt->oid_old, &src->oid_old);
	git_oid_cpy(&tgt->oid_cur, &src->oid_cur);

	tgt->msg = git_pool_strdup(pool, src->msg);
	GITERR_CHECK_ALLOC(tgt->msg);

	if (git_signature__pdup(&tgt->committer, src->committer, pool) < 0)
	return -1;
	}


	*out = reflog;
	return 0;
	}

	int git_transaction_set_reflog(git_transaction tx, const char refname, const git_reflog *reflog)
	{
	int error;
	transaction_node *node;

	assert(tx && refname && reflog);

	if ((error = find_locked(&node, tx, refname)) < 0)
	return error;

	if ((error = dup_reflog(&node->reflog, reflog, &tx->pool)) < 0)
	return error;

	return 0;
	}

	static int update_target(git_refdb db, transaction_node node)
	{
	git_reference *ref;
	int error, update_reflog;

	if (node->ref_type == GIT_REF_OID) {
	ref = git_reference__alloc(node->name, &node->target.id, NULL);
	} else if (node->ref_type == GIT_REF_SYMBOLIC) {
	ref = git_reference__alloc_symbolic(node->name, node->target.symbolic);
	} else {
	abort();
	}

	GITERR_CHECK_ALLOC(ref);
	update_reflog = node->reflog == NULL;

	if (node->remove) {
	error = git_refdb_unlock(db, node->payload, 2, false, ref, NULL, NULL);
	} else if (node->ref_type == GIT_REF_OID) {
	error = git_refdb_unlock(db, node->payload, true, update_reflog, ref, node->sig, node->message);
	} else if (node->ref_type == GIT_REF_SYMBOLIC) {
	error = git_refdb_unlock(db, node->payload, true, update_reflog, ref, node->sig, node->message);
	} else {
	abort();
	}

	git_reference_free(ref);
	node->committed = true;

	return error;
	}

	int git_transaction_commit(git_transaction *tx)
	{
	transaction_node *node;
	int error = 0;

	assert(tx);

	if (tx->type == TRANSACTION_CONFIG) {
	error = git_config_unlock(tx->cfg, true);
	tx->cfg = NULL;

	return error;
	}

	git_strmap_foreach_value(tx->locks, node, {
	if (node->reflog) {
	if ((error = tx->db->backend->reflog_write(tx->db->backend, node->reflog)) < 0)
	return error;
	}

	if (node->ref_type != GIT_REF_INVALID) {
	if ((error = update_target(tx->db, node)) < 0)
	return error;
	}
	});

	return 0;
	}

	void git_transaction_free(git_transaction *tx)
	{
	transaction_node *node;
	git_pool pool;

	assert(tx);

	if (tx->type == TRANSACTION_CONFIG) {
	if (tx->cfg) {
	git_config_unlock(tx->cfg, false);
	git_config_free(tx->cfg);
	}

	git__free(tx);
	return;
	}

	/* start by unlocking the ones we've left hanging, if any */
	git_strmap_foreach_value(tx->locks, node, {
	if (node->committed)
	continue;

	git_refdb_unlock(tx->db, node->payload, false, false, NULL, NULL, NULL);
	});

	git_refdb_free(tx->db);
	git_strmap_free(tx->locks);

	/* tx is inside the pool, so we need to extract the data */
	memcpy(&pool, &tx->pool, sizeof(git_pool));
	git_pool_clear(&pool);
	}