mirror of
https://github.com/git/git.git
synced 2026-08-06 16:12:01 +00:00
44f46f2be5
When initializing the reftable stack the caller may optionally pass some
write options. These write options mix up two different concerns though:
- Of course, they allow the caller to configure how new reftables are
being written.
- But they also allow the caller to configure the stack itself, like
its hash ID and the `on_reload` callback.
This is somewhat awkward, as it doesn't easily give the caller the
flexibility to for example write multiple reftables with different
options. Furthermore, this requires us to eagerly parse relevant
configuration when initializing the reftable backend.
Refactor the code by splitting out those options that configure the
stack itself. Creating a new stack will thus only require this limited
set of options, whereas the caller is expected to pass write options to
all functions that end up writing tables.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
104 lines
2.4 KiB
C
104 lines
2.4 KiB
C
#include "unit-test.h"
|
|
#include "lib-reftable.h"
|
|
#include "hex.h"
|
|
#include "parse-options.h"
|
|
#include "reftable/constants.h"
|
|
#include "reftable/writer.h"
|
|
#include "strbuf.h"
|
|
#include "string-list.h"
|
|
#include "strvec.h"
|
|
|
|
void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)
|
|
{
|
|
memset(p, (uint8_t)i, hash_size(id));
|
|
}
|
|
|
|
static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)
|
|
{
|
|
strbuf_add(b, data, sz);
|
|
return sz;
|
|
}
|
|
|
|
static int strbuf_writer_flush(void *arg UNUSED)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
|
|
enum reftable_hash hash_id,
|
|
struct reftable_write_options *opts)
|
|
{
|
|
struct reftable_writer *writer;
|
|
int ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,
|
|
buf, hash_id, opts);
|
|
cl_assert(!ret);
|
|
return writer;
|
|
}
|
|
|
|
void cl_reftable_write_to_buf(struct reftable_buf *buf,
|
|
struct reftable_ref_record *refs,
|
|
size_t nrefs,
|
|
struct reftable_log_record *logs,
|
|
size_t nlogs,
|
|
enum reftable_hash hash_id,
|
|
struct reftable_write_options *_opts)
|
|
{
|
|
struct reftable_write_options opts = { 0 };
|
|
const struct reftable_stats *stats;
|
|
struct reftable_writer *writer;
|
|
uint64_t min = 0xffffffff;
|
|
uint64_t max = 0;
|
|
int ret;
|
|
|
|
if (_opts)
|
|
opts = *_opts;
|
|
|
|
for (size_t i = 0; i < nrefs; i++) {
|
|
uint64_t ui = refs[i].update_index;
|
|
if (ui > max)
|
|
max = ui;
|
|
if (ui < min)
|
|
min = ui;
|
|
}
|
|
for (size_t i = 0; i < nlogs; i++) {
|
|
uint64_t ui = logs[i].update_index;
|
|
if (ui > max)
|
|
max = ui;
|
|
if (ui < min)
|
|
min = ui;
|
|
}
|
|
|
|
writer = cl_reftable_strbuf_writer(buf, hash_id, &opts);
|
|
ret = reftable_writer_set_limits(writer, min, max);
|
|
cl_assert(!ret);
|
|
|
|
if (nrefs) {
|
|
ret = reftable_writer_add_refs(writer, refs, nrefs);
|
|
cl_assert_equal_i(ret, 0);
|
|
}
|
|
|
|
if (nlogs) {
|
|
ret = reftable_writer_add_logs(writer, logs, nlogs);
|
|
cl_assert_equal_i(ret, 0);
|
|
}
|
|
|
|
ret = reftable_writer_close(writer);
|
|
cl_assert_equal_i(ret, 0);
|
|
|
|
stats = reftable_writer_stats(writer);
|
|
for (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {
|
|
size_t off = i * (opts.block_size ? opts.block_size
|
|
: DEFAULT_BLOCK_SIZE);
|
|
if (!off)
|
|
off = header_size(hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);
|
|
cl_assert(buf->buf[off] == 'r');
|
|
}
|
|
|
|
if (nrefs)
|
|
cl_assert(stats->ref_stats.blocks > 0);
|
|
if (nlogs)
|
|
cl_assert(stats->log_stats.blocks > 0);
|
|
|
|
reftable_writer_free(writer);
|
|
}
|