undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reftable: add print functions to the record types

Browse Source 
This isn't used per se, but it is useful for debugging, especially
Windows CI failures.

Signed-off-by: Han-Wen Nienhuys <hanwen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Han-Wen Nienhuys 2022-01-20 15:12:14 +00:00 committed by Junio C Hamano
parent 66c0dabab5
commit 01033de49f
3 changed files with 95 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
reftable/record.c
View File

@ -255,8 +255,8 @@ static void hex_format(char *dest, uint8_t *src, int hash_size)
} }
} }
void reftable_ref_record_print(const struct reftable_ref_record *ref, static void reftable_ref_record_print_sz(const struct reftable_ref_record *ref,
uint32_t hash_id) int hash_size)
{ {
char hex[GIT_MAX_HEXSZ + 1] = { 0 }; /* BUG */ char hex[GIT_MAX_HEXSZ + 1] = { 0 }; /* BUG */
printf("ref{%s(%" PRIu64 ") ", ref->refname, ref->update_index); printf("ref{%s(%" PRIu64 ") ", ref->refname, ref->update_index);
@ -265,14 +265,14 @@ void reftable_ref_record_print(const struct reftable_ref_record *ref,
printf("=> %s", ref->value.symref); printf("=> %s", ref->value.symref);
break; break;
case REFTABLE_REF_VAL2: case REFTABLE_REF_VAL2:
hex_format(hex, ref->value.val2.value, hash_size(hash_id)); hex_format(hex, ref->value.val2.value, hash_size);
printf("val 2 %s", hex); printf("val 2 %s", hex);
hex_format(hex, ref->value.val2.target_value, hex_format(hex, ref->value.val2.target_value,
hash_size(hash_id)); hash_size);
printf("(T %s)", hex); printf("(T %s)", hex);
break; break;
case REFTABLE_REF_VAL1: case REFTABLE_REF_VAL1:
hex_format(hex, ref->value.val1, hash_size(hash_id)); hex_format(hex, ref->value.val1, hash_size);
printf("val 1 %s", hex); printf("val 1 %s", hex);
break; break;
case REFTABLE_REF_DELETION: case REFTABLE_REF_DELETION:
@ -282,6 +282,11 @@ void reftable_ref_record_print(const struct reftable_ref_record *ref,
printf("}\n"); printf("}\n");
} }
void reftable_ref_record_print(const struct reftable_ref_record *ref,
uint32_t hash_id) {
reftable_ref_record_print_sz(ref, hash_size(hash_id));
}
static void reftable_ref_record_release_void(void *rec) static void reftable_ref_record_release_void(void *rec)
{ {
reftable_ref_record_release(rec); reftable_ref_record_release(rec);
@ -443,6 +448,12 @@ static int reftable_ref_record_equal_void(const void *a,
return reftable_ref_record_equal(ra, rb, hash_size); return reftable_ref_record_equal(ra, rb, hash_size);
} }
static void reftable_ref_record_print_void(const void *rec,
int hash_size)
{
reftable_ref_record_print_sz((struct reftable_ref_record *) rec, hash_size);
}
static struct reftable_record_vtable reftable_ref_record_vtable = { static struct reftable_record_vtable reftable_ref_record_vtable = {
.key = &reftable_ref_record_key, .key = &reftable_ref_record_key,
.type = BLOCK_TYPE_REF, .type = BLOCK_TYPE_REF,
@ -453,6 +464,7 @@ static struct reftable_record_vtable reftable_ref_record_vtable = {
.release = &reftable_ref_record_release_void, .release = &reftable_ref_record_release_void,
.is_deletion = &reftable_ref_record_is_deletion_void, .is_deletion = &reftable_ref_record_is_deletion_void,
.equal = &reftable_ref_record_equal_void, .equal = &reftable_ref_record_equal_void,
.print = &reftable_ref_record_print_void,
}; };
static void reftable_obj_record_key(const void *r, struct strbuf *dest) static void reftable_obj_record_key(const void *r, struct strbuf *dest)
@ -471,6 +483,21 @@ static void reftable_obj_record_release(void *rec)
memset(obj, 0, sizeof(struct reftable_obj_record)); memset(obj, 0, sizeof(struct reftable_obj_record));
} }
static void reftable_obj_record_print(const void *rec, int hash_size)
{
const struct reftable_obj_record *obj = rec;
char hex[GIT_MAX_HEXSZ + 1] = { 0 };
struct strbuf offset_str = STRBUF_INIT;
int i;
for (i = 0; i < obj->offset_len; i++)
strbuf_addf(&offset_str, "%" PRIu64 " ", obj->offsets[i]);
hex_format(hex, obj->hash_prefix, obj->hash_prefix_len);
printf("prefix %s (len %d), offsets [%s]\n",
hex, obj->hash_prefix_len, offset_str.buf);
strbuf_release(&offset_str);
}
static void reftable_obj_record_copy_from(void *rec, const void *src_rec, static void reftable_obj_record_copy_from(void *rec, const void *src_rec,
int hash_size) int hash_size)
{ {
@ -617,31 +644,41 @@ static struct reftable_record_vtable reftable_obj_record_vtable = {
.release = &reftable_obj_record_release, .release = &reftable_obj_record_release,
.is_deletion = &not_a_deletion, .is_deletion = &not_a_deletion,
.equal = &reftable_obj_record_equal_void, .equal = &reftable_obj_record_equal_void,
.print = &reftable_obj_record_print,
}; };
void reftable_log_record_print(struct reftable_log_record *log, static void reftable_log_record_print_sz(struct reftable_log_record *log,
uint32_t hash_id) int hash_size)
{ {
char hex[GIT_MAX_HEXSZ + 1] = { 0 }; char hex[GIT_MAX_HEXSZ + 1] = { 0 };
switch (log->value_type) { switch (log->value_type) {
case REFTABLE_LOG_DELETION: case REFTABLE_LOG_DELETION:
printf("log{%s(%" PRIu64 ") delete", log->refname, printf("log{%s(%" PRIu64 ") delete\n", log->refname,
log->update_index); log->update_index);
break; break;
case REFTABLE_LOG_UPDATE: case REFTABLE_LOG_UPDATE:
printf("log{%s(%" PRIu64 ") %s <%s> %" PRIu64 " %04d\n", printf("log{%s(%" PRIu64 ") %s <%s> %" PRIu64 " %04d\n",
log->refname, log->update_index, log->value.update.name, log->refname, log->update_index,
log->value.update.email, log->value.update.time, log->value.update.name ? log->value.update.name : "",
log->value.update.email ? log->value.update.email : "",
log->value.update.time,
log->value.update.tz_offset); log->value.update.tz_offset);
hex_format(hex, log->value.update.old_hash, hash_size(hash_id)); hex_format(hex, log->value.update.old_hash, hash_size);
printf("%s => ", hex); printf("%s => ", hex);
hex_format(hex, log->value.update.new_hash, hash_size(hash_id)); hex_format(hex, log->value.update.new_hash, hash_size);
printf("%s\n\n%s\n}\n", hex, log->value.update.message); printf("%s\n\n%s\n}\n", hex,
log->value.update.message ? log->value.update.message : "");
break; break;
} }
} }
void reftable_log_record_print(struct reftable_log_record *log,
uint32_t hash_id)
{
reftable_log_record_print_sz(log, hash_size(hash_id));
}
static void reftable_log_record_key(const void *r, struct strbuf *dest) static void reftable_log_record_key(const void *r, struct strbuf *dest)
{ {
const struct reftable_log_record *rec = const struct reftable_log_record *rec =
@ -959,6 +996,11 @@ static int reftable_log_record_is_deletion_void(const void *p)
(const struct reftable_log_record *)p); (const struct reftable_log_record *)p);
} }
static void reftable_log_record_print_void(const void *rec, int hash_size)
{
reftable_log_record_print_sz((struct reftable_log_record*)rec, hash_size);
}
static struct reftable_record_vtable reftable_log_record_vtable = { static struct reftable_record_vtable reftable_log_record_vtable = {
.key = &reftable_log_record_key, .key = &reftable_log_record_key,
.type = BLOCK_TYPE_LOG, .type = BLOCK_TYPE_LOG,
@ -968,7 +1010,8 @@ static struct reftable_record_vtable reftable_log_record_vtable = {
.decode = &reftable_log_record_decode, .decode = &reftable_log_record_decode,
.release = &reftable_log_record_release_void, .release = &reftable_log_record_release_void,
.is_deletion = &reftable_log_record_is_deletion_void, .is_deletion = &reftable_log_record_is_deletion_void,
.equal = &reftable_log_record_equal_void .equal = &reftable_log_record_equal_void,
.print = &reftable_log_record_print_void,
}; };
static void reftable_index_record_key(const void *r, struct strbuf *dest) static void reftable_index_record_key(const void *r, struct strbuf *dest)
@ -1043,6 +1086,13 @@ static int reftable_index_record_equal(const void *a, const void *b, int hash_si
return ia->offset == ib->offset && !strbuf_cmp(&ia->last_key, &ib->last_key); return ia->offset == ib->offset && !strbuf_cmp(&ia->last_key, &ib->last_key);
} }
static void reftable_index_record_print(const void *rec, int hash_size)
{
const struct reftable_index_record *idx = rec;
/* TODO: escape null chars? */
printf("\"%s\" %" PRIu64 "\n", idx->last_key.buf, idx->offset);
}
static struct reftable_record_vtable reftable_index_record_vtable = { static struct reftable_record_vtable reftable_index_record_vtable = {
.key = &reftable_index_record_key, .key = &reftable_index_record_key,
.type = BLOCK_TYPE_INDEX, .type = BLOCK_TYPE_INDEX,
@ -1053,6 +1103,7 @@ static struct reftable_record_vtable reftable_index_record_vtable = {
.release = &reftable_index_record_release, .release = &reftable_index_record_release,
.is_deletion = &not_a_deletion, .is_deletion = &not_a_deletion,
.equal = &reftable_index_record_equal, .equal = &reftable_index_record_equal,
.print = &reftable_index_record_print,
}; };
void reftable_record_key(struct reftable_record *rec, struct strbuf *dest) void reftable_record_key(struct reftable_record *rec, struct strbuf *dest)
@ -1255,3 +1306,9 @@ struct reftable_record reftable_new_record(uint8_t typ)
} }
return clean; return clean;
} }
void reftable_record_print(struct reftable_record *rec, int hash_size)
{
printf("'%c': ", rec->type);
reftable_record_vtable(rec)->print(reftable_record_data(rec), hash_size);
}

4
reftable/record.h
View File

@ -61,6 +61,9 @@ struct reftable_record_vtable {
/* Are two records equal? This assumes they have the same type. Returns 0 for non-equal. */ /* Are two records equal? This assumes they have the same type. Returns 0 for non-equal. */
int (*equal)(const void *a, const void *b, int hash_size); int (*equal)(const void *a, const void *b, int hash_size);
/* Print on stdout, for debugging. */
void (*print)(const void *rec, int hash_size);
}; };
/* returns true for recognized block types. Block start with the block type. */ /* returns true for recognized block types. Block start with the block type. */
@ -112,6 +115,7 @@ struct reftable_record {
/* see struct record_vtable */ /* see struct record_vtable */
int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size); int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
void reftable_record_print(struct reftable_record *rec, int hash_size);
void reftable_record_key(struct reftable_record *rec, struct strbuf *dest); void reftable_record_key(struct reftable_record *rec, struct strbuf *dest);
uint8_t reftable_record_type(struct reftable_record *rec); uint8_t reftable_record_type(struct reftable_record *rec);
void reftable_record_copy_from(struct reftable_record *rec, void reftable_record_copy_from(struct reftable_record *rec,

21
reftable/record_test.c
View File

@ -25,6 +25,10 @@ static void test_copy(struct reftable_record *rec)
/* do it twice to catch memory leaks */ /* do it twice to catch memory leaks */
reftable_record_copy_from(&copy, rec, GIT_SHA1_RAWSZ); reftable_record_copy_from(&copy, rec, GIT_SHA1_RAWSZ);
EXPECT(reftable_record_equal(rec, &copy, GIT_SHA1_RAWSZ)); EXPECT(reftable_record_equal(rec, &copy, GIT_SHA1_RAWSZ));
puts("testing print coverage:\n");
reftable_record_print(&copy, GIT_SHA1_RAWSZ);
reftable_record_release(&copy); reftable_record_release(&copy);
} }
@ -176,7 +180,8 @@ static void test_reftable_log_record_equal(void)
static void test_reftable_log_record_roundtrip(void) static void test_reftable_log_record_roundtrip(void)
{ {
int i; int i;
struct reftable_log_record in[2] = {
struct reftable_log_record in[] = {
{ {
.refname = xstrdup("refs/heads/master"), .refname = xstrdup("refs/heads/master"),
.update_index = 42, .update_index = 42,
@ -197,10 +202,24 @@ static void test_reftable_log_record_roundtrip(void)
.refname = xstrdup("refs/heads/master"), .refname = xstrdup("refs/heads/master"),
.update_index = 22, .update_index = 22,
.value_type = REFTABLE_LOG_DELETION, .value_type = REFTABLE_LOG_DELETION,
},
{
.refname = xstrdup("branch"),
.update_index = 33,
.value_type = REFTABLE_LOG_UPDATE,
.value = {
.update = {
.old_hash = reftable_malloc(GIT_SHA1_RAWSZ),
.new_hash = reftable_malloc(GIT_SHA1_RAWSZ),
/* rest of fields left empty. */
},
},
} }
}; };
set_test_hash(in[0].value.update.new_hash, 1); set_test_hash(in[0].value.update.new_hash, 1);
set_test_hash(in[0].value.update.old_hash, 2); set_test_hash(in[0].value.update.old_hash, 2);
set_test_hash(in[2].value.update.new_hash, 3);
set_test_hash(in[2].value.update.old_hash, 4);
for (i = 0; i < ARRAY_SIZE(in); i++) { for (i = 0; i < ARRAY_SIZE(in); i++) {
struct reftable_record rec = { .type = BLOCK_TYPE_LOG }; struct reftable_record rec = { .type = BLOCK_TYPE_LOG };
struct strbuf key = STRBUF_INIT; struct strbuf key = STRBUF_INIT;