def _copy_symlink(source_path: Path, target_path: Path, overwrite: str,
context: Optional[Path]) -> bool:
"""Copy a symlink.
Copies links to an existing file within the context as links and
returns True, otherwise returns False. If overwrite is True,
overwrites the target.
"""
target_path_exists = target_path.exists() or target_path.is_symlink()
if not target_path_exists or overwrite == 'always':
if context is not None:
linked_path = source_path.readlink(recursive=False)
if context in linked_path.parents:
rel_path = linked_path.relative_to(context)
logger.debug(
'Making relative link from %s to %s', target_path,
rel_path)
target_fs = target_path.filesystem
if target_path.exists() or target_path.is_symlink():
if target_path.is_dir():
target_path.rmdir(recursive=True)
else:
target_path.unlink()
target_path.symlink_to(target_fs / str(rel_path))
return True
return False # fall through and copy as file or directory
elif overwrite == 'raise':
raise FileExistsError('Target path exists, not overwriting')
return True # target path exists and overwrite is never, fail silently
def _get_approx_size(path: Path) -> int:
count = 0
if not path.is_symlink() and path.is_file():
count += path.size()
elif not path.is_symlink() and path.is_dir():
for subdir in path.iterdir():
count += _get_approx_size(subdir)
return count
def _copy_file(source_path: Path, target_path: Path, overwrite: str,
copy_permissions: bool, callback: Optional[CopyCallback],
already_written: int, size: int) -> int:
"""Copy a file.
Returns the number of bytes written.
"""
target_path_exists = target_path.exists() or target_path.is_symlink()
if not target_path_exists or overwrite == 'always':
logger.debug('Copying file from %s to %s', source_path, target_path)
if not target_path.is_symlink() and target_path.is_dir():
target_path.rmdir(recursive=True)
elif target_path.exists():
target_path.unlink()
target_path.touch()
perms = dict()
for permission in Permission:
perms[permission] = target_path.has_permission(permission)
try:
target_path.chmod(0o600)
except UnsupportedOperationError:
pass
target_path.streaming_write(
_call_back(
callback, perf_counter() + 1.0, already_written, size,
source_path.streaming_read()))
already_written += source_path.size()
try:
for permission in Permission:
if copy_permissions:
target_path.set_permission(
permission, source_path.has_permission(permission))
else:
target_path.set_permission(
permission,
perms[permission]
and source_path.has_permission(permission))
except UnsupportedOperationError:
pass
elif overwrite == 'raise':
raise FileExistsError('Target path exists, not overwriting')
return already_written
def _copy(source_path: Path, target_path: Path, overwrite: str,
copy_permissions: bool, context: Optional[Path],
callback: Optional[CopyCallback], already_written: int, size: int
) -> int:
"""Copy a file or directory from one path to another.
See the documentation of copy() for the required behaviour.
The context path is guaranteed to be a prefix of source_path, on \
the same file system.
Args:
source_path: The path to the source file.
target_path: A path to copy it to.
overwrite: Selects behaviour when the target exists.
copy_permissions: Whether to copy permissions along.
context: Root of the tree we are copying, or None.
callback: A callback function to call.
already_written: Starting count of bytes written.
size: Approximate total size of data to copy.
Returns:
The approximate total number of bytes written.
"""
logging.debug('Copying {} to {}'.format(source_path, target_path))
target_path_exists = target_path.exists() or target_path.is_symlink()
if source_path.is_symlink():
if _copy_symlink(source_path, target_path, overwrite, context):
return already_written
if source_path.is_file():
already_written = _copy_file(source_path, target_path, overwrite,
copy_permissions, callback,
already_written, size)
elif source_path.is_dir():
already_written = _copy_dir(source_path, target_path, overwrite,
copy_permissions, context, callback,
already_written, size)
elif source_path.exists() or source_path.is_symlink():
# We don't copy special entries or broken links
logging.debug(
'Skipping special entry or broken link {}'.format(source_path))
else:
raise FileNotFoundError(('Source path {} does not exist, cannot'
' copy').format(source_path))
return already_written
def _copy_dir(source_path: Path, target_path: Path, overwrite: str,
copy_permissions: bool, context: Optional[Path],
callback: Optional[CopyCallback], already_written: int, size: int
) -> int:
"""Copy a directory recursively.
"""
target_path_exists = target_path.exists() or target_path.is_symlink()
if target_path_exists:
if overwrite == 'always':
if not target_path.is_dir():
target_path.unlink()
elif overwrite == 'raise':
raise FileExistsError('Target path exists, not overwriting')
elif overwrite == 'never':
return already_written
if not target_path.exists():
logging.debug('Making new dir {}'.format(target_path))
target_path.mkdir()
perms = dict()
for permission in Permission:
perms[permission] = target_path.has_permission(permission)
try:
target_path.chmod(0o700)
except UnsupportedOperationError:
pass
for entry in source_path.iterdir():
logging.debug('Recursively copying entry {}'.format(entry))
already_written = _copy(entry, target_path / entry.name, overwrite,
copy_permissions, context, callback,
already_written, size)
try:
for permission in Permission:
if copy_permissions:
target_path.set_permission(
permission, source_path.has_permission(permission))
else:
target_path.set_permission(
permission,
perms[permission]
and source_path.has_permission(permission))
except UnsupportedOperationError:
pass
return already_written