const char *
svn_client__pathrev_relpath(const svn_client__pathrev_t *pathrev,
apr_pool_t *result_pool)
{
return svn_uri_skip_ancestor(pathrev->repos_root_url, pathrev->url,
result_pool);
}
const char *
svn_client__pathrev_fspath(const svn_client__pathrev_t *pathrev,
apr_pool_t *result_pool)
{
return svn_fspath__canonicalize(svn_uri_skip_ancestor(
pathrev->repos_root_url, pathrev->url,
result_pool),
result_pool);
}
svn_error_t *svn_ra_get_path_relative_to_session(svn_ra_session_t *session,
const char **rel_path,
const char *url,
apr_pool_t *pool)
{
const char *sess_url;
SVN_ERR(session->vtable->get_session_url(session, &sess_url, pool));
*rel_path = svn_uri_skip_ancestor(sess_url, url, pool);
if (! *rel_path)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("'%s' isn't a child of session URL '%s'"),
url, sess_url);
return SVN_NO_ERROR;
}
/* For all lock tokens in ALL_TOKENS for URLs under BASE_URL, add them
to a new hashtable allocated in POOL. *RESULT is set to point to this
new hash table. *RESULT will be keyed on const char * URI-decoded paths
relative to BASE_URL. The lock tokens will not be duplicated. */
static svn_error_t *
collect_lock_tokens(apr_hash_t **result,
apr_hash_t *all_tokens,
const char *base_url,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
*result = apr_hash_make(pool);
for (hi = apr_hash_first(pool, all_tokens); hi; hi = apr_hash_next(hi))
{
const char *url = svn__apr_hash_index_key(hi);
const char *token = svn__apr_hash_index_val(hi);
const char *relpath = svn_uri_skip_ancestor(base_url, url, pool);
if (relpath)
{
svn_hash_sets(*result, relpath, token);
}
}
return SVN_NO_ERROR;
}
static svn_error_t *
handle_external_item_change(svn_client_ctx_t *ctx,
const char *repos_root_url,
const char *parent_dir_abspath,
const char *parent_dir_url,
const char *local_abspath,
const char *old_defining_abspath,
const svn_wc_external_item2_t *new_item,
svn_boolean_t *timestamp_sleep,
apr_pool_t *scratch_pool)
{
svn_ra_session_t *ra_session;
svn_client__pathrev_t *new_loc;
const char *new_url;
svn_node_kind_t ext_kind;
SVN_ERR_ASSERT(repos_root_url && parent_dir_url);
SVN_ERR_ASSERT(new_item != NULL);
/* Don't bother to check status, since we'll get that for free by
attempting to retrieve the hash values anyway. */
/* When creating the absolute URL, use the pool and not the
iterpool, since the hash table values outlive the iterpool and
any pointers they have should also outlive the iterpool. */
SVN_ERR(svn_wc__resolve_relative_external_url(&new_url,
new_item, repos_root_url,
parent_dir_url,
scratch_pool, scratch_pool));
/* Determine if the external is a file or directory. */
/* Get the RA connection. */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &new_loc,
new_url, NULL,
&(new_item->peg_revision),
&(new_item->revision), ctx,
scratch_pool));
SVN_ERR(svn_ra_check_path(ra_session, "", new_loc->rev, &ext_kind,
scratch_pool));
if (svn_node_none == ext_kind)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' at revision %ld doesn't exist"),
new_loc->url, new_loc->rev);
if (svn_node_dir != ext_kind && svn_node_file != ext_kind)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' at revision %ld is not a file "
"or a directory"),
new_loc->url, new_loc->rev);
/* Not protecting against recursive externals. Detecting them in
the global case is hard, and it should be pretty obvious to a
user when it happens. Worst case: your disk fills up :-). */
/* First notify that we're about to handle an external. */
if (ctx->notify_func2)
{
(*ctx->notify_func2)(
ctx->notify_baton2,
svn_wc_create_notify(local_abspath,
svn_wc_notify_update_external,
scratch_pool),
scratch_pool);
}
if (! old_defining_abspath)
{
/* The target dir might have multiple components. Guarantee the path
leading down to the last component. */
SVN_ERR(svn_io_make_dir_recursively(svn_dirent_dirname(local_abspath,
scratch_pool),
scratch_pool));
}
switch (ext_kind)
{
case svn_node_dir:
SVN_ERR(switch_dir_external(local_abspath, new_loc->url,
new_item->url,
&(new_item->peg_revision),
&(new_item->revision),
parent_dir_abspath,
timestamp_sleep, ctx,
scratch_pool));
break;
case svn_node_file:
if (strcmp(repos_root_url, new_loc->repos_root_url))
{
const char *local_repos_root_url;
const char *local_repos_uuid;
const char *ext_repos_relpath;
svn_error_t *err;
/*
* The working copy library currently requires that all files
* in the working copy have the same repository root URL.
* The URL from the file external's definition differs from the
* one used by the working copy. As a workaround, replace the
* root URL portion of the file external's URL, after making
* sure both URLs point to the same repository. See issue #4087.
*/
err = svn_wc__node_get_repos_info(NULL, NULL,
&local_repos_root_url,
&local_repos_uuid,
ctx->wc_ctx, parent_dir_abspath,
scratch_pool, scratch_pool);
if (err)
{
if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND
&& err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
return svn_error_trace(err);
svn_error_clear(err);
local_repos_root_url = NULL;
local_repos_uuid = NULL;
}
ext_repos_relpath = svn_uri_skip_ancestor(new_loc->repos_root_url,
new_url, scratch_pool);
if (local_repos_uuid == NULL || local_repos_root_url == NULL ||
ext_repos_relpath == NULL ||
strcmp(local_repos_uuid, new_loc->repos_uuid) != 0)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Unsupported external: URL of file external '%s' "
"is not in repository '%s'"),
new_url, repos_root_url);
new_url = svn_path_url_add_component2(local_repos_root_url,
ext_repos_relpath,
scratch_pool);
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &new_loc,
new_url,
NULL,
&(new_item->peg_revision),
&(new_item->revision),
ctx, scratch_pool));
}
SVN_ERR(switch_file_external(local_abspath,
new_url,
&new_item->peg_revision,
&new_item->revision,
parent_dir_abspath,
ra_session,
ctx,
scratch_pool));
break;
default:
SVN_ERR_MALFUNCTION();
break;
}
return SVN_NO_ERROR;
}
/* Try to update a directory external at PATH to URL at REVISION.
Use POOL for temporary allocations, and use the client context CTX. */
static svn_error_t *
switch_dir_external(const char *local_abspath,
const char *url,
const char *url_from_externals_definition,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
const char *defining_abspath,
svn_boolean_t *timestamp_sleep,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_node_kind_t kind;
svn_error_t *err;
svn_revnum_t external_peg_rev = SVN_INVALID_REVNUM;
svn_revnum_t external_rev = SVN_INVALID_REVNUM;
apr_pool_t *subpool = svn_pool_create(pool);
const char *repos_root_url;
const char *repos_uuid;
SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
if (peg_revision->kind == svn_opt_revision_number)
external_peg_rev = peg_revision->value.number;
if (revision->kind == svn_opt_revision_number)
external_rev = revision->value.number;
/*
* The code below assumes existing versioned paths are *not* part of
* the external's defining working copy.
* The working copy library does not support registering externals
* on top of existing BASE nodes and will error out if we try.
* So if the external target is part of the defining working copy's
* BASE tree, don't attempt to create the external. Doing so would
* leave behind a switched path instead of an external (since the
* switch succeeds but registration of the external in the DB fails).
* The working copy then cannot be updated until the path is switched back.
* See issue #4085.
*/
SVN_ERR(svn_wc__node_get_base(&kind, NULL, NULL,
&repos_root_url, &repos_uuid,
NULL, ctx->wc_ctx, local_abspath,
TRUE, /* ignore_enoent */
TRUE, /* show hidden */
pool, pool));
if (kind != svn_node_unknown)
{
const char *wcroot_abspath;
const char *defining_wcroot_abspath;
SVN_ERR(svn_wc__get_wcroot(&wcroot_abspath, ctx->wc_ctx,
local_abspath, pool, pool));
SVN_ERR(svn_wc__get_wcroot(&defining_wcroot_abspath, ctx->wc_ctx,
defining_abspath, pool, pool));
if (strcmp(wcroot_abspath, defining_wcroot_abspath) == 0)
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("The external '%s' defined in %s at '%s' "
"cannot be checked out because '%s' is "
"already a versioned path."),
url_from_externals_definition,
SVN_PROP_EXTERNALS,
svn_dirent_local_style(defining_abspath,
pool),
svn_dirent_local_style(local_abspath,
pool));
}
/* If path is a directory, try to update/switch to the correct URL
and revision. */
SVN_ERR(svn_io_check_path(local_abspath, &kind, pool));
if (kind == svn_node_dir)
{
const char *node_url;
/* Doubles as an "is versioned" check. */
err = svn_wc__node_get_url(&node_url, ctx->wc_ctx, local_abspath,
pool, subpool);
if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
svn_error_clear(err);
err = SVN_NO_ERROR;
goto relegate;
}
else if (err)
return svn_error_trace(err);
if (node_url)
{
/* If we have what appears to be a version controlled
subdir, and its top-level URL matches that of our
externals definition, perform an update. */
if (strcmp(node_url, url) == 0)
{
SVN_ERR(svn_client__update_internal(NULL, local_abspath,
revision, svn_depth_unknown,
FALSE, FALSE, FALSE, TRUE,
FALSE, TRUE,
timestamp_sleep,
ctx, subpool));
/* We just decided that this existing directory is an external,
so update the external registry with this information, like
when checking out an external */
SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
defining_abspath,
local_abspath, svn_node_dir,
repos_root_url, repos_uuid,
svn_uri_skip_ancestor(repos_root_url,
url, pool),
external_peg_rev,
external_rev,
pool));
svn_pool_destroy(subpool);
goto cleanup;
}
/* We'd really prefer not to have to do a brute-force
relegation -- blowing away the current external working
copy and checking it out anew -- so we'll first see if we
can get away with a generally cheaper relocation (if
required) and switch-style update.
To do so, we need to know the repository root URL of the
external working copy as it currently sits. */
err = svn_wc__node_get_repos_info(NULL, NULL,
&repos_root_url, &repos_uuid,
ctx->wc_ctx, local_abspath,
pool, subpool);
if (err)
{
if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND
&& err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
return svn_error_trace(err);
svn_error_clear(err);
repos_root_url = NULL;
repos_uuid = NULL;
}
if (repos_root_url)
{
/* If the new external target URL is not obviously a
child of the external working copy's current
repository root URL... */
if (! svn_uri__is_ancestor(repos_root_url, url))
{
const char *repos_root;
/* ... then figure out precisely which repository
root URL that target URL *is* a child of ... */
SVN_ERR(svn_client_get_repos_root(&repos_root, NULL, url,
ctx, subpool, subpool));
/* ... and use that to try to relocate the external
working copy to the target location. */
err = svn_client_relocate2(local_abspath, repos_root_url,
repos_root, FALSE, ctx, subpool);
/* If the relocation failed because the new URL
points to a totally different repository, we've
no choice but to relegate and check out a new WC. */
if (err
&& (err->apr_err == SVN_ERR_WC_INVALID_RELOCATION
|| (err->apr_err
== SVN_ERR_CLIENT_INVALID_RELOCATION)))
{
svn_error_clear(err);
goto relegate;
}
else if (err)
return svn_error_trace(err);
/* If the relocation went without a hitch, we should
have a new repository root URL. */
repos_root_url = repos_root;
}
SVN_ERR(svn_client__switch_internal(NULL, local_abspath, url,
peg_revision, revision,
svn_depth_infinity,
TRUE, FALSE, FALSE,
TRUE /* ignore_ancestry */,
timestamp_sleep,
ctx, subpool));
SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
defining_abspath,
local_abspath, svn_node_dir,
repos_root_url, repos_uuid,
svn_uri_skip_ancestor(
repos_root_url,
url, subpool),
external_peg_rev,
external_rev,
subpool));
svn_pool_destroy(subpool);
goto cleanup;
}
}
}
relegate:
/* Fall back on removing the WC and checking out a new one. */
/* Ensure that we don't have any RA sessions or WC locks from failed
operations above. */
svn_pool_destroy(subpool);
if (kind == svn_node_dir)
{
/* Buh-bye, old and busted ... */
SVN_ERR(relegate_dir_external(ctx->wc_ctx, defining_abspath,
local_abspath,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
}
else
{
/* The target dir might have multiple components. Guarantee
the path leading down to the last component. */
const char *parent = svn_dirent_dirname(local_abspath, pool);
SVN_ERR(svn_io_make_dir_recursively(parent, pool));
}
/* ... Hello, new hotness. */
SVN_ERR(svn_client__checkout_internal(NULL, url, local_abspath, peg_revision,
revision, svn_depth_infinity,
FALSE, FALSE, timestamp_sleep,
ctx, pool));
SVN_ERR(svn_wc__node_get_repos_info(NULL, NULL,
&repos_root_url,
&repos_uuid,
ctx->wc_ctx, local_abspath,
pool, pool));
SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
defining_abspath,
local_abspath, svn_node_dir,
repos_root_url, repos_uuid,
svn_uri_skip_ancestor(repos_root_url,
url, pool),
external_peg_rev,
external_rev,
pool));
cleanup:
/* Issues #4123 and #4130: We don't need to keep the newly checked
out external's DB open. */
SVN_ERR(svn_wc__close_db(local_abspath, ctx->wc_ctx, pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_upgrade(const char *path,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
const char *local_abspath;
apr_hash_t *externals;
apr_hash_index_t *hi;
apr_pool_t *iterpool;
apr_pool_t *iterpool2;
svn_opt_revision_t rev = {svn_opt_revision_unspecified, {0}};
struct repos_info_baton info_baton;
info_baton.state_pool = scratch_pool;
info_baton.ctx = ctx;
info_baton.last_repos = NULL;
info_baton.last_uuid = NULL;
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
SVN_ERR(svn_wc_upgrade(ctx->wc_ctx, local_abspath,
fetch_repos_info, &info_baton,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool));
/* Now it's time to upgrade the externals too. We do it after the wc
upgrade to avoid that errors in the externals causes the wc upgrade to
fail. Thanks to caching the performance penalty of walking the wc a
second time shouldn't be too severe */
SVN_ERR(svn_client_propget4(&externals, SVN_PROP_EXTERNALS, local_abspath,
&rev, &rev, NULL, svn_depth_infinity, NULL, ctx,
scratch_pool, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
iterpool2 = svn_pool_create(scratch_pool);
for (hi = apr_hash_first(scratch_pool, externals); hi;
hi = apr_hash_next(hi))
{
int i;
const char *externals_parent = svn__apr_hash_index_key(hi);
svn_string_t *external_desc = svn__apr_hash_index_val(hi);
apr_array_header_t *externals_p;
svn_pool_clear(iterpool);
externals_p = apr_array_make(iterpool, 1,
sizeof(svn_wc_external_item2_t*));
SVN_ERR(svn_wc_parse_externals_description3(
&externals_p, svn_dirent_dirname(path, iterpool),
external_desc->data, TRUE, iterpool));
for (i = 0; i < externals_p->nelts; i++)
{
svn_wc_external_item2_t *item;
const char *external_abspath;
const char *external_path;
const char *repos_relpath;
const char *repos_root_url;
const char *repos_uuid;
svn_node_kind_t kind;
svn_revnum_t peg_revision;
svn_revnum_t revision;
svn_error_t *err;
item = APR_ARRAY_IDX(externals_p, i, svn_wc_external_item2_t*);
svn_pool_clear(iterpool2);
external_path = svn_dirent_join(externals_parent, item->target_dir,
iterpool2);
err = svn_dirent_get_absolute(&external_abspath, external_path,
iterpool2);
if (err)
goto handle_error;
/* This is hack. We can only send dirs to svn_wc_upgrade(). This
way we will get an exception saying that the wc must be
upgraded if it's a dir. If it's a file then the lookup is done
in an adm_dir belonging to the real wc and since that was
updated before the externals no error is returned. */
err = svn_wc_read_kind(&kind, ctx->wc_ctx, external_abspath, FALSE,
iterpool2);
if (err && err->apr_err == SVN_ERR_WC_UPGRADE_REQUIRED)
{
svn_error_clear(err);
err = svn_client_upgrade(external_abspath, ctx, iterpool2);
}
if (err)
goto handle_error;
/* The upgrade of any dir should be done now, get the (supposedly
* now reliable) kind. */
err = svn_wc_read_kind(&kind, ctx->wc_ctx, external_abspath,
FALSE, iterpool2);
if (err)
goto handle_error;
/* Update the EXTERNALS table according to the root URL,
* relpath and uuid known in the upgraded external WC. */
/* We should probably have a function that provides all three
* of root URL, repos relpath and uuid at once, but here goes... */
/* First get the relpath, as that returns SVN_ERR_WC_PATH_NOT_FOUND
* when the node is not present in the file system.
* (svn_wc__node_get_repos_info() would try to derive the URL). */
err = svn_wc__node_get_repos_relpath(&repos_relpath,
ctx->wc_ctx,
external_abspath,
iterpool2, iterpool2);
if (! err)
{
/* We got a repos relpath from a WC. So also get the root. */
err = svn_wc__node_get_repos_info(&repos_root_url,
&repos_uuid,
ctx->wc_ctx,
external_abspath,
iterpool2, iterpool2);
}
else if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
/* The external is not currently checked out. Try to figure out
* the URL parts via the defined URL and fetch_repos_info(). */
svn_error_clear(err);
/* The repos root / uuid from above get_repos_info() call, if it
* was successful, has returned the URL as derived from the WC's
* parent path, which is not what we want for the external. Only
* makes sense for added/deleted/not-present files. So make sure
* those values are not used. */
repos_root_url = NULL;
repos_relpath = NULL;
err = fetch_repos_info(&repos_root_url,
&repos_uuid,
&info_baton,
item->url,
scratch_pool, scratch_pool);
if (err)
goto handle_error;
repos_relpath = svn_uri_skip_ancestor(repos_root_url, item->url,
iterpool2);
/* There's just this URL, no idea what kind it is. */
kind = svn_node_unknown;
}
if (err)
goto handle_error;
peg_revision = (item->peg_revision.kind == svn_opt_revision_number
? item->peg_revision.value.number
: SVN_INVALID_REVNUM);
revision = (item->revision.kind == svn_opt_revision_number
? item->revision.value.number
: SVN_INVALID_REVNUM);
err = svn_wc__upgrade_add_external_info(ctx->wc_ctx,
external_abspath,
kind,
externals_parent,
repos_relpath,
repos_root_url,
repos_uuid,
peg_revision,
revision,
iterpool2);
handle_error:
if (err)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(external_abspath,
svn_wc_notify_failed_external,
scratch_pool);
notify->err = err;
ctx->notify_func2(ctx->notify_baton2,
notify, scratch_pool);
svn_error_clear(err);
}
}
}
svn_pool_destroy(iterpool);
svn_pool_destroy(iterpool2);
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_upgrade(const char *path,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
const char *local_abspath;
apr_hash_t *externals;
apr_hash_index_t *hi;
apr_pool_t *iterpool;
apr_pool_t *iterpool2;
svn_opt_revision_t rev = {svn_opt_revision_unspecified, {0}};
struct repos_info_baton info_baton;
info_baton.state_pool = scratch_pool;
info_baton.ctx = ctx;
info_baton.last_repos = NULL;
info_baton.last_uuid = NULL;
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
SVN_ERR(svn_wc_upgrade(ctx->wc_ctx, local_abspath,
fetch_repos_info, &info_baton,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool));
/* Now it's time to upgrade the externals too. We do it after the wc
upgrade to avoid that errors in the externals causes the wc upgrade to
fail. Thanks to caching the performance penalty of walking the wc a
second time shouldn't be too severe */
SVN_ERR(svn_client_propget5(&externals, NULL, SVN_PROP_EXTERNALS,
local_abspath, &rev, &rev, NULL,
svn_depth_infinity, NULL, ctx,
scratch_pool, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
iterpool2 = svn_pool_create(scratch_pool);
for (hi = apr_hash_first(scratch_pool, externals); hi;
hi = apr_hash_next(hi))
{
int i;
const char *externals_parent_abspath;
const char *externals_parent_url;
const char *externals_parent_repos_root_url;
const char *externals_parent_repos_relpath;
const char *externals_parent = svn__apr_hash_index_key(hi);
svn_string_t *external_desc = svn__apr_hash_index_val(hi);
apr_array_header_t *externals_p;
svn_error_t *err;
svn_pool_clear(iterpool);
externals_p = apr_array_make(iterpool, 1,
sizeof(svn_wc_external_item2_t*));
/* In this loop, an error causes the respective externals definition, or
* the external (inner loop), to be skipped, so that upgrade carries on
* with the other externals. */
err = svn_dirent_get_absolute(&externals_parent_abspath,
externals_parent, iterpool);
if (!err)
err = svn_wc__node_get_repos_info(NULL,
&externals_parent_repos_relpath,
&externals_parent_repos_root_url,
NULL,
ctx->wc_ctx,
externals_parent_abspath,
iterpool, iterpool);
if (!err)
externals_parent_url = svn_path_url_add_component2(
externals_parent_repos_root_url,
externals_parent_repos_relpath,
iterpool);
if (!err)
err = svn_wc_parse_externals_description3(
&externals_p, svn_dirent_dirname(path, iterpool),
external_desc->data, FALSE, iterpool);
if (err)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(externals_parent,
svn_wc_notify_failed_external,
scratch_pool);
notify->err = err;
ctx->notify_func2(ctx->notify_baton2,
notify, scratch_pool);
svn_error_clear(err);
/* Next externals definition, please... */
continue;
}
for (i = 0; i < externals_p->nelts; i++)
{
svn_wc_external_item2_t *item;
const char *resolved_url;
const char *external_abspath;
const char *repos_relpath;
const char *repos_root_url;
const char *repos_uuid;
svn_node_kind_t external_kind;
svn_revnum_t peg_revision;
svn_revnum_t revision;
item = APR_ARRAY_IDX(externals_p, i, svn_wc_external_item2_t*);
svn_pool_clear(iterpool2);
external_abspath = svn_dirent_join(externals_parent_abspath,
item->target_dir,
iterpool2);
err = svn_wc__resolve_relative_external_url(
&resolved_url,
item,
externals_parent_repos_root_url,
externals_parent_url,
scratch_pool, scratch_pool);
if (err)
goto handle_error;
/* This is a hack. We only need to call svn_wc_upgrade() on external
* dirs, as file externals are upgraded along with their defining
* WC. Reading the kind will throw an exception on an external dir,
* saying that the wc must be upgraded. If it's a file, the lookup
* is done in an adm_dir belonging to the defining wc (which has
* already been upgraded) and no error is returned. If it doesn't
* exist (external that isn't checked out yet), we'll just get
* svn_node_none. */
err = svn_wc_read_kind2(&external_kind, ctx->wc_ctx,
external_abspath, TRUE, FALSE, iterpool2);
if (err && err->apr_err == SVN_ERR_WC_UPGRADE_REQUIRED)
{
svn_error_clear(err);
err = svn_client_upgrade(external_abspath, ctx, iterpool2);
if (err)
goto handle_error;
}
else if (err)
goto handle_error;
/* The upgrade of any dir should be done now, get the now reliable
* kind. */
err = svn_wc_read_kind2(&external_kind, ctx->wc_ctx, external_abspath,
TRUE, FALSE, iterpool2);
if (err)
goto handle_error;
/* Update the EXTERNALS table according to the root URL,
* relpath and uuid known in the upgraded external WC. */
/* We should probably have a function that provides all three
* of root URL, repos relpath and uuid at once, but here goes... */
/* First get the relpath, as that returns SVN_ERR_WC_PATH_NOT_FOUND
* when the node is not present in the file system.
* svn_wc__node_get_repos_info() would try to derive the URL. */
err = svn_wc__node_get_repos_info(NULL,
&repos_relpath,
&repos_root_url,
&repos_uuid,
ctx->wc_ctx,
external_abspath,
iterpool2, iterpool2);
if (err)
goto handle_error;
/* If we haven't got any information from the checked out external,
* or if the URL information mismatches the external's definition,
* ask fetch_repos_info() to find out the repos root. */
if (0 != strcmp(resolved_url,
svn_path_url_add_component2(repos_root_url,
repos_relpath,
scratch_pool)))
{
err = fetch_repos_info(&repos_root_url,
&repos_uuid,
&info_baton,
resolved_url,
scratch_pool, scratch_pool);
if (err)
goto handle_error;
repos_relpath = svn_uri_skip_ancestor(repos_root_url,
resolved_url,
iterpool2);
/* There's just the URL, no idea what kind the external is.
* That's fine, as the external isn't even checked out yet.
* The kind will be set during the next 'update'. */
external_kind = svn_node_unknown;
}
if (err)
goto handle_error;
peg_revision = (item->peg_revision.kind == svn_opt_revision_number
? item->peg_revision.value.number
: SVN_INVALID_REVNUM);
revision = (item->revision.kind == svn_opt_revision_number
? item->revision.value.number
: SVN_INVALID_REVNUM);
err = svn_wc__upgrade_add_external_info(ctx->wc_ctx,
external_abspath,
external_kind,
externals_parent,
repos_relpath,
repos_root_url,
repos_uuid,
peg_revision,
revision,
iterpool2);
handle_error:
if (err)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(external_abspath,
svn_wc_notify_failed_external,
scratch_pool);
notify->err = err;
ctx->notify_func2(ctx->notify_baton2,
notify, scratch_pool);
svn_error_clear(err);
/* Next external node, please... */
}
}
}
svn_pool_destroy(iterpool);
svn_pool_destroy(iterpool2);
return SVN_NO_ERROR;
}
svn_error_t *
svn_path_remove_redundancies(apr_array_header_t **pcondensed_targets,
const apr_array_header_t *targets,
apr_pool_t *pool)
{
apr_pool_t *temp_pool;
apr_array_header_t *abs_targets;
apr_array_header_t *rel_targets;
int i;
if ((targets->nelts <= 0) || (! pcondensed_targets))
{
/* No targets or no place to store our work means this function
really has nothing to do. */
if (pcondensed_targets)
*pcondensed_targets = NULL;
return SVN_NO_ERROR;
}
/* Initialize our temporary pool. */
temp_pool = svn_pool_create(pool);
/* Create our list of absolute paths for our "keepers" */
abs_targets = apr_array_make(temp_pool, targets->nelts,
sizeof(const char *));
/* Create our list of untainted paths for our "keepers" */
rel_targets = apr_array_make(pool, targets->nelts,
sizeof(const char *));
/* For each target in our list we do the following:
1. Calculate its absolute path (ABS_PATH).
2. See if any of the keepers in ABS_TARGETS is a parent of, or
is the same path as, ABS_PATH. If so, we ignore this
target. If not, however, add this target's absolute path to
ABS_TARGETS and its original path to REL_TARGETS.
*/
for (i = 0; i < targets->nelts; i++)
{
const char *rel_path = APR_ARRAY_IDX(targets, i, const char *);
const char *abs_path;
int j;
svn_boolean_t is_url, keep_me;
/* Get the absolute path for this target. */
is_url = svn_path_is_url(rel_path);
if (is_url)
abs_path = rel_path;
else
SVN_ERR(svn_dirent_get_absolute(&abs_path, rel_path, temp_pool));
/* For each keeper in ABS_TARGETS, see if this target is the
same as or a child of that keeper. */
keep_me = TRUE;
for (j = 0; j < abs_targets->nelts; j++)
{
const char *keeper = APR_ARRAY_IDX(abs_targets, j, const char *);
svn_boolean_t keeper_is_url = svn_path_is_url(keeper);
const char *child_relpath;
/* If KEEPER hasn't the same is-url-ness as ABS_PATH, we
know they aren't equal and that one isn't the child of
the other. */
if (is_url != keeper_is_url)
continue;
/* Quit here if this path is the same as or a child of one of the
keepers. */
if (is_url)
child_relpath = svn_uri_skip_ancestor(keeper, abs_path, temp_pool);
else
child_relpath = svn_dirent_skip_ancestor(keeper, abs_path);
if (child_relpath)
{
keep_me = FALSE;
break;
}
}
/* If this is a new keeper, add its absolute path to ABS_TARGETS
and its original path to REL_TARGETS. */
if (keep_me)
{
APR_ARRAY_PUSH(abs_targets, const char *) = abs_path;
APR_ARRAY_PUSH(rel_targets, const char *) = rel_path;
}
}
/* Destroy our temporary pool. */
svn_pool_destroy(temp_pool);
/* Make sure we return the list of untainted keeper paths. */
*pcondensed_targets = rel_targets;
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra__get_inherited_props_walk(svn_ra_session_t *session,
const char *path,
svn_revnum_t revision,
apr_array_header_t **inherited_props,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *repos_root_url;
const char *session_url;
const char *parent_url;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
*inherited_props =
apr_array_make(result_pool, 1, sizeof(svn_prop_inherited_item_t *));
/* Walk to the root of the repository getting inherited
props for PATH. */
SVN_ERR(svn_ra_get_repos_root2(session, &repos_root_url, scratch_pool));
SVN_ERR(svn_ra_get_session_url(session, &session_url, scratch_pool));
parent_url = session_url;
while (strcmp(repos_root_url, parent_url))
{
apr_hash_index_t *hi;
apr_hash_t *parent_props;
apr_hash_t *final_hash = apr_hash_make(result_pool);
svn_error_t *err;
svn_pool_clear(iterpool);
parent_url = svn_uri_dirname(parent_url, scratch_pool);
SVN_ERR(svn_ra_reparent(session, parent_url, iterpool));
err = session->vtable->get_dir(session, NULL, NULL,
&parent_props, "",
revision, SVN_DIRENT_ALL,
iterpool);
/* If the user doesn't have read access to a parent path then
skip, but allow them to inherit from further up. */
if (err)
{
if ((err->apr_err == SVN_ERR_RA_NOT_AUTHORIZED)
|| (err->apr_err == SVN_ERR_RA_DAV_FORBIDDEN))
{
svn_error_clear(err);
continue;
}
else
{
return svn_error_trace(err);
}
}
for (hi = apr_hash_first(scratch_pool, parent_props);
hi;
hi = apr_hash_next(hi))
{
const char *name = apr_hash_this_key(hi);
apr_ssize_t klen = apr_hash_this_key_len(hi);
svn_string_t *value = apr_hash_this_val(hi);
if (svn_property_kind2(name) == svn_prop_regular_kind)
{
name = apr_pstrdup(result_pool, name);
value = svn_string_dup(value, result_pool);
apr_hash_set(final_hash, name, klen, value);
}
}
if (apr_hash_count(final_hash))
{
svn_prop_inherited_item_t *new_iprop =
apr_palloc(result_pool, sizeof(*new_iprop));
new_iprop->path_or_url = svn_uri_skip_ancestor(repos_root_url,
parent_url,
result_pool);
new_iprop->prop_hash = final_hash;
svn_sort__array_insert(*inherited_props, &new_iprop, 0);
}
}
/* Reparent session back to original URL. */
SVN_ERR(svn_ra_reparent(session, session_url, scratch_pool));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__path_relative_to_root(const char **rel_path,
svn_wc_context_t *wc_ctx,
const char *abspath_or_url,
const char *repos_root,
svn_boolean_t include_leading_slash,
svn_ra_session_t *ra_session,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *repos_relpath;
/* If we have a WC path... */
if (! svn_path_is_url(abspath_or_url))
{
/* ...fetch its entry, and attempt to get both its full URL and
repository root URL. If we can't get REPOS_ROOT from the WC
entry, we'll get it from the RA layer.*/
SVN_ERR(svn_wc__node_get_repos_relpath(&repos_relpath,
wc_ctx,
abspath_or_url,
result_pool,
scratch_pool));
SVN_ERR_ASSERT(repos_relpath != NULL);
}
/* Merge handling passes a root that is not the repos root */
else if (repos_root != NULL)
{
if (!svn_uri__is_ancestor(repos_root, abspath_or_url))
return svn_error_createf(SVN_ERR_CLIENT_UNRELATED_RESOURCES, NULL,
_("URL '%s' is not a child of repository "
"root URL '%s'"),
abspath_or_url, repos_root);
repos_relpath = svn_uri_skip_ancestor(repos_root, abspath_or_url,
result_pool);
}
else
{
svn_error_t *err;
SVN_ERR_ASSERT(ra_session != NULL);
/* Ask the RA layer to create a relative path for us */
err = svn_ra_get_path_relative_to_root(ra_session, &repos_relpath,
abspath_or_url, scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_RA_ILLEGAL_URL)
return svn_error_createf(SVN_ERR_CLIENT_UNRELATED_RESOURCES, err,
_("URL '%s' is not inside repository"),
abspath_or_url);
return svn_error_trace(err);
}
}
if (include_leading_slash)
*rel_path = apr_pstrcat(result_pool, "/", repos_relpath, NULL);
else
*rel_path = repos_relpath;
return SVN_NO_ERROR;
}
