]> git.ipfire.org Git - thirdparty/git.git/blame - reftable/stack_test.c
projects / thirdparty / git.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
reftable/stack: expose option to disable auto-compaction
[thirdparty/git.git] / reftable / stack_test.c
CommitLineData
e48d4272
HWN		 1/*
2Copyright 2020 Google LLC
3
4Use of this source code is governed by a BSD-style
5license that can be found in the LICENSE file or at
6https://developers.google.com/open-source/licenses/bsd
7*/
8
9#include "stack.h"
10
11#include "system.h"
12
13#include "reftable-reader.h"
14#include "merged.h"
15#include "basics.h"
e48d4272
HWN		 16#include "record.h"
17#include "test_framework.h"
18#include "reftable-tests.h"
cd1799de 19#include "reader.h"
e48d4272
HWN		 20
21#include <sys/types.h>
22#include <dirent.h>
23
24static void clear_dir(const char *dirname)
25{
26 struct strbuf path = STRBUF_INIT;
27 strbuf_addstr(&path, dirname);
28 remove_dir_recursively(&path, 0);
29 strbuf_release(&path);
30}
31
32static int count_dir_entries(const char *dirname)
33{
34 DIR *dir = opendir(dirname);
35 int len = 0;
36 struct dirent *d;
72a4ea71 37 if (!dir)
e48d4272
HWN		 38 return 0;
39
40 while ((d = readdir(dir))) {
41 if (!strcmp(d->d_name, "..") || !strcmp(d->d_name, "."))
42 continue;
43 len++;
44 }
45 closedir(dir);
46 return len;
47}
48
49/*
50 * Work linenumber into the tempdir, so we can see which tests forget to
51 * cleanup.
52 */
53static char *get_tmp_template(int linenumber)
54{
55 const char *tmp = getenv("TMPDIR");
56 static char template[1024];
57 snprintf(template, sizeof(template) - 1, "%s/stack_test-%d.XXXXXX",
58 tmp ? tmp : "/tmp", linenumber);
59 return template;
60}
61
62static char *get_tmp_dir(int linenumber)
63{
64 char *dir = get_tmp_template(linenumber);
65 EXPECT(mkdtemp(dir));
66 return dir;
67}
68
69static void test_read_file(void)
70{
71 char *fn = get_tmp_template(__LINE__);
72 int fd = mkstemp(fn);
73 char out[1024] = "line1\n\nline2\nline3";
74 int n, err;
75 char **names = NULL;
76 char *want[] = { "line1", "line2", "line3" };
77 int i = 0;
78
79 EXPECT(fd > 0);
85a8c899 80 n = write_in_full(fd, out, strlen(out));
e48d4272
HWN		 81 EXPECT(n == strlen(out));
82 err = close(fd);
83 EXPECT(err >= 0);
84
85 err = read_lines(fn, &names);
86 EXPECT_ERR(err);
87
88 for (i = 0; names[i]; i++) {
89 EXPECT(0 == strcmp(want[i], names[i]));
90 }
91 free_names(names);
f5f6a6cd 92 (void) remove(fn);
e48d4272
HWN		 93}
94
95static void test_parse_names(void)
96{
97 char buf[] = "line\n";
98 char **names = NULL;
99 parse_names(buf, strlen(buf), &names);
100
101 EXPECT(NULL != names[0]);
102 EXPECT(0 == strcmp(names[0], "line"));
103 EXPECT(NULL == names[1]);
104 free_names(names);
105}
106
107static void test_names_equal(void)
108{
109 char *a[] = { "a", "b", "c", NULL };
110 char *b[] = { "a", "b", "d", NULL };
111 char *c[] = { "a", "b", NULL };
112
113 EXPECT(names_equal(a, a));
114 EXPECT(!names_equal(a, b));
115 EXPECT(!names_equal(a, c));
116}
117
118static int write_test_ref(struct reftable_writer *wr, void *arg)
119{
120 struct reftable_ref_record *ref = arg;
121 reftable_writer_set_limits(wr, ref->update_index, ref->update_index);
122 return reftable_writer_add_ref(wr, ref);
123}
124
125struct write_log_arg {
126 struct reftable_log_record *log;
127 uint64_t update_index;
128};
129
130static int write_test_log(struct reftable_writer *wr, void *arg)
131{
132 struct write_log_arg *wla = arg;
133
134 reftable_writer_set_limits(wr, wla->update_index, wla->update_index);
135 return reftable_writer_add_log(wr, wla->log);
136}
137
138static void test_reftable_stack_add_one(void)
139{
140 char *dir = get_tmp_dir(__LINE__);
cd1799de
HWN		 141 struct strbuf scratch = STRBUF_INIT;
142 int mask = umask(002);
143 struct reftable_write_options cfg = {
144 .default_permissions = 0660,
145 };
e48d4272
HWN		 146 struct reftable_stack *st = NULL;
147 int err;
148 struct reftable_ref_record ref = {
149 .refname = "HEAD",
150 .update_index = 1,
151 .value_type = REFTABLE_REF_SYMREF,
152 .value.symref = "master",
153 };
154 struct reftable_ref_record dest = { NULL };
cd1799de 155 struct stat stat_result = { 0 };
e48d4272
HWN		 156 err = reftable_new_stack(&st, dir, cfg);
157 EXPECT_ERR(err);
158
159 err = reftable_stack_add(st, &write_test_ref, &ref);
160 EXPECT_ERR(err);
161
162 err = reftable_stack_read_ref(st, ref.refname, &dest);
163 EXPECT_ERR(err);
164 EXPECT(0 == strcmp("master", dest.value.symref));
cd1799de 165 EXPECT(st->readers_len > 0);
e48d4272
HWN		 166
167 printf("testing print functionality:\n");
168 err = reftable_stack_print_directory(dir, GIT_SHA1_FORMAT_ID);
169 EXPECT_ERR(err);
170
171 err = reftable_stack_print_directory(dir, GIT_SHA256_FORMAT_ID);
172 EXPECT(err == REFTABLE_FORMAT_ERROR);
173
cd1799de
HWN		 174#ifndef GIT_WINDOWS_NATIVE
175 strbuf_addstr(&scratch, dir);
176 strbuf_addstr(&scratch, "/tables.list");
177 err = stat(scratch.buf, &stat_result);
178 EXPECT(!err);
179 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
180
181 strbuf_reset(&scratch);
182 strbuf_addstr(&scratch, dir);
183 strbuf_addstr(&scratch, "/");
184 /* do not try at home; not an external API for reftable. */
185 strbuf_addstr(&scratch, st->readers[0]->name);
186 err = stat(scratch.buf, &stat_result);
187 EXPECT(!err);
188 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
189#else
190 (void) stat_result;
191#endif
192
e48d4272
HWN		 193 reftable_ref_record_release(&dest);
194 reftable_stack_destroy(st);
cd1799de 195 strbuf_release(&scratch);
e48d4272 196 clear_dir(dir);
cd1799de 197 umask(mask);
e48d4272
HWN		 198}
199
200static void test_reftable_stack_uptodate(void)
201{
202 struct reftable_write_options cfg = { 0 };
203 struct reftable_stack *st1 = NULL;
204 struct reftable_stack *st2 = NULL;
205 char *dir = get_tmp_dir(__LINE__);
206
207 int err;
208 struct reftable_ref_record ref1 = {
209 .refname = "HEAD",
210 .update_index = 1,
211 .value_type = REFTABLE_REF_SYMREF,
212 .value.symref = "master",
213 };
214 struct reftable_ref_record ref2 = {
215 .refname = "branch2",
216 .update_index = 2,
217 .value_type = REFTABLE_REF_SYMREF,
218 .value.symref = "master",
219 };
220
221
222 /* simulate multi-process access to the same stack
223 by creating two stacks for the same directory.
224 */
225 err = reftable_new_stack(&st1, dir, cfg);
226 EXPECT_ERR(err);
227
228 err = reftable_new_stack(&st2, dir, cfg);
229 EXPECT_ERR(err);
230
231 err = reftable_stack_add(st1, &write_test_ref, &ref1);
232 EXPECT_ERR(err);
233
234 err = reftable_stack_add(st2, &write_test_ref, &ref2);
af18098c 235 EXPECT(err == REFTABLE_OUTDATED_ERROR);
e48d4272
HWN		 236
237 err = reftable_stack_reload(st2);
238 EXPECT_ERR(err);
239
240 err = reftable_stack_add(st2, &write_test_ref, &ref2);
241 EXPECT_ERR(err);
242 reftable_stack_destroy(st1);
243 reftable_stack_destroy(st2);
244 clear_dir(dir);
245}
246
247static void test_reftable_stack_transaction_api(void)
248{
249 char *dir = get_tmp_dir(__LINE__);
250
251 struct reftable_write_options cfg = { 0 };
252 struct reftable_stack *st = NULL;
253 int err;
254 struct reftable_addition *add = NULL;
255
256 struct reftable_ref_record ref = {
257 .refname = "HEAD",
258 .update_index = 1,
259 .value_type = REFTABLE_REF_SYMREF,
260 .value.symref = "master",
261 };
262 struct reftable_ref_record dest = { NULL };
263
264
265 err = reftable_new_stack(&st, dir, cfg);
266 EXPECT_ERR(err);
267
268 reftable_addition_destroy(add);
269
270 err = reftable_stack_new_addition(&add, st);
271 EXPECT_ERR(err);
272
273 err = reftable_addition_add(add, &write_test_ref, &ref);
274 EXPECT_ERR(err);
275
276 err = reftable_addition_commit(add);
277 EXPECT_ERR(err);
278
279 reftable_addition_destroy(add);
280
281 err = reftable_stack_read_ref(st, ref.refname, &dest);
282 EXPECT_ERR(err);
283 EXPECT(REFTABLE_REF_SYMREF == dest.value_type);
284 EXPECT(0 == strcmp("master", dest.value.symref));
285
286 reftable_ref_record_release(&dest);
287 reftable_stack_destroy(st);
288 clear_dir(dir);
289}
290
5c086453
PS		 291static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
292{
293 char *dir = get_tmp_dir(__LINE__);
294 struct reftable_write_options cfg = {0};
295 struct reftable_addition *add = NULL;
296 struct reftable_stack *st = NULL;
297 int i, n = 20, err;
298
299 err = reftable_new_stack(&st, dir, cfg);
300 EXPECT_ERR(err);
301
302 for (i = 0; i <= n; i++) {
303 struct reftable_ref_record ref = {
304 .update_index = reftable_stack_next_update_index(st),
305 .value_type = REFTABLE_REF_SYMREF,
306 .value.symref = "master",
307 };
308 char name[100];
309
310 snprintf(name, sizeof(name), "branch%04d", i);
311 ref.refname = name;
312
313 /*
314 * Disable auto-compaction for all but the last runs. Like this
315 * we can ensure that we indeed honor this setting and have
316 * better control over when exactly auto compaction runs.
317 */
bc91330c 318 st->config.disable_auto_compact = i != n;
5c086453
PS		 319
320 err = reftable_stack_new_addition(&add, st);
321 EXPECT_ERR(err);
322
323 err = reftable_addition_add(add, &write_test_ref, &ref);
324 EXPECT_ERR(err);
325
326 err = reftable_addition_commit(add);
327 EXPECT_ERR(err);
328
329 reftable_addition_destroy(add);
330
331 /*
332 * The stack length should grow continuously for all runs where
333 * auto compaction is disabled. When enabled, we should merge
334 * all tables in the stack.
335 */
336 if (i != n)
337 EXPECT(st->merged->stack_len == i + 1);
338 else
339 EXPECT(st->merged->stack_len == 1);
340 }
341
342 reftable_stack_destroy(st);
343 clear_dir(dir);
344}
345
a2f711ad
PS		 346static void test_reftable_stack_auto_compaction_fails_gracefully(void)
347{
348 struct reftable_ref_record ref = {
349 .refname = "refs/heads/master",
350 .update_index = 1,
351 .value_type = REFTABLE_REF_VAL1,
352 .value.val1 = {0x01},
353 };
354 struct reftable_write_options cfg = {0};
355 struct reftable_stack *st;
356 struct strbuf table_path = STRBUF_INIT;
357 char *dir = get_tmp_dir(__LINE__);
358 int err;
359
360 err = reftable_new_stack(&st, dir, cfg);
361 EXPECT_ERR(err);
362
363 err = reftable_stack_add(st, write_test_ref, &ref);
364 EXPECT_ERR(err);
365 EXPECT(st->merged->stack_len == 1);
366 EXPECT(st->stats.attempts == 0);
367 EXPECT(st->stats.failures == 0);
368
369 /*
370 * Lock the newly written table such that it cannot be compacted.
371 * Adding a new table to the stack should not be impacted by this, even
372 * though auto-compaction will now fail.
373 */
374 strbuf_addf(&table_path, "%s/%s.lock", dir, st->readers[0]->name);
375 write_file_buf(table_path.buf, "", 0);
376
377 ref.update_index = 2;
378 err = reftable_stack_add(st, write_test_ref, &ref);
379 EXPECT_ERR(err);
380 EXPECT(st->merged->stack_len == 2);
381 EXPECT(st->stats.attempts == 1);
382 EXPECT(st->stats.failures == 1);
383
384 reftable_stack_destroy(st);
385 strbuf_release(&table_path);
386 clear_dir(dir);
387}
388
e48d4272
HWN		 389static void test_reftable_stack_validate_refname(void)
390{
391 struct reftable_write_options cfg = { 0 };
392 struct reftable_stack *st = NULL;
393 int err;
394 char *dir = get_tmp_dir(__LINE__);
395
396 int i;
397 struct reftable_ref_record ref = {
398 .refname = "a/b",
399 .update_index = 1,
400 .value_type = REFTABLE_REF_SYMREF,
401 .value.symref = "master",
402 };
403 char *additions[] = { "a", "a/b/c" };
404
405 err = reftable_new_stack(&st, dir, cfg);
406 EXPECT_ERR(err);
407
408 err = reftable_stack_add(st, &write_test_ref, &ref);
409 EXPECT_ERR(err);
410
411 for (i = 0; i < ARRAY_SIZE(additions); i++) {
412 struct reftable_ref_record ref = {
413 .refname = additions[i],
414 .update_index = 1,
415 .value_type = REFTABLE_REF_SYMREF,
416 .value.symref = "master",
417 };
418
419 err = reftable_stack_add(st, &write_test_ref, &ref);
420 EXPECT(err == REFTABLE_NAME_CONFLICT);
421 }
422
423 reftable_stack_destroy(st);
424 clear_dir(dir);
425}
426
427static int write_error(struct reftable_writer *wr, void *arg)
428{
429 return *((int *)arg);
430}
431
432static void test_reftable_stack_update_index_check(void)
433{
434 char *dir = get_tmp_dir(__LINE__);
435
436 struct reftable_write_options cfg = { 0 };
437 struct reftable_stack *st = NULL;
438 int err;
439 struct reftable_ref_record ref1 = {
440 .refname = "name1",
441 .update_index = 1,
442 .value_type = REFTABLE_REF_SYMREF,
443 .value.symref = "master",
444 };
445 struct reftable_ref_record ref2 = {
446 .refname = "name2",
447 .update_index = 1,
448 .value_type = REFTABLE_REF_SYMREF,
449 .value.symref = "master",
450 };
451
452 err = reftable_new_stack(&st, dir, cfg);
453 EXPECT_ERR(err);
454
455 err = reftable_stack_add(st, &write_test_ref, &ref1);
456 EXPECT_ERR(err);
457
458 err = reftable_stack_add(st, &write_test_ref, &ref2);
459 EXPECT(err == REFTABLE_API_ERROR);
460 reftable_stack_destroy(st);
461 clear_dir(dir);
462}
463
464static void test_reftable_stack_lock_failure(void)
465{
466 char *dir = get_tmp_dir(__LINE__);
467
468 struct reftable_write_options cfg = { 0 };
469 struct reftable_stack *st = NULL;
470 int err, i;
471
472 err = reftable_new_stack(&st, dir, cfg);
473 EXPECT_ERR(err);
474 for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
475 err = reftable_stack_add(st, &write_error, &i);
476 EXPECT(err == i);
477 }
478
479 reftable_stack_destroy(st);
480 clear_dir(dir);
481}
482
483static void test_reftable_stack_add(void)
484{
485 int i = 0;
486 int err = 0;
487 struct reftable_write_options cfg = {
488 .exact_log_message = 1,
b3a79dd4 489 .default_permissions = 0660,
bc91330c 490 .disable_auto_compact = 1,
e48d4272
HWN		 491 };
492 struct reftable_stack *st = NULL;
493 char *dir = get_tmp_dir(__LINE__);
e48d4272
HWN		 494 struct reftable_ref_record refs[2] = { { NULL } };
495 struct reftable_log_record logs[2] = { { NULL } };
b3a79dd4
PS		 496 struct strbuf path = STRBUF_INIT;
497 struct stat stat_result;
e48d4272
HWN		 498 int N = ARRAY_SIZE(refs);
499
e48d4272
HWN		 500 err = reftable_new_stack(&st, dir, cfg);
501 EXPECT_ERR(err);
e48d4272
HWN		 502
503 for (i = 0; i < N; i++) {
504 char buf[256];
505 snprintf(buf, sizeof(buf), "branch%02d", i);
506 refs[i].refname = xstrdup(buf);
507 refs[i].update_index = i + 1;
508 refs[i].value_type = REFTABLE_REF_VAL1;
e48d4272
HWN		 509 set_test_hash(refs[i].value.val1, i);
510
511 logs[i].refname = xstrdup(buf);
512 logs[i].update_index = N + i + 1;
513 logs[i].value_type = REFTABLE_LOG_UPDATE;
e48d4272
HWN		 514 logs[i].value.update.email = xstrdup("identity@invalid");
515 set_test_hash(logs[i].value.update.new_hash, i);
516 }
517
518 for (i = 0; i < N; i++) {
519 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
520 EXPECT_ERR(err);
521 }
522
523 for (i = 0; i < N; i++) {
524 struct write_log_arg arg = {
525 .log = &logs[i],
526 .update_index = reftable_stack_next_update_index(st),
527 };
528 int err = reftable_stack_add(st, &write_test_log, &arg);
529 EXPECT_ERR(err);
530 }
531
532 err = reftable_stack_compact_all(st, NULL);
533 EXPECT_ERR(err);
534
535 for (i = 0; i < N; i++) {
536 struct reftable_ref_record dest = { NULL };
537
538 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
539 EXPECT_ERR(err);
540 EXPECT(reftable_ref_record_equal(&dest, refs + i,
541 GIT_SHA1_RAWSZ));
542 reftable_ref_record_release(&dest);
543 }
544
545 for (i = 0; i < N; i++) {
546 struct reftable_log_record dest = { NULL };
547 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
548 EXPECT_ERR(err);
549 EXPECT(reftable_log_record_equal(&dest, logs + i,
550 GIT_SHA1_RAWSZ));
551 reftable_log_record_release(&dest);
552 }
553
b3a79dd4
PS		 554#ifndef GIT_WINDOWS_NATIVE
555 strbuf_addstr(&path, dir);
556 strbuf_addstr(&path, "/tables.list");
557 err = stat(path.buf, &stat_result);
558 EXPECT(!err);
559 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
560
561 strbuf_reset(&path);
562 strbuf_addstr(&path, dir);
563 strbuf_addstr(&path, "/");
564 /* do not try at home; not an external API for reftable. */
565 strbuf_addstr(&path, st->readers[0]->name);
566 err = stat(path.buf, &stat_result);
567 EXPECT(!err);
568 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
569#else
570 (void) stat_result;
571#endif
572
e48d4272
HWN		 573 /* cleanup */
574 reftable_stack_destroy(st);
575 for (i = 0; i < N; i++) {
576 reftable_ref_record_release(&refs[i]);
577 reftable_log_record_release(&logs[i]);
578 }
b3a79dd4 579 strbuf_release(&path);
e48d4272
HWN		 580 clear_dir(dir);
581}
582
583static void test_reftable_stack_log_normalize(void)
584{
585 int err = 0;
586 struct reftable_write_options cfg = {
587 0,
588 };
589 struct reftable_stack *st = NULL;
590 char *dir = get_tmp_dir(__LINE__);
87ff7230
PS		 591 struct reftable_log_record input = {
592 .refname = "branch",
593 .update_index = 1,
594 .value_type = REFTABLE_LOG_UPDATE,
595 .value = {
596 .update = {
597 .new_hash = { 1 },
598 .old_hash = { 2 },
599 },
600 },
601 };
e48d4272
HWN		 602 struct reftable_log_record dest = {
603 .update_index = 0,
604 };
605 struct write_log_arg arg = {
606 .log = &input,
607 .update_index = 1,
608 };
609
610 err = reftable_new_stack(&st, dir, cfg);
611 EXPECT_ERR(err);
612
613 input.value.update.message = "one\ntwo";
614 err = reftable_stack_add(st, &write_test_log, &arg);
615 EXPECT(err == REFTABLE_API_ERROR);
616
617 input.value.update.message = "one";
618 err = reftable_stack_add(st, &write_test_log, &arg);
619 EXPECT_ERR(err);
620
621 err = reftable_stack_read_log(st, input.refname, &dest);
622 EXPECT_ERR(err);
623 EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
624
625 input.value.update.message = "two\n";
626 arg.update_index = 2;
627 err = reftable_stack_add(st, &write_test_log, &arg);
628 EXPECT_ERR(err);
629 err = reftable_stack_read_log(st, input.refname, &dest);
630 EXPECT_ERR(err);
631 EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
632
633 /* cleanup */
634 reftable_stack_destroy(st);
635 reftable_log_record_release(&dest);
636 clear_dir(dir);
637}
638
639static void test_reftable_stack_tombstone(void)
640{
641 int i = 0;
642 char *dir = get_tmp_dir(__LINE__);
643
644 struct reftable_write_options cfg = { 0 };
645 struct reftable_stack *st = NULL;
646 int err;
647 struct reftable_ref_record refs[2] = { { NULL } };
648 struct reftable_log_record logs[2] = { { NULL } };
649 int N = ARRAY_SIZE(refs);
650 struct reftable_ref_record dest = { NULL };
651 struct reftable_log_record log_dest = { NULL };
652
653
654 err = reftable_new_stack(&st, dir, cfg);
655 EXPECT_ERR(err);
656
657 /* even entries add the refs, odd entries delete them. */
658 for (i = 0; i < N; i++) {
659 const char *buf = "branch";
660 refs[i].refname = xstrdup(buf);
661 refs[i].update_index = i + 1;
662 if (i % 2 == 0) {
663 refs[i].value_type = REFTABLE_REF_VAL1;
e48d4272
HWN		 664 set_test_hash(refs[i].value.val1, i);
665 }
666
667 logs[i].refname = xstrdup(buf);
668 /* update_index is part of the key. */
669 logs[i].update_index = 42;
670 if (i % 2 == 0) {
671 logs[i].value_type = REFTABLE_LOG_UPDATE;
e48d4272
HWN		 672 set_test_hash(logs[i].value.update.new_hash, i);
673 logs[i].value.update.email =
674 xstrdup("identity@invalid");
675 }
676 }
677 for (i = 0; i < N; i++) {
678 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
679 EXPECT_ERR(err);
680 }
681
682 for (i = 0; i < N; i++) {
683 struct write_log_arg arg = {
684 .log = &logs[i],
685 .update_index = reftable_stack_next_update_index(st),
686 };
687 int err = reftable_stack_add(st, &write_test_log, &arg);
688 EXPECT_ERR(err);
689 }
690
691 err = reftable_stack_read_ref(st, "branch", &dest);
692 EXPECT(err == 1);
693 reftable_ref_record_release(&dest);
694
695 err = reftable_stack_read_log(st, "branch", &log_dest);
696 EXPECT(err == 1);
697 reftable_log_record_release(&log_dest);
698
699 err = reftable_stack_compact_all(st, NULL);
700 EXPECT_ERR(err);
701
702 err = reftable_stack_read_ref(st, "branch", &dest);
703 EXPECT(err == 1);
704
705 err = reftable_stack_read_log(st, "branch", &log_dest);
706 EXPECT(err == 1);
707 reftable_ref_record_release(&dest);
708 reftable_log_record_release(&log_dest);
709
710 /* cleanup */
711 reftable_stack_destroy(st);
712 for (i = 0; i < N; i++) {
713 reftable_ref_record_release(&refs[i]);
714 reftable_log_record_release(&logs[i]);
715 }
716 clear_dir(dir);
717}
718
719static void test_reftable_stack_hash_id(void)
720{
721 char *dir = get_tmp_dir(__LINE__);
722
723 struct reftable_write_options cfg = { 0 };
724 struct reftable_stack *st = NULL;
725 int err;
726
727 struct reftable_ref_record ref = {
728 .refname = "master",
729 .value_type = REFTABLE_REF_SYMREF,
730 .value.symref = "target",
731 .update_index = 1,
732 };
733 struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
734 struct reftable_stack *st32 = NULL;
735 struct reftable_write_options cfg_default = { 0 };
736 struct reftable_stack *st_default = NULL;
737 struct reftable_ref_record dest = { NULL };
738
739 err = reftable_new_stack(&st, dir, cfg);
740 EXPECT_ERR(err);
741
742 err = reftable_stack_add(st, &write_test_ref, &ref);
743 EXPECT_ERR(err);
744
745 /* can't read it with the wrong hash ID. */
746 err = reftable_new_stack(&st32, dir, cfg32);
747 EXPECT(err == REFTABLE_FORMAT_ERROR);
748
749 /* check that we can read it back with default config too. */
750 err = reftable_new_stack(&st_default, dir, cfg_default);
751 EXPECT_ERR(err);
752
753 err = reftable_stack_read_ref(st_default, "master", &dest);
754 EXPECT_ERR(err);
755
756 EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
757 reftable_ref_record_release(&dest);
758 reftable_stack_destroy(st);
759 reftable_stack_destroy(st_default);
760 clear_dir(dir);
761}
762
763static void test_log2(void)
764{
765 EXPECT(1 == fastlog2(3));
766 EXPECT(2 == fastlog2(4));
767 EXPECT(2 == fastlog2(5));
768}
769
770static void test_sizes_to_segments(void)
771{
772 uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
773 /* .................0 1 2 3 4 5 */
774
6d5e80fb 775 size_t seglen = 0;
e48d4272
HWN		 776 struct segment *segs =
777 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
778 EXPECT(segs[2].log == 3);
779 EXPECT(segs[2].start == 5);
780 EXPECT(segs[2].end == 6);
781
782 EXPECT(segs[1].log == 2);
783 EXPECT(segs[1].start == 2);
784 EXPECT(segs[1].end == 5);
785 reftable_free(segs);
786}
787
788static void test_sizes_to_segments_empty(void)
789{
6d5e80fb 790 size_t seglen = 0;
e48d4272
HWN		 791 struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
792 EXPECT(seglen == 0);
793 reftable_free(segs);
794}
795
796static void test_sizes_to_segments_all_equal(void)
797{
798 uint64_t sizes[] = { 5, 5 };
6d5e80fb 799 size_t seglen = 0;
e48d4272
HWN		 800 struct segment *segs =
801 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
802 EXPECT(seglen == 1);
803 EXPECT(segs[0].start == 0);
804 EXPECT(segs[0].end == 2);
805 reftable_free(segs);
806}
807
808static void test_suggest_compaction_segment(void)
809{
810 uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
811 /* .................0 1 2 3 4 5 6 */
812 struct segment min =
813 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
814 EXPECT(min.start == 2);
815 EXPECT(min.end == 7);
816}
817
818static void test_suggest_compaction_segment_nothing(void)
819{
820 uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
821 struct segment result =
822 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
823 EXPECT(result.start == result.end);
824}
825
826static void test_reflog_expire(void)
827{
828 char *dir = get_tmp_dir(__LINE__);
829
830 struct reftable_write_options cfg = { 0 };
831 struct reftable_stack *st = NULL;
832 struct reftable_log_record logs[20] = { { NULL } };
833 int N = ARRAY_SIZE(logs) - 1;
834 int i = 0;
835 int err;
836 struct reftable_log_expiry_config expiry = {
837 .time = 10,
838 };
839 struct reftable_log_record log = { NULL };
840
841
842 err = reftable_new_stack(&st, dir, cfg);
843 EXPECT_ERR(err);
844
845 for (i = 1; i <= N; i++) {
846 char buf[256];
847 snprintf(buf, sizeof(buf), "branch%02d", i);
848
849 logs[i].refname = xstrdup(buf);
850 logs[i].update_index = i;
851 logs[i].value_type = REFTABLE_LOG_UPDATE;
852 logs[i].value.update.time = i;
e48d4272
HWN		 853 logs[i].value.update.email = xstrdup("identity@invalid");
854 set_test_hash(logs[i].value.update.new_hash, i);
855 }
856
857 for (i = 1; i <= N; i++) {
858 struct write_log_arg arg = {
859 .log = &logs[i],
860 .update_index = reftable_stack_next_update_index(st),
861 };
862 int err = reftable_stack_add(st, &write_test_log, &arg);
863 EXPECT_ERR(err);
864 }
865
866 err = reftable_stack_compact_all(st, NULL);
867 EXPECT_ERR(err);
868
869 err = reftable_stack_compact_all(st, &expiry);
870 EXPECT_ERR(err);
871
872 err = reftable_stack_read_log(st, logs[9].refname, &log);
873 EXPECT(err == 1);
874
875 err = reftable_stack_read_log(st, logs[11].refname, &log);
876 EXPECT_ERR(err);
877
878 expiry.min_update_index = 15;
879 err = reftable_stack_compact_all(st, &expiry);
880 EXPECT_ERR(err);
881
882 err = reftable_stack_read_log(st, logs[14].refname, &log);
883 EXPECT(err == 1);
884
885 err = reftable_stack_read_log(st, logs[16].refname, &log);
886 EXPECT_ERR(err);
887
888 /* cleanup */
889 reftable_stack_destroy(st);
890 for (i = 0; i <= N; i++) {
891 reftable_log_record_release(&logs[i]);
892 }
893 clear_dir(dir);
894 reftable_log_record_release(&log);
895}
896
897static int write_nothing(struct reftable_writer *wr, void *arg)
898{
899 reftable_writer_set_limits(wr, 1, 1);
900 return 0;
901}
902
903static void test_empty_add(void)
904{
905 struct reftable_write_options cfg = { 0 };
906 struct reftable_stack *st = NULL;
907 int err;
908 char *dir = get_tmp_dir(__LINE__);
909
910 struct reftable_stack *st2 = NULL;
911
912
913 err = reftable_new_stack(&st, dir, cfg);
914 EXPECT_ERR(err);
915
916 err = reftable_stack_add(st, &write_nothing, NULL);
917 EXPECT_ERR(err);
918
919 err = reftable_new_stack(&st2, dir, cfg);
920 EXPECT_ERR(err);
921 clear_dir(dir);
922 reftable_stack_destroy(st);
923 reftable_stack_destroy(st2);
924}
925
926static void test_reftable_stack_auto_compaction(void)
927{
bc91330c
JT		 928 struct reftable_write_options cfg = {
929 .disable_auto_compact = 1,
930 };
e48d4272
HWN		 931 struct reftable_stack *st = NULL;
932 char *dir = get_tmp_dir(__LINE__);
933
934 int err, i;
935 int N = 100;
936
937 err = reftable_new_stack(&st, dir, cfg);
938 EXPECT_ERR(err);
939
e48d4272
HWN		 940 for (i = 0; i < N; i++) {
941 char name[100];
942 struct reftable_ref_record ref = {
943 .refname = name,
944 .update_index = reftable_stack_next_update_index(st),
945 .value_type = REFTABLE_REF_SYMREF,
946 .value.symref = "master",
947 };
948 snprintf(name, sizeof(name), "branch%04d", i);
949
950 err = reftable_stack_add(st, &write_test_ref, &ref);
951 EXPECT_ERR(err);
952
953 err = reftable_stack_auto_compact(st);
f7445865 954 EXPECT_ERR(err);
e48d4272
HWN		 955 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
956 }
957
958 EXPECT(reftable_stack_compaction_stats(st)->entries_written <
959 (uint64_t)(N * fastlog2(N)));
960
961 reftable_stack_destroy(st);
962 clear_dir(dir);
963}
964
15f98b60
PS		 965static void test_reftable_stack_add_performs_auto_compaction(void)
966{
967 struct reftable_write_options cfg = { 0 };
968 struct reftable_stack *st = NULL;
969 struct strbuf refname = STRBUF_INIT;
970 char *dir = get_tmp_dir(__LINE__);
971 int err, i, n = 20;
972
973 err = reftable_new_stack(&st, dir, cfg);
974 EXPECT_ERR(err);
975
976 for (i = 0; i <= n; i++) {
977 struct reftable_ref_record ref = {
978 .update_index = reftable_stack_next_update_index(st),
979 .value_type = REFTABLE_REF_SYMREF,
980 .value.symref = "master",
981 };
982
983 /*
984 * Disable auto-compaction for all but the last runs. Like this
985 * we can ensure that we indeed honor this setting and have
986 * better control over when exactly auto compaction runs.
987 */
bc91330c 988 st->config.disable_auto_compact = i != n;
15f98b60
PS		 989
990 strbuf_reset(&refname);
991 strbuf_addf(&refname, "branch-%04d", i);
992 ref.refname = refname.buf;
993
994 err = reftable_stack_add(st, &write_test_ref, &ref);
995 EXPECT_ERR(err);
996
997 /*
998 * The stack length should grow continuously for all runs where
999 * auto compaction is disabled. When enabled, we should merge
1000 * all tables in the stack.
1001 */
1002 if (i != n)
1003 EXPECT(st->merged->stack_len == i + 1);
1004 else
1005 EXPECT(st->merged->stack_len == 1);
1006 }
1007
1008 reftable_stack_destroy(st);
1009 strbuf_release(&refname);
1010 clear_dir(dir);
1011}
1012
e48d4272
HWN		 1013static void test_reftable_stack_compaction_concurrent(void)
1014{
1015 struct reftable_write_options cfg = { 0 };
1016 struct reftable_stack *st1 = NULL, *st2 = NULL;
1017 char *dir = get_tmp_dir(__LINE__);
1018
1019 int err, i;
1020 int N = 3;
1021
1022 err = reftable_new_stack(&st1, dir, cfg);
1023 EXPECT_ERR(err);
1024
1025 for (i = 0; i < N; i++) {
1026 char name[100];
1027 struct reftable_ref_record ref = {
1028 .refname = name,
1029 .update_index = reftable_stack_next_update_index(st1),
1030 .value_type = REFTABLE_REF_SYMREF,
1031 .value.symref = "master",
1032 };
1033 snprintf(name, sizeof(name), "branch%04d", i);
1034
1035 err = reftable_stack_add(st1, &write_test_ref, &ref);
1036 EXPECT_ERR(err);
1037 }
1038
1039 err = reftable_new_stack(&st2, dir, cfg);
1040 EXPECT_ERR(err);
1041
1042 err = reftable_stack_compact_all(st1, NULL);
1043 EXPECT_ERR(err);
1044
1045 reftable_stack_destroy(st1);
1046 reftable_stack_destroy(st2);
1047
1048 EXPECT(count_dir_entries(dir) == 2);
1049 clear_dir(dir);
1050}
1051
1052static void unclean_stack_close(struct reftable_stack *st)
1053{
1054 /* break abstraction boundary to simulate unclean shutdown. */
1055 int i = 0;
1056 for (; i < st->readers_len; i++) {
1057 reftable_reader_free(st->readers[i]);
1058 }
1059 st->readers_len = 0;
1060 FREE_AND_NULL(st->readers);
1061}
1062
1063static void test_reftable_stack_compaction_concurrent_clean(void)
1064{
1065 struct reftable_write_options cfg = { 0 };
1066 struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
1067 char *dir = get_tmp_dir(__LINE__);
1068
1069 int err, i;
1070 int N = 3;
1071
1072 err = reftable_new_stack(&st1, dir, cfg);
1073 EXPECT_ERR(err);
1074
1075 for (i = 0; i < N; i++) {
1076 char name[100];
1077 struct reftable_ref_record ref = {
1078 .refname = name,
1079 .update_index = reftable_stack_next_update_index(st1),
1080 .value_type = REFTABLE_REF_SYMREF,
1081 .value.symref = "master",
1082 };
1083 snprintf(name, sizeof(name), "branch%04d", i);
1084
1085 err = reftable_stack_add(st1, &write_test_ref, &ref);
1086 EXPECT_ERR(err);
1087 }
1088
1089 err = reftable_new_stack(&st2, dir, cfg);
1090 EXPECT_ERR(err);
1091
1092 err = reftable_stack_compact_all(st1, NULL);
1093 EXPECT_ERR(err);
1094
1095 unclean_stack_close(st1);
1096 unclean_stack_close(st2);
1097
1098 err = reftable_new_stack(&st3, dir, cfg);
1099 EXPECT_ERR(err);
1100
1101 err = reftable_stack_clean(st3);
1102 EXPECT_ERR(err);
1103 EXPECT(count_dir_entries(dir) == 2);
1104
1105 reftable_stack_destroy(st1);
1106 reftable_stack_destroy(st2);
1107 reftable_stack_destroy(st3);
1108
1109 clear_dir(dir);
1110}
1111
1112int stack_test_main(int argc, const char *argv[])
1113{
1114 RUN_TEST(test_empty_add);
1115 RUN_TEST(test_log2);
1116 RUN_TEST(test_names_equal);
1117 RUN_TEST(test_parse_names);
1118 RUN_TEST(test_read_file);
1119 RUN_TEST(test_reflog_expire);
1120 RUN_TEST(test_reftable_stack_add);
1121 RUN_TEST(test_reftable_stack_add_one);
1122 RUN_TEST(test_reftable_stack_auto_compaction);
15f98b60 1123 RUN_TEST(test_reftable_stack_add_performs_auto_compaction);
e48d4272
HWN		 1124 RUN_TEST(test_reftable_stack_compaction_concurrent);
1125 RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
1126 RUN_TEST(test_reftable_stack_hash_id);
1127 RUN_TEST(test_reftable_stack_lock_failure);
1128 RUN_TEST(test_reftable_stack_log_normalize);
1129 RUN_TEST(test_reftable_stack_tombstone);
1130 RUN_TEST(test_reftable_stack_transaction_api);
5c086453 1131 RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
a2f711ad 1132 RUN_TEST(test_reftable_stack_auto_compaction_fails_gracefully);
e48d4272
HWN		 1133 RUN_TEST(test_reftable_stack_update_index_check);
1134 RUN_TEST(test_reftable_stack_uptodate);
1135 RUN_TEST(test_reftable_stack_validate_refname);
1136 RUN_TEST(test_sizes_to_segments);
1137 RUN_TEST(test_sizes_to_segments_all_equal);
1138 RUN_TEST(test_sizes_to_segments_empty);
1139 RUN_TEST(test_suggest_compaction_segment);
1140 RUN_TEST(test_suggest_compaction_segment_nothing);
1141 return 0;
1142}
Unnamed repository; edit this file 'description' to name the repository.