refdb.c 5.1 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * 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 "posix.h"
10

11 12 13
#include "git2/object.h"
#include "git2/refs.h"
#include "git2/refdb.h"
14 15
#include "git2/sys/refdb_backend.h"

16 17 18
#include "hash.h"
#include "refdb.h"
#include "refs.h"
19
#include "reflog.h"
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

int git_refdb_new(git_refdb **out, git_repository *repo)
{
	git_refdb *db;

	assert(out && repo);

	db = git__calloc(1, sizeof(*db));
	GITERR_CHECK_ALLOC(db);

	db->repo = repo;

	*out = db;
	GIT_REFCOUNT_INC(db);
	return 0;
}

int git_refdb_open(git_refdb **out, git_repository *repo)
{
	git_refdb *db;
	git_refdb_backend *dir;

	assert(out && repo);

	*out = NULL;

	if (git_refdb_new(&db, repo) < 0)
		return -1;

	/* Add the default (filesystem) backend */
50
	if (git_refdb_backend_fs(&dir, repo) < 0) {
51 52 53 54 55 56 57 58 59 60 61
		git_refdb_free(db);
		return -1;
	}

	db->repo = repo;
	db->backend = dir;

	*out = db;
	return 0;
}

62
static void refdb_free_backend(git_refdb *db)
63
{
64 65
	if (db->backend)
		db->backend->free(db->backend);
66
}
67

68 69 70
int git_refdb_set_backend(git_refdb *db, git_refdb_backend *backend)
{
	refdb_free_backend(db);
71 72 73 74 75 76 77 78
	db->backend = backend;

	return 0;
}

int git_refdb_compress(git_refdb *db)
{
	assert(db);
79

80
	if (db->backend->compress)
81
		return db->backend->compress(db->backend);
82

83 84 85
	return 0;
}

Vicent Marti committed
86
void git_refdb__free(git_refdb *db)
87
{
88
	refdb_free_backend(db);
89
	git__memzero(db, sizeof(*db));
90 91 92
	git__free(db);
}

93 94 95 96 97
void git_refdb_free(git_refdb *db)
{
	if (db == NULL)
		return;

Vicent Marti committed
98
	GIT_REFCOUNT_DEC(db, git_refdb__free);
99 100
}

101 102 103 104 105 106 107 108 109
int git_refdb_exists(int *exists, git_refdb *refdb, const char *ref_name)
{
	assert(exists && refdb && refdb->backend);

	return refdb->backend->exists(exists, refdb->backend, ref_name);
}

int git_refdb_lookup(git_reference **out, git_refdb *db, const char *ref_name)
{
110 111 112
	git_reference *ref;
	int error;

113
	assert(db && db->backend && out && ref_name);
114

115 116 117 118 119 120
	error = db->backend->lookup(&ref, db->backend, ref_name);
	if (error < 0)
		return error;

	GIT_REFCOUNT_INC(db);
	ref->db = db;
121

122 123
	*out = ref;
	return 0;
124 125
}

126
int git_refdb_iterator(git_reference_iterator **out, git_refdb *db, const char *glob)
127
{
128 129 130 131 132
	if (!db->backend || !db->backend->iterator) {
		giterr_set(GITERR_REFERENCE, "This backend doesn't support iterators");
		return -1;
	}

133
	if (db->backend->iterator(out, db->backend, glob) < 0)
134 135
		return -1;

136 137 138
	GIT_REFCOUNT_INC(db);
	(*out)->db = db;

139 140 141
	return 0;
}

142
int git_refdb_iterator_next(git_reference **out, git_reference_iterator *iter)
143
{
144
	int error;
145

146 147
	if ((error = iter->next(out, iter)) < 0)
		return error;
148

149 150
	GIT_REFCOUNT_INC(iter->db);
	(*out)->db = iter->db;
151 152 153 154

	return 0;
}

155
int git_refdb_iterator_next_name(const char **out, git_reference_iterator *iter)
156
{
157
	return iter->next_name(out, iter);
158 159 160 161
}

void git_refdb_iterator_free(git_reference_iterator *iter)
{
Vicent Marti committed
162
	GIT_REFCOUNT_DEC(iter->db, git_refdb__free);
163
	iter->free(iter);
164 165
}

166
int git_refdb_write(git_refdb *db, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old_id, const char *old_target)
167 168
{
	assert(db && db->backend);
Vicent Marti committed
169 170 171 172

	GIT_REFCOUNT_INC(db);
	ref->db = db;

173
	return db->backend->write(db->backend, ref, force, who, message, old_id, old_target);
Vicent Marti committed
174 175 176 177 178 179 180
}

int git_refdb_rename(
	git_reference **out,
	git_refdb *db,
	const char *old_name,
	const char *new_name,
181
	int force,
182
	const git_signature *who,
183
	const char *message)
Vicent Marti committed
184 185 186 187
{
	int error;

	assert(db && db->backend);
188
	error = db->backend->rename(out, db->backend, old_name, new_name, force, who, message);
Vicent Marti committed
189 190 191 192 193 194 195 196 197
	if (error < 0)
		return error;

	if (out) {
		GIT_REFCOUNT_INC(db);
		(*out)->db = db;
	}

	return 0;
198 199
}

200
int git_refdb_delete(struct git_refdb *db, const char *ref_name, const git_oid *old_id, const char *old_target)
201 202
{
	assert(db && db->backend);
203
	return db->backend->del(db->backend, ref_name, old_id, old_target);
204
}
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name)
{
	int error;

	assert(db && db->backend);

	if ((error = db->backend->reflog_read(out, db->backend, name)) < 0)
		return error;

	GIT_REFCOUNT_INC(db);
	(*out)->db = db;

	return 0;
}
220

221 222 223 224 225 226 227
int git_refdb_has_log(git_refdb *db, const char *refname)
{
	assert(db && refname);

	return db->backend->has_log(db->backend, refname);
}

228 229 230 231 232 233
int git_refdb_ensure_log(git_refdb *db, const char *refname)
{
	assert(db && refname);

	return db->backend->ensure_log(db->backend, refname);
}
234

235
int git_refdb_init_backend(git_refdb_backend *backend, unsigned int version)
236
{
237 238 239
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		backend, version, git_refdb_backend, GIT_REFDB_BACKEND_INIT);
	return 0;
240
}
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259

int git_refdb_lock(void **payload, git_refdb *db, const char *refname)
{
	assert(payload && db && refname);

	if (!db->backend->lock) {
		giterr_set(GITERR_REFERENCE, "backend does not support locking");
		return -1;
	}

	return db->backend->lock(payload, db->backend, refname);
}

int git_refdb_unlock(git_refdb *db, void *payload, int success, int update_reflog, const git_reference *ref, const git_signature *sig, const char *message)
{
	assert(db);

	return db->backend->unlock(db->backend, payload, success, update_reflog, ref, sig, message);
}