/* Make an unversioned copy of the versioned file or directory tree at the
* source path FROM_ABSPATH. Copy it to the destination path TO_ABSPATH.
*
* If REVISION is svn_opt_revision_working, copy the working version,
* otherwise copy the base version.
*
* See copy_one_versioned_file() for details of file copying behaviour,
* including IGNORE_KEYWORDS and NATIVE_EOL.
*
* Include externals unless IGNORE_EXTERNALS is true.
*
* Recurse according to DEPTH.
*
*/
static svn_error_t *
copy_versioned_files(const char *from_abspath,
const char *to_abspath,
const svn_opt_revision_t *revision,
svn_boolean_t force,
svn_boolean_t ignore_externals,
svn_boolean_t ignore_keywords,
svn_depth_t depth,
const char *native_eol,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_error_t *err;
apr_pool_t *iterpool;
const apr_array_header_t *children;
svn_node_kind_t from_kind;
svn_depth_t node_depth;
SVN_ERR_ASSERT(svn_dirent_is_absolute(from_abspath));
SVN_ERR_ASSERT(svn_dirent_is_absolute(to_abspath));
/* Only export 'added' and 'replaced' files when the revision is WORKING;
when the revision is BASE (i.e. != WORKING), only export 'added' and
'replaced' files when they are part of a copy-/move-here. Otherwise, skip
them, since they don't have an associated text-base. This condition for
added/replaced simply is an optimization. Added and replaced files would
be handled similarly by svn_wc_get_pristine_contents2(), which would
return NULL if they have no base associated.
TODO: We may prefer not to duplicate this condition and rather use
svn_wc_get_pristine_contents2() or a dedicated new function instead.
Don't export 'deleted' files and directories unless it's a
revision other than WORKING. These files and directories
don't really exist in WORKING. */
if (revision->kind != svn_opt_revision_working)
{
svn_boolean_t is_added;
const char *repos_relpath;
SVN_ERR(svn_wc__node_get_origin(&is_added, NULL, &repos_relpath,
NULL, NULL, NULL,
ctx->wc_ctx, from_abspath, FALSE,
pool, pool));
if (is_added && !repos_relpath)
return SVN_NO_ERROR; /* Local addition */
}
else
{
svn_boolean_t is_deleted;
SVN_ERR(svn_wc__node_is_status_deleted(&is_deleted, ctx->wc_ctx,
from_abspath, pool));
if (is_deleted)
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind(&from_kind, ctx->wc_ctx, from_abspath, FALSE,
pool));
if (from_kind == svn_node_dir)
{
apr_fileperms_t perm = APR_OS_DEFAULT;
int j;
/* Try to make the new directory. If this fails because the
directory already exists, check our FORCE flag to see if we
care. */
/* Keep the source directory's permissions if applicable.
Skip retrieving the umask on windows. Apr does not implement setting
filesystem privileges on Windows.
Retrieving the file permissions with APR_FINFO_PROT | APR_FINFO_OWNER
is documented to be 'incredibly expensive' */
#ifndef WIN32
if (revision->kind == svn_opt_revision_working)
{
apr_finfo_t finfo;
SVN_ERR(svn_io_stat(&finfo, from_abspath, APR_FINFO_PROT, pool));
perm = finfo.protection;
}
#endif
err = svn_io_dir_make(to_abspath, perm, pool);
if (err)
{
if (! APR_STATUS_IS_EEXIST(err->apr_err))
return svn_error_trace(err);
if (! force)
SVN_ERR_W(err, _("Destination directory exists, and will not be "
"overwritten unless forced"));
else
svn_error_clear(err);
}
SVN_ERR(svn_wc__node_get_children(&children, ctx->wc_ctx, from_abspath,
FALSE, pool, pool));
iterpool = svn_pool_create(pool);
for (j = 0; j < children->nelts; j++)
{
const char *child_abspath = APR_ARRAY_IDX(children, j, const char *);
const char *child_name = svn_dirent_basename(child_abspath, NULL);
const char *target_abspath;
svn_node_kind_t child_kind;
svn_pool_clear(iterpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
target_abspath = svn_dirent_join(to_abspath, child_name, iterpool);
SVN_ERR(svn_wc_read_kind(&child_kind, ctx->wc_ctx, child_abspath,
FALSE, iterpool));
if (child_kind == svn_node_dir)
{
if (depth == svn_depth_infinity
|| depth == svn_depth_immediates)
{
if (ctx->notify_func2)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(target_abspath,
svn_wc_notify_update_add, pool);
notify->kind = svn_node_dir;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
if (depth == svn_depth_infinity)
SVN_ERR(copy_versioned_files(child_abspath, target_abspath,
revision, force,
ignore_externals,
ignore_keywords, depth,
native_eol, ctx, iterpool));
else
SVN_ERR(svn_io_make_dir_recursively(target_abspath,
iterpool));
}
}
else if (child_kind == svn_node_file
&& depth >= svn_depth_files)
{
svn_node_kind_t external_kind;
SVN_ERR(svn_wc__read_external_info(&external_kind,
NULL, NULL, NULL,
NULL, ctx->wc_ctx,
child_abspath,
child_abspath, TRUE,
pool, pool));
if (external_kind != svn_node_file)
SVN_ERR(copy_one_versioned_file(child_abspath, target_abspath,
ctx, revision,
native_eol, ignore_keywords,
iterpool));
}
}
SVN_ERR(svn_wc__node_get_depth(&node_depth, ctx->wc_ctx,
from_abspath, pool));
/* Handle externals. */
if (! ignore_externals && depth == svn_depth_infinity
&& node_depth == svn_depth_infinity)
{
apr_array_header_t *ext_items;
const svn_string_t *prop_val;
SVN_ERR(svn_wc_prop_get2(&prop_val, ctx->wc_ctx, from_abspath,
SVN_PROP_EXTERNALS, pool, pool));
if (prop_val != NULL)
{
int i;
SVN_ERR(svn_wc_parse_externals_description3(&ext_items,
from_abspath,
prop_val->data,
FALSE, pool));
for (i = 0; i < ext_items->nelts; ++i)
{
svn_wc_external_item2_t *ext_item;
const char *new_from, *new_to;
svn_pool_clear(iterpool);
ext_item = APR_ARRAY_IDX(ext_items, i,
svn_wc_external_item2_t *);
new_from = svn_dirent_join(from_abspath,
ext_item->target_dir,
iterpool);
new_to = svn_dirent_join(to_abspath, ext_item->target_dir,
iterpool);
/* The target dir might have parents that don't exist.
Guarantee the path upto the last component. */
if (!svn_dirent_is_root(ext_item->target_dir,
strlen(ext_item->target_dir)))
{
const char *parent = svn_dirent_dirname(new_to, iterpool);
SVN_ERR(svn_io_make_dir_recursively(parent, iterpool));
}
SVN_ERR(copy_versioned_files(new_from, new_to,
revision, force, FALSE,
ignore_keywords,
svn_depth_infinity, native_eol,
ctx, iterpool));
}
}
svn_error_t * CCachedDirectory::GetStatusCallback(void *baton, const char *path, const svn_client_status_t *status, apr_pool_t * pool)
{
CCachedDirectory* pThis = (CCachedDirectory*)baton;
if (path == NULL)
return SVN_NO_ERROR;
CTSVNPath svnPath;
bool forceNormal = false;
bool needsLock = false;
const svn_wc_status_kind nodeStatus = status->node_status;
if(status->versioned)
{
if ((nodeStatus != svn_wc_status_none)&&(nodeStatus != svn_wc_status_ignored))
svnPath.SetFromSVN(path, (status->kind == svn_node_dir));
else
svnPath.SetFromSVN(path);
if(svnPath.IsDirectory())
{
if(!svnPath.IsEquivalentToWithoutCase(pThis->m_directoryPath))
{
// Make sure we know about this child directory
// This initial status value is likely to be overwritten from below at some point
svn_wc_status_kind s = nodeStatus;
if (status->conflicted)
s = SVNStatus::GetMoreImportant(s, svn_wc_status_conflicted);
CCachedDirectory * cdir = CSVNStatusCache::Instance().GetDirectoryCacheEntryNoCreate(svnPath);
if (cdir)
{
// This child directory is already in our cache!
// So ask this dir about its recursive status
svn_wc_status_kind st = SVNStatus::GetMoreImportant(s, cdir->GetCurrentFullStatus());
pThis->SetChildStatus(svnPath, st);
}
else
{
// the child directory is not in the cache. Create a new entry for it in the cache which is
// initially 'unversioned'. But we added that directory to the crawling list above, which
// means the cache will be updated soon.
CSVNStatusCache::Instance().GetDirectoryCacheEntry(svnPath);
pThis->SetChildStatus(svnPath, s);
}
}
}
else
{
// only fetch the svn:needs-lock property if the status of this file is 'normal', because
// if the status is something else, the needs-lock overlay won't show up anyway
if ((pThis->m_pCtx)&&(nodeStatus == svn_wc_status_normal))
{
const svn_string_t * value = NULL;
svn_error_t * err = svn_wc_prop_get2(&value, pThis->m_pCtx->wc_ctx, path, "svn:needs-lock", pool, pool);
if ((err==NULL) && value)
needsLock = true;
if (err)
svn_error_clear(err);
}
}
}
else
{
if ((status->kind != svn_node_unknown)&&(status->kind != svn_node_none))
svnPath.SetFromSVN(path, status->kind == svn_node_dir);
else
svnPath.SetFromSVN(path);
// Subversion returns no 'entry' field for versioned folders if they're
// part of another working copy (nested layouts).
// So we have to make sure that such an 'unversioned' folder really
// is unversioned.
if (((nodeStatus == svn_wc_status_unversioned)||(nodeStatus == svn_wc_status_ignored))&&(!svnPath.IsEquivalentToWithoutCase(pThis->m_directoryPath))&&(svnPath.IsDirectory()))
{
if (svnPath.IsWCRoot())
{
CSVNStatusCache::Instance().AddFolderForCrawling(svnPath);
// Mark the directory as 'versioned' (status 'normal' for now).
// This initial value will be overwritten from below some time later
pThis->SetChildStatus(svnPath, svn_wc_status_normal);
// Make sure the entry is also in the cache
CSVNStatusCache::Instance().GetDirectoryCacheEntry(svnPath);
// also mark the status in the status object as normal
forceNormal = true;
}
else
{
pThis->SetChildStatus(svnPath, nodeStatus);
}
}
else if (nodeStatus == svn_wc_status_external)
{
if ((status->kind == svn_node_dir) || (svnPath.IsDirectory()))
{
CSVNStatusCache::Instance().AddFolderForCrawling(svnPath);
// Mark the directory as 'versioned' (status 'normal' for now).
// This initial value will be overwritten from below some time later
pThis->SetChildStatus(svnPath, svn_wc_status_normal);
// we have added a directory to the child-directory list of this
// directory. We now must make sure that this directory also has
// an entry in the cache.
CSVNStatusCache::Instance().GetDirectoryCacheEntry(svnPath);
// also mark the status in the status object as normal
forceNormal = true;
}
}
else
{
if (svnPath.IsDirectory())
{
svn_wc_status_kind s = nodeStatus;
if (status->conflicted)
s = SVNStatus::GetMoreImportant(s, svn_wc_status_conflicted);
pThis->SetChildStatus(svnPath, s);
}
}
}
pThis->AddEntry(svnPath, status, needsLock, forceNormal);
return SVN_NO_ERROR;
}
