def copy_to(self, target, force=False):
""" copy from a the current path object to a target path """
if not target.exists() and not target.is_symlink() or force:
# FIXME copytree does not happen, so sources cannot currently
# be directories, what are the downsides of homogenizing that?
shutil.copy2(self, target)
else:
raise exc.PathExistsError(f'{target}')
def copy_to(self, target, force=False, copy_cache_meta=False):
""" copy from a the current path object to a target path """
if type(target) != type(self):
target = self.__class__(target)
if not target.exists() and not target.is_symlink() or force:
target.data = self.data
else:
raise exc.PathExistsError(f'{target}')
if copy_cache_meta:
log.debug(f'copying cache meta {self.cache.meta}')
target.cache_init(self.cache.meta)
def meta(self):
if hasattr(self, '_meta'):
return self._meta
if self.is_symlink():
if not self.exists(
): # if a symlink exists it is something other than what we want
#assert pathlib.PurePosixPath(self.name) == self.readlink().parent.parent
return PathMeta.from_symlink(self)
else:
raise exc.PathExistsError(
f'Target of symlink exists!\n{self} -> {self.resolve()}')
else:
return super().meta
def move(self, *, remote=None, target=None, meta=None):
""" instantiate a new cache and cleanup self because we are moving """
# FIXME what to do if we have data
if remote is None and (target is None or meta is None):
raise TypeError(
'either remote or meta and target are required arguments')
# deal with moving to a different directory that might not even exist yet
if target is None:
if not isinstance(self.anchor, self.__class__):
raise TypeError(
f'mismatched anchor types {self!r} {self.anchor!r}')
target = self.anchor / remote # FIXME why does this not try to instantiate the caches? or does it?
if target.absolute() == self.absolute():
log.warning(f'trying to move a file onto itself {self.absolute()}')
return target
common = self.commonpath(target).absolute()
target_parent = target.parent.absolute()
parent = self.parent.absolute()
assert target.name != self.name or target_parent != parent
if target_parent != parent:
_id = remote.id if remote else meta.id
log.warning('A parent of current file has changed location!\n'
f'{common}\n{self.relative_to(common)}\n'
f'{target.relative_to(common)}\n{_id}')
if not target_parent.exists():
if remote is None: # we have to have a remote to pull parent structure
remote = self._remote_class(meta)
target_parent.mkdir_cache(remote)
do_cast = not isinstance(target, self.__class__)
if do_cast:
target = self.__class__(target, meta=meta)
if target.exists() or target.is_broken_symlink():
if target.id == self.id: #(remote.id if remote else meta.id):
if self.is_broken_symlink():
# we may be a package with extra metadata that needs to
# be merged with the target before we are unlinked
file_is_different = target._meta_updater(self.meta)
# FIXME ... if file is different then this causes staleness
# and we need to fetch
if file_is_different:
log.critical('DO SOMETHING ABOUT THIS STALE DATA'
f'\n{target}\n{target.meta.as_pretty()}')
elif do_cast:
# the target meta was just put there, if the ids match it should be ok
# however since arbitrary meta can be passed in, best to double check
file_is_different = target._meta_updater(self.meta)
if file_is_different:
log.critical('Something has gone wrong'
f'\n{target}\n{target.meta.as_pretty()}')
else:
# directory moves that are resolved during pull
log.warning(f'what is this!?\n{target}\n{self}')
elif target.is_broken_symlink():
remote._cache = self # restore the mapping for remote -> self
raise exc.WhyDidntThisGetMovedBeforeError(
f'\n{target}\n{self}')
else:
raise exc.PathExistsError(f'Target {target} already exists!')
if self.exists():
safe_unlink = target.local.parent / f'.unlink-{target.name}'
try:
if target.is_broken_symlink():
target.rename(safe_unlink)
self.rename(
target
) # if target is_dir then this will fail, which is ok
except BaseException as e:
log.exception(e)
if safe_unlink.is_broken_symlink():
safe_unlink.rename(target)
finally:
if safe_unlink.is_broken_symlink():
safe_unlink.unlink()
elif self.is_broken_symlink():
# we don't move to trash here because this was just a file rename
self.unlink(
) # don't move the meta since it will break the naming insurance measure
return target
def meta(self, pathmeta):
if not self.exists():
# if the path does not exist write even temporary to disk
if self.is_symlink():
meta = self.meta
if meta == pathmeta:
log.debug(
f'Metadata unchanged for {meta.id}. Not updating.')
return
if meta.id != pathmeta.id:
msg = ('Existing cache id does not match new id!\n'
f'{self!r}\n'
f'{meta.id} != {pathmeta.id}\n'
f'{meta.as_pretty()}\n'
f'{pathmeta.as_pretty()}')
log.critical(msg)
meta_newer = 'Meta newer. Not updating.'
pathmeta_newer = 'Other meta newer.'
msg = '{}' # apparently I was out of my mind when I wrote this originally ...
if meta.updated is None and pathmeta.updated is None:
log.warning(
'no change since either has an updated value (wat)'
)
return #FIXME
if meta.updated > pathmeta.updated:
log.info(msg.format(meta_newer))
return # this is the right thing to do for a sane filesystem
elif meta.updated < pathmeta.updated:
log.info(msg.format(pathmeta_newer))
# THIS IS EXPLICITLY ALLOWED
else: # they are equal
extra = 'Both updated at the same time '
if meta.created is not None and pathmeta.created is not None:
if meta.created > pathmeta.created:
log.info(msg.format(extra + meta_newer))
return
elif meta.created < pathmeta.created:
log.info(msg.format(extra + pathmeta_newer))
# THIS IS EXPLICITLY ALLOWED
else: # same created
log.info(
msg.format(
'Identical timestamps. Not updating.'))
return
elif meta.created is not None:
log.info(
msg.format(
extra +
'Meta has datetime other does not. Not updating.'
))
return
elif pathmeta.created is not None:
msg = msg.format(
extra + 'Meta has no datetime other does.')
log.info(msg)
raise exc.MetadataIdMismatchError(msg)
else: # both none
log.info(
msg.format(extra + (
'Identical update time both missing created time. '
'Not updating.')))
return
# equality
# id mismatch all cases above should return or raise except for other metadata newer
if meta.size is not None and pathmeta.size is None:
log.error('new meta has no size so will not overwrite')
return
# FIXME do the timestamp dance above here
log.debug('Metadata exists, but ids match so will update')
# trash old versions instead of just unlinking
pc = self.local.cache
trash = pc.trash
self.rename(trash / f'{pc.parent.id}-{meta.id}-{self.name}')
#self.unlink()
# FIXME if an id starts with / then the local name is overwritten due to pathlib logic
# we need to error if that happens
#symlink = pathlib.PurePosixPath(self.local.name, pathmeta.as_symlink().as_posix().strip('/'))
symlink = pathlib.PurePosixPath(
self.local.name) / pathmeta.as_symlink()
self.local.symlink_to(symlink)
else:
raise exc.PathExistsError(f'Path exists {self}')