subversion/libsvn_fs/editor.c

/*
 * editor.c:  Editor for modifying FS transactions
 *
 * ====================================================================
 *    Licensed to the Apache Software Foundation (ASF) under one
 *    or more contributor license agreements.  See the NOTICE file
 *    distributed with this work for additional information
 *    regarding copyright ownership.  The ASF licenses this file
 *    to you under the Apache License, Version 2.0 (the
 *    "License"); you may not use this file except in compliance
 *    with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing,
 *    software distributed under the License is distributed on an
 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *    KIND, either express or implied.  See the License for the
 *    specific language governing permissions and limitations
 *    under the License.
 * ====================================================================
 */

#include <apr_pools.h>

#include "svn_types.h"
#include "svn_error.h"
#include "svn_pools.h"
#include "svn_fs.h"
#include "svn_props.h"
#include "svn_path.h"

#include "svn_private_config.h"

#include "fs-loader.h"

#include "private/svn_fspath.h"
#include "private/svn_fs_private.h"
#include "private/svn_editor.h"


struct edit_baton {
  /* The transaction associated with this editor.  */
  svn_fs_txn_t *txn;

  /* Has this editor been completed?  */
  svn_boolean_t completed;

  /* We sometimes need the cancellation beyond what svn_editor_t provides  */
  svn_cancel_func_t cancel_func;
  void *cancel_baton;

  /* The pool that the txn lives within. When we create a ROOT, it will
     be allocated within a subpool of this. The root will be closed in
     complete/abort and that subpool will be destroyed.

     This pool SHOULD NOT be used for any allocations.  */
  apr_pool_t *txn_pool;

  /* This is the root from the txn. Use get_root() to fetch/create this
     member as appropriate.  */
  svn_fs_root_t *root;
};

#define FSPATH(relpath, pool) apr_pstrcat(pool, "/", relpath, SVN_VA_NULL)

static svn_error_t *
get_root(svn_fs_root_t **root,
         struct edit_baton *eb)
{
  if (eb->root == NULL)
    SVN_ERR(svn_fs_txn_root(&eb->root, eb->txn, eb->txn_pool));
  *root = eb->root;
  return SVN_NO_ERROR;
}


/* Apply each property in PROPS to the node at FSPATH in ROOT.  */
static svn_error_t *
add_new_props(svn_fs_root_t *root,
              const char *fspath,
              apr_hash_t *props,
              apr_pool_t *scratch_pool)
{
  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
  apr_hash_index_t *hi;

  /* ### it would be nice to have svn_fs_set_node_props(). but since we
     ### don't... add each property to the node. this is a new node, so
     ### we don't need to worry about deleting props. just adding.  */

  for (hi = apr_hash_first(scratch_pool, props); hi;
       hi = apr_hash_next(hi))
    {
      const char *name = apr_hash_this_key(hi);
      const svn_string_t *value = apr_hash_this_val(hi);

      svn_pool_clear(iterpool);

      SVN_ERR(svn_fs_change_node_prop(root, fspath, name, value, iterpool));
    }

  svn_pool_destroy(iterpool);
  return SVN_NO_ERROR;
}


static svn_error_t *
alter_props(svn_fs_root_t *root,
            const char *fspath,
            apr_hash_t *props,
            apr_pool_t *scratch_pool)
{
  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
  apr_hash_t *old_props;
  apr_array_header_t *propdiffs;
  int i;

  SVN_ERR(svn_fs_node_proplist(&old_props, root, fspath, scratch_pool));

  SVN_ERR(svn_prop_diffs(&propdiffs, props, old_props, scratch_pool));

  for (i = 0; i < propdiffs->nelts; ++i)
    {
      const svn_prop_t *prop = &APR_ARRAY_IDX(propdiffs, i, svn_prop_t);

      svn_pool_clear(iterpool);

      /* Add, change, or delete properties.  */
      SVN_ERR(svn_fs_change_node_prop(root, fspath, prop->name, prop->value,
                                      iterpool));
    }

  svn_pool_destroy(iterpool);
  return SVN_NO_ERROR;
}


static svn_error_t *
set_text(svn_fs_root_t *root,
         const char *fspath,
         const svn_checksum_t *checksum,
         svn_stream_t *contents,
         svn_cancel_func_t cancel_func,
         void *cancel_baton,
         apr_pool_t *scratch_pool)
{
  svn_stream_t *fs_contents;

  /* ### We probably don't have an MD5 checksum, so no digest is available
     ### for svn_fs_apply_text() to validate. It would be nice to have an
     ### FS API that takes our CHECKSUM/CONTENTS pair (and PROPS!).  */
  SVN_ERR(svn_fs_apply_text(&fs_contents, root, fspath,
                            NULL /* result_checksum */,
                            scratch_pool));
  SVN_ERR(svn_stream_copy3(contents, fs_contents,
                           cancel_func, cancel_baton,
                           scratch_pool));

  return SVN_NO_ERROR;
}


/* The caller wants to modify REVISION of FSPATH. Is that allowed?  */
static svn_error_t *
can_modify(svn_fs_root_t *txn_root,
           const char *fspath,
           svn_revnum_t revision,
           apr_pool_t *scratch_pool)
{
  svn_revnum_t created_rev;

  /* Out-of-dateness check:  compare the created-rev of the node
     in the txn against the created-rev of FSPATH.  */
  SVN_ERR(svn_fs_node_created_rev(&created_rev, txn_root, fspath,
                                  scratch_pool));

  /* Uncommitted nodes (eg. a descendant of a copy/move destination)
     have no (committed) revision number. Let the caller go ahead and
     modify these nodes.

     Note: strictly speaking, they might be performing an "illegal" edit
     in certain cases, but let's just assume they're Good Little Boys.

     If CREATED_REV is invalid, that means it's already mutable in the
     txn, which means it has already passed this out-of-dateness check.
     (Usually, this happens when looking at a parent directory of an
     already-modified node)  */
  if (!SVN_IS_VALID_REVNUM(created_rev))
    return SVN_NO_ERROR;

  /* If the node is immutable (has a revision), then the caller should
     have supplied a valid revision number [that they expect to change].
     The checks further below will determine the out-of-dateness of the
     specified revision.  */
  /* ### ugh. descendants of copy/move destinations carry along
     ### their original immutable state and (thus) a valid CREATED_REV.
     ### but they are logically uncommitted, so the caller will pass
     ### SVN_INVALID_REVNUM. (technically, the caller could provide
     ### ORIGINAL_REV, but that is semantically incorrect for the Ev2
     ### API).
     ###
     ### for now, we will assume the caller knows what they are doing
     ### and an invalid revision implies such a descendant. in the
     ### future, we could examine the ancestor chain looking for a
     ### copy/move-here node and allow the modification (and the
     ### converse: if no such ancestor, the caller must specify the
     ### correct/intended revision to modify).
  */
#if 1
  if (!SVN_IS_VALID_REVNUM(revision))
    return SVN_NO_ERROR;
#else
  if (!SVN_IS_VALID_REVNUM(revision))
    /* ### use a custom error code?  */
    return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
                             _("Revision for modifying '%s' is required"),
                             fspath);
#endif

  if (revision < created_rev)
    {
      /* We asked to change a node that is *older* than what we found
         in the transaction. The client is out of date.  */
      return svn_error_createf(SVN_ERR_FS_OUT_OF_DATE, NULL,
                               _("'%s' is out of date; try updating"),
                               fspath);
    }

  if (revision > created_rev)
    {
      /* We asked to change a node that is *newer* than what we found
         in the transaction. Given that the transaction was based off
         of 'youngest', then either:
         - the caller asked to modify a future node
         - the caller has committed more revisions since this txn
         was constructed, and is asking to modify a node in one
         of those new revisions.
         In either case, the node may not have changed in those new
         revisions; use the node's ID to determine this case.  */
      svn_fs_root_t *rev_root;
      svn_fs_node_relation_t relation;

      /* Get the ID from the future/new revision.  */
      SVN_ERR(svn_fs_revision_root(&rev_root, svn_fs_root_fs(txn_root),
                                   revision, scratch_pool));
      SVN_ERR(svn_fs_node_relation(&relation, txn_root, fspath, rev_root,
                                   fspath, scratch_pool));
      svn_fs_close_root(rev_root);

      /* Has the target node changed in the future?  */
      if (relation != svn_fs_node_unchanged)
        {
          /* Restarting the commit will base the txn on the future/new
             revision, allowing the modification at REVISION.  */
          /* ### use a custom error code  */
          return svn_error_createf(SVN_ERR_FS_CONFLICT, NULL,
                                   _("'%s' has been modified since the "
                                     "commit began (restart the commit)"),
                                   fspath);
        }
    }

  return SVN_NO_ERROR;
}


/* Can we create a node at FSPATH in TXN_ROOT? If something already exists
   at that path, then the client MAY be out of date. We then have to see if
   the path was created/modified in this transaction. IOW, it is new and
   can be replaced without problem.

   Note: the editor protocol disallows double-modifications. This is to
   ensure somebody does not accidentally overwrite another file due to
   being out-of-date.  */
static svn_error_t *
can_create(svn_fs_root_t *txn_root,
           const char *fspath,
           apr_pool_t *scratch_pool)
{
  svn_node_kind_t kind;
  const char *cur_fspath;

  SVN_ERR(svn_fs_check_path(&kind, txn_root, fspath, scratch_pool));
  if (kind == svn_node_none)
    return SVN_NO_ERROR;

  /* ### I'm not sure if this works perfectly. We might have an ancestor
     ### that was modified as a result of a change on a cousin. We might
     ### misinterpret that as a *-here node which brought along this
     ### child. Need to write a test to verify. We may also be able to
     ### test the ancestor to determine if it has been *-here in this
     ### txn, or just a simple modification.  */

  /* Are any of the parents copied/moved-here?  */
  for (cur_fspath = fspath;
       strlen(cur_fspath) > 1;  /* not the root  */
       cur_fspath = svn_fspath__dirname(cur_fspath, scratch_pool))
    {
      svn_revnum_t created_rev;

      SVN_ERR(svn_fs_node_created_rev(&created_rev, txn_root, cur_fspath,
                                      scratch_pool));
      if (!SVN_IS_VALID_REVNUM(created_rev))
        {
          /* The node has no created revision, meaning it is uncommitted.
             Thus, it was created in this transaction, or it has already
             been modified in some way (implying it has already passed a
             modification check.  */
          /* ### verify the node has been *-here ??  */
          return SVN_NO_ERROR;
        }
    }

  return svn_error_createf(SVN_ERR_FS_OUT_OF_DATE, NULL,
                           _("'%s' already exists, so may be out"
                             " of date; try updating"),
                           fspath);
}


/* This implements svn_editor_cb_add_directory_t */
static svn_error_t *
add_directory_cb(void *baton,
                 const char *relpath,
                 const apr_array_header_t *children,
                 apr_hash_t *props,
                 svn_revnum_t replaces_rev,
                 apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *fspath = FSPATH(relpath, scratch_pool);
  svn_fs_root_t *root;

  /* Note: we ignore CHILDREN. We have no "incomplete" state to worry about,
     so we don't need to be aware of what children will be created.  */

  SVN_ERR(get_root(&root, eb));

  if (SVN_IS_VALID_REVNUM(replaces_rev))
    {
      SVN_ERR(can_modify(root, fspath, replaces_rev, scratch_pool));
      SVN_ERR(svn_fs_delete(root, fspath, scratch_pool));
    }
  else
    {
      SVN_ERR(can_create(root, fspath, scratch_pool));
    }

  SVN_ERR(svn_fs_make_dir(root, fspath, scratch_pool));
  SVN_ERR(add_new_props(root, fspath, props, scratch_pool));

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_add_file_t */
static svn_error_t *
add_file_cb(void *baton,
            const char *relpath,
            const svn_checksum_t *checksum,
            svn_stream_t *contents,
            apr_hash_t *props,
            svn_revnum_t replaces_rev,
            apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *fspath = FSPATH(relpath, scratch_pool);
  svn_fs_root_t *root;

  SVN_ERR(get_root(&root, eb));

  if (SVN_IS_VALID_REVNUM(replaces_rev))
    {
      SVN_ERR(can_modify(root, fspath, replaces_rev, scratch_pool));
      SVN_ERR(svn_fs_delete(root, fspath, scratch_pool));
    }
  else
    {
      SVN_ERR(can_create(root, fspath, scratch_pool));
    }

  SVN_ERR(svn_fs_make_file(root, fspath, scratch_pool));

  SVN_ERR(set_text(root, fspath, checksum, contents,
                   eb->cancel_func, eb->cancel_baton, scratch_pool));
  SVN_ERR(add_new_props(root, fspath, props, scratch_pool));

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_add_symlink_t */
static svn_error_t *
add_symlink_cb(void *baton,
               const char *relpath,
               const char *target,
               apr_hash_t *props,
               svn_revnum_t replaces_rev,
               apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *fspath = FSPATH(relpath, scratch_pool);
  svn_fs_root_t *root;

  SVN_ERR(get_root(&root, eb));

  if (SVN_IS_VALID_REVNUM(replaces_rev))
    {
      SVN_ERR(can_modify(root, fspath, replaces_rev, scratch_pool));
      SVN_ERR(svn_fs_delete(root, fspath, scratch_pool));
    }
  else
    {
      SVN_ERR(can_create(root, fspath, scratch_pool));
    }

  /* ### we probably need to construct a file with specific contents
     ### (until the FS grows some symlink APIs)  */
#if 0
  SVN_ERR(svn_fs_make_file(root, fspath, scratch_pool));
  SVN_ERR(svn_fs_apply_text(&fs_contents, root, fspath,
                            NULL /* result_checksum */,
                            scratch_pool));
  /* ### SVN_ERR(svn_stream_printf(fs_contents, ..., scratch_pool));  */
  apr_hash_set(props, SVN_PROP_SPECIAL, APR_HASH_KEY_STRING,
               SVN_PROP_SPECIAL_VALUE);

  SVN_ERR(add_new_props(root, fspath, props, scratch_pool));
#endif

  SVN__NOT_IMPLEMENTED();
}


/* This implements svn_editor_cb_add_absent_t */
static svn_error_t *
add_absent_cb(void *baton,
              const char *relpath,
              svn_node_kind_t kind,
              svn_revnum_t replaces_rev,
              apr_pool_t *scratch_pool)
{
  /* This is a programming error. Code should not attempt to create these
     kinds of nodes within the FS.  */
  /* ### use a custom error code  */
  return svn_error_create(
           SVN_ERR_UNSUPPORTED_FEATURE, NULL,
           _("The filesystem does not support 'absent' nodes"));
}


/* This implements svn_editor_cb_alter_directory_t */
static svn_error_t *
alter_directory_cb(void *baton,
                   const char *relpath,
                   svn_revnum_t revision,
                   const apr_array_header_t *children,
                   apr_hash_t *props,
                   apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *fspath = FSPATH(relpath, scratch_pool);
  svn_fs_root_t *root;

  /* Note: we ignore CHILDREN. We have no "incomplete" state to worry about,
     so we don't need to be aware of what children will be created.  */

  SVN_ERR(get_root(&root, eb));
  SVN_ERR(can_modify(root, fspath, revision, scratch_pool));

  if (props)
    SVN_ERR(alter_props(root, fspath, props, scratch_pool));

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_alter_file_t */
static svn_error_t *
alter_file_cb(void *baton,
              const char *relpath,
              svn_revnum_t revision,
              const svn_checksum_t *checksum,
              svn_stream_t *contents,
              apr_hash_t *props,
              apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *fspath = FSPATH(relpath, scratch_pool);
  svn_fs_root_t *root;

  SVN_ERR(get_root(&root, eb));
  SVN_ERR(can_modify(root, fspath, revision, scratch_pool));

  if (contents != NULL)
    {
      SVN_ERR_ASSERT(checksum != NULL);
      SVN_ERR(set_text(root, fspath, checksum, contents,
                       eb->cancel_func, eb->cancel_baton, scratch_pool));
    }

  if (props != NULL)
    {
      SVN_ERR(alter_props(root, fspath, props, scratch_pool));
    }

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_alter_symlink_t */
static svn_error_t *
alter_symlink_cb(void *baton,
                 const char *relpath,
                 svn_revnum_t revision,
                 const char *target,
                 apr_hash_t *props,
                 apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;

  SVN_UNUSED(eb);
  SVN__NOT_IMPLEMENTED();
}


/* This implements svn_editor_cb_delete_t */
static svn_error_t *
delete_cb(void *baton,
          const char *relpath,
          svn_revnum_t revision,
          apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *fspath = FSPATH(relpath, scratch_pool);
  svn_fs_root_t *root;

  SVN_ERR(get_root(&root, eb));
  SVN_ERR(can_modify(root, fspath, revision, scratch_pool));

  SVN_ERR(svn_fs_delete(root, fspath, scratch_pool));

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_copy_t */
static svn_error_t *
copy_cb(void *baton,
        const char *src_relpath,
        svn_revnum_t src_revision,
        const char *dst_relpath,
        svn_revnum_t replaces_rev,
        apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *src_fspath = FSPATH(src_relpath, scratch_pool);
  const char *dst_fspath = FSPATH(dst_relpath, scratch_pool);
  svn_fs_root_t *root;
  svn_fs_root_t *src_root;

  SVN_ERR(get_root(&root, eb));

  /* Check if we can we replace the maybe-specified destination (revision).  */
  if (SVN_IS_VALID_REVNUM(replaces_rev))
    {
      SVN_ERR(can_modify(root, dst_fspath, replaces_rev, scratch_pool));
      SVN_ERR(svn_fs_delete(root, dst_fspath, scratch_pool));
    }
  else
    {
      SVN_ERR(can_create(root, dst_fspath, scratch_pool));
    }

  SVN_ERR(svn_fs_revision_root(&src_root, svn_fs_root_fs(root), src_revision,
                               scratch_pool));
  SVN_ERR(svn_fs_copy(src_root, src_fspath, root, dst_fspath, scratch_pool));
  svn_fs_close_root(src_root);

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_move_t */
static svn_error_t *
move_cb(void *baton,
        const char *src_relpath,
        svn_revnum_t src_revision,
        const char *dst_relpath,
        svn_revnum_t replaces_rev,
        apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  const char *src_fspath = FSPATH(src_relpath, scratch_pool);
  const char *dst_fspath = FSPATH(dst_relpath, scratch_pool);
  svn_fs_root_t *root;
  svn_fs_root_t *src_root;

  SVN_ERR(get_root(&root, eb));

  /* Check if we delete the specified source (revision), and can we replace
     the maybe-specified destination (revision).  */
  SVN_ERR(can_modify(root, src_fspath, src_revision, scratch_pool));
  if (SVN_IS_VALID_REVNUM(replaces_rev))
    {
      SVN_ERR(can_modify(root, dst_fspath, replaces_rev, scratch_pool));
      SVN_ERR(svn_fs_delete(root, dst_fspath, scratch_pool));
    }
  else
    {
      SVN_ERR(can_create(root, dst_fspath, scratch_pool));
    }

  /* ### would be nice to have svn_fs_move()  */

  /* Copy the src to the dst. */
  SVN_ERR(svn_fs_revision_root(&src_root, svn_fs_root_fs(root), src_revision,
                               scratch_pool));
  SVN_ERR(svn_fs_copy(src_root, src_fspath, root, dst_fspath, scratch_pool));
  svn_fs_close_root(src_root);

  /* Notice: we're deleting the src repos path from the dst root. */
  SVN_ERR(svn_fs_delete(root, src_fspath, scratch_pool));

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_complete_t */
static svn_error_t *
complete_cb(void *baton,
            apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;

  /* Watch out for a following call to svn_fs_editor_commit(). Note that
     we are likely here because svn_fs_editor_commit() was called, and it
     invoked svn_editor_complete().  */
  eb->completed = TRUE;

  if (eb->root != NULL)
    {
      svn_fs_close_root(eb->root);
      eb->root = NULL;
    }

  return SVN_NO_ERROR;
}


/* This implements svn_editor_cb_abort_t */
static svn_error_t *
abort_cb(void *baton,
         apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = baton;
  svn_error_t *err;

  /* Don't allow a following call to svn_fs_editor_commit().  */
  eb->completed = TRUE;

  if (eb->root != NULL)
    {
      svn_fs_close_root(eb->root);
      eb->root = NULL;
    }

  /* ### should we examine the error and attempt svn_fs_purge_txn() ?  */
  err = svn_fs_abort_txn(eb->txn, scratch_pool);

  /* For safety, clear the now-useless txn.  */
  eb->txn = NULL;

  return svn_error_trace(err);
}


static svn_error_t *
make_editor(svn_editor_t **editor,
            svn_fs_txn_t *txn,
            svn_cancel_func_t cancel_func,
            void *cancel_baton,
            apr_pool_t *result_pool,
            apr_pool_t *scratch_pool)
{
  static const svn_editor_cb_many_t editor_cbs = {
    add_directory_cb,
    add_file_cb,
    add_symlink_cb,
    add_absent_cb,
    alter_directory_cb,
    alter_file_cb,
    alter_symlink_cb,
    delete_cb,
    copy_cb,
    move_cb,
    complete_cb,
    abort_cb
  };
  struct edit_baton *eb = apr_pcalloc(result_pool, sizeof(*eb));

  eb->txn = txn;
  eb->cancel_func = cancel_func;
  eb->cancel_baton = cancel_baton;
  eb->txn_pool = result_pool;

  SVN_ERR(svn_editor_create(editor, eb, cancel_func, cancel_baton,
                            result_pool, scratch_pool));
  SVN_ERR(svn_editor_setcb_many(*editor, &editor_cbs, scratch_pool));

  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs__editor_create(svn_editor_t **editor,
                      const char **txn_name,
                      svn_fs_t *fs,
                      apr_uint32_t flags,
                      svn_cancel_func_t cancel_func,
                      void *cancel_baton,
                      apr_pool_t *result_pool,
                      apr_pool_t *scratch_pool)
{
  svn_revnum_t revision;
  svn_fs_txn_t *txn;

  SVN_ERR(svn_fs_youngest_rev(&revision, fs, scratch_pool));
  SVN_ERR(svn_fs_begin_txn2(&txn, fs, revision, flags, result_pool));
  SVN_ERR(svn_fs_txn_name(txn_name, txn, result_pool));
  return svn_error_trace(make_editor(editor, txn,
                                     cancel_func, cancel_baton,
                                     result_pool, scratch_pool));
}


svn_error_t *
svn_fs__editor_create_for(svn_editor_t **editor,
                          svn_fs_t *fs,
                          const char *txn_name,
                          svn_cancel_func_t cancel_func,
                          void *cancel_baton,
                          apr_pool_t *result_pool,
                          apr_pool_t *scratch_pool)
{
  svn_fs_txn_t *txn;

  SVN_ERR(svn_fs_open_txn(&txn, fs, txn_name, result_pool));
  return svn_error_trace(make_editor(editor, txn,
                                     cancel_func, cancel_baton,
                                     result_pool, scratch_pool));
}


svn_error_t *
svn_fs__editor_commit(svn_revnum_t *revision,
                      svn_error_t **post_commit_err,
                      const char **conflict_path,
                      svn_editor_t *editor,
                      apr_pool_t *result_pool,
                      apr_pool_t *scratch_pool)
{
  struct edit_baton *eb = svn_editor_get_baton(editor);
  const char *inner_conflict_path;
  svn_error_t *err = NULL;

  /* make sure people are using the correct sequencing.  */
  if (eb->completed)
    return svn_error_create(SVN_ERR_FS_INCORRECT_EDITOR_COMPLETION,
                            NULL, NULL);

  *revision = SVN_INVALID_REVNUM;
  *post_commit_err = NULL;
  *conflict_path = NULL;

  /* Clean up internal resources (eg. eb->root). This also allows the
     editor infrastructure to know this editor is "complete".  */
  err = svn_editor_complete(editor);
  if (err)
    {
      svn_fs_txn_t *txn = eb->txn;

      eb->txn = NULL;
      return svn_error_trace(svn_error_compose_create(
                  err,
                  svn_fs_abort_txn(txn, scratch_pool)));
    }

  /* Note: docco for svn_fs_commit_txn() states that CONFLICT_PATH will
     be allocated in the txn's pool. But it lies. Regardless, we want
     it placed into RESULT_POOL.  */

  err = svn_fs_commit_txn(&inner_conflict_path,
                          revision,
                          eb->txn,
                          scratch_pool);
  if (SVN_IS_VALID_REVNUM(*revision))
    {
      if (err)
        {
          /* Case 3. ERR is a post-commit (cleanup) error.  */

          /* Pass responsibility via POST_COMMIT_ERR.  */
          *post_commit_err = err;
          err = SVN_NO_ERROR;
        }
      /* else: Case 1.  */
    }
  else
    {
      SVN_ERR_ASSERT(err != NULL);
      if (err->apr_err == SVN_ERR_FS_CONFLICT)
        {
          /* Case 2.  */

          /* Copy this into the correct pool (see note above).  */
          *conflict_path = apr_pstrdup(result_pool, inner_conflict_path);

          /* Return success. The caller should inspect CONFLICT_PATH to
             determine this particular case.  */
          svn_error_clear(err);
          err = SVN_NO_ERROR;
        }
      /* else: Case 4.  */

      /* Abort the TXN. Nobody wants to use it.  */
      /* ### should we examine the error and attempt svn_fs_purge_txn() ?  */
      err = svn_error_compose_create(
        err,
        svn_fs_abort_txn(eb->txn, scratch_pool));
    }

  /* For safety, clear the now-useless txn.  */
  eb->txn = NULL;

  return svn_error_trace(err);
}