refdb.c 5.12 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
	int error;

130 131 132 133 134
	if (!db->backend || !db->backend->iterator) {
		giterr_set(GITERR_REFERENCE, "This backend doesn't support iterators");
		return -1;
	}

135 136
	if ((error = db->backend->iterator(out, db->backend, glob)) < 0)
		return error;
137

138 139 140
	GIT_REFCOUNT_INC(db);
	(*out)->db = db;

141 142 143
	return 0;
}

144
int git_refdb_iterator_next(git_reference **out, git_reference_iterator *iter)
145
{
146
	int error;
147

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

151 152
	GIT_REFCOUNT_INC(iter->db);
	(*out)->db = iter->db;
153 154 155 156

	return 0;
}

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

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

168
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)
169 170
{
	assert(db && db->backend);
Vicent Marti committed
171 172 173 174

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

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

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

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

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

	return 0;
200 201
}

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

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;
}
222

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

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

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

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

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

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);
}