loose.c 9.79 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "odb.h"
3
#include "git2/odb_backend.h"
4 5
#include "posix.h"
#include "loose_data.h"
6
#include "repository.h"
7

8 9 10 11 12
#ifdef __ANDROID_API__
# define S_IREAD        S_IRUSR
# define S_IWRITE       S_IWUSR
#endif

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
static void write_object_files(object_data *d)
{
	int fd;

	if (p_mkdir(d->dir, GIT_OBJECT_DIR_MODE) < 0)
		cl_assert(errno == EEXIST);

	cl_assert((fd = p_creat(d->file, S_IREAD | S_IWRITE)) >= 0);
	cl_must_pass(p_write(fd, d->bytes, d->blen));

	p_close(fd);
}

static void cmp_objects(git_rawobj *o, object_data *d)
{
	cl_assert(o->type == git_object_string2type(d->type));
	cl_assert(o->len == d->dlen);

	if (o->len > 0)
		cl_assert(memcmp(o->data, d->data, o->len) == 0);
}

static void test_read_object(object_data *data)
{
37 38
	git_oid id;
	git_odb_object *obj;
39
	git_odb *odb;
Vicent Marti committed
40
	git_rawobj tmp;
41 42 43
	git_odb_options opts = GIT_ODB_OPTIONS_INIT;

	opts.oid_type = data->id_type;
44

45
	write_object_files(data);
46

47 48
	cl_git_pass(git_odb__open(&odb, "test-objects", &opts));
	cl_git_pass(git_oid__fromstr(&id, data->id, data->id_type));
49
	cl_git_pass(git_odb_read(&obj, odb, &id));
50

Vicent Marti committed
51 52 53 54
	tmp.data = obj->buffer;
	tmp.len = obj->cached.size;
	tmp.type = obj->cached.type;

55
	cmp_objects(&tmp, data);
56

57
	git_odb_object_free(obj);
58 59 60
	git_odb_free(odb);
}

61 62 63 64 65
static void test_read_header(object_data *data)
{
	git_oid id;
	git_odb *odb;
	size_t len;
66
	git_object_t type;
67 68 69
	git_odb_options opts = GIT_ODB_OPTIONS_INIT;

	opts.oid_type = data->id_type;
70 71 72

	write_object_files(data);

73 74
	cl_git_pass(git_odb__open(&odb, "test-objects", &opts));
	cl_git_pass(git_oid__fromstr(&id, data->id, data->id_type));
75 76 77 78 79 80 81 82
	cl_git_pass(git_odb_read_header(&len, &type, odb, &id));

	cl_assert_equal_sz(data->dlen, len);
	cl_assert_equal_i(git_object_string2type(data->type), type);

	git_odb_free(odb);
}

83 84 85 86 87 88 89 90 91
static void test_readstream_object(object_data *data, size_t blocksize)
{
	git_oid id;
	git_odb *odb;
	git_odb_stream *stream;
	git_rawobj tmp;
	char buf[2048], *ptr = buf;
	size_t remain;
	int ret;
92 93 94
	git_odb_options opts = GIT_ODB_OPTIONS_INIT;

	opts.oid_type = data->id_type;
95 96 97

	write_object_files(data);

98 99
	cl_git_pass(git_odb__open(&odb, "test-objects", &opts));
	cl_git_pass(git_oid__fromstr(&id, data->id, data->id_type));
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
	cl_git_pass(git_odb_open_rstream(&stream, &tmp.len, &tmp.type, odb, &id));

	remain = tmp.len;

	while (remain) {
		cl_assert((ret = git_odb_stream_read(stream, ptr, blocksize)) >= 0);
		if (ret == 0)
			break;

		cl_assert(remain >= (size_t)ret);
		remain -= ret;
		ptr += ret;
	}

	cl_assert(remain == 0);

	tmp.data = buf;

	cmp_objects(&tmp, data);

	git_odb_stream_free(stream);
	git_odb_free(odb);
}

124 125
void test_odb_loose__initialize(void)
{
126
	p_fsync__cnt = 0;
127 128 129 130 131
	cl_must_pass(p_mkdir("test-objects", GIT_OBJECT_DIR_MODE));
}

void test_odb_loose__cleanup(void)
{
132
	cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_FSYNC_GITDIR, 0));
133 134 135
	cl_fixture_cleanup("test-objects");
}

136
void test_odb_loose__exists_sha1(void)
137
{
138
	git_oid id, id2;
139 140
	git_odb *odb;

141
	write_object_files(&one);
142
	cl_git_pass(git_odb__open(&odb, "test-objects", NULL));
143

144
	cl_git_pass(git_oid__fromstr(&id, one.id, GIT_OID_SHA1));
145
	cl_assert(git_odb_exists(odb, &id));
146

147
	cl_git_pass(git_oid__fromstrp(&id, "8b137891", GIT_OID_SHA1));
148 149
	cl_git_pass(git_odb_exists_prefix(&id2, odb, &id, 8));
	cl_assert_equal_i(0, git_oid_streq(&id2, one.id));
150

151
	/* Test for a missing object */
152
	cl_git_pass(git_oid__fromstr(&id, "8b137891791fe96927ad78e64b0aad7bded08baa", GIT_OID_SHA1));
153
	cl_assert(!git_odb_exists(odb, &id));
154

155
	cl_git_pass(git_oid__fromstrp(&id, "8b13789a", GIT_OID_SHA1));
156
	cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(&id2, odb, &id, 8));
157 158 159 160

	git_odb_free(odb);
}

161 162
void test_odb_loose__exists_sha256(void)
{
163 164 165
#ifndef GIT_EXPERIMENTAL_SHA256
	cl_skip();
#else
166 167 168 169 170 171 172
	git_oid id, id2;
	git_odb *odb;
	git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;

	odb_opts.oid_type = GIT_OID_SHA256;

	write_object_files(&one_sha256);
173
	cl_git_pass(git_odb__open(&odb, "test-objects", &odb_opts));
174

175
	cl_git_pass(git_oid__fromstr(&id, one_sha256.id, GIT_OID_SHA256));
176 177
	cl_assert(git_odb_exists(odb, &id));

178
	cl_git_pass(git_oid__fromstrp(&id, "4c0d52d1", GIT_OID_SHA256));
179 180 181 182
	cl_git_pass(git_odb_exists_prefix(&id2, odb, &id, 8));
	cl_assert_equal_i(0, git_oid_streq(&id2, one_sha256.id));

	/* Test for a missing object */
183
	cl_git_pass(git_oid__fromstr(&id, "4c0d52d180c61d01ce1a91dec5ee58f0cbe65fd59433aea803ab927965493faa", GIT_OID_SHA256));
184 185
	cl_assert(!git_odb_exists(odb, &id));

186
	cl_git_pass(git_oid__fromstrp(&id, "4c0d52da", GIT_OID_SHA256));
187 188 189
	cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(&id2, odb, &id, 8));

	git_odb_free(odb);
190
#endif
191 192 193
}

void test_odb_loose__simple_reads_sha1(void)
194 195 196 197 198 199 200 201 202
{
	test_read_object(&commit);
	test_read_object(&tree);
	test_read_object(&tag);
	test_read_object(&zero);
	test_read_object(&one);
	test_read_object(&two);
	test_read_object(&some);
}
203

204 205
void test_odb_loose__simple_reads_sha256(void)
{
206 207 208
#ifndef GIT_EXPERIMENTAL_SHA256
	cl_skip();
#else
209 210 211 212 213 214 215
	test_read_object(&commit_sha256);
	test_read_object(&tree_sha256);
	test_read_object(&tag_sha256);
	test_read_object(&zero_sha256);
	test_read_object(&one_sha256);
	test_read_object(&two_sha256);
	test_read_object(&some_sha256);
216
#endif
217 218 219
}

void test_odb_loose__streaming_reads_sha1(void)
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
{
	size_t blocksizes[] = { 1, 2, 4, 16, 99, 1024, 123456789 };
	size_t i;

	for (i = 0; i < ARRAY_SIZE(blocksizes); i++) {
		test_readstream_object(&commit, blocksizes[i]);
		test_readstream_object(&tree, blocksizes[i]);
		test_readstream_object(&tag, blocksizes[i]);
		test_readstream_object(&zero, blocksizes[i]);
		test_readstream_object(&one, blocksizes[i]);
		test_readstream_object(&two, blocksizes[i]);
		test_readstream_object(&some, blocksizes[i]);
	}
}

235 236
void test_odb_loose__streaming_reads_sha256(void)
{
237 238 239
#ifndef GIT_EXPERIMENTAL_SHA256
	cl_skip();
#else
240 241 242 243 244 245 246 247 248 249 250 251
	size_t blocksizes[] = { 1, 2, 4, 16, 99, 1024, 123456789 };
	size_t i;

	for (i = 0; i < ARRAY_SIZE(blocksizes); i++) {
		test_readstream_object(&commit_sha256, blocksizes[i]);
		test_readstream_object(&tree_sha256, blocksizes[i]);
		test_readstream_object(&tag_sha256, blocksizes[i]);
		test_readstream_object(&zero_sha256, blocksizes[i]);
		test_readstream_object(&one_sha256, blocksizes[i]);
		test_readstream_object(&two_sha256, blocksizes[i]);
		test_readstream_object(&some_sha256, blocksizes[i]);
	}
252
#endif
253 254 255
}

void test_odb_loose__read_header_sha1(void)
256 257 258 259 260 261 262 263 264 265
{
	test_read_header(&commit);
	test_read_header(&tree);
	test_read_header(&tag);
	test_read_header(&zero);
	test_read_header(&one);
	test_read_header(&two);
	test_read_header(&some);
}

266 267
void test_odb_loose__read_header_sha256(void)
{
268 269 270
#ifndef GIT_EXPERIMENTAL_SHA256
	cl_skip();
#else
271 272 273 274 275 276 277
	test_read_header(&commit_sha256);
	test_read_header(&tree_sha256);
	test_read_header(&tag_sha256);
	test_read_header(&zero_sha256);
	test_read_header(&one_sha256);
	test_read_header(&two_sha256);
	test_read_header(&some_sha256);
278
#endif
279 280
}

281
static void test_write_object_permission(
282 283 284 285 286 287 288 289
	mode_t dir_mode, mode_t file_mode,
	mode_t expected_dir_mode, mode_t expected_file_mode)
{
	git_odb *odb;
	git_odb_backend *backend;
	git_oid oid;
	struct stat statbuf;
	mode_t mask, os_mask;
290
	git_odb_backend_loose_options opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT;
291 292 293 294 295 296 297 298 299 300 301 302 303

	/* Windows does not return group/user bits from stat,
	* files are never executable.
	*/
#ifdef GIT_WIN32
	os_mask = 0600;
#else
	os_mask = 0777;
#endif

	mask = p_umask(0);
	p_umask(mask);

304 305 306
	opts.dir_mode = dir_mode;
	opts.file_mode = file_mode;

307 308
	cl_git_pass(git_odb__new(&odb, NULL));
	cl_git_pass(git_odb__backend_loose(&backend, "test-objects", &opts));
309
	cl_git_pass(git_odb_add_backend(odb, backend, 1));
310
	cl_git_pass(git_odb_write(&oid, odb, "Test data\n", 10, GIT_OBJECT_BLOB));
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325

	cl_git_pass(p_stat("test-objects/67", &statbuf));
	cl_assert_equal_i(statbuf.st_mode & os_mask, (expected_dir_mode & ~mask) & os_mask);

	cl_git_pass(p_stat("test-objects/67/b808feb36201507a77f85e6d898f0a2836e4a5", &statbuf));
	cl_assert_equal_i(statbuf.st_mode & os_mask, (expected_file_mode & ~mask) & os_mask);

	git_odb_free(odb);
}

void test_odb_loose__permissions_standard(void)
{
	test_write_object_permission(0, 0, GIT_OBJECT_DIR_MODE, GIT_OBJECT_FILE_MODE);
}

326
void test_odb_loose__permissions_readonly(void)
327 328 329 330 331 332 333 334
{
	test_write_object_permission(0777, 0444, 0777, 0444);
}

void test_odb_loose__permissions_readwrite(void)
{
	test_write_object_permission(0777, 0666, 0777, 0666);
}
335 336 337 338 339 340

static void write_object_to_loose_odb(int fsync)
{
	git_odb *odb;
	git_odb_backend *backend;
	git_oid oid;
341 342 343 344 345 346 347
	git_odb_backend_loose_options opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT;

	if (fsync)
		opts.flags |= GIT_ODB_BACKEND_LOOSE_FSYNC;

	opts.dir_mode = 0777;
	opts.file_mode = 0666;
348

349 350
	cl_git_pass(git_odb__new(&odb, NULL));
	cl_git_pass(git_odb__backend_loose(&backend, "test-objects", &opts));
351
	cl_git_pass(git_odb_add_backend(odb, backend, 1));
352
	cl_git_pass(git_odb_write(&oid, odb, "Test data\n", 10, GIT_OBJECT_BLOB));
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
	git_odb_free(odb);
}

void test_odb_loose__does_not_fsync_by_default(void)
{
	write_object_to_loose_odb(0);
	cl_assert_equal_sz(0, p_fsync__cnt);
}

void test_odb_loose__fsync_obeys_odb_option(void)
{
	write_object_to_loose_odb(1);
	cl_assert(p_fsync__cnt > 0);
}

void test_odb_loose__fsync_obeys_global_setting(void)
{
370
	cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_FSYNC_GITDIR, 1));
371 372 373
	write_object_to_loose_odb(0);
	cl_assert(p_fsync__cnt > 0);
}
374 375 376 377 378 379 380 381 382

void test_odb_loose__fsync_obeys_repo_setting(void)
{
	git_repository *repo;
	git_odb *odb;
	git_oid oid;

	cl_git_pass(git_repository_init(&repo, "test-objects", 1));
	cl_git_pass(git_repository_odb__weakptr(&odb, repo));
383
	cl_git_pass(git_odb_write(&oid, odb, "No fsync here\n", 14, GIT_OBJECT_BLOB));
384 385 386 387 388 389
	cl_assert(p_fsync__cnt == 0);
	git_repository_free(repo);

	cl_git_pass(git_repository_open(&repo, "test-objects"));
	cl_repo_set_bool(repo, "core.fsyncObjectFiles", true);
	cl_git_pass(git_repository_odb__weakptr(&odb, repo));
390
	cl_git_pass(git_odb_write(&oid, odb, "Now fsync\n", 10, GIT_OBJECT_BLOB));
391 392 393
	cl_assert(p_fsync__cnt > 0);
	git_repository_free(repo);
}