reftable/stack_test.c

   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_LOCK_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_validate_refname(void)
 347 {
 348         struct reftable_write_options cfg = { 0 };
 349         struct reftable_stack *st = NULL;
 350         int err;
 351         char *dir = get_tmp_dir(__LINE__);
 352
 353         int i;
 354         struct reftable_ref_record ref = {
 355                 .refname = "a/b",
 356                 .update_index = 1,
 357                 .value_type = REFTABLE_REF_SYMREF,
 358                 .value.symref = "master",
 359         };
 360         char *additions[] = { "a", "a/b/c" };
 361
 362         err = reftable_new_stack(&st, dir, cfg);
 363         EXPECT_ERR(err);
 364
 365         err = reftable_stack_add(st, &write_test_ref, &ref);
 366         EXPECT_ERR(err);
 367
 368         for (i = 0; i < ARRAY_SIZE(additions); i++) {
 369                 struct reftable_ref_record ref = {
 370                         .refname = additions[i],
 371                         .update_index = 1,
 372                         .value_type = REFTABLE_REF_SYMREF,
 373                         .value.symref = "master",
 374                 };
 375
 376                 err = reftable_stack_add(st, &write_test_ref, &ref);
 377                 EXPECT(err == REFTABLE_NAME_CONFLICT);
 378         }
 379
 380         reftable_stack_destroy(st);
 381         clear_dir(dir);
 382 }
 383
 384 static int write_error(struct reftable_writer *wr, void *arg)
 385 {
 386         return *((int *)arg);
 387 }
 388
 389 static void test_reftable_stack_update_index_check(void)
 390 {
 391         char *dir = get_tmp_dir(__LINE__);
 392
 393         struct reftable_write_options cfg = { 0 };
 394         struct reftable_stack *st = NULL;
 395         int err;
 396         struct reftable_ref_record ref1 = {
 397                 .refname = "name1",
 398                 .update_index = 1,
 399                 .value_type = REFTABLE_REF_SYMREF,
 400                 .value.symref = "master",
 401         };
 402         struct reftable_ref_record ref2 = {
 403                 .refname = "name2",
 404                 .update_index = 1,
 405                 .value_type = REFTABLE_REF_SYMREF,
 406                 .value.symref = "master",
 407         };
 408
 409         err = reftable_new_stack(&st, dir, cfg);
 410         EXPECT_ERR(err);
 411
 412         err = reftable_stack_add(st, &write_test_ref, &ref1);
 413         EXPECT_ERR(err);
 414
 415         err = reftable_stack_add(st, &write_test_ref, &ref2);
 416         EXPECT(err == REFTABLE_API_ERROR);
 417         reftable_stack_destroy(st);
 418         clear_dir(dir);
 419 }
 420
 421 static void test_reftable_stack_lock_failure(void)
 422 {
 423         char *dir = get_tmp_dir(__LINE__);
 424
 425         struct reftable_write_options cfg = { 0 };
 426         struct reftable_stack *st = NULL;
 427         int err, i;
 428
 429         err = reftable_new_stack(&st, dir, cfg);
 430         EXPECT_ERR(err);
 431         for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
 432                 err = reftable_stack_add(st, &write_error, &i);
 433                 EXPECT(err == i);
 434         }
 435
 436         reftable_stack_destroy(st);
 437         clear_dir(dir);
 438 }
 439
 440 static void test_reftable_stack_add(void)
 441 {
 442         int i = 0;
 443         int err = 0;
 444         struct reftable_write_options cfg = {
 445                 .exact_log_message = 1,
 446                 .default_permissions = 0660,
 447         };
 448         struct reftable_stack *st = NULL;
 449         char *dir = get_tmp_dir(__LINE__);
 450         struct reftable_ref_record refs[2] = { { NULL } };
 451         struct reftable_log_record logs[2] = { { NULL } };
 452         struct strbuf path = STRBUF_INIT;
 453         struct stat stat_result;
 454         int N = ARRAY_SIZE(refs);
 455
 456         err = reftable_new_stack(&st, dir, cfg);
 457         EXPECT_ERR(err);
 458         st->disable_auto_compact = 1;
 459
 460         for (i = 0; i < N; i++) {
 461                 char buf[256];
 462                 snprintf(buf, sizeof(buf), "branch%02d", i);
 463                 refs[i].refname = xstrdup(buf);
 464                 refs[i].update_index = i + 1;
 465                 refs[i].value_type = REFTABLE_REF_VAL1;
 466                 set_test_hash(refs[i].value.val1, i);
 467
 468                 logs[i].refname = xstrdup(buf);
 469                 logs[i].update_index = N + i + 1;
 470                 logs[i].value_type = REFTABLE_LOG_UPDATE;
 471                 logs[i].value.update.email = xstrdup("identity@invalid");
 472                 set_test_hash(logs[i].value.update.new_hash, i);
 473         }
 474
 475         for (i = 0; i < N; i++) {
 476                 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
 477                 EXPECT_ERR(err);
 478         }
 479
 480         for (i = 0; i < N; i++) {
 481                 struct write_log_arg arg = {
 482                         .log = &logs[i],
 483                         .update_index = reftable_stack_next_update_index(st),
 484                 };
 485                 int err = reftable_stack_add(st, &write_test_log, &arg);
 486                 EXPECT_ERR(err);
 487         }
 488
 489         err = reftable_stack_compact_all(st, NULL);
 490         EXPECT_ERR(err);
 491
 492         for (i = 0; i < N; i++) {
 493                 struct reftable_ref_record dest = { NULL };
 494
 495                 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
 496                 EXPECT_ERR(err);
 497                 EXPECT(reftable_ref_record_equal(&dest, refs + i,
 498                                                  GIT_SHA1_RAWSZ));
 499                 reftable_ref_record_release(&dest);
 500         }
 501
 502         for (i = 0; i < N; i++) {
 503                 struct reftable_log_record dest = { NULL };
 504                 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
 505                 EXPECT_ERR(err);
 506                 EXPECT(reftable_log_record_equal(&dest, logs + i,
 507                                                  GIT_SHA1_RAWSZ));
 508                 reftable_log_record_release(&dest);
 509         }
 510
 511 #ifndef GIT_WINDOWS_NATIVE
 512         strbuf_addstr(&path, dir);
 513         strbuf_addstr(&path, "/tables.list");
 514         err = stat(path.buf, &stat_result);
 515         EXPECT(!err);
 516         EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
 517
 518         strbuf_reset(&path);
 519         strbuf_addstr(&path, dir);
 520         strbuf_addstr(&path, "/");
 521         /* do not try at home; not an external API for reftable. */
 522         strbuf_addstr(&path, st->readers[0]->name);
 523         err = stat(path.buf, &stat_result);
 524         EXPECT(!err);
 525         EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
 526 #else
 527         (void) stat_result;
 528 #endif
 529
 530         /* cleanup */
 531         reftable_stack_destroy(st);
 532         for (i = 0; i < N; i++) {
 533                 reftable_ref_record_release(&refs[i]);
 534                 reftable_log_record_release(&logs[i]);
 535         }
 536         strbuf_release(&path);
 537         clear_dir(dir);
 538 }
 539
 540 static void test_reftable_stack_log_normalize(void)
 541 {
 542         int err = 0;
 543         struct reftable_write_options cfg = {
 544                 0,
 545         };
 546         struct reftable_stack *st = NULL;
 547         char *dir = get_tmp_dir(__LINE__);
 548         struct reftable_log_record input = {
 549                 .refname = "branch",
 550                 .update_index = 1,
 551                 .value_type = REFTABLE_LOG_UPDATE,
 552                 .value = {
 553                         .update = {
 554                                 .new_hash = { 1 },
 555                                 .old_hash = { 2 },
 556                         },
 557                 },
 558         };
 559         struct reftable_log_record dest = {
 560                 .update_index = 0,
 561         };
 562         struct write_log_arg arg = {
 563                 .log = &input,
 564                 .update_index = 1,
 565         };
 566
 567         err = reftable_new_stack(&st, dir, cfg);
 568         EXPECT_ERR(err);
 569
 570         input.value.update.message = "one\ntwo";
 571         err = reftable_stack_add(st, &write_test_log, &arg);
 572         EXPECT(err == REFTABLE_API_ERROR);
 573
 574         input.value.update.message = "one";
 575         err = reftable_stack_add(st, &write_test_log, &arg);
 576         EXPECT_ERR(err);
 577
 578         err = reftable_stack_read_log(st, input.refname, &dest);
 579         EXPECT_ERR(err);
 580         EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
 581
 582         input.value.update.message = "two\n";
 583         arg.update_index = 2;
 584         err = reftable_stack_add(st, &write_test_log, &arg);
 585         EXPECT_ERR(err);
 586         err = reftable_stack_read_log(st, input.refname, &dest);
 587         EXPECT_ERR(err);
 588         EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
 589
 590         /* cleanup */
 591         reftable_stack_destroy(st);
 592         reftable_log_record_release(&dest);
 593         clear_dir(dir);
 594 }
 595
 596 static void test_reftable_stack_tombstone(void)
 597 {
 598         int i = 0;
 599         char *dir = get_tmp_dir(__LINE__);
 600
 601         struct reftable_write_options cfg = { 0 };
 602         struct reftable_stack *st = NULL;
 603         int err;
 604         struct reftable_ref_record refs[2] = { { NULL } };
 605         struct reftable_log_record logs[2] = { { NULL } };
 606         int N = ARRAY_SIZE(refs);
 607         struct reftable_ref_record dest = { NULL };
 608         struct reftable_log_record log_dest = { NULL };
 609
 610
 611         err = reftable_new_stack(&st, dir, cfg);
 612         EXPECT_ERR(err);
 613
 614         /* even entries add the refs, odd entries delete them. */
 615         for (i = 0; i < N; i++) {
 616                 const char *buf = "branch";
 617                 refs[i].refname = xstrdup(buf);
 618                 refs[i].update_index = i + 1;
 619                 if (i % 2 == 0) {
 620                         refs[i].value_type = REFTABLE_REF_VAL1;
 621                         set_test_hash(refs[i].value.val1, i);
 622                 }
 623
 624                 logs[i].refname = xstrdup(buf);
 625                 /* update_index is part of the key. */
 626                 logs[i].update_index = 42;
 627                 if (i % 2 == 0) {
 628                         logs[i].value_type = REFTABLE_LOG_UPDATE;
 629                         set_test_hash(logs[i].value.update.new_hash, i);
 630                         logs[i].value.update.email =
 631                                 xstrdup("identity@invalid");
 632                 }
 633         }
 634         for (i = 0; i < N; i++) {
 635                 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
 636                 EXPECT_ERR(err);
 637         }
 638
 639         for (i = 0; i < N; i++) {
 640                 struct write_log_arg arg = {
 641                         .log = &logs[i],
 642                         .update_index = reftable_stack_next_update_index(st),
 643                 };
 644                 int err = reftable_stack_add(st, &write_test_log, &arg);
 645                 EXPECT_ERR(err);
 646         }
 647
 648         err = reftable_stack_read_ref(st, "branch", &dest);
 649         EXPECT(err == 1);
 650         reftable_ref_record_release(&dest);
 651
 652         err = reftable_stack_read_log(st, "branch", &log_dest);
 653         EXPECT(err == 1);
 654         reftable_log_record_release(&log_dest);
 655
 656         err = reftable_stack_compact_all(st, NULL);
 657         EXPECT_ERR(err);
 658
 659         err = reftable_stack_read_ref(st, "branch", &dest);
 660         EXPECT(err == 1);
 661
 662         err = reftable_stack_read_log(st, "branch", &log_dest);
 663         EXPECT(err == 1);
 664         reftable_ref_record_release(&dest);
 665         reftable_log_record_release(&log_dest);
 666
 667         /* cleanup */
 668         reftable_stack_destroy(st);
 669         for (i = 0; i < N; i++) {
 670                 reftable_ref_record_release(&refs[i]);
 671                 reftable_log_record_release(&logs[i]);
 672         }
 673         clear_dir(dir);
 674 }
 675
 676 static void test_reftable_stack_hash_id(void)
 677 {
 678         char *dir = get_tmp_dir(__LINE__);
 679
 680         struct reftable_write_options cfg = { 0 };
 681         struct reftable_stack *st = NULL;
 682         int err;
 683
 684         struct reftable_ref_record ref = {
 685                 .refname = "master",
 686                 .value_type = REFTABLE_REF_SYMREF,
 687                 .value.symref = "target",
 688                 .update_index = 1,
 689         };
 690         struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
 691         struct reftable_stack *st32 = NULL;
 692         struct reftable_write_options cfg_default = { 0 };
 693         struct reftable_stack *st_default = NULL;
 694         struct reftable_ref_record dest = { NULL };
 695
 696         err = reftable_new_stack(&st, dir, cfg);
 697         EXPECT_ERR(err);
 698
 699         err = reftable_stack_add(st, &write_test_ref, &ref);
 700         EXPECT_ERR(err);
 701
 702         /* can't read it with the wrong hash ID. */
 703         err = reftable_new_stack(&st32, dir, cfg32);
 704         EXPECT(err == REFTABLE_FORMAT_ERROR);
 705
 706         /* check that we can read it back with default config too. */
 707         err = reftable_new_stack(&st_default, dir, cfg_default);
 708         EXPECT_ERR(err);
 709
 710         err = reftable_stack_read_ref(st_default, "master", &dest);
 711         EXPECT_ERR(err);
 712
 713         EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
 714         reftable_ref_record_release(&dest);
 715         reftable_stack_destroy(st);
 716         reftable_stack_destroy(st_default);
 717         clear_dir(dir);
 718 }
 719
 720 static void test_log2(void)
 721 {
 722         EXPECT(1 == fastlog2(3));
 723         EXPECT(2 == fastlog2(4));
 724         EXPECT(2 == fastlog2(5));
 725 }
 726
 727 static void test_sizes_to_segments(void)
 728 {
 729         uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
 730         /* .................0  1  2  3  4  5 */
 731
 732         size_t seglen = 0;
 733         struct segment *segs =
 734                 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
 735         EXPECT(segs[2].log == 3);
 736         EXPECT(segs[2].start == 5);
 737         EXPECT(segs[2].end == 6);
 738
 739         EXPECT(segs[1].log == 2);
 740         EXPECT(segs[1].start == 2);
 741         EXPECT(segs[1].end == 5);
 742         reftable_free(segs);
 743 }
 744
 745 static void test_sizes_to_segments_empty(void)
 746 {
 747         size_t seglen = 0;
 748         struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
 749         EXPECT(seglen == 0);
 750         reftable_free(segs);
 751 }
 752
 753 static void test_sizes_to_segments_all_equal(void)
 754 {
 755         uint64_t sizes[] = { 5, 5 };
 756         size_t seglen = 0;
 757         struct segment *segs =
 758                 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
 759         EXPECT(seglen == 1);
 760         EXPECT(segs[0].start == 0);
 761         EXPECT(segs[0].end == 2);
 762         reftable_free(segs);
 763 }
 764
 765 static void test_suggest_compaction_segment(void)
 766 {
 767         uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
 768         /* .................0    1    2  3   4  5  6 */
 769         struct segment min =
 770                 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
 771         EXPECT(min.start == 2);
 772         EXPECT(min.end == 7);
 773 }
 774
 775 static void test_suggest_compaction_segment_nothing(void)
 776 {
 777         uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
 778         struct segment result =
 779                 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
 780         EXPECT(result.start == result.end);
 781 }
 782
 783 static void test_reflog_expire(void)
 784 {
 785         char *dir = get_tmp_dir(__LINE__);
 786
 787         struct reftable_write_options cfg = { 0 };
 788         struct reftable_stack *st = NULL;
 789         struct reftable_log_record logs[20] = { { NULL } };
 790         int N = ARRAY_SIZE(logs) - 1;
 791         int i = 0;
 792         int err;
 793         struct reftable_log_expiry_config expiry = {
 794                 .time = 10,
 795         };
 796         struct reftable_log_record log = { NULL };
 797
 798
 799         err = reftable_new_stack(&st, dir, cfg);
 800         EXPECT_ERR(err);
 801
 802         for (i = 1; i <= N; i++) {
 803                 char buf[256];
 804                 snprintf(buf, sizeof(buf), "branch%02d", i);
 805
 806                 logs[i].refname = xstrdup(buf);
 807                 logs[i].update_index = i;
 808                 logs[i].value_type = REFTABLE_LOG_UPDATE;
 809                 logs[i].value.update.time = i;
 810                 logs[i].value.update.email = xstrdup("identity@invalid");
 811                 set_test_hash(logs[i].value.update.new_hash, i);
 812         }
 813
 814         for (i = 1; i <= N; i++) {
 815                 struct write_log_arg arg = {
 816                         .log = &logs[i],
 817                         .update_index = reftable_stack_next_update_index(st),
 818                 };
 819                 int err = reftable_stack_add(st, &write_test_log, &arg);
 820                 EXPECT_ERR(err);
 821         }
 822
 823         err = reftable_stack_compact_all(st, NULL);
 824         EXPECT_ERR(err);
 825
 826         err = reftable_stack_compact_all(st, &expiry);
 827         EXPECT_ERR(err);
 828
 829         err = reftable_stack_read_log(st, logs[9].refname, &log);
 830         EXPECT(err == 1);
 831
 832         err = reftable_stack_read_log(st, logs[11].refname, &log);
 833         EXPECT_ERR(err);
 834
 835         expiry.min_update_index = 15;
 836         err = reftable_stack_compact_all(st, &expiry);
 837         EXPECT_ERR(err);
 838
 839         err = reftable_stack_read_log(st, logs[14].refname, &log);
 840         EXPECT(err == 1);
 841
 842         err = reftable_stack_read_log(st, logs[16].refname, &log);
 843         EXPECT_ERR(err);
 844
 845         /* cleanup */
 846         reftable_stack_destroy(st);
 847         for (i = 0; i <= N; i++) {
 848                 reftable_log_record_release(&logs[i]);
 849         }
 850         clear_dir(dir);
 851         reftable_log_record_release(&log);
 852 }
 853
 854 static int write_nothing(struct reftable_writer *wr, void *arg)
 855 {
 856         reftable_writer_set_limits(wr, 1, 1);
 857         return 0;
 858 }
 859
 860 static void test_empty_add(void)
 861 {
 862         struct reftable_write_options cfg = { 0 };
 863         struct reftable_stack *st = NULL;
 864         int err;
 865         char *dir = get_tmp_dir(__LINE__);
 866
 867         struct reftable_stack *st2 = NULL;
 868
 869
 870         err = reftable_new_stack(&st, dir, cfg);
 871         EXPECT_ERR(err);
 872
 873         err = reftable_stack_add(st, &write_nothing, NULL);
 874         EXPECT_ERR(err);
 875
 876         err = reftable_new_stack(&st2, dir, cfg);
 877         EXPECT_ERR(err);
 878         clear_dir(dir);
 879         reftable_stack_destroy(st);
 880         reftable_stack_destroy(st2);
 881 }
 882
 883 static void test_reftable_stack_auto_compaction(void)
 884 {
 885         struct reftable_write_options cfg = { 0 };
 886         struct reftable_stack *st = NULL;
 887         char *dir = get_tmp_dir(__LINE__);
 888
 889         int err, i;
 890         int N = 100;
 891
 892         err = reftable_new_stack(&st, dir, cfg);
 893         EXPECT_ERR(err);
 894
 895         st->disable_auto_compact = 1; /* call manually below for coverage. */
 896         for (i = 0; i < N; i++) {
 897                 char name[100];
 898                 struct reftable_ref_record ref = {
 899                         .refname = name,
 900                         .update_index = reftable_stack_next_update_index(st),
 901                         .value_type = REFTABLE_REF_SYMREF,
 902                         .value.symref = "master",
 903                 };
 904                 snprintf(name, sizeof(name), "branch%04d", i);
 905
 906                 err = reftable_stack_add(st, &write_test_ref, &ref);
 907                 EXPECT_ERR(err);
 908
 909                 err = reftable_stack_auto_compact(st);
 910                 EXPECT_ERR(err);
 911                 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
 912         }
 913
 914         EXPECT(reftable_stack_compaction_stats(st)->entries_written <
 915                (uint64_t)(N * fastlog2(N)));
 916
 917         reftable_stack_destroy(st);
 918         clear_dir(dir);
 919 }
 920
 921 static void test_reftable_stack_add_performs_auto_compaction(void)
 922 {
 923         struct reftable_write_options cfg = { 0 };
 924         struct reftable_stack *st = NULL;
 925         struct strbuf refname = STRBUF_INIT;
 926         char *dir = get_tmp_dir(__LINE__);
 927         int err, i, n = 20;
 928
 929         err = reftable_new_stack(&st, dir, cfg);
 930         EXPECT_ERR(err);
 931
 932         for (i = 0; i <= n; i++) {
 933                 struct reftable_ref_record ref = {
 934                         .update_index = reftable_stack_next_update_index(st),
 935                         .value_type = REFTABLE_REF_SYMREF,
 936                         .value.symref = "master",
 937                 };
 938
 939                 /*
 940                  * Disable auto-compaction for all but the last runs. Like this
 941                  * we can ensure that we indeed honor this setting and have
 942                  * better control over when exactly auto compaction runs.
 943                  */
 944                 st->disable_auto_compact = i != n;
 945
 946                 strbuf_reset(&refname);
 947                 strbuf_addf(&refname, "branch-%04d", i);
 948                 ref.refname = refname.buf;
 949
 950                 err = reftable_stack_add(st, &write_test_ref, &ref);
 951                 EXPECT_ERR(err);
 952
 953                 /*
 954                  * The stack length should grow continuously for all runs where
 955                  * auto compaction is disabled. When enabled, we should merge
 956                  * all tables in the stack.
 957                  */
 958                 if (i != n)
 959                         EXPECT(st->merged->stack_len == i + 1);
 960                 else
 961                         EXPECT(st->merged->stack_len == 1);
 962         }
 963
 964         reftable_stack_destroy(st);
 965         strbuf_release(&refname);
 966         clear_dir(dir);
 967 }
 968
 969 static void test_reftable_stack_compaction_concurrent(void)
 970 {
 971         struct reftable_write_options cfg = { 0 };
 972         struct reftable_stack *st1 = NULL, *st2 = NULL;
 973         char *dir = get_tmp_dir(__LINE__);
 974
 975         int err, i;
 976         int N = 3;
 977
 978         err = reftable_new_stack(&st1, dir, cfg);
 979         EXPECT_ERR(err);
 980
 981         for (i = 0; i < N; i++) {
 982                 char name[100];
 983                 struct reftable_ref_record ref = {
 984                         .refname = name,
 985                         .update_index = reftable_stack_next_update_index(st1),
 986                         .value_type = REFTABLE_REF_SYMREF,
 987                         .value.symref = "master",
 988                 };
 989                 snprintf(name, sizeof(name), "branch%04d", i);
 990
 991                 err = reftable_stack_add(st1, &write_test_ref, &ref);
 992                 EXPECT_ERR(err);
 993         }
 994
 995         err = reftable_new_stack(&st2, dir, cfg);
 996         EXPECT_ERR(err);
 997
 998         err = reftable_stack_compact_all(st1, NULL);
 999         EXPECT_ERR(err);
1000
1001         reftable_stack_destroy(st1);
1002         reftable_stack_destroy(st2);
1003
1004         EXPECT(count_dir_entries(dir) == 2);
1005         clear_dir(dir);
1006 }
1007
1008 static void unclean_stack_close(struct reftable_stack *st)
1009 {
1010         /* break abstraction boundary to simulate unclean shutdown. */
1011         int i = 0;
1012         for (; i < st->readers_len; i++) {
1013                 reftable_reader_free(st->readers[i]);
1014         }
1015         st->readers_len = 0;
1016         FREE_AND_NULL(st->readers);
1017 }
1018
1019 static void test_reftable_stack_compaction_concurrent_clean(void)
1020 {
1021         struct reftable_write_options cfg = { 0 };
1022         struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
1023         char *dir = get_tmp_dir(__LINE__);
1024
1025         int err, i;
1026         int N = 3;
1027
1028         err = reftable_new_stack(&st1, dir, cfg);
1029         EXPECT_ERR(err);
1030
1031         for (i = 0; i < N; i++) {
1032                 char name[100];
1033                 struct reftable_ref_record ref = {
1034                         .refname = name,
1035                         .update_index = reftable_stack_next_update_index(st1),
1036                         .value_type = REFTABLE_REF_SYMREF,
1037                         .value.symref = "master",
1038                 };
1039                 snprintf(name, sizeof(name), "branch%04d", i);
1040
1041                 err = reftable_stack_add(st1, &write_test_ref, &ref);
1042                 EXPECT_ERR(err);
1043         }
1044
1045         err = reftable_new_stack(&st2, dir, cfg);
1046         EXPECT_ERR(err);
1047
1048         err = reftable_stack_compact_all(st1, NULL);
1049         EXPECT_ERR(err);
1050
1051         unclean_stack_close(st1);
1052         unclean_stack_close(st2);
1053
1054         err = reftable_new_stack(&st3, dir, cfg);
1055         EXPECT_ERR(err);
1056
1057         err = reftable_stack_clean(st3);
1058         EXPECT_ERR(err);
1059         EXPECT(count_dir_entries(dir) == 2);
1060
1061         reftable_stack_destroy(st1);
1062         reftable_stack_destroy(st2);
1063         reftable_stack_destroy(st3);
1064
1065         clear_dir(dir);
1066 }
1067
1068 int stack_test_main(int argc, const char *argv[])
1069 {
1070         RUN_TEST(test_empty_add);
1071         RUN_TEST(test_log2);
1072         RUN_TEST(test_names_equal);
1073         RUN_TEST(test_parse_names);
1074         RUN_TEST(test_read_file);
1075         RUN_TEST(test_reflog_expire);
1076         RUN_TEST(test_reftable_stack_add);
1077         RUN_TEST(test_reftable_stack_add_one);
1078         RUN_TEST(test_reftable_stack_auto_compaction);
1079         RUN_TEST(test_reftable_stack_add_performs_auto_compaction);
1080         RUN_TEST(test_reftable_stack_compaction_concurrent);
1081         RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
1082         RUN_TEST(test_reftable_stack_hash_id);
1083         RUN_TEST(test_reftable_stack_lock_failure);
1084         RUN_TEST(test_reftable_stack_log_normalize);
1085         RUN_TEST(test_reftable_stack_tombstone);
1086         RUN_TEST(test_reftable_stack_transaction_api);
1087         RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
1088         RUN_TEST(test_reftable_stack_update_index_check);
1089         RUN_TEST(test_reftable_stack_uptodate);
1090         RUN_TEST(test_reftable_stack_validate_refname);
1091         RUN_TEST(test_sizes_to_segments);
1092         RUN_TEST(test_sizes_to_segments_all_equal);
1093         RUN_TEST(test_sizes_to_segments_empty);
1094         RUN_TEST(test_suggest_compaction_segment);
1095         RUN_TEST(test_suggest_compaction_segment_nothing);
1096         return 0;
1097 }