Merge branch 'ps/reftable-write-optim'

Code to write out reftable has seen some optimization and
simplification.

* ps/reftable-write-optim:
  reftable/block: reuse compressed array
  reftable/block: reuse zstream when writing log blocks
  reftable/writer: reset `last_key` instead of releasing it
  reftable/writer: unify releasing memory
  reftable/writer: refactorings for `writer_flush_nonempty_block()`
  reftable/writer: refactorings for `writer_add_record()`
  refs/reftable: don't recompute committer ident
  reftable: remove name checks
  refs/reftable: skip duplicate name checks
  refs/reftable: perform explicit D/F check when writing symrefs
  refs/reftable: fix D/F conflict error message on ref copy

diff --cc Makefile
Simple merge

diff --cc refs/reftable-backend.c
Simple merge

diff --cc reftable/block.c
Simple merge

diff --cc reftable/block.h
Simple merge

diff --cc reftable/error.c
Simple merge

diff --cc reftable/reftable-error.h
Simple merge

diff --cc reftable/reftable-writer.h
Simple merge

diff --cc reftable/stack.c
Simple merge

diff --cc reftable/stack_test.c
index 1df3ffce5261f2cf63c3719198e0e2d71df13bb8,b88097c3b6b51115d2ecdbff7c59d7f92de77eec..7889f818d16ebb96a169bf2b95f4b2dbd071b75a
--- 1/reftable/stack_test.c
--- 2/reftable/stack_test.c
+++ b/reftable/stack_test.c
@@@ -353,87 -353,6 +353,49 @@@ static void test_reftable_stack_transac
        clear_dir(dir);
  }
  
- static void test_reftable_stack_validate_refname(void)
- {
-       struct reftable_write_options cfg = { 0 };
-       struct reftable_stack *st = NULL;
-       int err;
-       char *dir = get_tmp_dir(__LINE__);
- 
-       int i;
-       struct reftable_ref_record ref = {
-               .refname = "a/b",
-               .update_index = 1,
-               .value_type = REFTABLE_REF_SYMREF,
-               .value.symref = "master",
-       };
-       char *additions[] = { "a", "a/b/c" };
- 
-       err = reftable_new_stack(&st, dir, cfg);
-       EXPECT_ERR(err);
- 
-       err = reftable_stack_add(st, &write_test_ref, &ref);
-       EXPECT_ERR(err);
- 
-       for (i = 0; i < ARRAY_SIZE(additions); i++) {
-               struct reftable_ref_record ref = {
-                       .refname = additions[i],
-                       .update_index = 1,
-                       .value_type = REFTABLE_REF_SYMREF,
-                       .value.symref = "master",
-               };
- 
-               err = reftable_stack_add(st, &write_test_ref, &ref);
-               EXPECT(err == REFTABLE_NAME_CONFLICT);
-       }
- 
-       reftable_stack_destroy(st);
-       clear_dir(dir);
- }
- 
 +static void test_reftable_stack_auto_compaction_fails_gracefully(void)
 +{
 +      struct reftable_ref_record ref = {
 +              .refname = "refs/heads/master",
 +              .update_index = 1,
 +              .value_type = REFTABLE_REF_VAL1,
 +              .value.val1 = {0x01},
 +      };
 +      struct reftable_write_options cfg = {0};
 +      struct reftable_stack *st;
 +      struct strbuf table_path = STRBUF_INIT;
 +      char *dir = get_tmp_dir(__LINE__);
 +      int err;
 +
 +      err = reftable_new_stack(&st, dir, cfg);
 +      EXPECT_ERR(err);
 +
 +      err = reftable_stack_add(st, write_test_ref, &ref);
 +      EXPECT_ERR(err);
 +      EXPECT(st->merged->stack_len == 1);
 +      EXPECT(st->stats.attempts == 0);
 +      EXPECT(st->stats.failures == 0);
 +
 +      /*
 +       * Lock the newly written table such that it cannot be compacted.
 +       * Adding a new table to the stack should not be impacted by this, even
 +       * though auto-compaction will now fail.
 +       */
 +      strbuf_addf(&table_path, "%s/%s.lock", dir, st->readers[0]->name);
 +      write_file_buf(table_path.buf, "", 0);
 +
 +      ref.update_index = 2;
 +      err = reftable_stack_add(st, write_test_ref, &ref);
 +      EXPECT_ERR(err);
 +      EXPECT(st->merged->stack_len == 2);
 +      EXPECT(st->stats.attempts == 1);
 +      EXPECT(st->stats.failures == 1);
 +
 +      reftable_stack_destroy(st);
 +      strbuf_release(&table_path);
 +      clear_dir(dir);
 +}
 +
  static int write_error(struct reftable_writer *wr, void *arg)
  {
        return *((int *)arg);
@@@ -1102,10 -1057,11 +1064,9 @@@ int stack_test_main(int argc, const cha
        RUN_TEST(test_reftable_stack_tombstone);
        RUN_TEST(test_reftable_stack_transaction_api);
        RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
 +      RUN_TEST(test_reftable_stack_auto_compaction_fails_gracefully);
        RUN_TEST(test_reftable_stack_update_index_check);
        RUN_TEST(test_reftable_stack_uptodate);
-       RUN_TEST(test_reftable_stack_validate_refname);
 -      RUN_TEST(test_sizes_to_segments);
 -      RUN_TEST(test_sizes_to_segments_all_equal);
 -      RUN_TEST(test_sizes_to_segments_empty);
        RUN_TEST(test_suggest_compaction_segment);
        RUN_TEST(test_suggest_compaction_segment_nothing);
        return 0;

diff --cc t/t0610-reftable-basics.sh
Simple merge