/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__revert(apr_getopt_t *os,
void *baton,
apr_pool_t *scratch_pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_array_header_t *targets = NULL;
svn_error_t *err;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE,
scratch_pool));
/* Revert has no implicit dot-target `.', so don't you put that code here! */
if (! targets->nelts)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
/* Revert is especially conservative, by default it is as
nonrecursive as possible. */
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool));
SVN_ERR(svn_cl__check_targets_are_local_paths(targets));
err = svn_client_revert2(targets, opt_state->depth,
opt_state->changelists, ctx, scratch_pool);
if (err
&& (err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH)
&& (! SVN_DEPTH_IS_RECURSIVE(opt_state->depth)))
{
err = svn_error_quick_wrap
(err, _("Try 'svn revert --depth infinity' instead?"));
}
return svn_error_trace(err);
}
static svn_error_t *
switch_internal(svn_revnum_t *result_rev,
const char *local_abspath,
const char *anchor_abspath,
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 svn_ra_reporter3_t *reporter;
void *report_baton;
const char *url, *target, *source_root, *switch_rev_url;
svn_ra_session_t *ra_session;
svn_revnum_t revnum;
svn_error_t *err = SVN_NO_ERROR;
const char *diff3_cmd;
svn_boolean_t use_commit_times;
svn_boolean_t sleep_here = FALSE;
svn_boolean_t *use_sleep = timestamp_sleep ? timestamp_sleep : &sleep_here;
const svn_delta_editor_t *switch_editor;
void *switch_edit_baton;
const char *preserved_exts_str;
apr_array_header_t *preserved_exts;
svn_boolean_t server_supports_depth;
struct svn_client__dirent_fetcher_baton_t dfb;
svn_config_t *cfg = ctx->config ? apr_hash_get(ctx->config,
SVN_CONFIG_CATEGORY_CONFIG,
APR_HASH_KEY_STRING)
: NULL;
/* An unknown depth can't be sticky. */
if (depth == svn_depth_unknown)
depth_is_sticky = FALSE;
/* Do not support the situation of both exclude and switch a target. */
if (depth == svn_depth_exclude)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot both exclude and switch a path"));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
{
svn_boolean_t has_working;
SVN_ERR(svn_wc__node_has_working(&has_working, ctx->wc_ctx, local_abspath,
pool));
if (has_working)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot switch '%s' because it is not in the "
"repository yet"),
svn_dirent_local_style(local_abspath, pool));
}
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, pool)
: NULL;
/* Sanity check. Without these, the switch is meaningless. */
SVN_ERR_ASSERT(switch_url && (switch_url[0] != '\0'));
if (strcmp(local_abspath, anchor_abspath))
target = svn_dirent_basename(local_abspath, pool);
else
target = "";
SVN_ERR(svn_wc__node_get_url(&url, ctx->wc_ctx, anchor_abspath, pool, pool));
if (! url)
return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL,
_("Directory '%s' has no URL"),
svn_dirent_local_style(anchor_abspath, pool));
/* We may need to crop the tree if the depth is sticky */
if (depth_is_sticky && depth < svn_depth_infinity)
{
svn_node_kind_t target_kind;
if (depth == svn_depth_exclude)
{
SVN_ERR(svn_wc_exclude(ctx->wc_ctx,
local_abspath,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
/* Target excluded, we are done now */
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind(&target_kind, ctx->wc_ctx, local_abspath, TRUE,
pool));
if (target_kind == svn_node_dir)
SVN_ERR(svn_wc_crop_tree2(ctx->wc_ctx, local_abspath, depth,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
}
/* Open an RA session to 'source' URL */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &revnum,
&switch_rev_url,
switch_url, anchor_abspath,
peg_revision, revision,
ctx, pool));
SVN_ERR(svn_ra_get_repos_root2(ra_session, &source_root, pool));
/* Disallow a switch operation to change the repository root of the
target. */
if (! svn_uri__is_ancestor(source_root, url))
return svn_error_createf(SVN_ERR_WC_INVALID_SWITCH, NULL,
_("'%s'\nis not the same repository as\n'%s'"),
url, source_root);
/* If we're not ignoring ancestry, then error out if the switch
source and target don't have a common ancestory.
### We're acting on the anchor here, not the target. Is that
### okay? */
if (! ignore_ancestry)
{
const char *target_url, *yc_path;
svn_revnum_t target_rev, yc_rev;
SVN_ERR(svn_wc__node_get_url(&target_url, ctx->wc_ctx, local_abspath,
pool, pool));
SVN_ERR(svn_wc__node_get_base_rev(&target_rev, ctx->wc_ctx,
local_abspath, pool));
/* ### It would be nice if this function could reuse the existing
ra session instead of opening two for its own use. */
SVN_ERR(svn_client__get_youngest_common_ancestor(&yc_path, &yc_rev,
switch_rev_url, revnum,
target_url, target_rev,
ctx, pool));
if (! (yc_path && SVN_IS_VALID_REVNUM(yc_rev)))
return svn_error_createf(SVN_ERR_CLIENT_UNRELATED_RESOURCES, NULL,
_("'%s' shares no common ancestry with '%s'"),
switch_url, local_abspath);
}
SVN_ERR(svn_ra_reparent(ra_session, url, pool));
/* Fetch the switch (update) editor. If REVISION is invalid, that's
okay; the RA driver will call editor->set_target_revision() later on. */
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
dfb.ra_session = ra_session;
SVN_ERR(svn_ra_get_session_url(ra_session, &dfb.anchor_url, pool));
dfb.target_revision = revnum;
SVN_ERR(svn_wc_get_switch_editor4(&switch_editor, &switch_edit_baton,
&revnum, ctx->wc_ctx, anchor_abspath,
target, switch_rev_url, use_commit_times,
depth,
depth_is_sticky, allow_unver_obstructions,
server_supports_depth,
diff3_cmd, preserved_exts,
svn_client__dirent_fetcher, &dfb,
ctx->conflict_func2, ctx->conflict_baton2,
NULL, NULL,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool, pool));
/* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
invalid revnum, that means RA will use the latest revision. */
SVN_ERR(svn_ra_do_switch2(ra_session, &reporter, &report_baton, revnum,
target,
depth_is_sticky ? depth : svn_depth_unknown,
switch_rev_url,
switch_editor, switch_edit_baton, pool));
/* Drive the reporter structure, describing the revisions within
PATH. When we call reporter->finish_report, the update_editor
will be driven by svn_repos_dir_delta2.
We pass in an external_func for recording all externals. It
shouldn't be needed for a switch if it wasn't for the relative
externals of type '../path'. All of those must be resolved to
the new location. */
err = svn_wc_crawl_revisions5(ctx->wc_ctx, local_abspath, reporter,
report_baton, TRUE, depth, (! depth_is_sticky),
(! server_supports_depth),
use_commit_times,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2, pool);
if (err)
{
/* Don't rely on the error handling to handle the sleep later, do
it now */
svn_io_sleep_for_timestamps(local_abspath, pool);
return svn_error_trace(err);
}
*use_sleep = TRUE;
/* We handle externals after the switch is complete, so that
handling external items (and any errors therefrom) doesn't delay
the primary operation. */
if (SVN_DEPTH_IS_RECURSIVE(depth) && (! ignore_externals))
{
apr_hash_t *new_externals;
apr_hash_t *new_depths;
SVN_ERR(svn_wc__externals_gather_definitions(&new_externals,
&new_depths,
ctx->wc_ctx, local_abspath,
depth, pool, pool));
SVN_ERR(svn_client__handle_externals(new_externals,
new_depths,
source_root, local_abspath,
depth, use_sleep,
ctx, pool));
}
/* Sleep to ensure timestamp integrity (we do this regardless of
errors in the actual switch operation(s)). */
if (sleep_here)
svn_io_sleep_for_timestamps(local_abspath, pool);
/* Return errors we might have sustained. */
if (err)
return svn_error_trace(err);
/* Let everyone know we're finished here. */
if (ctx->notify_func2)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(anchor_abspath, svn_wc_notify_update_completed,
pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = revnum;
return SVN_NO_ERROR;
}
/* This is a helper for svn_client__update_internal(), which see for
an explanation of most of these parameters. Some stuff that's
unique is as follows:
ANCHOR_ABSPATH is the local absolute path of the update anchor.
This is typically either the same as LOCAL_ABSPATH, or the
immediate parent of LOCAL_ABSPATH.
If NOTIFY_SUMMARY is set (and there's a notification handler in
CTX), transmit the final update summary upon successful
completion of the update.
Add the paths of any conflict victims to CONFLICTED_PATHS, if that
is not null.
*/
static svn_error_t *
update_internal(svn_revnum_t *result_rev,
apr_hash_t *conflicted_paths,
const char *local_abspath,
const char *anchor_abspath,
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 adds_as_modification,
svn_boolean_t *timestamp_sleep,
svn_boolean_t notify_summary,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const svn_delta_editor_t *update_editor;
void *update_edit_baton;
const svn_ra_reporter3_t *reporter;
void *report_baton;
const char *corrected_url;
const char *target;
const char *repos_root_url;
const char *repos_relpath;
const char *repos_uuid;
const char *anchor_url;
svn_revnum_t revnum;
svn_boolean_t use_commit_times;
svn_boolean_t clean_checkout = FALSE;
const char *diff3_cmd;
apr_hash_t *wcroot_iprops;
svn_opt_revision_t opt_rev;
svn_ra_session_t *ra_session;
const char *preserved_exts_str;
apr_array_header_t *preserved_exts;
struct svn_client__dirent_fetcher_baton_t dfb;
svn_boolean_t server_supports_depth;
svn_boolean_t cropping_target;
svn_boolean_t target_conflicted = FALSE;
svn_config_t *cfg = ctx->config
? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
: NULL;
if (result_rev)
*result_rev = SVN_INVALID_REVNUM;
/* An unknown depth can't be sticky. */
if (depth == svn_depth_unknown)
depth_is_sticky = FALSE;
if (strcmp(local_abspath, anchor_abspath))
target = svn_dirent_basename(local_abspath, pool);
else
target = "";
/* Check if our anchor exists in BASE. If it doesn't we can't update. */
SVN_ERR(svn_wc__node_get_base(NULL, NULL, &repos_relpath, &repos_root_url,
&repos_uuid, NULL,
ctx->wc_ctx, anchor_abspath,
TRUE, FALSE,
pool, pool));
/* It does not make sense to update conflict victims. */
if (repos_relpath)
{
svn_error_t *err;
svn_boolean_t text_conflicted, prop_conflicted;
anchor_url = svn_path_url_add_component2(repos_root_url, repos_relpath,
pool);
err = svn_wc_conflicted_p3(&text_conflicted, &prop_conflicted,
NULL,
ctx->wc_ctx, local_abspath, pool);
if (err && err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
return svn_error_trace(err);
svn_error_clear(err);
/* tree-conflicts are handled by the update editor */
if (!err && (text_conflicted || prop_conflicted))
target_conflicted = TRUE;
}
else
anchor_url = NULL;
if (! anchor_url || target_conflicted)
{
if (ctx->notify_func2)
{
svn_wc_notify_t *nt;
nt = svn_wc_create_notify(local_abspath,
target_conflicted
? svn_wc_notify_skip_conflicted
: svn_wc_notify_update_skip_working_only,
pool);
ctx->notify_func2(ctx->notify_baton2, nt, pool);
}
return SVN_NO_ERROR;
}
/* We may need to crop the tree if the depth is sticky */
cropping_target = (depth_is_sticky && depth < svn_depth_infinity);
if (cropping_target)
{
svn_node_kind_t target_kind;
if (depth == svn_depth_exclude)
{
SVN_ERR(svn_wc_exclude(ctx->wc_ctx,
local_abspath,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
/* Target excluded, we are done now */
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind2(&target_kind, ctx->wc_ctx, local_abspath,
TRUE, TRUE, pool));
if (target_kind == svn_node_dir)
{
SVN_ERR(svn_wc_crop_tree2(ctx->wc_ctx, local_abspath, depth,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
}
}
/* check whether the "clean c/o" optimization is applicable */
SVN_ERR(is_empty_wc(&clean_checkout, local_abspath, anchor_abspath, pool));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, pool)
: NULL;
/* Let everyone know we're starting a real update (unless we're
asked not to). */
if (ctx->notify_func2 && notify_summary)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(local_abspath, svn_wc_notify_update_started,
pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* Open an RA session for the URL */
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, &corrected_url,
anchor_url,
anchor_abspath, NULL, TRUE,
TRUE, ctx, pool, pool));
/* If we got a corrected URL from the RA subsystem, we'll need to
relocate our working copy first. */
if (corrected_url)
{
const char *new_repos_root_url;
/* To relocate everything inside our repository we need the old and new
repos root. */
SVN_ERR(svn_ra_get_repos_root2(ra_session, &new_repos_root_url, pool));
/* svn_client_relocate2() will check the uuid */
SVN_ERR(svn_client_relocate2(anchor_abspath, repos_root_url,
new_repos_root_url, ignore_externals,
ctx, pool));
/* Store updated repository root for externals */
repos_root_url = new_repos_root_url;
/* ### We should update anchor_loc->repos_uuid too, although currently
* we don't use it. */
anchor_url = corrected_url;
}
/* Resolve unspecified REVISION now, because we need to retrieve the
correct inherited props prior to the editor drive and we need to
use the same value of HEAD for both. */
opt_rev.kind = revision->kind;
opt_rev.value = revision->value;
if (opt_rev.kind == svn_opt_revision_unspecified)
opt_rev.kind = svn_opt_revision_head;
/* ### todo: shouldn't svn_client__get_revision_number be able
to take a URL as easily as a local path? */
SVN_ERR(svn_client__get_revision_number(&revnum, NULL, ctx->wc_ctx,
local_abspath, ra_session, &opt_rev,
pool));
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
dfb.ra_session = ra_session;
dfb.target_revision = revnum;
dfb.anchor_url = anchor_url;
SVN_ERR(svn_client__get_inheritable_props(&wcroot_iprops, local_abspath,
revnum, depth, ra_session,
ctx, pool, pool));
/* Fetch the update editor. If REVISION is invalid, that's okay;
the RA driver will call editor->set_target_revision later on. */
SVN_ERR(svn_wc__get_update_editor(&update_editor, &update_edit_baton,
&revnum, ctx->wc_ctx, anchor_abspath,
target, wcroot_iprops, use_commit_times,
depth, depth_is_sticky,
allow_unver_obstructions,
adds_as_modification,
server_supports_depth,
clean_checkout,
diff3_cmd, preserved_exts,
svn_client__dirent_fetcher, &dfb,
conflicted_paths ? record_conflict : NULL,
conflicted_paths,
NULL, NULL,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool, pool));
/* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
invalid revnum, that means RA will use the latest revision. */
SVN_ERR(svn_ra_do_update3(ra_session, &reporter, &report_baton,
revnum, target,
(!server_supports_depth || depth_is_sticky
? depth
: svn_depth_unknown),
FALSE /* send_copyfrom_args */,
FALSE /* ignore_ancestry */,
update_editor, update_edit_baton, pool, pool));
/* Past this point, we assume the WC is going to be modified so we will
* need to sleep for timestamps. */
*timestamp_sleep = TRUE;
/* Drive the reporter structure, describing the revisions within
PATH. When we call reporter->finish_report, the
update_editor will be driven by svn_repos_dir_delta2. */
SVN_ERR(svn_wc_crawl_revisions5(ctx->wc_ctx, local_abspath, reporter,
report_baton, TRUE,
depth, (! depth_is_sticky),
(! server_supports_depth),
use_commit_times,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
/* We handle externals after the update is complete, so that
handling external items (and any errors therefrom) doesn't delay
the primary operation. */
if ((SVN_DEPTH_IS_RECURSIVE(depth) || cropping_target)
&& (! ignore_externals))
{
apr_hash_t *new_externals;
apr_hash_t *new_depths;
SVN_ERR(svn_wc__externals_gather_definitions(&new_externals,
&new_depths,
ctx->wc_ctx, local_abspath,
depth, pool, pool));
SVN_ERR(svn_client__handle_externals(new_externals,
new_depths,
repos_root_url, local_abspath,
depth, timestamp_sleep,
ctx, pool));
}
/* Let everyone know we're finished here (unless we're asked not to). */
if (ctx->notify_func2 && notify_summary)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(local_abspath, svn_wc_notify_update_completed,
pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = revnum;
return SVN_NO_ERROR;
}
/* ...
Add the paths of any conflict victims to CONFLICTED_PATHS, if that
is not null.
*/
static svn_error_t *
switch_internal(svn_revnum_t *result_rev,
apr_hash_t *conflicted_paths,
const char *local_abspath,
const char *anchor_abspath,
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 svn_ra_reporter3_t *reporter;
void *report_baton;
const char *anchor_url, *target;
svn_client__pathrev_t *switch_loc;
svn_ra_session_t *ra_session;
svn_revnum_t revnum;
const char *diff3_cmd;
apr_hash_t *wcroot_iprops;
apr_array_header_t *inherited_props;
svn_boolean_t use_commit_times;
const svn_delta_editor_t *switch_editor;
void *switch_edit_baton;
const char *preserved_exts_str;
apr_array_header_t *preserved_exts;
svn_boolean_t server_supports_depth;
struct svn_client__dirent_fetcher_baton_t dfb;
svn_config_t *cfg = ctx->config
? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
: NULL;
/* An unknown depth can't be sticky. */
if (depth == svn_depth_unknown)
depth_is_sticky = FALSE;
/* Do not support the situation of both exclude and switch a target. */
if (depth == svn_depth_exclude)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot both exclude and switch a path"));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
{
svn_boolean_t has_working;
SVN_ERR(svn_wc__node_has_working(&has_working, ctx->wc_ctx, local_abspath,
pool));
if (has_working)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot switch '%s' because it is not in the "
"repository yet"),
svn_dirent_local_style(local_abspath, pool));
}
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, pool)
: NULL;
/* Sanity check. Without these, the switch is meaningless. */
SVN_ERR_ASSERT(switch_url && (switch_url[0] != '\0'));
if (strcmp(local_abspath, anchor_abspath))
target = svn_dirent_basename(local_abspath, pool);
else
target = "";
SVN_ERR(svn_wc__node_get_url(&anchor_url, ctx->wc_ctx, anchor_abspath,
pool, pool));
if (! anchor_url)
return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL,
_("Directory '%s' has no URL"),
svn_dirent_local_style(anchor_abspath, pool));
/* We may need to crop the tree if the depth is sticky */
if (depth_is_sticky && depth < svn_depth_infinity)
{
svn_node_kind_t target_kind;
if (depth == svn_depth_exclude)
{
SVN_ERR(svn_wc_exclude(ctx->wc_ctx,
local_abspath,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
/* Target excluded, we are done now */
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind2(&target_kind, ctx->wc_ctx, local_abspath,
TRUE, TRUE, pool));
if (target_kind == svn_node_dir)
SVN_ERR(svn_wc_crop_tree2(ctx->wc_ctx, local_abspath, depth,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
}
/* Open an RA session to 'source' URL */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &switch_loc,
switch_url, anchor_abspath,
peg_revision, revision,
ctx, pool));
/* Disallow a switch operation to change the repository root of the
target. */
if (! svn_uri__is_ancestor(switch_loc->repos_root_url, anchor_url))
return svn_error_createf(SVN_ERR_WC_INVALID_SWITCH, NULL,
_("'%s'\nis not the same repository as\n'%s'"),
anchor_url, switch_loc->repos_root_url);
/* If we're not ignoring ancestry, then error out if the switch
source and target don't have a common ancestory.
### We're acting on the anchor here, not the target. Is that
### okay? */
if (! ignore_ancestry)
{
svn_client__pathrev_t *target_base_loc, *yca;
SVN_ERR(svn_client__wc_node_get_base(&target_base_loc, local_abspath,
ctx->wc_ctx, pool, pool));
if (!target_base_loc)
yca = NULL; /* Not versioned */
else
{
SVN_ERR(svn_client__get_youngest_common_ancestor(
&yca, switch_loc, target_base_loc, ra_session, ctx,
pool, pool));
}
if (! yca)
return svn_error_createf(SVN_ERR_CLIENT_UNRELATED_RESOURCES, NULL,
_("'%s' shares no common ancestry with '%s'"),
switch_url,
svn_dirent_local_style(local_abspath, pool));
}
wcroot_iprops = apr_hash_make(pool);
/* Will the base of LOCAL_ABSPATH require an iprop cache post-switch?
If we are switching LOCAL_ABSPATH to the root of the repository then
we don't need to cache inherited properties. In all other cases we
*might* need to cache iprops. */
if (strcmp(switch_loc->repos_root_url, switch_loc->url) != 0)
{
svn_boolean_t wc_root;
svn_boolean_t needs_iprop_cache = TRUE;
SVN_ERR(svn_wc__is_wcroot(&wc_root, ctx->wc_ctx, local_abspath,
pool));
/* Switching the WC root to anything but the repos root means
we need an iprop cache. */
if (!wc_root)
{
/* We know we are switching a subtree to something other than the
repos root, but if we are unswitching that subtree we don't
need an iprops cache. */
const char *target_parent_url;
const char *unswitched_url;
/* Calculate the URL LOCAL_ABSPATH would have if it was unswitched
relative to its parent. */
SVN_ERR(svn_wc__node_get_url(&target_parent_url, ctx->wc_ctx,
svn_dirent_dirname(local_abspath,
pool),
pool, pool));
unswitched_url = svn_path_url_add_component2(
target_parent_url,
svn_dirent_basename(local_abspath, pool),
pool);
/* If LOCAL_ABSPATH will be unswitched relative to its parent, then
it doesn't need an iprop cache. Note: It doesn't matter if
LOCAL_ABSPATH is withing a switched subtree, only if it's the
*root* of a switched subtree.*/
if (strcmp(unswitched_url, switch_loc->url) == 0)
needs_iprop_cache = FALSE;
}
if (needs_iprop_cache)
{
SVN_ERR(svn_ra_get_inherited_props(ra_session, &inherited_props,
"", switch_loc->rev, pool,
pool));
svn_hash_sets(wcroot_iprops, local_abspath, inherited_props);
}
}
SVN_ERR(svn_ra_reparent(ra_session, anchor_url, pool));
/* Fetch the switch (update) editor. If REVISION is invalid, that's
okay; the RA driver will call editor->set_target_revision() later on. */
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
dfb.ra_session = ra_session;
dfb.anchor_url = anchor_url;
dfb.target_revision = switch_loc->rev;
SVN_ERR(svn_wc__get_switch_editor(&switch_editor, &switch_edit_baton,
&revnum, ctx->wc_ctx, anchor_abspath,
target, switch_loc->url, wcroot_iprops,
use_commit_times, depth,
depth_is_sticky, allow_unver_obstructions,
server_supports_depth,
diff3_cmd, preserved_exts,
svn_client__dirent_fetcher, &dfb,
conflicted_paths ? record_conflict : NULL,
conflicted_paths,
NULL, NULL,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool, pool));
/* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
invalid revnum, that means RA will use the latest revision. */
SVN_ERR(svn_ra_do_switch3(ra_session, &reporter, &report_baton,
switch_loc->rev,
target,
depth_is_sticky ? depth : svn_depth_unknown,
switch_loc->url,
FALSE /* send_copyfrom_args */,
ignore_ancestry,
switch_editor, switch_edit_baton,
pool, pool));
/* Past this point, we assume the WC is going to be modified so we will
* need to sleep for timestamps. */
*timestamp_sleep = TRUE;
/* Drive the reporter structure, describing the revisions within
LOCAL_ABSPATH. When this calls reporter->finish_report, the
reporter will drive the switch_editor. */
SVN_ERR(svn_wc_crawl_revisions5(ctx->wc_ctx, local_abspath, reporter,
report_baton, TRUE,
depth, (! depth_is_sticky),
(! server_supports_depth),
use_commit_times,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
/* We handle externals after the switch is complete, so that
handling external items (and any errors therefrom) doesn't delay
the primary operation. */
if (SVN_DEPTH_IS_RECURSIVE(depth) && (! ignore_externals))
{
apr_hash_t *new_externals;
apr_hash_t *new_depths;
SVN_ERR(svn_wc__externals_gather_definitions(&new_externals,
&new_depths,
ctx->wc_ctx, local_abspath,
depth, pool, pool));
SVN_ERR(svn_client__handle_externals(new_externals,
new_depths,
switch_loc->repos_root_url,
local_abspath,
depth, timestamp_sleep,
ctx, pool));
}
/* Let everyone know we're finished here. */
if (ctx->notify_func2)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(anchor_abspath, svn_wc_notify_update_completed,
pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = revnum;
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_status6(svn_revnum_t *result_rev,
svn_client_ctx_t *ctx,
const char *path,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t get_all,
svn_boolean_t check_out_of_date,
svn_boolean_t check_working_copy,
svn_boolean_t no_ignore,
svn_boolean_t ignore_externals,
svn_boolean_t depth_as_sticky,
const apr_array_header_t *changelists,
svn_client_status_func_t status_func,
void *status_baton,
apr_pool_t *pool) /* ### aka scratch_pool */
{
struct status_baton sb;
const char *dir, *dir_abspath;
const char *target_abspath;
const char *target_basename;
apr_array_header_t *ignores;
svn_error_t *err;
apr_hash_t *changelist_hash = NULL;
/* Override invalid combinations of the check_out_of_date and
check_working_copy flags. */
if (!check_out_of_date)
check_working_copy = TRUE;
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
if (changelists && changelists->nelts)
SVN_ERR(svn_hash_from_cstring_keys(&changelist_hash, changelists, pool));
if (result_rev)
*result_rev = SVN_INVALID_REVNUM;
sb.real_status_func = status_func;
sb.real_status_baton = status_baton;
sb.deleted_in_repos = FALSE;
sb.changelist_hash = changelist_hash;
sb.wc_ctx = ctx->wc_ctx;
SVN_ERR(svn_dirent_get_absolute(&target_abspath, path, pool));
if (check_out_of_date)
{
/* The status editor only works on directories, so get the ancestor
if necessary */
svn_node_kind_t kind;
SVN_ERR(svn_wc_read_kind2(&kind, ctx->wc_ctx, target_abspath,
TRUE, FALSE, pool));
/* Dir must be a working copy directory or the status editor fails */
if (kind == svn_node_dir)
{
dir_abspath = target_abspath;
target_basename = "";
dir = path;
}
else
{
dir_abspath = svn_dirent_dirname(target_abspath, pool);
target_basename = svn_dirent_basename(target_abspath, NULL);
dir = svn_dirent_dirname(path, pool);
if (kind == svn_node_file)
{
if (depth == svn_depth_empty)
depth = svn_depth_files;
}
else
{
err = svn_wc_read_kind2(&kind, ctx->wc_ctx, dir_abspath,
FALSE, FALSE, pool);
svn_error_clear(err);
if (err || kind != svn_node_dir)
{
return svn_error_createf(SVN_ERR_WC_NOT_WORKING_COPY, NULL,
_("'%s' is not a working copy"),
svn_dirent_local_style(path, pool));
}
}
}
}
else
{
dir = path;
dir_abspath = target_abspath;
}
if (svn_dirent_is_absolute(dir))
{
sb.anchor_abspath = NULL;
sb.anchor_relpath = NULL;
}
else
{
sb.anchor_abspath = dir_abspath;
sb.anchor_relpath = dir;
}
/* Get the status edit, and use our wrapping status function/baton
as the callback pair. */
SVN_ERR(svn_wc_get_default_ignores(&ignores, ctx->config, pool));
/* If we want to know about out-of-dateness, we crawl the working copy and
let the RA layer drive the editor for real. Otherwise, we just close the
edit. :-) */
if (check_out_of_date)
{
svn_ra_session_t *ra_session;
const char *URL;
svn_node_kind_t kind;
svn_boolean_t server_supports_depth;
const svn_delta_editor_t *editor;
void *edit_baton, *set_locks_baton;
svn_revnum_t edit_revision = SVN_INVALID_REVNUM;
/* Get full URL from the ANCHOR. */
SVN_ERR(svn_client_url_from_path2(&URL, dir_abspath, ctx,
pool, pool));
if (!URL)
return svn_error_createf
(SVN_ERR_ENTRY_MISSING_URL, NULL,
_("Entry '%s' has no URL"),
svn_dirent_local_style(dir, pool));
/* Open a repository session to the URL. */
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, NULL, URL,
dir_abspath, NULL,
FALSE, TRUE,
ctx, pool, pool));
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
SVN_ERR(svn_wc__get_status_editor(&editor, &edit_baton, &set_locks_baton,
&edit_revision, ctx->wc_ctx,
dir_abspath, target_basename,
depth, get_all, check_working_copy,
no_ignore, depth_as_sticky,
server_supports_depth,
ignores, tweak_status, &sb,
ctx->cancel_func, ctx->cancel_baton,
pool, pool));
/* Verify that URL exists in HEAD. If it doesn't, this can save
us a whole lot of hassle; if it does, the cost of this
request should be minimal compared to the size of getting
back the average amount of "out-of-date" information. */
SVN_ERR(svn_ra_check_path(ra_session, "", SVN_INVALID_REVNUM,
&kind, pool));
if (kind == svn_node_none)
{
svn_boolean_t added;
/* Our status target does not exist in HEAD. If we've got
it locally added, that's okay. But if it was previously
versioned, then it must have since been deleted from the
repository. (Note that "locally replaced" doesn't count
as "added" in this case.) */
SVN_ERR(svn_wc__node_is_added(&added, ctx->wc_ctx,
dir_abspath, pool));
if (! added)
sb.deleted_in_repos = TRUE;
/* And now close the edit. */
SVN_ERR(editor->close_edit(edit_baton, pool));
}
else
{
svn_revnum_t revnum;
report_baton_t rb;
svn_depth_t status_depth;
if (revision->kind == svn_opt_revision_head)
{
/* Cause the revision number to be omitted from the request,
which implies HEAD. */
revnum = SVN_INVALID_REVNUM;
}
else
{
/* Get a revision number for our status operation. */
SVN_ERR(svn_client__get_revision_number(&revnum, NULL,
ctx->wc_ctx,
target_abspath,
ra_session, revision,
pool));
}
if (depth_as_sticky || !server_supports_depth)
status_depth = depth;
else
status_depth = svn_depth_unknown; /* Use depth from WC */
/* Do the deed. Let the RA layer drive the status editor. */
SVN_ERR(svn_ra_do_status2(ra_session, &rb.wrapped_reporter,
&rb.wrapped_report_baton,
target_basename, revnum, status_depth,
editor, edit_baton, pool));
/* Init the report baton. */
rb.ancestor = apr_pstrdup(pool, URL); /* Edited later */
rb.set_locks_baton = set_locks_baton;
rb.ctx = ctx;
rb.pool = pool;
if (depth == svn_depth_unknown)
rb.depth = svn_depth_infinity;
else
rb.depth = depth;
/* Drive the reporter structure, describing the revisions
within PATH. When we call reporter->finish_report,
EDITOR will be driven to describe differences between our
working copy and HEAD. */
SVN_ERR(svn_wc_crawl_revisions5(ctx->wc_ctx,
target_abspath,
&lock_fetch_reporter, &rb,
FALSE /* restore_files */,
depth, (! depth_as_sticky),
(! server_supports_depth),
FALSE /* use_commit_times */,
ctx->cancel_func, ctx->cancel_baton,
NULL, NULL, pool));
}
if (ctx->notify_func2)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(target_abspath,
svn_wc_notify_status_completed, pool);
notify->revision = edit_revision;
ctx->notify_func2(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = edit_revision;
}
else
{
err = svn_wc_walk_status(ctx->wc_ctx, target_abspath,
depth, get_all, no_ignore, FALSE, ignores,
tweak_status, &sb,
ctx->cancel_func, ctx->cancel_baton,
pool);
if (err && err->apr_err == SVN_ERR_WC_MISSING)
{
/* This error code is checked for in svn to continue after
this error */
svn_error_clear(err);
return svn_error_createf(SVN_ERR_WC_NOT_WORKING_COPY, NULL,
_("'%s' is not a working copy"),
svn_dirent_local_style(path, pool));
}
SVN_ERR(err);
}
/* We only descend into an external if depth is svn_depth_infinity or
svn_depth_unknown. However, there are conceivable behaviors that
would involve descending under other circumstances; thus, we pass
depth anyway, so the code will DTRT if we change the conditional
in the future.
*/
if (SVN_DEPTH_IS_RECURSIVE(depth) && (! ignore_externals))
{
apr_hash_t *external_map;
SVN_ERR(svn_wc__externals_defined_below(&external_map,
ctx->wc_ctx, target_abspath,
pool, pool));
SVN_ERR(do_external_status(ctx, external_map,
depth, get_all,
check_out_of_date, check_working_copy,
no_ignore, changelists,
sb.anchor_abspath, sb.anchor_relpath,
status_func, status_baton, pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_status4(svn_revnum_t *result_rev,
const char *path,
const svn_opt_revision_t *revision,
svn_wc_status_func3_t status_func,
void *status_baton,
svn_depth_t depth,
svn_boolean_t get_all,
svn_boolean_t update,
svn_boolean_t no_ignore,
svn_boolean_t ignore_externals,
const apr_array_header_t *changelists,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_wc_adm_access_t *anchor_access, *target_access;
svn_wc_traversal_info_t *traversal_info = svn_wc_init_traversal_info(pool);
const char *anchor, *target;
const svn_delta_editor_t *editor;
void *edit_baton, *set_locks_baton;
const svn_wc_entry_t *entry = NULL;
struct status_baton sb;
apr_array_header_t *ignores;
svn_error_t *err;
apr_hash_t *changelist_hash = NULL;
svn_revnum_t edit_revision = SVN_INVALID_REVNUM;
if (changelists && changelists->nelts)
SVN_ERR(svn_hash_from_cstring_keys(&changelist_hash, changelists, pool));
sb.real_status_func = status_func;
sb.real_status_baton = status_baton;
sb.deleted_in_repos = FALSE;
sb.changelist_hash = changelist_hash;
/* Try to open the target directory. If the target is a file or an
unversioned directory, open the parent directory instead */
err = svn_wc_adm_open3(&anchor_access, NULL, path, FALSE,
SVN_DEPTH_IS_RECURSIVE(depth) ? -1 : 1,
ctx->cancel_func, ctx->cancel_baton,
pool);
if (err && err->apr_err == SVN_ERR_WC_NOT_DIRECTORY)
{
svn_error_clear(err);
SVN_ERR(svn_wc_adm_open_anchor(&anchor_access, &target_access, &target,
path, FALSE,
SVN_DEPTH_IS_RECURSIVE(depth) ? -1 : 1,
ctx->cancel_func, ctx->cancel_baton,
pool));
}
else if (!err)
{
target = "";
target_access = anchor_access;
}
else
return err;
anchor = svn_wc_adm_access_path(anchor_access);
/* Get the status edit, and use our wrapping status function/baton
as the callback pair. */
SVN_ERR(svn_wc_get_default_ignores(&ignores, ctx->config, pool));
SVN_ERR(svn_wc_get_status_editor4(&editor, &edit_baton, &set_locks_baton,
&edit_revision, anchor_access, target,
depth, get_all, no_ignore, ignores,
tweak_status, &sb, ctx->cancel_func,
ctx->cancel_baton, traversal_info,
pool));
/* If we want to know about out-of-dateness, we crawl the working copy and
let the RA layer drive the editor for real. Otherwise, we just close the
edit. :-) */
if (update)
{
svn_ra_session_t *ra_session;
const char *URL;
svn_node_kind_t kind;
svn_boolean_t server_supports_depth;
/* Get full URL from the ANCHOR. */
if (! entry)
SVN_ERR(svn_wc__entry_versioned(&entry, anchor, anchor_access, FALSE,
pool));
if (! entry->url)
return svn_error_createf
(SVN_ERR_ENTRY_MISSING_URL, NULL,
_("Entry '%s' has no URL"),
svn_path_local_style(anchor, pool));
URL = apr_pstrdup(pool, entry->url);
/* Open a repository session to the URL. */
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, URL, anchor,
anchor_access, NULL,
FALSE, TRUE,
ctx, pool));
/* Verify that URL exists in HEAD. If it doesn't, this can save
us a whole lot of hassle; if it does, the cost of this
request should be minimal compared to the size of getting
back the average amount of "out-of-date" information. */
SVN_ERR(svn_ra_check_path(ra_session, "", SVN_INVALID_REVNUM,
&kind, pool));
if (kind == svn_node_none)
{
/* Our status target does not exist in HEAD of the
repository. If we're just adding this thing, that's
fine. But if it was previously versioned, then it must
have been deleted from the repository. */
if (entry->schedule != svn_wc_schedule_add)
sb.deleted_in_repos = TRUE;
/* And now close the edit. */
SVN_ERR(editor->close_edit(edit_baton, pool));
}
else
{
svn_revnum_t revnum;
report_baton_t rb;
if (revision->kind == svn_opt_revision_head)
{
/* Cause the revision number to be omitted from the request,
which implies HEAD. */
revnum = SVN_INVALID_REVNUM;
}
else
{
/* Get a revision number for our status operation. */
SVN_ERR(svn_client__get_revision_number
(&revnum, NULL, ra_session, revision, target, pool));
}
/* Do the deed. Let the RA layer drive the status editor. */
SVN_ERR(svn_ra_do_status2(ra_session, &rb.wrapped_reporter,
&rb.wrapped_report_baton,
target, revnum, depth, editor,
edit_baton, pool));
/* Init the report baton. */
rb.ancestor = apr_pstrdup(pool, URL);
rb.set_locks_baton = set_locks_baton;
rb.ctx = ctx;
rb.pool = pool;
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
/* Drive the reporter structure, describing the revisions
within PATH. When we call reporter->finish_report,
EDITOR will be driven to describe differences between our
working copy and HEAD. */
SVN_ERR(svn_wc_crawl_revisions4(path, target_access,
&lock_fetch_reporter, &rb, FALSE,
depth, TRUE, (! server_supports_depth),
FALSE, NULL, NULL, NULL, pool));
}
}
else
{
SVN_ERR(editor->close_edit(edit_baton, pool));
}
if (ctx->notify_func2 && update)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(path, svn_wc_notify_status_completed, pool);
notify->revision = edit_revision;
(ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = edit_revision;
/* Close the access baton here, as svn_client__do_external_status()
calls back into this function and thus will be re-opening the
working copy. */
SVN_ERR(svn_wc_adm_close2(anchor_access, pool));
/* If there are svn:externals set, we don't want those to show up as
unversioned or unrecognized, so patch up the hash. If caller wants
all the statuses, we will change unversioned status items that
are interesting to an svn:externals property to
svn_wc_status_unversioned, otherwise we'll just remove the status
item altogether.
We only descend into an external if depth is svn_depth_infinity or
svn_depth_unknown. However, there are conceivable behaviors that
would involve descending under other circumstances; thus, we pass
depth anyway, so the code will DTRT if we change the conditional
in the future.
*/
if (SVN_DEPTH_IS_RECURSIVE(depth) && (! ignore_externals))
SVN_ERR(svn_client__do_external_status(traversal_info, status_func,
status_baton, depth, get_all,
update, no_ignore, ctx, pool));
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propdel(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
const char *pname, *pname_utf8;
apr_array_header_t *args, *targets;
int i;
/* Get the property's name (and a UTF-8 version of that name). */
SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool));
pname = APR_ARRAY_IDX(args, 0, const char *);
SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool));
/* No need to check svn_prop_name_is_valid for *deleting*
properties, and it may even be useful to allow, in case invalid
properties sneaked through somehow. */
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
pool));
/* Add "." if user passed 0 file arguments */
svn_opt_push_implicit_dot_target(targets, pool);
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, pool));
/* Let libsvn_client do the real work. */
SVN_ERR(svn_client_revprop_set(pname_utf8, NULL,
URL, &(opt_state->start_revision),
&rev, FALSE, ctx, pool));
if (! opt_state->quiet)
{
SVN_ERR(svn_cmdline_printf(pool,
_("property '%s' deleted from"
" repository revision %ld\n"),
pname_utf8, rev));
}
}
else if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
return svn_error_createf
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Cannot specify revision for deleting versioned property '%s'"),
pname);
}
else /* operate on a normal, versioned property (not a revprop) */
{
apr_pool_t *subpool = svn_pool_create(pool);
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
/* For each target, remove the property PNAME. */
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_commit_info_t *commit_info;
svn_boolean_t success;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Pass FALSE for 'skip_checks' because it doesn't matter here,
and opt_state->force doesn't apply to this command anyway. */
SVN_ERR(svn_cl__try(svn_client_propset3
(&commit_info, pname_utf8,
NULL, target,
opt_state->depth,
FALSE, SVN_INVALID_REVNUM,
opt_state->changelists, NULL,
ctx, subpool),
&success, opt_state->quiet,
SVN_ERR_UNVERSIONED_RESOURCE,
SVN_ERR_ENTRY_NOT_FOUND,
SVN_NO_ERROR));
if (success && (! opt_state->quiet))
{
SVN_ERR(svn_cmdline_printf
(subpool,
SVN_DEPTH_IS_RECURSIVE(opt_state->depth)
? _("property '%s' deleted (recursively) from '%s'.\n")
: _("property '%s' deleted from '%s'.\n"),
pname_utf8, svn_path_local_style(target, subpool)));
}
}
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}
/* This is a helper for svn_client__update_internal(), which see for
an explanation of most of these parameters. Some stuff that's
unique is as follows:
ANCHOR_ABSPATH is the local absolute path of the update anchor.
This is typically either the same as LOCAL_ABSPATH, or the
immediate parent of LOCAL_ABSPATH.
If NOTIFY_SUMMARY is set (and there's a notification handler in
CTX), transmit the final update summary upon successful
completion of the update.
*/
static svn_error_t *
update_internal(svn_revnum_t *result_rev,
const char *local_abspath,
const char *anchor_abspath,
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 adds_as_modification,
svn_boolean_t *timestamp_sleep,
svn_boolean_t notify_summary,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const svn_delta_editor_t *update_editor;
void *update_edit_baton;
const svn_ra_reporter3_t *reporter;
void *report_baton;
const char *anchor_url;
const char *corrected_url;
const char *target;
const char *repos_root;
svn_error_t *err;
svn_revnum_t revnum;
svn_boolean_t use_commit_times;
svn_boolean_t sleep_here = FALSE;
svn_boolean_t *use_sleep = timestamp_sleep ? timestamp_sleep : &sleep_here;
svn_boolean_t clean_checkout = FALSE;
const char *diff3_cmd;
svn_ra_session_t *ra_session;
const char *preserved_exts_str;
apr_array_header_t *preserved_exts;
struct svn_client__dirent_fetcher_baton_t dfb;
svn_boolean_t server_supports_depth;
svn_boolean_t tree_conflicted;
svn_config_t *cfg = ctx->config ? apr_hash_get(ctx->config,
SVN_CONFIG_CATEGORY_CONFIG,
APR_HASH_KEY_STRING) : NULL;
/* An unknown depth can't be sticky. */
if (depth == svn_depth_unknown)
depth_is_sticky = FALSE;
if (strcmp(local_abspath, anchor_abspath))
target = svn_dirent_basename(local_abspath, pool);
else
target = "";
/* Get full URL from the ANCHOR. */
SVN_ERR(svn_wc__node_get_url(&anchor_url, ctx->wc_ctx, anchor_abspath,
pool, pool));
if (! anchor_url)
return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL,
_("'%s' has no URL"),
svn_dirent_local_style(anchor_abspath, pool));
/* Check if our anchor exists in BASE. If it doesn't we can't update.
### For performance reasons this should be handled with the same query
### as retrieving the anchor url. */
SVN_ERR(svn_wc__node_get_base_rev(&revnum, ctx->wc_ctx, anchor_abspath,
pool));
/* It does not make sense to update tree-conflict victims. */
err = svn_wc_conflicted_p3(NULL, NULL, &tree_conflicted,
ctx->wc_ctx, local_abspath, pool);
if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
svn_error_clear(err);
tree_conflicted = FALSE;
}
else
SVN_ERR(err);
if (!SVN_IS_VALID_REVNUM(revnum) || tree_conflicted)
{
if (ctx->notify_func2)
{
svn_wc_notify_t *nt;
nt = svn_wc_create_notify(local_abspath,
tree_conflicted
? svn_wc_notify_skip_conflicted
: svn_wc_notify_update_skip_working_only,
pool);
ctx->notify_func2(ctx->notify_baton2, nt, pool);
}
return SVN_NO_ERROR;
}
/* We may need to crop the tree if the depth is sticky */
if (depth_is_sticky && depth < svn_depth_infinity)
{
svn_node_kind_t target_kind;
if (depth == svn_depth_exclude)
{
SVN_ERR(svn_wc_exclude(ctx->wc_ctx,
local_abspath,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
/* Target excluded, we are done now */
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind(&target_kind, ctx->wc_ctx, local_abspath, TRUE,
pool));
if (target_kind == svn_node_dir)
{
SVN_ERR(svn_wc_crop_tree2(ctx->wc_ctx, local_abspath, depth,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
}
}
/* check whether the "clean c/o" optimization is applicable */
SVN_ERR(is_empty_wc(&clean_checkout, local_abspath, anchor_abspath, pool));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, pool)
: NULL;
/* Let everyone know we're starting a real update (unless we're
asked not to). */
if (ctx->notify_func2 && notify_summary)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(local_abspath, svn_wc_notify_update_started,
pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* Open an RA session for the URL */
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, &corrected_url,
anchor_url,
anchor_abspath, NULL, TRUE,
TRUE, ctx, pool));
SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_root, pool));
/* If we got a corrected URL from the RA subsystem, we'll need to
relocate our working copy first. */
if (corrected_url)
{
const char *current_repos_root;
const char *current_uuid;
/* To relocate everything inside our repository we need the old and new
repos root. ### And we should only perform relocates on the wcroot */
SVN_ERR(svn_wc__node_get_repos_info(¤t_repos_root, ¤t_uuid,
ctx->wc_ctx, anchor_abspath,
pool, pool));
/* ### Check uuid here before calling relocate? */
SVN_ERR(svn_client_relocate2(anchor_abspath, current_repos_root,
repos_root, ignore_externals, ctx, pool));
anchor_url = corrected_url;
}
/* ### todo: shouldn't svn_client__get_revision_number be able
to take a URL as easily as a local path? */
SVN_ERR(svn_client__get_revision_number(&revnum, NULL, ctx->wc_ctx,
local_abspath, ra_session, revision,
pool));
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
dfb.ra_session = ra_session;
dfb.target_revision = revnum;
dfb.anchor_url = anchor_url;
/* Fetch the update editor. If REVISION is invalid, that's okay;
the RA driver will call editor->set_target_revision later on. */
SVN_ERR(svn_wc_get_update_editor4(&update_editor, &update_edit_baton,
&revnum, ctx->wc_ctx, anchor_abspath,
target, use_commit_times, depth,
depth_is_sticky, allow_unver_obstructions,
adds_as_modification,
server_supports_depth,
clean_checkout,
diff3_cmd, preserved_exts,
svn_client__dirent_fetcher, &dfb,
ctx->conflict_func2, ctx->conflict_baton2,
NULL, NULL,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool, pool));
/* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
invalid revnum, that means RA will use the latest revision. */
SVN_ERR(svn_ra_do_update2(ra_session, &reporter, &report_baton,
revnum, target,
(!server_supports_depth || depth_is_sticky
? depth
: svn_depth_unknown),
FALSE, update_editor, update_edit_baton, pool));
/* Drive the reporter structure, describing the revisions within
PATH. When we call reporter->finish_report, the
update_editor will be driven by svn_repos_dir_delta2. */
err = svn_wc_crawl_revisions5(ctx->wc_ctx, local_abspath, reporter,
report_baton, TRUE, depth, (! depth_is_sticky),
(! server_supports_depth),
use_commit_times,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool);
if (err)
{
/* Don't rely on the error handling to handle the sleep later, do
it now */
svn_io_sleep_for_timestamps(local_abspath, pool);
return svn_error_trace(err);
}
*use_sleep = TRUE;
/* We handle externals after the update is complete, so that
handling external items (and any errors therefrom) doesn't delay
the primary operation. */
if (SVN_DEPTH_IS_RECURSIVE(depth) && (! ignore_externals))
{
apr_hash_t *new_externals;
apr_hash_t *new_depths;
SVN_ERR(svn_wc__externals_gather_definitions(&new_externals,
&new_depths,
ctx->wc_ctx, local_abspath,
depth, pool, pool));
SVN_ERR(svn_client__handle_externals(new_externals,
new_depths,
repos_root, local_abspath,
depth, use_sleep,
ctx, pool));
}
if (sleep_here)
svn_io_sleep_for_timestamps(local_abspath, pool);
/* Let everyone know we're finished here (unless we're asked not to). */
if (ctx->notify_func2 && notify_summary)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(local_abspath, svn_wc_notify_update_completed,
pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = revnum;
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_wc_adm_access_t *adm_access,
svn_depth_t depth,
svn_boolean_t depth_is_sticky,
svn_boolean_t *timestamp_sleep,
svn_boolean_t ignore_externals,
svn_boolean_t allow_unver_obstructions,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const svn_ra_reporter3_t *reporter;
void *report_baton;
const svn_wc_entry_t *entry;
const char *URL, *anchor, *target, *source_root, *switch_rev_url;
svn_ra_session_t *ra_session;
svn_revnum_t revnum;
svn_error_t *err = SVN_NO_ERROR;
svn_wc_adm_access_t *dir_access;
const svn_boolean_t close_adm_access = ! adm_access;
const char *diff3_cmd;
svn_boolean_t use_commit_times;
svn_boolean_t sleep_here;
svn_boolean_t *use_sleep = timestamp_sleep ? timestamp_sleep : &sleep_here;
const svn_delta_editor_t *switch_editor;
void *switch_edit_baton;
svn_wc_traversal_info_t *traversal_info = svn_wc_init_traversal_info(pool);
const char *preserved_exts_str;
apr_array_header_t *preserved_exts;
svn_boolean_t server_supports_depth;
svn_config_t *cfg = ctx->config ? apr_hash_get(ctx->config,
SVN_CONFIG_CATEGORY_CONFIG,
APR_HASH_KEY_STRING)
: NULL;
/* An unknown depth can't be sticky. */
if (depth == svn_depth_unknown)
depth_is_sticky = FALSE;
/* Do not support the situation of both exclude and switch a target. */
if (depth_is_sticky && depth == svn_depth_exclude)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot both exclude and switch a path"));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, pool)
: NULL;
/* Sanity check. Without these, the switch is meaningless. */
SVN_ERR_ASSERT(path);
SVN_ERR_ASSERT(switch_url && (switch_url[0] != '\0'));
/* ### Need to lock the whole target tree to invalidate wcprops. Does
non-recursive switch really need to invalidate the whole tree? */
if (adm_access)
{
svn_wc_adm_access_t *a = adm_access;
const char *dir_access_path;
/* This is a little hacky, but open two new read-only access
baton's to get the anchor and target access batons that would
be used if a locked access baton was not available. */
SVN_ERR(svn_wc_adm_open_anchor(&adm_access, &dir_access, &target, path,
FALSE, -1, ctx->cancel_func,
ctx->cancel_baton, pool));
anchor = svn_wc_adm_access_path(adm_access);
dir_access_path = svn_wc_adm_access_path(dir_access);
SVN_ERR(svn_wc_adm_close2(adm_access, pool));
SVN_ERR(svn_wc_adm_retrieve(&adm_access, a, anchor, pool));
SVN_ERR(svn_wc_adm_retrieve(&dir_access, a, dir_access_path, pool));
}
else
{
SVN_ERR(svn_wc_adm_open_anchor(&adm_access, &dir_access, &target, path,
TRUE, -1, ctx->cancel_func,
ctx->cancel_baton, pool));
anchor = svn_wc_adm_access_path(adm_access);
}
SVN_ERR(svn_wc__entry_versioned(&entry, anchor, adm_access, FALSE, pool));
if (! entry->url)
return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL,
_("Directory '%s' has no URL"),
svn_path_local_style(anchor, pool));
URL = apr_pstrdup(pool, entry->url);
/* Open an RA session to 'source' URL */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &revnum,
&switch_rev_url,
switch_url, adm_access,
peg_revision, revision,
ctx, pool));
SVN_ERR(svn_ra_get_repos_root2(ra_session, &source_root, pool));
/* Disallow a switch operation to change the repository root of the
target. */
if (! svn_path_is_ancestor(source_root, URL))
return svn_error_createf
(SVN_ERR_WC_INVALID_SWITCH, NULL,
_("'%s'\n"
"is not the same repository as\n"
"'%s'"), URL, source_root);
/* We may need to crop the tree if the depth is sticky */
if (depth_is_sticky && depth < svn_depth_infinity)
{
const svn_wc_entry_t *target_entry;
SVN_ERR(svn_wc_entry(
&target_entry,
svn_dirent_join(svn_wc_adm_access_path(adm_access), target, pool),
adm_access, TRUE, pool));
if (target_entry && target_entry->kind == svn_node_dir)
{
SVN_ERR(svn_wc_crop_tree(adm_access, target, depth,
ctx->notify_func2, ctx->notify_baton2,
ctx->cancel_func, ctx->cancel_baton,
pool));
}
}
SVN_ERR(svn_ra_reparent(ra_session, URL, pool));
/* Fetch the switch (update) editor. If REVISION is invalid, that's
okay; the RA driver will call editor->set_target_revision() later on. */
SVN_ERR(svn_wc_get_switch_editor3(&revnum, adm_access, target,
switch_rev_url, use_commit_times, depth,
depth_is_sticky, allow_unver_obstructions,
ctx->notify_func2, ctx->notify_baton2,
ctx->cancel_func, ctx->cancel_baton,
ctx->conflict_func, ctx->conflict_baton,
diff3_cmd, preserved_exts,
&switch_editor, &switch_edit_baton,
traversal_info, pool));
/* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
invalid revnum, that means RA will use the latest revision. */
SVN_ERR(svn_ra_do_switch2(ra_session, &reporter, &report_baton, revnum,
target, depth, switch_rev_url,
switch_editor, switch_edit_baton, pool));
SVN_ERR(svn_ra_has_capability(ra_session, &server_supports_depth,
SVN_RA_CAPABILITY_DEPTH, pool));
/* Drive the reporter structure, describing the revisions within
PATH. When we call reporter->finish_report, the update_editor
will be driven by svn_repos_dir_delta2.
We pass in a traversal_info for recording all externals. It
shouldn't be needed for a switch if it wasn't for the relative
externals of type '../path'. All of those must be resolved to
the new location. */
err = svn_wc_crawl_revisions4(path, dir_access, reporter, report_baton,
TRUE, depth, (! depth_is_sticky),
(! server_supports_depth),
use_commit_times,
ctx->notify_func2, ctx->notify_baton2,
traversal_info,
pool);
if (err)
{
/* Don't rely on the error handling to handle the sleep later, do
it now */
svn_io_sleep_for_timestamps(path, pool);
return err;
}
*use_sleep = TRUE;
/* We handle externals after the switch is complete, so that
handling external items (and any errors therefrom) doesn't delay
the primary operation. */
if (SVN_DEPTH_IS_RECURSIVE(depth) && (! ignore_externals))
err = svn_client__handle_externals(adm_access, traversal_info, switch_url,
path, source_root, depth,
use_sleep, ctx, pool);
/* Sleep to ensure timestamp integrity (we do this regardless of
errors in the actual switch operation(s)). */
if (sleep_here)
svn_io_sleep_for_timestamps(path, pool);
/* Return errors we might have sustained. */
if (err)
return err;
if (close_adm_access)
SVN_ERR(svn_wc_adm_close2(adm_access, pool));
/* Let everyone know we're finished here. */
if (ctx->notify_func2)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(anchor, svn_wc_notify_update_completed, pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
/* If the caller wants the result revision, give it to them. */
if (result_rev)
*result_rev = revnum;
return SVN_NO_ERROR;
}
