svn_error_t *
svn_repos_fs_begin_txn_for_update(svn_fs_txn_t **txn_p,
svn_repos_t *repos,
svn_revnum_t rev,
const char *author,
apr_pool_t *pool)
{
/* ### someday, we might run a read-hook here. */
/* Begin the transaction. */
SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev, 0, pool));
/* We pass the author to the filesystem by adding it as a property
on the txn. */
/* User (author). */
if (author)
{
svn_string_t val;
val.data = author;
val.len = strlen(author);
SVN_ERR(svn_fs_change_txn_prop(*txn_p, SVN_PROP_REVISION_AUTHOR,
&val, pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_fs_begin_txn_for_commit2(svn_fs_txn_t **txn_p,
svn_repos_t *repos,
svn_revnum_t rev,
apr_hash_t *revprop_table,
apr_pool_t *pool)
{
svn_string_t *author = apr_hash_get(revprop_table, SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING);
apr_array_header_t *revprops;
/* Run start-commit hooks. */
SVN_ERR(svn_repos__hooks_start_commit(repos, author ? author->data : NULL,
repos->client_capabilities, pool));
/* Begin the transaction, ask for the fs to do on-the-fly lock checks. */
SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev,
SVN_FS_TXN_CHECK_LOCKS, pool));
/* We pass the revision properties to the filesystem by adding them
as properties on the txn. Later, when we commit the txn, these
properties will be copied into the newly created revision. */
revprops = svn_prop_hash_to_array(revprop_table, pool);
return svn_repos_fs_change_txn_props(*txn_p, revprops, pool);
}
/* Create a repository with a filesystem based on OPTS in a subdir NAME,
* commit the standard Greek tree as revision 1, and set *REPOS_URL to
* the URL we will use to access it.
*
* ### This always returns a file: URL. We should upgrade this to use the
* test suite's specified URL scheme instead. */
static svn_error_t *
create_greek_repos(const char **repos_url,
const char *name,
const svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_repos_t *repos;
svn_revnum_t committed_rev;
svn_fs_txn_t *txn;
svn_fs_root_t *txn_root;
/* Create a filesytem and repository. */
SVN_ERR(svn_test__create_repos(&repos, name, opts, pool));
/* Prepare and commit a txn containing the Greek tree. */
SVN_ERR(svn_fs_begin_txn2(&txn, svn_repos_fs(repos), 0 /* rev */,
0 /* flags */, pool));
SVN_ERR(svn_fs_txn_root(&txn_root, txn, pool));
SVN_ERR(svn_test__create_greek_tree(txn_root, pool));
SVN_ERR(svn_repos_fs_commit_txn(NULL, repos, &committed_rev, txn, pool));
SVN_TEST_ASSERT(SVN_IS_VALID_REVNUM(committed_rev));
SVN_ERR(svn_uri_get_file_url_from_dirent(repos_url, name, pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_fs_begin_txn_for_commit2(svn_fs_txn_t **txn_p,
svn_repos_t *repos,
svn_revnum_t rev,
apr_hash_t *revprop_table,
apr_pool_t *pool)
{
apr_array_header_t *revprops;
const char *txn_name;
svn_string_t *author = svn_hash_gets(revprop_table, SVN_PROP_REVISION_AUTHOR);
apr_hash_t *hooks_env;
/* Parse the hooks-env file (if any). */
SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
pool, pool));
/* Begin the transaction, ask for the fs to do on-the-fly lock checks.
We fetch its name, too, so the start-commit hook can use it. */
SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev,
SVN_FS_TXN_CHECK_LOCKS, pool));
SVN_ERR(svn_fs_txn_name(&txn_name, *txn_p, pool));
/* We pass the revision properties to the filesystem by adding them
as properties on the txn. Later, when we commit the txn, these
properties will be copied into the newly created revision. */
revprops = svn_prop_hash_to_array(revprop_table, pool);
SVN_ERR(svn_repos_fs_change_txn_props(*txn_p, revprops, pool));
/* Run start-commit hooks. */
SVN_ERR(svn_repos__hooks_start_commit(repos, hooks_env,
author ? author->data : NULL,
repos->client_capabilities, txn_name,
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));
}
static svn_error_t *
new_revision_record(void **revision_baton,
apr_hash_t *headers,
void *parse_baton,
apr_pool_t *pool)
{
struct parse_baton *pb = parse_baton;
struct revision_baton *rb;
svn_revnum_t head_rev;
rb = make_revision_baton(headers, pb, pool);
/* ### If we're filtering revisions, and this is one we've skipped,
### and we've skipped it because it has a revision number younger
### than the youngest in our acceptable range, then should we
### just bail out here? */
/*
if (rb->skipped && (rb->rev > pb->end_rev))
return svn_error_createf(SVN_ERR_CEASE_INVOCATION, 0,
_("Finished processing acceptable load "
"revision range"));
*/
SVN_ERR(svn_fs_youngest_rev(&head_rev, pb->fs, pool));
/* FIXME: This is a lame fallback loading multiple segments of dump in
several separate operations. It is highly susceptible to race conditions.
Calculate the revision 'offset' for finding copyfrom sources.
It might be positive or negative. */
rb->rev_offset = (apr_int32_t) ((rb->rev) - (head_rev + 1));
if ((rb->rev > 0) && (! rb->skipped))
{
/* Create a new fs txn. */
SVN_ERR(svn_fs_begin_txn2(&(rb->txn), pb->fs, head_rev,
SVN_FS_TXN_CLIENT_DATE, pool));
SVN_ERR(svn_fs_txn_root(&(rb->txn_root), rb->txn, pool));
if (pb->notify_func)
{
/* ### TODO: Use proper scratch pool instead of pb->notify_pool */
svn_repos_notify_t *notify = svn_repos_notify_create(
svn_repos_notify_load_txn_start,
pb->notify_pool);
notify->old_revision = rb->rev;
pb->notify_func(pb->notify_baton, notify, pb->notify_pool);
svn_pool_clear(pb->notify_pool);
}
/* Stash the oldest "old" revision committed from the load stream. */
if (!SVN_IS_VALID_REVNUM(pb->oldest_dumpstream_rev))
pb->oldest_dumpstream_rev = rb->rev;
}
/* If we're skipping this revision, try to notify someone. */
if (rb->skipped && pb->notify_func)
{
/* ### TODO: Use proper scratch pool instead of pb->notify_pool */
svn_repos_notify_t *notify = svn_repos_notify_create(
svn_repos_notify_load_skipped_rev,
pb->notify_pool);
notify->old_revision = rb->rev;
pb->notify_func(pb->notify_baton, notify, pb->notify_pool);
svn_pool_clear(pb->notify_pool);
}
/* If we're parsing revision 0, only the revision props are (possibly)
interesting to us: when loading the stream into an empty
filesystem, then we want new filesystem's revision 0 to have the
same props. Otherwise, we just ignore revision 0 in the stream. */
*revision_baton = rb;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_begin_txn(svn_fs_txn_t **txn_p, svn_fs_t *fs, svn_revnum_t rev,
apr_pool_t *pool)
{
return svn_error_trace(svn_fs_begin_txn2(txn_p, fs, rev, 0, pool));
}