svn_error_t *
sbox_wc_resolve(svn_test__sandbox_t *b, const char *path, svn_depth_t depth,
svn_wc_conflict_choice_t conflict_choice)
{
const char *lock_abspath;
svn_error_t *err;
SVN_ERR(svn_wc__acquire_write_lock_for_resolve(&lock_abspath, b->wc_ctx,
sbox_wc_path(b, path),
b->pool, b->pool));
err = svn_wc__resolve_conflicts(b->wc_ctx, sbox_wc_path(b, path),
depth,
TRUE /* resolve_text */,
"" /* resolve_prop (ALL props) */,
TRUE /* resolve_tree */,
conflict_choice,
NULL, NULL, /* conflict func */
NULL, NULL, /* cancellation */
NULL, NULL, /* notification */
b->pool);
err = svn_error_compose_create(err, svn_wc__release_write_lock(b->wc_ctx,
lock_abspath,
b->pool));
return err;
}
svn_error_t *
svn_client__switch_internal(svn_revnum_t *result_rev,
const char *path,
const char *switch_url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t depth_is_sticky,
svn_boolean_t ignore_externals,
svn_boolean_t allow_unver_obstructions,
svn_boolean_t ignore_ancestry,
svn_boolean_t *timestamp_sleep,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const char *local_abspath, *anchor_abspath;
svn_boolean_t acquired_lock;
svn_error_t *err, *err1, *err2;
apr_hash_t *conflicted_paths
= ctx->conflict_func2 ? apr_hash_make(pool) : NULL;
SVN_ERR_ASSERT(path);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
/* Rely on svn_wc__acquire_write_lock setting ANCHOR_ABSPATH even
when it returns SVN_ERR_WC_LOCKED */
err = svn_wc__acquire_write_lock(&anchor_abspath,
ctx->wc_ctx, local_abspath, TRUE,
pool, pool);
if (err && err->apr_err != SVN_ERR_WC_LOCKED)
return svn_error_trace(err);
acquired_lock = (err == SVN_NO_ERROR);
svn_error_clear(err);
err1 = switch_internal(result_rev, conflicted_paths,
local_abspath, anchor_abspath,
switch_url, peg_revision, revision,
depth, depth_is_sticky,
ignore_externals,
allow_unver_obstructions, ignore_ancestry,
timestamp_sleep, ctx, pool);
/* Give the conflict resolver callback the opportunity to
* resolve any conflicts that were raised. */
if (! err1 && ctx->conflict_func2)
{
err1 = svn_client__resolve_conflicts(NULL, conflicted_paths, ctx, pool);
}
if (acquired_lock)
err2 = svn_wc__release_write_lock(ctx->wc_ctx, anchor_abspath, pool);
else
err2 = SVN_NO_ERROR;
return svn_error_compose_create(err1, err2);
}
svn_error_t *
sbox_wc_add(svn_test__sandbox_t *b, const char *path)
{
const char *parent_abspath;
path = sbox_wc_path(b, path);
parent_abspath = svn_dirent_dirname(path, b->pool);
SVN_ERR(svn_wc__acquire_write_lock(NULL, b->wc_ctx, parent_abspath, FALSE,
b->pool, b->pool));
SVN_ERR(svn_wc_add_from_disk2(b->wc_ctx, path, NULL /*props*/,
NULL, NULL, b->pool));
SVN_ERR(svn_wc__release_write_lock(b->wc_ctx, parent_abspath, b->pool));
return SVN_NO_ERROR;
}
svn_error_t *
sbox_wc_copy(svn_test__sandbox_t *b, const char *from_path, const char *to_path)
{
const char *parent_abspath;
from_path = sbox_wc_path(b, from_path);
to_path = sbox_wc_path(b, to_path);
parent_abspath = svn_dirent_dirname(to_path, b->pool);
SVN_ERR(svn_wc__acquire_write_lock(NULL, b->wc_ctx, parent_abspath, FALSE,
b->pool, b->pool));
SVN_ERR(svn_wc_copy3(b->wc_ctx, from_path, to_path, FALSE,
NULL, NULL, NULL, NULL, b->pool));
SVN_ERR(svn_wc__release_write_lock(b->wc_ctx, parent_abspath, b->pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__switch_internal(svn_revnum_t *result_rev,
const char *path,
const char *switch_url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t depth_is_sticky,
svn_boolean_t ignore_externals,
svn_boolean_t allow_unver_obstructions,
svn_boolean_t ignore_ancestry,
svn_boolean_t *timestamp_sleep,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const char *local_abspath, *anchor_abspath;
svn_boolean_t acquired_lock;
svn_error_t *err, *err1, *err2;
SVN_ERR_ASSERT(path);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
/* Rely on svn_wc__acquire_write_lock setting ANCHOR_ABSPATH even
when it returns SVN_ERR_WC_LOCKED */
err = svn_wc__acquire_write_lock(&anchor_abspath,
ctx->wc_ctx, local_abspath, TRUE,
pool, pool);
if (err && err->apr_err != SVN_ERR_WC_LOCKED)
return svn_error_trace(err);
acquired_lock = (err == SVN_NO_ERROR);
svn_error_clear(err);
err1 = switch_internal(result_rev, local_abspath, anchor_abspath,
switch_url, peg_revision, revision,
depth, depth_is_sticky,
ignore_externals,
allow_unver_obstructions, ignore_ancestry,
timestamp_sleep, ctx, pool);
if (acquired_lock)
err2 = svn_wc__release_write_lock(ctx->wc_ctx, anchor_abspath, pool);
else
err2 = SVN_NO_ERROR;
return svn_error_compose_create(err1, err2);
}
svn_error_t *
sbox_wc_exclude(svn_test__sandbox_t *b, const char *path)
{
const char *abspath = sbox_wc_path(b, path);
const char *lock_root_abspath;
SVN_ERR(svn_wc__acquire_write_lock(&lock_root_abspath, b->wc_ctx,
abspath, TRUE,
b->pool, b->pool));
SVN_ERR(svn_wc_exclude(b->wc_ctx, abspath,
NULL, NULL, /* cancel baton + func */
NULL, NULL, /* notify baton + func */
b->pool));
SVN_ERR(svn_wc__release_write_lock(b->wc_ctx, lock_root_abspath, b->pool));
return SVN_NO_ERROR;
}
svn_error_t *
sbox_wc_revert(svn_test__sandbox_t *b, const char *path, svn_depth_t depth)
{
const char *abspath = sbox_wc_path(b, path);
const char *dir_abspath;
const char *lock_root_abspath;
if (strcmp(abspath, b->wc_abspath))
dir_abspath = svn_dirent_dirname(abspath, b->pool);
else
dir_abspath = abspath;
SVN_ERR(svn_wc__acquire_write_lock(&lock_root_abspath, b->wc_ctx,
dir_abspath, FALSE /* lock_anchor */,
b->pool, b->pool));
SVN_ERR(svn_wc_revert4(b->wc_ctx, abspath, depth, FALSE, NULL,
NULL, NULL, /* cancel baton + func */
NULL, NULL, /* notify baton + func */
b->pool));
SVN_ERR(svn_wc__release_write_lock(b->wc_ctx, lock_root_abspath, b->pool));
return SVN_NO_ERROR;
}
