?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
refs/reftable: print errors on compaction failure
[alt-git.git] / reftable / stack_test.c
blob887f458e5c3b5adba67ea363958740766487d241
1 /*
2 Copyright 2020 Google LLC
3
4 Use of this source code is governed by a BSD-style
5 license that can be found in the LICENSE file or at
6 https://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"
16 #include "record.h"
17 #include "test_framework.h"
18 #include "reftable-tests.h"
19 #include "reader.h"
20
21 #include <sys/types.h>
22 #include <dirent.h>
23
24 static 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
32 static int count_dir_entries(const char *dirname)
33 {
34 DIR *dir = opendir(dirname);
35 int len = 0;
36 struct dirent *d;
37 if (!dir)
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 */
53 static 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
62 static char *get_tmp_dir(int linenumber)
63 {
64 char *dir = get_tmp_template(linenumber);
65 EXPECT(mkdtemp(dir));
66 return dir;
67 }
68
69 static 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);
80 n = write_in_full(fd, out, strlen(out));
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);
92 (void) remove(fn);
93 }
94
95 static 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
107 static 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
118 static 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
125 struct write_log_arg {
126 struct reftable_log_record *log;
127 uint64_t update_index;
128 };
129
130 static 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
138 static void test_reftable_stack_add_one(void)
139 {
140 char *dir = get_tmp_dir(__LINE__);
141 struct strbuf scratch = STRBUF_INIT;
142 int mask = umask(002);
143 struct reftable_write_options cfg = {
144 .default_permissions = 0660,
145 };
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 };
155 struct stat stat_result = { 0 };
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));
165 EXPECT(st->readers_len > 0);
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
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
193 reftable_ref_record_release(&dest);
194 reftable_stack_destroy(st);
195 strbuf_release(&scratch);
196 clear_dir(dir);
197 umask(mask);
198 }
199
200 static 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);
235 EXPECT(err == REFTABLE_OUTDATED_ERROR);
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
247 static 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
291 static 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 */
318 st->disable_auto_compact = i != n;
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
346 static 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
389 static 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
427 static int write_error(struct reftable_writer *wr, void *arg)
428 {
429 return *((int *)arg);
430 }
431
432 static 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
464 static 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
483 static 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,
489 .default_permissions = 0660,
490 };
491 struct reftable_stack *st = NULL;
492 char *dir = get_tmp_dir(__LINE__);
493 struct reftable_ref_record refs[2] = { { NULL } };
494 struct reftable_log_record logs[2] = { { NULL } };
495 struct strbuf path = STRBUF_INIT;
496 struct stat stat_result;
497 int N = ARRAY_SIZE(refs);
498
499 err = reftable_new_stack(&st, dir, cfg);
500 EXPECT_ERR(err);
501 st->disable_auto_compact = 1;
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;
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;
514
515 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
516 logs[i].value.update.email = xstrdup("identity@invalid");
517 set_test_hash(logs[i].value.update.new_hash, i);
518 }
519
520 for (i = 0; i < N; i++) {
521 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
522 EXPECT_ERR(err);
523 }
524
525 for (i = 0; i < N; i++) {
526 struct write_log_arg arg = {
527 .log = &logs[i],
528 .update_index = reftable_stack_next_update_index(st),
529 };
530 int err = reftable_stack_add(st, &write_test_log, &arg);
531 EXPECT_ERR(err);
532 }
533
534 err = reftable_stack_compact_all(st, NULL);
535 EXPECT_ERR(err);
536
537 for (i = 0; i < N; i++) {
538 struct reftable_ref_record dest = { NULL };
539
540 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
541 EXPECT_ERR(err);
542 EXPECT(reftable_ref_record_equal(&dest, refs + i,
543 GIT_SHA1_RAWSZ));
544 reftable_ref_record_release(&dest);
545 }
546
547 for (i = 0; i < N; i++) {
548 struct reftable_log_record dest = { NULL };
549 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
550 EXPECT_ERR(err);
551 EXPECT(reftable_log_record_equal(&dest, logs + i,
552 GIT_SHA1_RAWSZ));
553 reftable_log_record_release(&dest);
554 }
555
556 #ifndef GIT_WINDOWS_NATIVE
557 strbuf_addstr(&path, dir);
558 strbuf_addstr(&path, "/tables.list");
559 err = stat(path.buf, &stat_result);
560 EXPECT(!err);
561 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
562
563 strbuf_reset(&path);
564 strbuf_addstr(&path, dir);
565 strbuf_addstr(&path, "/");
566 /* do not try at home; not an external API for reftable. */
567 strbuf_addstr(&path, st->readers[0]->name);
568 err = stat(path.buf, &stat_result);
569 EXPECT(!err);
570 EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
571 #else
572 (void) stat_result;
573 #endif
574
575 /* cleanup */
576 reftable_stack_destroy(st);
577 for (i = 0; i < N; i++) {
578 reftable_ref_record_release(&refs[i]);
579 reftable_log_record_release(&logs[i]);
580 }
581 strbuf_release(&path);
582 clear_dir(dir);
583 }
584
585 static void test_reftable_stack_log_normalize(void)
586 {
587 int err = 0;
588 struct reftable_write_options cfg = {
589 0,
590 };
591 struct reftable_stack *st = NULL;
592 char *dir = get_tmp_dir(__LINE__);
593
594 uint8_t h1[GIT_SHA1_RAWSZ] = { 0x01 }, h2[GIT_SHA1_RAWSZ] = { 0x02 };
595
596 struct reftable_log_record input = { .refname = "branch",
597 .update_index = 1,
598 .value_type = REFTABLE_LOG_UPDATE,
599 .value = { .update = {
600 .new_hash = h1,
601 .old_hash = h2,
602 } } };
603 struct reftable_log_record dest = {
604 .update_index = 0,
605 };
606 struct write_log_arg arg = {
607 .log = &input,
608 .update_index = 1,
609 };
610
611 err = reftable_new_stack(&st, dir, cfg);
612 EXPECT_ERR(err);
613
614 input.value.update.message = "one\ntwo";
615 err = reftable_stack_add(st, &write_test_log, &arg);
616 EXPECT(err == REFTABLE_API_ERROR);
617
618 input.value.update.message = "one";
619 err = reftable_stack_add(st, &write_test_log, &arg);
620 EXPECT_ERR(err);
621
622 err = reftable_stack_read_log(st, input.refname, &dest);
623 EXPECT_ERR(err);
624 EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
625
626 input.value.update.message = "two\n";
627 arg.update_index = 2;
628 err = reftable_stack_add(st, &write_test_log, &arg);
629 EXPECT_ERR(err);
630 err = reftable_stack_read_log(st, input.refname, &dest);
631 EXPECT_ERR(err);
632 EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
633
634 /* cleanup */
635 reftable_stack_destroy(st);
636 reftable_log_record_release(&dest);
637 clear_dir(dir);
638 }
639
640 static void test_reftable_stack_tombstone(void)
641 {
642 int i = 0;
643 char *dir = get_tmp_dir(__LINE__);
644
645 struct reftable_write_options cfg = { 0 };
646 struct reftable_stack *st = NULL;
647 int err;
648 struct reftable_ref_record refs[2] = { { NULL } };
649 struct reftable_log_record logs[2] = { { NULL } };
650 int N = ARRAY_SIZE(refs);
651 struct reftable_ref_record dest = { NULL };
652 struct reftable_log_record log_dest = { NULL };
653
654
655 err = reftable_new_stack(&st, dir, cfg);
656 EXPECT_ERR(err);
657
658 /* even entries add the refs, odd entries delete them. */
659 for (i = 0; i < N; i++) {
660 const char *buf = "branch";
661 refs[i].refname = xstrdup(buf);
662 refs[i].update_index = i + 1;
663 if (i % 2 == 0) {
664 refs[i].value_type = REFTABLE_REF_VAL1;
665 set_test_hash(refs[i].value.val1, i);
666 }
667
668 logs[i].refname = xstrdup(buf);
669 /* update_index is part of the key. */
670 logs[i].update_index = 42;
671 if (i % 2 == 0) {
672 logs[i].value_type = REFTABLE_LOG_UPDATE;
673 logs[i].value.update.new_hash =
674 reftable_malloc(GIT_SHA1_RAWSZ);
675 set_test_hash(logs[i].value.update.new_hash, i);
676 logs[i].value.update.email =
677 xstrdup("identity@invalid");
678 }
679 }
680 for (i = 0; i < N; i++) {
681 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
682 EXPECT_ERR(err);
683 }
684
685 for (i = 0; i < N; i++) {
686 struct write_log_arg arg = {
687 .log = &logs[i],
688 .update_index = reftable_stack_next_update_index(st),
689 };
690 int err = reftable_stack_add(st, &write_test_log, &arg);
691 EXPECT_ERR(err);
692 }
693
694 err = reftable_stack_read_ref(st, "branch", &dest);
695 EXPECT(err == 1);
696 reftable_ref_record_release(&dest);
697
698 err = reftable_stack_read_log(st, "branch", &log_dest);
699 EXPECT(err == 1);
700 reftable_log_record_release(&log_dest);
701
702 err = reftable_stack_compact_all(st, NULL);
703 EXPECT_ERR(err);
704
705 err = reftable_stack_read_ref(st, "branch", &dest);
706 EXPECT(err == 1);
707
708 err = reftable_stack_read_log(st, "branch", &log_dest);
709 EXPECT(err == 1);
710 reftable_ref_record_release(&dest);
711 reftable_log_record_release(&log_dest);
712
713 /* cleanup */
714 reftable_stack_destroy(st);
715 for (i = 0; i < N; i++) {
716 reftable_ref_record_release(&refs[i]);
717 reftable_log_record_release(&logs[i]);
718 }
719 clear_dir(dir);
720 }
721
722 static void test_reftable_stack_hash_id(void)
723 {
724 char *dir = get_tmp_dir(__LINE__);
725
726 struct reftable_write_options cfg = { 0 };
727 struct reftable_stack *st = NULL;
728 int err;
729
730 struct reftable_ref_record ref = {
731 .refname = "master",
732 .value_type = REFTABLE_REF_SYMREF,
733 .value.symref = "target",
734 .update_index = 1,
735 };
736 struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
737 struct reftable_stack *st32 = NULL;
738 struct reftable_write_options cfg_default = { 0 };
739 struct reftable_stack *st_default = NULL;
740 struct reftable_ref_record dest = { NULL };
741
742 err = reftable_new_stack(&st, dir, cfg);
743 EXPECT_ERR(err);
744
745 err = reftable_stack_add(st, &write_test_ref, &ref);
746 EXPECT_ERR(err);
747
748 /* can't read it with the wrong hash ID. */
749 err = reftable_new_stack(&st32, dir, cfg32);
750 EXPECT(err == REFTABLE_FORMAT_ERROR);
751
752 /* check that we can read it back with default config too. */
753 err = reftable_new_stack(&st_default, dir, cfg_default);
754 EXPECT_ERR(err);
755
756 err = reftable_stack_read_ref(st_default, "master", &dest);
757 EXPECT_ERR(err);
758
759 EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
760 reftable_ref_record_release(&dest);
761 reftable_stack_destroy(st);
762 reftable_stack_destroy(st_default);
763 clear_dir(dir);
764 }
765
766 static void test_log2(void)
767 {
768 EXPECT(1 == fastlog2(3));
769 EXPECT(2 == fastlog2(4));
770 EXPECT(2 == fastlog2(5));
771 }
772
773 static void test_sizes_to_segments(void)
774 {
775 uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
776 /* .................0 1 2 3 4 5 */
777
778 size_t seglen = 0;
779 struct segment *segs =
780 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
781 EXPECT(segs[2].log == 3);
782 EXPECT(segs[2].start == 5);
783 EXPECT(segs[2].end == 6);
784
785 EXPECT(segs[1].log == 2);
786 EXPECT(segs[1].start == 2);
787 EXPECT(segs[1].end == 5);
788 reftable_free(segs);
789 }
790
791 static void test_sizes_to_segments_empty(void)
792 {
793 size_t seglen = 0;
794 struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
795 EXPECT(seglen == 0);
796 reftable_free(segs);
797 }
798
799 static void test_sizes_to_segments_all_equal(void)
800 {
801 uint64_t sizes[] = { 5, 5 };
802 size_t seglen = 0;
803 struct segment *segs =
804 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
805 EXPECT(seglen == 1);
806 EXPECT(segs[0].start == 0);
807 EXPECT(segs[0].end == 2);
808 reftable_free(segs);
809 }
810
811 static void test_suggest_compaction_segment(void)
812 {
813 uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
814 /* .................0 1 2 3 4 5 6 */
815 struct segment min =
816 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
817 EXPECT(min.start == 2);
818 EXPECT(min.end == 7);
819 }
820
821 static void test_suggest_compaction_segment_nothing(void)
822 {
823 uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
824 struct segment result =
825 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
826 EXPECT(result.start == result.end);
827 }
828
829 static void test_reflog_expire(void)
830 {
831 char *dir = get_tmp_dir(__LINE__);
832
833 struct reftable_write_options cfg = { 0 };
834 struct reftable_stack *st = NULL;
835 struct reftable_log_record logs[20] = { { NULL } };
836 int N = ARRAY_SIZE(logs) - 1;
837 int i = 0;
838 int err;
839 struct reftable_log_expiry_config expiry = {
840 .time = 10,
841 };
842 struct reftable_log_record log = { NULL };
843
844
845 err = reftable_new_stack(&st, dir, cfg);
846 EXPECT_ERR(err);
847
848 for (i = 1; i <= N; i++) {
849 char buf[256];
850 snprintf(buf, sizeof(buf), "branch%02d", i);
851
852 logs[i].refname = xstrdup(buf);
853 logs[i].update_index = i;
854 logs[i].value_type = REFTABLE_LOG_UPDATE;
855 logs[i].value.update.time = i;
856 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
857 logs[i].value.update.email = xstrdup("identity@invalid");
858 set_test_hash(logs[i].value.update.new_hash, i);
859 }
860
861 for (i = 1; i <= N; i++) {
862 struct write_log_arg arg = {
863 .log = &logs[i],
864 .update_index = reftable_stack_next_update_index(st),
865 };
866 int err = reftable_stack_add(st, &write_test_log, &arg);
867 EXPECT_ERR(err);
868 }
869
870 err = reftable_stack_compact_all(st, NULL);
871 EXPECT_ERR(err);
872
873 err = reftable_stack_compact_all(st, &expiry);
874 EXPECT_ERR(err);
875
876 err = reftable_stack_read_log(st, logs[9].refname, &log);
877 EXPECT(err == 1);
878
879 err = reftable_stack_read_log(st, logs[11].refname, &log);
880 EXPECT_ERR(err);
881
882 expiry.min_update_index = 15;
883 err = reftable_stack_compact_all(st, &expiry);
884 EXPECT_ERR(err);
885
886 err = reftable_stack_read_log(st, logs[14].refname, &log);
887 EXPECT(err == 1);
888
889 err = reftable_stack_read_log(st, logs[16].refname, &log);
890 EXPECT_ERR(err);
891
892 /* cleanup */
893 reftable_stack_destroy(st);
894 for (i = 0; i <= N; i++) {
895 reftable_log_record_release(&logs[i]);
896 }
897 clear_dir(dir);
898 reftable_log_record_release(&log);
899 }
900
901 static int write_nothing(struct reftable_writer *wr, void *arg)
902 {
903 reftable_writer_set_limits(wr, 1, 1);
904 return 0;
905 }
906
907 static void test_empty_add(void)
908 {
909 struct reftable_write_options cfg = { 0 };
910 struct reftable_stack *st = NULL;
911 int err;
912 char *dir = get_tmp_dir(__LINE__);
913
914 struct reftable_stack *st2 = NULL;
915
916
917 err = reftable_new_stack(&st, dir, cfg);
918 EXPECT_ERR(err);
919
920 err = reftable_stack_add(st, &write_nothing, NULL);
921 EXPECT_ERR(err);
922
923 err = reftable_new_stack(&st2, dir, cfg);
924 EXPECT_ERR(err);
925 clear_dir(dir);
926 reftable_stack_destroy(st);
927 reftable_stack_destroy(st2);
928 }
929
930 static void test_reftable_stack_auto_compaction(void)
931 {
932 struct reftable_write_options cfg = { 0 };
933 struct reftable_stack *st = NULL;
934 char *dir = get_tmp_dir(__LINE__);
935
936 int err, i;
937 int N = 100;
938
939 err = reftable_new_stack(&st, dir, cfg);
940 EXPECT_ERR(err);
941
942 st->disable_auto_compact = 1; /* call manually below for coverage. */
943 for (i = 0; i < N; i++) {
944 char name[100];
945 struct reftable_ref_record ref = {
946 .refname = name,
947 .update_index = reftable_stack_next_update_index(st),
948 .value_type = REFTABLE_REF_SYMREF,
949 .value.symref = "master",
950 };
951 snprintf(name, sizeof(name), "branch%04d", i);
952
953 err = reftable_stack_add(st, &write_test_ref, &ref);
954 EXPECT_ERR(err);
955
956 err = reftable_stack_auto_compact(st);
957 EXPECT_ERR(err);
958 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
959 }
960
961 EXPECT(reftable_stack_compaction_stats(st)->entries_written <
962 (uint64_t)(N * fastlog2(N)));
963
964 reftable_stack_destroy(st);
965 clear_dir(dir);
966 }
967
968 static void test_reftable_stack_add_performs_auto_compaction(void)
969 {
970 struct reftable_write_options cfg = { 0 };
971 struct reftable_stack *st = NULL;
972 struct strbuf refname = STRBUF_INIT;
973 char *dir = get_tmp_dir(__LINE__);
974 int err, i, n = 20;
975
976 err = reftable_new_stack(&st, dir, cfg);
977 EXPECT_ERR(err);
978
979 for (i = 0; i <= n; i++) {
980 struct reftable_ref_record ref = {
981 .update_index = reftable_stack_next_update_index(st),
982 .value_type = REFTABLE_REF_SYMREF,
983 .value.symref = "master",
984 };
985
986 /*
987 * Disable auto-compaction for all but the last runs. Like this
988 * we can ensure that we indeed honor this setting and have
989 * better control over when exactly auto compaction runs.
990 */
991 st->disable_auto_compact = i != n;
992
993 strbuf_reset(&refname);
994 strbuf_addf(&refname, "branch-%04d", i);
995 ref.refname = refname.buf;
996
997 err = reftable_stack_add(st, &write_test_ref, &ref);
998 EXPECT_ERR(err);
999
1000 /*
1001 * The stack length should grow continuously for all runs where
1002 * auto compaction is disabled. When enabled, we should merge
1003 * all tables in the stack.
1004 */
1005 if (i != n)
1006 EXPECT(st->merged->stack_len == i + 1);
1007 else
1008 EXPECT(st->merged->stack_len == 1);
1009 }
1010
1011 reftable_stack_destroy(st);
1012 strbuf_release(&refname);
1013 clear_dir(dir);
1014 }
1015
1016 static void test_reftable_stack_compaction_concurrent(void)
1017 {
1018 struct reftable_write_options cfg = { 0 };
1019 struct reftable_stack *st1 = NULL, *st2 = NULL;
1020 char *dir = get_tmp_dir(__LINE__);
1021
1022 int err, i;
1023 int N = 3;
1024
1025 err = reftable_new_stack(&st1, dir, cfg);
1026 EXPECT_ERR(err);
1027
1028 for (i = 0; i < N; i++) {
1029 char name[100];
1030 struct reftable_ref_record ref = {
1031 .refname = name,
1032 .update_index = reftable_stack_next_update_index(st1),
1033 .value_type = REFTABLE_REF_SYMREF,
1034 .value.symref = "master",
1035 };
1036 snprintf(name, sizeof(name), "branch%04d", i);
1037
1038 err = reftable_stack_add(st1, &write_test_ref, &ref);
1039 EXPECT_ERR(err);
1040 }
1041
1042 err = reftable_new_stack(&st2, dir, cfg);
1043 EXPECT_ERR(err);
1044
1045 err = reftable_stack_compact_all(st1, NULL);
1046 EXPECT_ERR(err);
1047
1048 reftable_stack_destroy(st1);
1049 reftable_stack_destroy(st2);
1050
1051 EXPECT(count_dir_entries(dir) == 2);
1052 clear_dir(dir);
1053 }
1054
1055 static void unclean_stack_close(struct reftable_stack *st)
1056 {
1057 /* break abstraction boundary to simulate unclean shutdown. */
1058 int i = 0;
1059 for (; i < st->readers_len; i++) {
1060 reftable_reader_free(st->readers[i]);
1061 }
1062 st->readers_len = 0;
1063 FREE_AND_NULL(st->readers);
1064 }
1065
1066 static void test_reftable_stack_compaction_concurrent_clean(void)
1067 {
1068 struct reftable_write_options cfg = { 0 };
1069 struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
1070 char *dir = get_tmp_dir(__LINE__);
1071
1072 int err, i;
1073 int N = 3;
1074
1075 err = reftable_new_stack(&st1, dir, cfg);
1076 EXPECT_ERR(err);
1077
1078 for (i = 0; i < N; i++) {
1079 char name[100];
1080 struct reftable_ref_record ref = {
1081 .refname = name,
1082 .update_index = reftable_stack_next_update_index(st1),
1083 .value_type = REFTABLE_REF_SYMREF,
1084 .value.symref = "master",
1085 };
1086 snprintf(name, sizeof(name), "branch%04d", i);
1087
1088 err = reftable_stack_add(st1, &write_test_ref, &ref);
1089 EXPECT_ERR(err);
1090 }
1091
1092 err = reftable_new_stack(&st2, dir, cfg);
1093 EXPECT_ERR(err);
1094
1095 err = reftable_stack_compact_all(st1, NULL);
1096 EXPECT_ERR(err);
1097
1098 unclean_stack_close(st1);
1099 unclean_stack_close(st2);
1100
1101 err = reftable_new_stack(&st3, dir, cfg);
1102 EXPECT_ERR(err);
1103
1104 err = reftable_stack_clean(st3);
1105 EXPECT_ERR(err);
1106 EXPECT(count_dir_entries(dir) == 2);
1107
1108 reftable_stack_destroy(st1);
1109 reftable_stack_destroy(st2);
1110 reftable_stack_destroy(st3);
1111
1112 clear_dir(dir);
1113 }
1114
1115 int stack_test_main(int argc, const char *argv[])
1116 {
1117 RUN_TEST(test_empty_add);
1118 RUN_TEST(test_log2);
1119 RUN_TEST(test_names_equal);
1120 RUN_TEST(test_parse_names);
1121 RUN_TEST(test_read_file);
1122 RUN_TEST(test_reflog_expire);
1123 RUN_TEST(test_reftable_stack_add);
1124 RUN_TEST(test_reftable_stack_add_one);
1125 RUN_TEST(test_reftable_stack_auto_compaction);
1126 RUN_TEST(test_reftable_stack_add_performs_auto_compaction);
1127 RUN_TEST(test_reftable_stack_compaction_concurrent);
1128 RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
1129 RUN_TEST(test_reftable_stack_hash_id);
1130 RUN_TEST(test_reftable_stack_lock_failure);
1131 RUN_TEST(test_reftable_stack_log_normalize);
1132 RUN_TEST(test_reftable_stack_tombstone);
1133 RUN_TEST(test_reftable_stack_transaction_api);
1134 RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
1135 RUN_TEST(test_reftable_stack_auto_compaction_fails_gracefully);
1136 RUN_TEST(test_reftable_stack_update_index_check);
1137 RUN_TEST(test_reftable_stack_uptodate);
1138 RUN_TEST(test_reftable_stack_validate_refname);
1139 RUN_TEST(test_sizes_to_segments);
1140 RUN_TEST(test_sizes_to_segments_all_equal);
1141 RUN_TEST(test_sizes_to_segments_empty);
1142 RUN_TEST(test_suggest_compaction_segment);
1143 RUN_TEST(test_suggest_compaction_segment_nothing);
1144 return 0;
1145 }
Alternate source for your git.git needs