Allow Repository to work on relative paths

A previous change adjusted the Repository class to work with absolute paths, even if a relative one was passed in. With the introduction of remote directories this approach is no longer feasible: in general we want to avoid executing (and thus, relying, on) anything except what is truly necessary (think: the btrfs suite of programs) on the remote end of the connection. This includes utilities such as realpath and whatnot to canonicalize paths. This change allows for relative paths to be accepted on various repository based operations.

Author: d-e-s-o

btrfs-backup/src/deso/btrfs/repository.py

@@ -50,12 +50,15 @@
  pipeline,
 )
 from os import (
+ curdir,
+ pardir,
  sep,
  uname,
 )
 from os.path import (
- abspath,
  dirname,
+ expanduser,
+ isabs,
  isdir,
  join,
  realpath,
@@ -234,7 +237,6 @@ def isDir(directory):
 def _findRoot(directory, repository):
  """Find the root of the btrfs file system containing the given directory."""
  assert directory
- assert directory == abspath(directory)
 
  # Note that we have no guard here against an empty directory as input
  # or later because of a dirname invocation. However, the show command
@@ -509,7 +511,6 @@ def sync(subvolumes, src, dst):
 def _restore(subvolume, src, dst, snapshots, snapshots_only):
  """Restore a snapshot/subvolume by transferal from another repository."""
  snapshot = _findMostRecent(snapshots, subvolume)
- subvolume = realpath(subvolume)
 
  # In case the given source repository does not contain any snapshots
  # for the given subvolume we cannot do anything but signal that to
@@ -552,7 +553,7 @@ def restore(subvolumes, src, dst, snapshots_only=False):
  snapshots = src.snapshots()
 
  for subvolume in subvolumes:
- _restore(subvolume, src, dst, snapshots, snapshots_only)
+ _restore(realpath(subvolume), src, dst, snapshots, snapshots_only)
 
 
 def _diff(snapshot, subvolume, repository):
@@ -618,18 +619,31 @@ def _untrail(path):
  return path
 
 
+def _relativize(path):
+ """Adjust a relative path to make it point to the current directory."""
+ if expanduser(path) == path and\
+ not path.startswith(curdir) and\
+ not path.startswith(pardir) and\
+ not isabs(path):
+ return join(curdir, path)
+
+ return path
+
+
 class RepositoryBase:
  """This class represents the base class for repositories for snapshots."""
  def __init__(self, directory, filters=None, read_err=True,
  remote_cmd=None):
  """Initialize the object and bind it to the given directory."""
- # We always work with absolute paths here.
- directory = abspath(directory)
-
  self._filters = filters
  self._read_err = read_err
  self._remote_cmd = remote_cmd
- self._directory = _trail(directory)
+ # In order to properly handle relative paths correctly we need them
+ # to start with the system's indicator for the current directory.
+ # TODO: We could use a better story for path handling. The main
+ # concern are probably character based path comparisons (for
+ # prefixes, for instance).
+ self._directory = _trail(_relativize(directory))
 
  def snapshots(self):
  """Retrieve a list of snapshots in this repository."""
@@ -690,7 +704,7 @@ class Repository(RepositoryBase):
  def __init__(self, directory, *args, **kwargs):
  """Initialize the repository, query its root in the btrfs file system."""
  super().__init__(directory, *args, **kwargs)
- self._root = _findRoot(abspath(directory), self)
+ self._root = _findRoot(_untrail(self._directory), self)
 
 
  def snapshots(self):
@@ -732,7 +746,7 @@ def purge(self, subvolumes, duration):
  snapshots = self.snapshots()
 
  for subvolume in subvolumes:
- _purge(subvolume, self, duration, snapshots)
+ _purge(realpath(subvolume), self, duration, snapshots)
 
 
  def diff(self, snapshot, subvolume):

btrfs-backup/src/deso/btrfs/test/testRepository.py

@@ -39,6 +39,7 @@
  Repository,
  restore,
  _findCommonSnapshots,
+ _relativize,
  _snapshots,
  sync as syncRepos,
  _trail,
@@ -52,6 +53,9 @@
  make,
  Mount,
 )
+from deso.cleanup import (
+ defer,
+)
 from deso.execute import (
  execute,
  findCommand,
@@ -60,6 +64,8 @@
  glob,
 )
 from os import (
+ chdir,
+ getcwd,
  remove,
 )
 from os.path import (
@@ -96,6 +102,15 @@ def testPathUntrail(self):
  self.assertEqual(_untrail("/home/user/"), "/home/user")
 
 
+ def testRelativize(self):
+ """Verify that the detection and adjustment of relative paths is sane."""
+ self.assertEqual(_relativize("."), ".")
+ self.assertEqual(_relativize("test"), "./test")
+ self.assertEqual(_relativize("test/"), "./test/")
+ self.assertEqual(_relativize("../test/"), "../test/")
+ self.assertEqual(_relativize("~/test"), "~/test")
+
+
  def testRepositoryInNonExistentDirectory(self):
  """Verify that creation of a repository in a non-existent directory fails."""
  directory = "a-non-existent-directory"
@@ -830,5 +845,72 @@ def testRepositoryPurge(self):
  self.assertEqual(src.snapshots(), [most_recent])
 
 
+ def runRelativeSubvolumeTest(self, file_repo):
+ """Perform a sync and restore using only relative paths for repositories and subvolumes."""
+ with defer() as d:
+ # Under all circumstances we should change back the working
+ # directory. Leaving it in the btrfs root causes the cleanup to
+ # fail.
+ # Note that we need to retrieve the current working directory
+ # outside of the lambda to have it evaluated before we change it.
+ cwd = getcwd()
+ d.defer(lambda: chdir(cwd))
+
+ with alias(self._mount) as m:
+ # All subvolumes are specified relative to our btrfs root.
+ chdir(m.path())
+
+ make(m, "root", subvol=True)
+ make(m, "snapshots")
+ make(m, "backup")
+
+ # Use relative path here.
+ subvolume = "root"
+ src = Repository("snapshots")
+ if not file_repo:
+ dst = Repository("backup")
+ else:
+ recv_filter = [[_DD, "of={file}"]]
+ dst = FileRepository("backup", ".bin", recv_filter)
+
+ # We test all main operations on a repository with relative
+ # paths here. Start with the sync.
+ syncRepos([subvolume], src, dst)
+
+ snap, = src.snapshots()
+ make(m, "root", "file1", data=b"test")
+ # Next the changed file detection.
+ self.assertNotEqual(src.diff(snap["path"], subvolume), [])
+
+ # We need a second snapshot to test purging.
+ syncRepos([subvolume], src, dst)
+
+ if not file_repo:
+ # And test purging. Note that purging is currently unavailable
+ # for file repositories.
+ dst.purge([subvolume], timedelta(minutes=0))
+ else:
+ # For file repositories we need to adjust the destination
+ # slightly because now we send from it (so we need a different
+ # filter).
+ send_filter = [[_DD, "if={file}"]]
+ dst = FileRepository("backup", ".bin", send_filter)
+
+ # And last but not least test restoration.
+ execute(*delete(m.path(subvolume)))
+ execute(*delete(src.path(snap["path"])))
+ restore([subvolume], dst, src)
+
+
+ def testRepositoryRelativeSubvolumes(self):
+ """Verify that normal repositories can handle relative subvolume paths."""
+ self.runRelativeSubvolumeTest(False)
+
+
+ def testFileRepositoryRelativeSubvolumes(self):
+ """Verify that file repositories can handle relative subvolume paths."""
+ self.runRelativeSubvolumeTest(True)
+
+
 if __name__ == "__main__":
  main()