mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reftable: consistently refer to reftable_write_options as opts

Browse Source 
Throughout the reftable library the `reftable_write_options` are
sometimes referred to as `cfg` and sometimes as `opts`. Unify these to
consistently use `opts` to avoid confusion.

While at it, touch up the coding style a bit by removing unneeded braces
around one-line statements and newlines between variable declarations.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Patrick Steinhardt
2024-05-13 10:17:54 +02:00
committed by Junio C Hamano
parent 0f3415f1f8
commit 4d35bb2aba
5 changed files with 74 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
reftable/dump.c
View File

@ -27,9 +27,9 @@ https://developers.google.com/open-source/licenses/bsd
static int compact_stack(const char *stackdir) static int compact_stack(const char *stackdir)
{ {
struct reftable_stack *stack = NULL; struct reftable_stack *stack = NULL;
struct reftable_write_options cfg = { 0 }; struct reftable_write_options opts = { 0 };
int err = reftable_new_stack(&stack, stackdir, cfg); int err = reftable_new_stack(&stack, stackdir, opts);
if (err < 0) if (err < 0)
goto done; goto done;

2
reftable/reftable-stack.h
View File

@ -29,7 +29,7 @@ struct reftable_stack;
* stored in 'dir'. Typically, this should be .git/reftables. * stored in 'dir'. Typically, this should be .git/reftables.
*/ */
int reftable_new_stack(struct reftable_stack **dest, const char *dir, int reftable_new_stack(struct reftable_stack **dest, const char *dir,
struct reftable_write_options config); struct reftable_write_options opts);
/* returns the update_index at which a next table should be written. */ /* returns the update_index at which a next table should be written. */
uint64_t reftable_stack_next_update_index(struct reftable_stack *st); uint64_t reftable_stack_next_update_index(struct reftable_stack *st);

41
reftable/stack.c
View File

@ -54,15 +54,14 @@ static int reftable_fd_flush(void *arg)
} }
int reftable_new_stack(struct reftable_stack **dest, const char *dir, int reftable_new_stack(struct reftable_stack **dest, const char *dir,
struct reftable_write_options config) struct reftable_write_options opts)
{ {
struct reftable_stack *p = reftable_calloc(1, sizeof(*p)); struct reftable_stack *p = reftable_calloc(1, sizeof(*p));
struct strbuf list_file_name = STRBUF_INIT; struct strbuf list_file_name = STRBUF_INIT;
int err = 0; int err = 0;
if (config.hash_id == 0) { if (opts.hash_id == 0)
config.hash_id = GIT_SHA1_FORMAT_ID; opts.hash_id = GIT_SHA1_FORMAT_ID;
}
*dest = NULL; *dest = NULL;
@ -73,7 +72,7 @@ int reftable_new_stack(struct reftable_stack **dest, const char *dir,
p->list_file = strbuf_detach(&list_file_name, NULL); p->list_file = strbuf_detach(&list_file_name, NULL);
p->list_fd = -1; p->list_fd = -1;
p->reftable_dir = xstrdup(dir); p->reftable_dir = xstrdup(dir);
p->config = config; p->opts = opts;
err = reftable_stack_reload_maybe_reuse(p, 1); err = reftable_stack_reload_maybe_reuse(p, 1);
if (err < 0) { if (err < 0) {
@ -255,7 +254,7 @@ static int reftable_stack_reload_once(struct reftable_stack *st, char **names,
/* success! */ /* success! */
err = reftable_new_merged_table(&new_merged, new_tables, err = reftable_new_merged_table(&new_merged, new_tables,
new_readers_len, st->config.hash_id); new_readers_len, st->opts.hash_id);
if (err < 0) if (err < 0)
goto done; goto done;
@ -578,8 +577,8 @@ static int reftable_stack_init_addition(struct reftable_addition *add,
} }
goto done; goto done;
} }
if (st->config.default_permissions) { if (st->opts.default_permissions) {
if (chmod(add->lock_file->filename.buf, st->config.default_permissions) < 0) { if (chmod(add->lock_file->filename.buf, st->opts.default_permissions) < 0) {
err = REFTABLE_IO_ERROR; err = REFTABLE_IO_ERROR;
goto done; goto done;
} }
@ -678,7 +677,7 @@ int reftable_addition_commit(struct reftable_addition *add)
if (err) if (err)
goto done; goto done;
if (!add->stack->config.disable_auto_compact) { if (!add->stack->opts.disable_auto_compact) {
/* /*
* Auto-compact the stack to keep the number of tables in * Auto-compact the stack to keep the number of tables in
* control. It is possible that a concurrent writer is already * control. It is possible that a concurrent writer is already
@ -756,9 +755,9 @@ int reftable_addition_add(struct reftable_addition *add,
err = REFTABLE_IO_ERROR; err = REFTABLE_IO_ERROR;
goto done; goto done;
} }
if (add->stack->config.default_permissions) { if (add->stack->opts.default_permissions) {
if (chmod(get_tempfile_path(tab_file), if (chmod(get_tempfile_path(tab_file),
add->stack->config.default_permissions)) { add->stack->opts.default_permissions)) {
err = REFTABLE_IO_ERROR; err = REFTABLE_IO_ERROR;
goto done; goto done;
} }
@ -766,7 +765,7 @@ int reftable_addition_add(struct reftable_addition *add,
tab_fd = get_tempfile_fd(tab_file); tab_fd = get_tempfile_fd(tab_file);
wr = reftable_new_writer(reftable_fd_write, reftable_fd_flush, &tab_fd, wr = reftable_new_writer(reftable_fd_write, reftable_fd_flush, &tab_fd,
&add->stack->config); &add->stack->opts);
err = write_table(wr, arg); err = write_table(wr, arg);
if (err < 0) if (err < 0)
goto done; goto done;
@ -849,14 +848,14 @@ static int stack_compact_locked(struct reftable_stack *st,
} }
tab_fd = get_tempfile_fd(tab_file); tab_fd = get_tempfile_fd(tab_file);
if (st->config.default_permissions && if (st->opts.default_permissions &&
chmod(get_tempfile_path(tab_file), st->config.default_permissions) < 0) { chmod(get_tempfile_path(tab_file), st->opts.default_permissions) < 0) {
err = REFTABLE_IO_ERROR; err = REFTABLE_IO_ERROR;
goto done; goto done;
} }
wr = reftable_new_writer(reftable_fd_write, reftable_fd_flush, wr = reftable_new_writer(reftable_fd_write, reftable_fd_flush,
&tab_fd, &st->config); &tab_fd, &st->opts);
err = stack_write_compact(st, wr, first, last, config); err = stack_write_compact(st, wr, first, last, config);
if (err < 0) if (err < 0)
goto done; goto done;
@ -904,7 +903,7 @@ static int stack_write_compact(struct reftable_stack *st,
st->readers[last]->max_update_index); st->readers[last]->max_update_index);
err = reftable_new_merged_table(&mt, subtabs, subtabs_len, err = reftable_new_merged_table(&mt, subtabs, subtabs_len,
st->config.hash_id); st->opts.hash_id);
if (err < 0) { if (err < 0) {
reftable_free(subtabs); reftable_free(subtabs);
goto done; goto done;
@ -1094,9 +1093,9 @@ static int stack_compact_range(struct reftable_stack *st,
goto done; goto done;
} }
if (st->config.default_permissions) { if (st->opts.default_permissions) {
if (chmod(get_lock_file_path(&tables_list_lock), if (chmod(get_lock_file_path(&tables_list_lock),
st->config.default_permissions) < 0) { st->opts.default_permissions) < 0) {
err = REFTABLE_IO_ERROR; err = REFTABLE_IO_ERROR;
goto done; goto done;
} }
@ -1286,7 +1285,7 @@ static uint64_t *stack_table_sizes_for_compaction(struct reftable_stack *st)
{ {
uint64_t *sizes = uint64_t *sizes =
reftable_calloc(st->merged->stack_len, sizeof(*sizes)); reftable_calloc(st->merged->stack_len, sizeof(*sizes));
int version = (st->config.hash_id == GIT_SHA1_FORMAT_ID) ? 1 : 2; int version = (st->opts.hash_id == GIT_SHA1_FORMAT_ID) ? 1 : 2;
int overhead = header_size(version) - 1; int overhead = header_size(version) - 1;
int i = 0; int i = 0;
for (i = 0; i < st->merged->stack_len; i++) { for (i = 0; i < st->merged->stack_len; i++) {
@ -1435,11 +1434,11 @@ done:
int reftable_stack_print_directory(const char *stackdir, uint32_t hash_id) int reftable_stack_print_directory(const char *stackdir, uint32_t hash_id)
{ {
struct reftable_stack *stack = NULL; struct reftable_stack *stack = NULL;
struct reftable_write_options cfg = { .hash_id = hash_id }; struct reftable_write_options opts = { .hash_id = hash_id };
struct reftable_merged_table *merged = NULL; struct reftable_merged_table *merged = NULL;
struct reftable_table table = { NULL }; struct reftable_table table = { NULL };
int err = reftable_new_stack(&stack, stackdir, cfg); int err = reftable_new_stack(&stack, stackdir, opts);
if (err < 0) if (err < 0)
goto done; goto done;

2
reftable/stack.h
View File

@ -20,7 +20,7 @@ struct reftable_stack {
char *reftable_dir; char *reftable_dir;
struct reftable_write_options config; struct reftable_write_options opts;
struct reftable_reader **readers; struct reftable_reader **readers;
size_t readers_len; size_t readers_len;

114
reftable/stack_test.c
View File

@ -150,7 +150,7 @@ static void test_reftable_stack_add_one(void)
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct strbuf scratch = STRBUF_INIT; struct strbuf scratch = STRBUF_INIT;
int mask = umask(002); int mask = umask(002);
struct reftable_write_options cfg = { struct reftable_write_options opts = {
.default_permissions = 0660, .default_permissions = 0660,
}; };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
@ -163,7 +163,7 @@ static void test_reftable_stack_add_one(void)
}; };
struct reftable_ref_record dest = { NULL }; struct reftable_ref_record dest = { NULL };
struct stat stat_result = { 0 }; struct stat stat_result = { 0 };
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_add(st, &write_test_ref, &ref); err = reftable_stack_add(st, &write_test_ref, &ref);
@ -186,7 +186,7 @@ static void test_reftable_stack_add_one(void)
strbuf_addstr(&scratch, "/tables.list"); strbuf_addstr(&scratch, "/tables.list");
err = stat(scratch.buf, &stat_result); err = stat(scratch.buf, &stat_result);
EXPECT(!err); EXPECT(!err);
EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions); EXPECT((stat_result.st_mode & 0777) == opts.default_permissions);
strbuf_reset(&scratch); strbuf_reset(&scratch);
strbuf_addstr(&scratch, dir); strbuf_addstr(&scratch, dir);
@ -195,7 +195,7 @@ static void test_reftable_stack_add_one(void)
strbuf_addstr(&scratch, st->readers[0]->name); strbuf_addstr(&scratch, st->readers[0]->name);
err = stat(scratch.buf, &stat_result); err = stat(scratch.buf, &stat_result);
EXPECT(!err); EXPECT(!err);
EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions); EXPECT((stat_result.st_mode & 0777) == opts.default_permissions);
#else #else
(void) stat_result; (void) stat_result;
#endif #endif
@ -209,7 +209,7 @@ static void test_reftable_stack_add_one(void)
static void test_reftable_stack_uptodate(void) static void test_reftable_stack_uptodate(void)
{ {
struct reftable_write_options cfg = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL; struct reftable_stack *st1 = NULL;
struct reftable_stack *st2 = NULL; struct reftable_stack *st2 = NULL;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
@ -232,10 +232,10 @@ static void test_reftable_stack_uptodate(void)
/* simulate multi-process access to the same stack /* simulate multi-process access to the same stack
by creating two stacks for the same directory. by creating two stacks for the same directory.
*/ */
err = reftable_new_stack(&st1, dir, cfg); err = reftable_new_stack(&st1, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_new_stack(&st2, dir, cfg); err = reftable_new_stack(&st2, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_add(st1, &write_test_ref, &ref1); err = reftable_stack_add(st1, &write_test_ref, &ref1);
@ -257,8 +257,7 @@ static void test_reftable_stack_uptodate(void)
static void test_reftable_stack_transaction_api(void) static void test_reftable_stack_transaction_api(void)
{ {
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_write_options cfg = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int err; int err;
struct reftable_addition *add = NULL; struct reftable_addition *add = NULL;
@ -271,8 +270,7 @@ static void test_reftable_stack_transaction_api(void)
}; };
struct reftable_ref_record dest = { NULL }; struct reftable_ref_record dest = { NULL };
err = reftable_new_stack(&st, dir, opts);
err = reftable_new_stack(&st, dir, cfg);
EXPECT_ERR(err); EXPECT_ERR(err);
reftable_addition_destroy(add); reftable_addition_destroy(add);
@ -301,12 +299,12 @@ static void test_reftable_stack_transaction_api(void)
static void test_reftable_stack_transaction_api_performs_auto_compaction(void) static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
{ {
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options cfg = {0}; struct reftable_write_options opts = {0};
struct reftable_addition *add = NULL; struct reftable_addition *add = NULL;
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int i, n = 20, err; int i, n = 20, err;
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 0; i <= n; i++) { for (i = 0; i <= n; i++) {
@ -325,7 +323,7 @@ static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
* we can ensure that we indeed honor this setting and have * we can ensure that we indeed honor this setting and have
* better control over when exactly auto compaction runs. * better control over when exactly auto compaction runs.
*/ */
st->config.disable_auto_compact = i != n; st->opts.disable_auto_compact = i != n;
err = reftable_stack_new_addition(&add, st); err = reftable_stack_new_addition(&add, st);
EXPECT_ERR(err); EXPECT_ERR(err);
@ -361,13 +359,13 @@ static void test_reftable_stack_auto_compaction_fails_gracefully(void)
.value_type = REFTABLE_REF_VAL1, .value_type = REFTABLE_REF_VAL1,
.value.val1 = {0x01}, .value.val1 = {0x01},
}; };
struct reftable_write_options cfg = {0}; struct reftable_write_options opts = {0};
struct reftable_stack *st; struct reftable_stack *st;
struct strbuf table_path = STRBUF_INIT; struct strbuf table_path = STRBUF_INIT;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
int err; int err;
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_add(st, write_test_ref, &ref); err = reftable_stack_add(st, write_test_ref, &ref);
@ -404,8 +402,7 @@ static int write_error(struct reftable_writer *wr, void *arg)
static void test_reftable_stack_update_index_check(void) static void test_reftable_stack_update_index_check(void)
{ {
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_write_options cfg = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int err; int err;
struct reftable_ref_record ref1 = { struct reftable_ref_record ref1 = {
@ -421,7 +418,7 @@ static void test_reftable_stack_update_index_check(void)
.value.symref = "master", .value.symref = "master",
}; };
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_add(st, &write_test_ref, &ref1); err = reftable_stack_add(st, &write_test_ref, &ref1);
@ -436,12 +433,11 @@ static void test_reftable_stack_update_index_check(void)
static void test_reftable_stack_lock_failure(void) static void test_reftable_stack_lock_failure(void)
{ {
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_write_options cfg = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int err, i; int err, i;
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) { for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
err = reftable_stack_add(st, &write_error, &i); err = reftable_stack_add(st, &write_error, &i);
@ -456,7 +452,7 @@ static void test_reftable_stack_add(void)
{ {
int i = 0; int i = 0;
int err = 0; int err = 0;
struct reftable_write_options cfg = { struct reftable_write_options opts = {
.exact_log_message = 1, .exact_log_message = 1,
.default_permissions = 0660, .default_permissions = 0660,
.disable_auto_compact = 1, .disable_auto_compact = 1,
@ -469,7 +465,7 @@ static void test_reftable_stack_add(void)
struct stat stat_result; struct stat stat_result;
int N = ARRAY_SIZE(refs); int N = ARRAY_SIZE(refs);
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@ -528,7 +524,7 @@ static void test_reftable_stack_add(void)
strbuf_addstr(&path, "/tables.list"); strbuf_addstr(&path, "/tables.list");
err = stat(path.buf, &stat_result); err = stat(path.buf, &stat_result);
EXPECT(!err); EXPECT(!err);
EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions); EXPECT((stat_result.st_mode & 0777) == opts.default_permissions);
strbuf_reset(&path); strbuf_reset(&path);
strbuf_addstr(&path, dir); strbuf_addstr(&path, dir);
@ -537,7 +533,7 @@ static void test_reftable_stack_add(void)
strbuf_addstr(&path, st->readers[0]->name); strbuf_addstr(&path, st->readers[0]->name);
err = stat(path.buf, &stat_result); err = stat(path.buf, &stat_result);
EXPECT(!err); EXPECT(!err);
EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions); EXPECT((stat_result.st_mode & 0777) == opts.default_permissions);
#else #else
(void) stat_result; (void) stat_result;
#endif #endif
@ -555,7 +551,7 @@ static void test_reftable_stack_add(void)
static void test_reftable_stack_log_normalize(void) static void test_reftable_stack_log_normalize(void)
{ {
int err = 0; int err = 0;
struct reftable_write_options cfg = { struct reftable_write_options opts = {
0, 0,
}; };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
@ -579,7 +575,7 @@ static void test_reftable_stack_log_normalize(void)
.update_index = 1, .update_index = 1,
}; };
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
input.value.update.message = "one\ntwo"; input.value.update.message = "one\ntwo";
@ -612,8 +608,7 @@ static void test_reftable_stack_tombstone(void)
{ {
int i = 0; int i = 0;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_write_options cfg = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int err; int err;
struct reftable_ref_record refs[2] = { { NULL } }; struct reftable_ref_record refs[2] = { { NULL } };
@ -622,8 +617,7 @@ static void test_reftable_stack_tombstone(void)
struct reftable_ref_record dest = { NULL }; struct reftable_ref_record dest = { NULL };
struct reftable_log_record log_dest = { NULL }; struct reftable_log_record log_dest = { NULL };
err = reftable_new_stack(&st, dir, opts);
err = reftable_new_stack(&st, dir, cfg);
EXPECT_ERR(err); EXPECT_ERR(err);
/* even entries add the refs, odd entries delete them. */ /* even entries add the refs, odd entries delete them. */
@ -691,8 +685,7 @@ static void test_reftable_stack_tombstone(void)
static void test_reftable_stack_hash_id(void) static void test_reftable_stack_hash_id(void)
{ {
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_write_options cfg = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int err; int err;
@ -702,24 +695,24 @@ static void test_reftable_stack_hash_id(void)
.value.symref = "target", .value.symref = "target",
.update_index = 1, .update_index = 1,
}; };
struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID }; struct reftable_write_options opts32 = { .hash_id = GIT_SHA256_FORMAT_ID };
struct reftable_stack *st32 = NULL; struct reftable_stack *st32 = NULL;
struct reftable_write_options cfg_default = { 0 }; struct reftable_write_options opts_default = { 0 };
struct reftable_stack *st_default = NULL; struct reftable_stack *st_default = NULL;
struct reftable_ref_record dest = { NULL }; struct reftable_ref_record dest = { NULL };
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_add(st, &write_test_ref, &ref); err = reftable_stack_add(st, &write_test_ref, &ref);
EXPECT_ERR(err); EXPECT_ERR(err);
/* can't read it with the wrong hash ID. */ /* can't read it with the wrong hash ID. */
err = reftable_new_stack(&st32, dir, cfg32); err = reftable_new_stack(&st32, dir, opts32);
EXPECT(err == REFTABLE_FORMAT_ERROR); EXPECT(err == REFTABLE_FORMAT_ERROR);
/* check that we can read it back with default config too. */ /* check that we can read it back with default opts too. */
err = reftable_new_stack(&st_default, dir, cfg_default); err = reftable_new_stack(&st_default, dir, opts_default);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_read_ref(st_default, "master", &dest); err = reftable_stack_read_ref(st_default, "master", &dest);
@ -752,8 +745,7 @@ static void test_suggest_compaction_segment_nothing(void)
static void test_reflog_expire(void) static void test_reflog_expire(void)
{ {
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_write_options cfg = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
struct reftable_log_record logs[20] = { { NULL } }; struct reftable_log_record logs[20] = { { NULL } };
int N = ARRAY_SIZE(logs) - 1; int N = ARRAY_SIZE(logs) - 1;
@ -764,8 +756,7 @@ static void test_reflog_expire(void)
}; };
struct reftable_log_record log = { NULL }; struct reftable_log_record log = { NULL };
err = reftable_new_stack(&st, dir, opts);
err = reftable_new_stack(&st, dir, cfg);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 1; i <= N; i++) { for (i = 1; i <= N; i++) {
@ -828,21 +819,19 @@ static int write_nothing(struct reftable_writer *wr, void *arg)
static void test_empty_add(void) static void test_empty_add(void)
{ {
struct reftable_write_options cfg = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
int err; int err;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
struct reftable_stack *st2 = NULL; struct reftable_stack *st2 = NULL;
err = reftable_new_stack(&st, dir, opts);
err = reftable_new_stack(&st, dir, cfg);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_add(st, &write_nothing, NULL); err = reftable_stack_add(st, &write_nothing, NULL);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_new_stack(&st2, dir, cfg); err = reftable_new_stack(&st2, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
clear_dir(dir); clear_dir(dir);
reftable_stack_destroy(st); reftable_stack_destroy(st);
@ -861,16 +850,15 @@ static int fastlog2(uint64_t sz)
static void test_reftable_stack_auto_compaction(void) static void test_reftable_stack_auto_compaction(void)
{ {
struct reftable_write_options cfg = { struct reftable_write_options opts = {
.disable_auto_compact = 1, .disable_auto_compact = 1,
}; };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
int err, i; int err, i;
int N = 100; int N = 100;
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@ -900,13 +888,13 @@ static void test_reftable_stack_auto_compaction(void)
static void test_reftable_stack_add_performs_auto_compaction(void) static void test_reftable_stack_add_performs_auto_compaction(void)
{ {
struct reftable_write_options cfg = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
struct strbuf refname = STRBUF_INIT; struct strbuf refname = STRBUF_INIT;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
int err, i, n = 20; int err, i, n = 20;
err = reftable_new_stack(&st, dir, cfg); err = reftable_new_stack(&st, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 0; i <= n; i++) { for (i = 0; i <= n; i++) {
@ -921,7 +909,7 @@ static void test_reftable_stack_add_performs_auto_compaction(void)
* we can ensure that we indeed honor this setting and have * we can ensure that we indeed honor this setting and have
* better control over when exactly auto compaction runs. * better control over when exactly auto compaction runs.
*/ */
st->config.disable_auto_compact = i != n; st->opts.disable_auto_compact = i != n;
strbuf_reset(&refname); strbuf_reset(&refname);
strbuf_addf(&refname, "branch-%04d", i); strbuf_addf(&refname, "branch-%04d", i);
@ -948,14 +936,13 @@ static void test_reftable_stack_add_performs_auto_compaction(void)
static void test_reftable_stack_compaction_concurrent(void) static void test_reftable_stack_compaction_concurrent(void)
{ {
struct reftable_write_options cfg = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL, *st2 = NULL; struct reftable_stack *st1 = NULL, *st2 = NULL;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
int err, i; int err, i;
int N = 3; int N = 3;
err = reftable_new_stack(&st1, dir, cfg); err = reftable_new_stack(&st1, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@ -972,7 +959,7 @@ static void test_reftable_stack_compaction_concurrent(void)
EXPECT_ERR(err); EXPECT_ERR(err);
} }
err = reftable_new_stack(&st2, dir, cfg); err = reftable_new_stack(&st2, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_compact_all(st1, NULL); err = reftable_stack_compact_all(st1, NULL);
@ -998,14 +985,13 @@ static void unclean_stack_close(struct reftable_stack *st)
static void test_reftable_stack_compaction_concurrent_clean(void) static void test_reftable_stack_compaction_concurrent_clean(void)
{ {
struct reftable_write_options cfg = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL; struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
int err, i; int err, i;
int N = 3; int N = 3;
err = reftable_new_stack(&st1, dir, cfg); err = reftable_new_stack(&st1, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@ -1022,7 +1008,7 @@ static void test_reftable_stack_compaction_concurrent_clean(void)
EXPECT_ERR(err); EXPECT_ERR(err);
} }
err = reftable_new_stack(&st2, dir, cfg); err = reftable_new_stack(&st2, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_compact_all(st1, NULL); err = reftable_stack_compact_all(st1, NULL);
@ -1031,7 +1017,7 @@ static void test_reftable_stack_compaction_concurrent_clean(void)
unclean_stack_close(st1); unclean_stack_close(st1);
unclean_stack_close(st2); unclean_stack_close(st2);
err = reftable_new_stack(&st3, dir, cfg); err = reftable_new_stack(&st3, dir, opts);
EXPECT_ERR(err); EXPECT_ERR(err);
err = reftable_stack_clean(st3); err = reftable_stack_clean(st3);