kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

reftable: stop using `strbuf_addf()` 

We're about to introduce our own `reftable_buf` type to replace
`strbuf`. One function we'll have to convert is `strbuf_addf()`, which
is used in a handful of places. This function uses `snprintf()`
internally, which makes porting it a bit more involved:

  - It is not available on all platforms.

  - Some platforms like Windows have broken implementations.

So by using `snprintf()` we'd also push the burden on downstream users
of the reftable library to make available a properly working version of
it.

Most callsites of `strbuf_addf()` are trivial to convert to not using
it. We do end up using `snprintf()` in our unit tests, but that isn't
much of a problem for downstream users of the reftable library.

While at it, remove a useless call to `strbuf_reset()` in
`t_reftable_stack_auto_compaction_with_locked_tables()`. We don't write
to the buffer before this and initialize it with `STRBUF_INIT`, so there
is no need to reset anything.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
maint
Patrick Steinhardt 2024-10-17 06:53:47 +02:00 committed by Taylor Blau
parent 409f04995e
commit 7fa7e14ebe
4 changed files with 50 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
reftable/stack.c
View File

@ -1387,12 +1387,18 @@ static int stack_compact_range(struct reftable_stack *st,
* have just written. In case the compacted table became empty we * have just written. In case the compacted table became empty we
* simply skip writing it. * simply skip writing it.
*/ */
for (i = 0; i < first_to_replace; i++) for (i = 0; i < first_to_replace; i++) {
strbuf_addf(&tables_list_buf, "%s\n", names[i]); strbuf_addstr(&tables_list_buf, names[i]);
if (!is_empty_table) strbuf_addstr(&tables_list_buf, "\n");
strbuf_addf(&tables_list_buf, "%s\n", new_table_name.buf); }
for (i = last_to_replace + 1; names[i]; i++) if (!is_empty_table) {
strbuf_addf(&tables_list_buf, "%s\n", names[i]); strbuf_addstr(&tables_list_buf, new_table_name.buf);
strbuf_addstr(&tables_list_buf, "\n");
}
for (i = last_to_replace + 1; names[i]; i++) {
strbuf_addstr(&tables_list_buf, names[i]);
strbuf_addstr(&tables_list_buf, "\n");
}


err = write_in_full(get_lock_file_fd(&tables_list_lock), err = write_in_full(get_lock_file_fd(&tables_list_lock),
tables_list_buf.buf, tables_list_buf.len); tables_list_buf.buf, tables_list_buf.len);

7
t/unit-tests/t-reftable-block.c
View File

@ -308,10 +308,13 @@ static void t_index_block_read_write(void)
check(!ret); check(!ret);


for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
strbuf_init(&recs[i].u.idx.last_key, 9); char buf[128];


snprintf(buf, sizeof(buf), "branch%02"PRIuMAX, (uintmax_t)i);

strbuf_init(&recs[i].u.idx.last_key, 9);
recs[i].type = BLOCK_TYPE_INDEX; recs[i].type = BLOCK_TYPE_INDEX;
strbuf_addf(&recs[i].u.idx.last_key, "branch%02"PRIuMAX, (uintmax_t)i); strbuf_addstr(&recs[i].u.idx.last_key, buf);
recs[i].u.idx.offset = i; recs[i].u.idx.offset = i;


ret = block_writer_add(&bw, &recs[i]); ret = block_writer_add(&bw, &recs[i]);

20
t/unit-tests/t-reftable-readwrite.c
View File

@ -753,12 +753,13 @@ static void t_write_multiple_indices(void)
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 100, .block_size = 100,
}; };
struct strbuf writer_buf = STRBUF_INIT, buf = STRBUF_INIT; struct strbuf writer_buf = STRBUF_INIT;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_iterator it = { 0 }; struct reftable_iterator it = { 0 };
const struct reftable_stats *stats; const struct reftable_stats *stats;
struct reftable_writer *writer; struct reftable_writer *writer;
struct reftable_reader *reader; struct reftable_reader *reader;
char buf[128];
int err, i; int err, i;


writer = t_reftable_strbuf_writer(&writer_buf, &opts); writer = t_reftable_strbuf_writer(&writer_buf, &opts);
@ -770,9 +771,8 @@ static void t_write_multiple_indices(void)
.value.val1 = {i}, .value.val1 = {i},
}; };


strbuf_reset(&buf); snprintf(buf, sizeof(buf), "refs/heads/%04d", i);
strbuf_addf(&buf, "refs/heads/%04d", i); ref.refname = buf;
ref.refname = buf.buf,


err = reftable_writer_add_ref(writer, &ref); err = reftable_writer_add_ref(writer, &ref);
check(!err); check(!err);
@ -788,9 +788,8 @@ static void t_write_multiple_indices(void)
}, },
}; };


strbuf_reset(&buf); snprintf(buf, sizeof(buf), "refs/heads/%04d", i);
strbuf_addf(&buf, "refs/heads/%04d", i); log.refname = buf;
log.refname = buf.buf,


err = reftable_writer_add_log(writer, &log); err = reftable_writer_add_log(writer, &log);
check(!err); check(!err);
@ -824,7 +823,6 @@ static void t_write_multiple_indices(void)
reftable_writer_free(writer); reftable_writer_free(writer);
reftable_reader_decref(reader); reftable_reader_decref(reader);
strbuf_release(&writer_buf); strbuf_release(&writer_buf);
strbuf_release(&buf);
} }


static void t_write_multi_level_index(void) static void t_write_multi_level_index(void)
@ -848,10 +846,10 @@ static void t_write_multi_level_index(void)
.value_type = REFTABLE_REF_VAL1, .value_type = REFTABLE_REF_VAL1,
.value.val1 = {i}, .value.val1 = {i},
}; };
char buf[128];


strbuf_reset(&buf); snprintf(buf, sizeof(buf), "refs/heads/%03" PRIuMAX, (uintmax_t)i);
strbuf_addf(&buf, "refs/heads/%03" PRIuMAX, (uintmax_t)i); ref.refname = buf;
ref.refname = buf.buf,


err = reftable_writer_add_ref(writer, &ref); err = reftable_writer_add_ref(writer, &ref);
check(!err); check(!err);

42
t/unit-tests/t-reftable-stack.c
View File

@ -105,7 +105,6 @@ static int write_test_ref(struct reftable_writer *wr, void *arg)
static void write_n_ref_tables(struct reftable_stack *st, static void write_n_ref_tables(struct reftable_stack *st,
size_t n) size_t n)
{ {
struct strbuf buf = STRBUF_INIT;
int disable_auto_compact; int disable_auto_compact;
int err; int err;


@ -117,10 +116,10 @@ static void write_n_ref_tables(struct reftable_stack *st,
.update_index = reftable_stack_next_update_index(st), .update_index = reftable_stack_next_update_index(st),
.value_type = REFTABLE_REF_VAL1, .value_type = REFTABLE_REF_VAL1,
}; };
char buf[128];


strbuf_reset(&buf); snprintf(buf, sizeof(buf), "refs/heads/branch-%04"PRIuMAX, (uintmax_t)i);
strbuf_addf(&buf, "refs/heads/branch-%04"PRIuMAX, (uintmax_t)i); ref.refname = buf;
ref.refname = buf.buf;
t_reftable_set_hash(ref.value.val1, i, GIT_SHA1_FORMAT_ID); t_reftable_set_hash(ref.value.val1, i, GIT_SHA1_FORMAT_ID);


err = reftable_stack_add(st, &write_test_ref, &ref); err = reftable_stack_add(st, &write_test_ref, &ref);
@ -128,7 +127,6 @@ static void write_n_ref_tables(struct reftable_stack *st,
} }


st->opts.disable_auto_compact = disable_auto_compact; st->opts.disable_auto_compact = disable_auto_compact;
strbuf_release(&buf);
} }


struct write_log_arg { struct write_log_arg {
@ -434,7 +432,10 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
* Adding a new table to the stack should not be impacted by this, even * Adding a new table to the stack should not be impacted by this, even
* though auto-compaction will now fail. * though auto-compaction will now fail.
*/ */
strbuf_addf(&table_path, "%s/%s.lock", dir, st->readers[0]->name); strbuf_addstr(&table_path, dir);
strbuf_addstr(&table_path, "/");
strbuf_addstr(&table_path, st->readers[0]->name);
strbuf_addstr(&table_path, ".lock");
write_file_buf(table_path.buf, "", 0); write_file_buf(table_path.buf, "", 0);


ref.update_index = 2; ref.update_index = 2;
@ -1077,8 +1078,10 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
* size, we expect that auto-compaction will want to compact all of the * size, we expect that auto-compaction will want to compact all of the
* tables. Locking any of the tables will keep it from doing so. * tables. Locking any of the tables will keep it from doing so.
*/ */
strbuf_reset(&buf); strbuf_addstr(&buf, dir);
strbuf_addf(&buf, "%s/%s.lock", dir, st->readers[2]->name); strbuf_addstr(&buf, "/");
strbuf_addstr(&buf, st->readers[2]->name);
strbuf_addstr(&buf, ".lock");
write_file_buf(buf.buf, "", 0); write_file_buf(buf.buf, "", 0);


/* /*
@ -1101,7 +1104,6 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
{ {
struct reftable_write_options opts = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL; struct reftable_stack *st = NULL;
struct strbuf refname = STRBUF_INIT;
char *dir = get_tmp_dir(__LINE__); char *dir = get_tmp_dir(__LINE__);
int err; int err;
size_t i, n = 20; size_t i, n = 20;
@ -1115,6 +1117,7 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
.value_type = REFTABLE_REF_SYMREF, .value_type = REFTABLE_REF_SYMREF,
.value.symref = (char *) "master", .value.symref = (char *) "master",
}; };
char buf[128];


/* /*
* Disable auto-compaction for all but the last runs. Like this * Disable auto-compaction for all but the last runs. Like this
@ -1123,9 +1126,8 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
*/ */
st->opts.disable_auto_compact = i != n; st->opts.disable_auto_compact = i != n;


strbuf_reset(&refname); snprintf(buf, sizeof(buf), "branch-%04"PRIuMAX, (uintmax_t)i);
strbuf_addf(&refname, "branch-%04"PRIuMAX, (uintmax_t)i); ref.refname = buf;
ref.refname = refname.buf;


err = reftable_stack_add(st, write_test_ref, &ref); err = reftable_stack_add(st, write_test_ref, &ref);
check(!err); check(!err);
@ -1142,7 +1144,6 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
} }


reftable_stack_destroy(st); reftable_stack_destroy(st);
strbuf_release(&refname);
clear_dir(dir); clear_dir(dir);
} }


@ -1163,8 +1164,10 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
check_int(st->merged->readers_len, ==, 3); check_int(st->merged->readers_len, ==, 3);


/* Lock one of the tables that we're about to compact. */ /* Lock one of the tables that we're about to compact. */
strbuf_reset(&buf); strbuf_addstr(&buf, dir);
strbuf_addf(&buf, "%s/%s.lock", dir, st->readers[1]->name); strbuf_addstr(&buf, "/");
strbuf_addstr(&buf, st->readers[1]->name);
strbuf_addstr(&buf, ".lock");
write_file_buf(buf.buf, "", 0); write_file_buf(buf.buf, "", 0);


/* /*
@ -1321,10 +1324,13 @@ static void t_reftable_stack_reload_with_missing_table(void)
* our old readers. This should trigger a partial reload of the stack, * our old readers. This should trigger a partial reload of the stack,
* where we try to reuse our old readers. * where we try to reuse our old readers.
*/ */
strbuf_addf(&content, "%s\n", st->readers[0]->name); strbuf_addstr(&content, st->readers[0]->name);
strbuf_addf(&content, "%s\n", st->readers[1]->name); strbuf_addstr(&content, "\n");
strbuf_addstr(&content, st->readers[1]->name);
strbuf_addstr(&content, "\n");
strbuf_addstr(&content, "garbage\n"); strbuf_addstr(&content, "garbage\n");
strbuf_addf(&table_path, "%s.lock", st->list_file); strbuf_addstr(&table_path, st->list_file);
strbuf_addstr(&table_path, ".lock");
write_file_buf(table_path.buf, content.buf, content.len); write_file_buf(table_path.buf, content.buf, content.len);
err = rename(table_path.buf, st->list_file); err = rename(table_path.buf, st->list_file);
check(!err); check(!err);