svn_error_t *
svn_wc_ensure_adm3(const char *path,
const char *uuid,
const char *url,
const char *repos,
svn_revnum_t revision,
svn_depth_t depth,
apr_pool_t *pool)
{
svn_wc_adm_access_t *adm_access;
const svn_wc_entry_t *entry;
int format;
SVN_ERR(svn_wc_check_wc(path, &format, pool));
/* Early out: we know we're not dealing with an existing wc, so
just create one. */
if (format == 0)
return init_adm(path, uuid, url, repos, revision, depth, pool);
/* Now, get the existing url and repos for PATH. */
SVN_ERR(svn_wc_adm_open3(&adm_access, NULL, path, FALSE, 0,
NULL, NULL, pool));
SVN_ERR(svn_wc__entry_versioned(&entry, path, adm_access, FALSE, pool));
SVN_ERR(svn_wc_adm_close2(adm_access, pool));
/* When the directory exists and is scheduled for deletion do not
* check the revision or the URL. The revision can be any
* arbitrary revision and the URL may differ if the add is
* being driven from a merge which will have a different URL. */
if (entry->schedule != svn_wc_schedule_delete)
{
if (entry->revision != revision)
return
svn_error_createf
(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("Revision %ld doesn't match existing revision %ld in '%s'"),
revision, entry->revision, path);
/** ### comparing URLs, should they be canonicalized first? */
if (strcmp(entry->url, url) != 0)
return
svn_error_createf
(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("URL '%s' doesn't match existing URL '%s' in '%s'"),
url, entry->url, path);
}
return SVN_NO_ERROR;
}
/* Helper function: push the svn_wc_entry_t for WCPATH at
RECEIVER/BATON, and possibly recurse over more entries. */
static svn_error_t *
crawl_entries(const char *wcpath,
svn_info_receiver_t receiver,
void *receiver_baton,
svn_depth_t depth,
apr_hash_t *changelist_hash,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_wc_adm_access_t *adm_access;
const svn_wc_entry_t *entry;
int adm_lock_level = SVN_WC__LEVELS_TO_LOCK_FROM_DEPTH(depth);
SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, wcpath, FALSE,
adm_lock_level, ctx->cancel_func,
ctx->cancel_baton, pool));
SVN_ERR(svn_wc__entry_versioned(&entry, wcpath, adm_access, FALSE, pool));
if (entry->kind == svn_node_file)
{
if (SVN_WC__CL_MATCH(changelist_hash, entry))
{
svn_info_t *info;
SVN_ERR(build_info_from_entry(&info, entry, pool));
return receiver(receiver_baton, wcpath, info, pool);
}
}
else if (entry->kind == svn_node_dir)
{
struct found_entry_baton fe_baton;
fe_baton.changelist_hash = changelist_hash;
fe_baton.receiver = receiver;
fe_baton.receiver_baton = receiver_baton;
SVN_ERR(svn_wc_walk_entries3(wcpath, adm_access,
&entry_walk_callbacks, &fe_baton,
depth, FALSE, ctx->cancel_func,
ctx->cancel_baton, pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__derive_location(const char **url,
svn_revnum_t *peg_revnum,
const char *path_or_url,
const svn_opt_revision_t *peg_revision,
const svn_ra_session_t *ra_session,
svn_wc_adm_access_t *adm_access,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
/* If PATH_OR_URL is a local path (not a URL), we need to transform
it into a URL. */
if (! svn_path_is_url(path_or_url))
{
const svn_wc_entry_t *entry;
if (adm_access)
{
SVN_ERR(svn_wc__entry_versioned(&entry, path_or_url, adm_access,
FALSE, pool));
}
else
{
svn_cancel_func_t cancel_func;
void *cancel_baton;
if (ctx)
{
cancel_func = ctx->cancel_func;
cancel_baton = ctx->cancel_baton;
}
SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, path_or_url,
FALSE, 0, cancel_func, cancel_baton,
pool));
SVN_ERR(svn_wc__entry_versioned(&entry, path_or_url, adm_access,
FALSE, pool));
SVN_ERR(svn_wc_adm_close(adm_access));
}
SVN_ERR(svn_client__entry_location(url, peg_revnum, path_or_url,
peg_revision->kind, entry, pool));
}
else
{
*url = path_or_url;
/* peg_revnum (if provided) will be set below. */
}
/* If we haven't resolved for ourselves a numeric peg revision, do so. */
if (peg_revnum && !SVN_IS_VALID_REVNUM(*peg_revnum))
{
/* Use sesspool to assure that if we opened an RA session, we
close it. */
apr_pool_t *sesspool = NULL;
svn_ra_session_t *session = (svn_ra_session_t *) ra_session;
if (session == NULL)
{
sesspool = svn_pool_create(pool);
SVN_ERR(svn_client__open_ra_session_internal(&session, *url, NULL,
NULL, NULL, FALSE,
TRUE, ctx, sesspool));
}
SVN_ERR(svn_client__get_revision_number(peg_revnum, NULL, session,
peg_revision, NULL, pool));
if (sesspool)
svn_pool_destroy(sesspool);
}
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;
}
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;
}
svn_error_t *
svn_client__get_revision_number(svn_revnum_t *revnum,
svn_revnum_t *youngest_rev,
svn_ra_session_t *ra_session,
const svn_opt_revision_t *revision,
const char *path,
apr_pool_t *pool)
{
switch (revision->kind)
{
case svn_opt_revision_unspecified:
*revnum = SVN_INVALID_REVNUM;
break;
case svn_opt_revision_number:
*revnum = revision->value.number;
break;
case svn_opt_revision_head:
/* If our caller provided a value for HEAD that he wants us to
use, we'll use it. Otherwise, we have to query the
repository (and possible return our fetched value in
*YOUNGEST_REV, too). */
if (youngest_rev && SVN_IS_VALID_REVNUM(*youngest_rev))
{
*revnum = *youngest_rev;
}
else
{
if (! ra_session)
return svn_error_create(SVN_ERR_CLIENT_RA_ACCESS_REQUIRED,
NULL, NULL);
SVN_ERR(svn_ra_get_latest_revnum(ra_session, revnum, pool));
if (youngest_rev)
*youngest_rev = *revnum;
}
break;
case svn_opt_revision_committed:
case svn_opt_revision_working:
case svn_opt_revision_base:
case svn_opt_revision_previous:
{
svn_wc_adm_access_t *adm_access;
const svn_wc_entry_t *ent;
/* Sanity check. */
if (path == NULL)
return svn_error_create(SVN_ERR_CLIENT_VERSIONED_PATH_REQUIRED,
NULL, NULL);
SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, path, FALSE,
0, NULL, NULL, pool));
SVN_ERR(svn_wc__entry_versioned(&ent, path, adm_access, FALSE, pool));
SVN_ERR(svn_wc_adm_close(adm_access));
if ((revision->kind == svn_opt_revision_base)
|| (revision->kind == svn_opt_revision_working))
{
*revnum = ent->revision;
}
else
{
if (! SVN_IS_VALID_REVNUM(ent->cmt_rev))
return svn_error_createf(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Path '%s' has no committed "
"revision"), path);
*revnum = ent->cmt_rev;
if (revision->kind == svn_opt_revision_previous)
(*revnum)--;
}
}
break;
case svn_opt_revision_date:
/* ### When revision->kind == svn_opt_revision_date, is there an
### optimization such that we can compare
### revision->value->date with the committed-date in the
### entries file (or rather, with some range of which
### committed-date is one endpoint), and sometimes avoid a
### trip over the RA layer? The only optimizations I can
### think of involve examining other entries to build a
### timespan across which committed-revision is known to be
### the head, but it doesn't seem worth it. -kff */
if (! ra_session)
return svn_error_create(SVN_ERR_CLIENT_RA_ACCESS_REQUIRED, NULL, NULL);
SVN_ERR(svn_ra_get_dated_revision(ra_session, revnum,
revision->value.date, pool));
break;
default:
return svn_error_createf(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Unrecognized revision type requested for "
"'%s'"),
svn_path_local_style(path, pool));
}
/* Final check -- if our caller provided a youngest revision, and
the number we wound up with is younger than that revision, we need
to stick to our caller's idea of "youngest". */
if (youngest_rev
&& SVN_IS_VALID_REVNUM(*youngest_rev)
&& SVN_IS_VALID_REVNUM(*revnum)
&& (*revnum > *youngest_rev))
*revnum = *youngest_rev;
return SVN_NO_ERROR;
}
