Merge lp:~jelmer/brz/dirty-tracker into lp:brz/3.1

[Jelmer Vernooij]

Add a Workspace module for efficient rapid changes to large working trees.

Add a Workspace module.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/250/

=== added file 'breezy/dirty_tracker.py'
--- breezy/dirty_tracker.py	1970-01-01 00:00:00 +0000
+++ breezy/dirty_tracker.py	2020-07-27 22:52:34 +0000
@@ -0,0 +1,108 @@
+#!/usr/bin/python3
+# Copyright (C) 2019 Jelmer Vernooij
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Track whether a directory structure was touched since last revision.
+"""
+
+from __future__ import absolute_import
+
+# TODO(jelmer): Add support for ignore files
+
+import os
+try:
+    from pyinotify import (
+        WatchManager,
+        IN_CREATE,
+        IN_CLOSE_WRITE,
+        IN_Q_OVERFLOW,
+        IN_DELETE,
+        IN_MOVED_TO,
+        IN_MOVED_FROM,
+        IN_ATTRIB,
+        ProcessEvent,
+        Notifier,
+        Event,
+        )
+except ImportError as e:
+    from .errors import DependencyNotPresent
+    raise DependencyNotPresent(library='pyinotify', error=e)
+
+
+MASK = (
+    IN_CLOSE_WRITE | IN_DELETE | IN_Q_OVERFLOW | IN_MOVED_TO | IN_MOVED_FROM |
+    IN_ATTRIB)
+
+
+class _Process(ProcessEvent):
+
+    def my_init(self):
+        self.paths = set()
+        self.created = set()
+
+    def process_default(self, event):
+        path = os.path.join(event.path, event.name)
+        if event.mask & IN_CREATE:
+            self.created.add(path)
+        self.paths.add(path)
+        if event.mask & IN_DELETE and path in self.created:
+            self.paths.remove(path)
+            self.created.remove(path)
+
+
+class DirtyTracker(object):
+    """Track the changes to (part of) a working tree."""
+
+    def __init__(self, tree, subpath='.'):
+        self._tree = tree
+        self._wm = WatchManager()
+        self._process = _Process()
+        self._notifier = Notifier(self._wm, self._process)
+        self._notifier.coalesce_events(True)
+
+        def check_excluded(p):
+            return tree.is_control_filename(tree.relpath(p))
+        self._wdd = self._wm.add_watch(
+            tree.abspath(subpath), MASK, rec=True, auto_add=True,
+            exclude_filter=check_excluded)
+
+    def _process_pending(self):
+        if self._notifier.check_events(timeout=0):
+            self._notifier.read_events()
+        self._notifier.process_events()
+
+    def __del__(self):
+        self._notifier.stop()
+
+    def mark_clean(self):
+        """Mark the subtree as not having any changes."""
+        self._process_pending()
+        self._process.paths.clear()
+        self._process.created.clear()
+
+    def is_dirty(self):
+        """Check whether there are any changes."""
+        self._process_pending()
+        return bool(self._process.paths)
+
+    def paths(self):
+        """Return the paths that have changed."""
+        self._process_pending()
+        return self._process.paths
+
+    def relpaths(self):
+        """Return the paths relative to the tree root that changed."""
+        return set(self._tree.relpath(p) for p in self.paths())

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2020-06-28 19:19:25 +0000
+++ breezy/tests/__init__.py	2020-07-27 22:52:34 +0000
@@ -4057,6 +4057,7 @@
         'breezy.tests.test_debug',
         'breezy.tests.test_diff',
         'breezy.tests.test_directory_service',
+        'breezy.tests.test_dirty_tracker',
         'breezy.tests.test_email_message',
         'breezy.tests.test_eol_filters',
         'breezy.tests.test_errors',
@@ -4181,6 +4182,7 @@
         'breezy.tests.test_views',
         'breezy.tests.test_whitebox',
         'breezy.tests.test_win32utils',
+        'breezy.tests.test_workspace',
         'breezy.tests.test_workingtree',
         'breezy.tests.test_wsgi',
         ]

=== added file 'breezy/tests/test_dirty_tracker.py'
--- breezy/tests/test_dirty_tracker.py	1970-01-01 00:00:00 +0000
+++ breezy/tests/test_dirty_tracker.py	2020-07-27 22:52:34 +0000
@@ -0,0 +1,98 @@
+#!/usr/bin/python
+# Copyright (C) 2019 Jelmer Vernooij
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Tests for lintian_brush.dirty_tracker."""
+
+import os
+
+from breezy.tests import (
+    TestCaseWithTransport,
+    )
+
+
+class DirtyTrackerTests(TestCaseWithTransport):
+
+    def setUp(self):
+        super(DirtyTrackerTests, self).setUp()
+        self.tree = self.make_branch_and_tree('tree')
+        try:
+            from lintian_brush.dirty_tracker import DirtyTracker
+        except ImportError:
+            self.skipTest('pyinotify not available')
+        self.tracker = DirtyTracker(self.tree)
+
+    def test_nothing_changes(self):
+        self.assertFalse(self.tracker.is_dirty())
+
+    def test_regular_file_added(self):
+        self.build_tree_contents([('tree/foo', 'bar')])
+        self.assertTrue(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set(['foo']))
+
+    def test_many_added(self):
+        self.build_tree_contents(
+            [('tree/f%d' % d, 'content') for d in range(100)])
+        self.assertTrue(self.tracker.is_dirty())
+        self.assertEqual(
+            self.tracker.relpaths(), set(['f%d' % d for d in range(100)]))
+
+    def test_regular_file_in_subdir_added(self):
+        self.build_tree_contents([('tree/foo/', ), ('tree/foo/blah', 'bar')])
+        self.assertTrue(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set(['foo', 'foo/blah']))
+
+    def test_directory_added(self):
+        self.build_tree_contents([('tree/foo/', )])
+        self.assertTrue(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set(['foo']))
+
+    def test_file_removed(self):
+        self.build_tree_contents([('tree/foo', 'foo')])
+        self.assertTrue(self.tracker.is_dirty())
+        self.tracker.mark_clean()
+        self.build_tree_contents([('tree/foo', 'bar')])
+        self.assertTrue(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set(['foo']))
+
+    def test_control_file(self):
+        self.tree.commit('Some change')
+        self.assertFalse(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set([]))
+
+    def test_renamed(self):
+        self.build_tree_contents([('tree/foo', 'bar')])
+        self.tracker.mark_clean()
+        self.assertFalse(self.tracker.is_dirty())
+        os.rename('tree/foo', 'tree/bar')
+        self.assertTrue(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set(['foo', 'bar']))
+
+    def test_deleted(self):
+        self.build_tree_contents([('tree/foo', 'bar')])
+        self.tracker.mark_clean()
+        self.assertFalse(self.tracker.is_dirty())
+        os.unlink('tree/foo')
+        self.assertTrue(self.tracker.is_dirty(), self.tracker._process.paths)
+        self.assertEqual(self.tracker.relpaths(), set(['foo']))
+
+    def test_added_then_deleted(self):
+        self.tracker.mark_clean()
+        self.assertFalse(self.tracker.is_dirty())
+        self.build_tree_contents([('tree/foo', 'bar')])
+        os.unlink('tree/foo')
+        self.assertFalse(self.tracker.is_dirty())
+        self.assertEqual(self.tracker.relpaths(), set([]))

=== added file 'breezy/tests/test_workspace.py'
--- breezy/tests/test_workspace.py	1970-01-01 00:00:00 +0000
+++ breezy/tests/test_workspace.py	2020-07-27 22:52:34 +0000
@@ -0,0 +1,204 @@
+# Copyright (C) 2020 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import os
+
+from . import (
+    TestCaseWithTransport,
+    multiply_scenarios,
+    )
+from .scenarios import load_tests_apply_scenarios
+
+from ..workspace import (
+    WorkspaceDirty,
+    Workspace,
+    check_clean_tree,
+    )
+
+
+load_tests = load_tests_apply_scenarios
+
+
+class CheckCleanTreeTests(TestCaseWithTransport):
+
+    def make_test_tree(self, format=None):
+        tree = self.make_branch_and_tree('.', format=format)
+        self.build_tree_contents([
+            ('debian/', ),
+            ('debian/control', """\
+Source: blah
+Vcs-Git: https://example.com/blah
+Testsuite: autopkgtest
+
+Binary: blah
+Arch: all
+
+"""),
+            ('debian/changelog', 'Some contents')])
+        tree.add(['debian', 'debian/changelog', 'debian/control'])
+        tree.commit('Initial thingy.')
+        return tree
+
+    def test_pending_changes(self):
+        tree = self.make_test_tree()
+        self.build_tree_contents([('debian/changelog', 'blah')])
+        with tree.lock_write():
+            self.assertRaises(
+                WorkspaceDirty, check_clean_tree, tree)
+
+    def test_pending_changes_bzr_empty_dir(self):
+        # See https://bugs.debian.org/914038
+        tree = self.make_test_tree(format='bzr')
+        self.build_tree_contents([('debian/upstream/', )])
+        with tree.lock_write():
+            self.assertRaises(
+                WorkspaceDirty, check_clean_tree, tree)
+
+    def test_pending_changes_git_empty_dir(self):
+        # See https://bugs.debian.org/914038
+        tree = self.make_test_tree(format='git')
+        self.build_tree_contents([('debian/upstream/', )])
+        with tree.lock_write():
+            check_clean_tree(tree)
+
+    def test_pending_changes_git_dir_with_ignored(self):
+        # See https://bugs.debian.org/914038
+        tree = self.make_test_tree(format='git')
+        self.build_tree_contents([
+            ('debian/upstream/', ),
+            ('debian/upstream/blah', ''),
+            ('.gitignore', 'blah\n'),
+            ])
+        tree.add('.gitignore')
+        tree.commit('add gitignore')
+        with tree.lock_write():
+            check_clean_tree(tree)
+
+    def test_extra(self):
+        tree = self.make_test_tree()
+        self.build_tree_contents([('debian/foo', 'blah')])
+        with tree.lock_write():
+            self.assertRaises(
+                WorkspaceDirty, check_clean_tree,
+                tree)
+
+
+def vary_by_inotify():
+    return [
+        ('with_inotify', dict(_use_inotify=True)),
+        ('without_inotify', dict(_use_inotify=False)),
+    ]
+
+
+def vary_by_format():
+    return [
+        ('bzr', dict(_format='bzr')),
+        ('git', dict(_format='git')),
+    ]
+
+
+class WorkspaceTests(TestCaseWithTransport):
+
+    scenarios = multiply_scenarios(
+        vary_by_inotify(),
+        vary_by_format(),
+    )
+
+    def test_root_add(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        with Workspace(tree, use_inotify=self._use_inotify) as ws:
+            self.build_tree_contents([('afile', 'somecontents')])
+            changes = [c for c in ws.iter_changes() if c.path[1] != '']
+            self.assertEqual(1, len(changes), changes)
+            self.assertEqual((None, 'afile'), changes[0].path)
+            ws.commit(message='Commit message')
+            self.assertEqual(list(ws.iter_changes()), [])
+            self.build_tree_contents([('afile', 'newcontents')])
+            [change] = list(ws.iter_changes())
+            self.assertEqual(('afile', 'afile'), change.path)
+
+    def test_root_remove(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        self.build_tree_contents([('afile', 'somecontents')])
+        tree.add(['afile'])
+        tree.commit('Afile')
+        with Workspace(tree, use_inotify=self._use_inotify) as ws:
+            os.remove('afile')
+            changes = list(ws.iter_changes())
+            self.assertEqual(1, len(changes), changes)
+            self.assertEqual(('afile', None), changes[0].path)
+            ws.commit(message='Commit message')
+            self.assertEqual(list(ws.iter_changes()), [])
+
+    def test_subpath_add(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        self.build_tree(['subpath/'])
+        tree.add('subpath')
+        tree.commit('add subpath')
+        with Workspace(
+                tree, subpath='subpath', use_inotify=self._use_inotify) as ws:
+            self.build_tree_contents([('outside', 'somecontents')])
+            self.build_tree_contents([('subpath/afile', 'somecontents')])
+            changes = [c for c in ws.iter_changes() if c.path[1] != 'subpath']
+            self.assertEqual(1, len(changes), changes)
+            self.assertEqual((None, 'subpath/afile'), changes[0].path)
+            ws.commit(message='Commit message')
+            self.assertEqual(list(ws.iter_changes()), [])
+
+    def test_dirty(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        self.build_tree(['subpath'])
+        self.assertRaises(
+            WorkspaceDirty, Workspace(tree, use_inotify=self._use_inotify).__enter__)
+
+    def test_reset(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        with Workspace(tree, use_inotify=self._use_inotify) as ws:
+            self.build_tree(['blah'])
+            ws.reset()
+            self.assertPathDoesNotExist('blah')
+
+    def test_tree_path(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        tree.mkdir('subdir')
+        tree.commit('Add subdir')
+        with Workspace(tree, use_inotify=self._use_inotify) as ws:
+            self.assertEqual('foo', ws.tree_path('foo'))
+            self.assertEqual('', ws.tree_path())
+        with Workspace(tree, subpath='subdir', use_inotify=self._use_inotify) as ws:
+            self.assertEqual('subdir/foo', ws.tree_path('foo'))
+            self.assertEqual('subdir/', ws.tree_path())
+
+    def test_abspath(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        tree.mkdir('subdir')
+        tree.commit('Add subdir')
+        with Workspace(tree, use_inotify=self._use_inotify) as ws:
+            self.assertEqual(tree.abspath('foo'), ws.abspath('foo'))
+            self.assertEqual(tree.abspath(''), ws.abspath())
+        with Workspace(tree, subpath='subdir', use_inotify=self._use_inotify) as ws:
+            self.assertEqual(tree.abspath('subdir/foo'), ws.abspath('foo'))
+            self.assertEqual(tree.abspath('subdir') + '/', ws.abspath(''))
+            self.assertEqual(tree.abspath('subdir') + '/', ws.abspath())
+
+    def test_open_containing(self):
+        tree = self.make_branch_and_tree('.', format=self._format)
+        tree.mkdir('subdir')
+        tree.commit('Add subdir')
+        ws = Workspace.from_path('subdir')
+        self.assertEqual(ws.tree.abspath('.'), tree.abspath('.'))
+        self.assertEqual(ws.subpath, 'subdir')
+        self.assertEqual(None, ws.use_inotify)

=== added file 'breezy/workspace.py'
--- breezy/workspace.py	1970-01-01 00:00:00 +0000
+++ breezy/workspace.py	2020-07-27 22:52:34 +0000
@@ -0,0 +1,217 @@
+# Copyright (C) 2018-2020 Jelmer Vernooij
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Convenience functions for efficiently making changes to a working tree.
+
+If possible, uses inotify to track changes in the tree - providing
+high performance in large trees with a small number of changes.
+"""
+
+from __future__ import absolute_import
+
+import errno
+import os
+import shutil
+
+
+from .clean_tree import iter_deletables
+from .errors import BzrError, DependencyNotPresent
+from .trace import warning
+from .transform import revert
+from .workingtree import WorkingTree
+
+
+class WorkspaceDirty(BzrError):
+    _fmt = "The directory %(path)s has pending changes."
+
+    def __init__(self, tree):
+        BzrError(self, path=tree.abspath('.'))
+
+
+# TODO(jelmer): Move to .clean_tree?
+def reset_tree(local_tree, subpath=''):
+    """Reset a tree back to its basis tree.
+
+    This will leave ignored and detritus files alone.
+
+    Args:
+      local_tree: tree to work on
+      subpath: Subpath to operate on
+    """
+    revert(local_tree, local_tree.branch.basis_tree(),
+           [subpath] if subpath not in ('.', '') else None)
+    deletables = list(iter_deletables(
+        local_tree, unknown=True, ignored=False, detritus=False))
+    delete_items(deletables)
+
+
+# TODO(jelmer): Move to .clean_tree?
+def check_clean_tree(local_tree):
+    """Check that a tree is clean and has no pending changes or unknown files.
+
+    Args:
+      local_tree: The tree to check
+    Raises:
+      PendingChanges: When there are pending changes
+    """
+    # Just check there are no changes to begin with
+    if local_tree.has_changes():
+        raise WorkspaceDirty(local_tree)
+    if list(local_tree.unknowns()):
+        raise WorkspaceDirty(local_tree)
+
+
+def delete_items(deletables, dry_run: bool = False):
+    """Delete files in the deletables iterable"""
+    def onerror(function, path, excinfo):
+        """Show warning for errors seen by rmtree.
+        """
+        # Handle only permission error while removing files.
+        # Other errors are re-raised.
+        if function is not os.remove or excinfo[1].errno != errno.EACCES:
+            raise
+        warnings.warn('unable to remove %s' % path)
+    for path, subp in deletables:
+        if os.path.isdir(path):
+            shutil.rmtree(path, onerror=onerror)
+        else:
+            try:
+                os.unlink(path)
+            except OSError as e:
+                # We handle only permission error here
+                if e.errno != errno.EACCES:
+                    raise e
+                warning('unable to remove "%s": %s.', path, e.strerror)
+
+
+def get_dirty_tracker(local_tree, subpath='', use_inotify=None):
+    """Create a dirty tracker object."""
+    if use_inotify is True:
+        from .dirty_tracker import DirtyTracker
+        return DirtyTracker(local_tree, subpath)
+    elif use_inotify is False:
+        return None
+    else:
+        try:
+            from .dirty_tracker import DirtyTracker
+        except DependencyNotPresent:
+            return None
+        else:
+            return DirtyTracker(local_tree, subpath)
+
+
+class Workspace(object):
+    """Create a workspace.
+
+    :param tree: Tree to work in
+    :param subpath: path under which to consider and commit changes
+    :param use_inotify: whether to use inotify (default: yes, if available)
+    """
+
+    def __init__(self, tree, subpath='', use_inotify=None):
+        self.tree = tree
+        self.subpath = subpath
+        self.use_inotify = use_inotify
+        self._dirty_tracker = None
+
+    @classmethod
+    def from_path(cls, path, use_inotify=None):
+        tree, subpath = WorkingTree.open_containing(path)
+        return cls(tree, subpath, use_inotify=use_inotify)
+
+    def __enter__(self):
+        check_clean_tree(self.tree)
+        self._dirty_tracker = get_dirty_tracker(
+            self.tree, subpath=self.subpath, use_inotify=self.use_inotify)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._dirty_tracker:
+            del self._dirty_tracker
+            self._dirty_tracker = None
+        return False
+
+    def tree_path(self, path=''):
+        """Return a path relative to the tree subpath used by this workspace.
+        """
+        return os.path.join(self.subpath, path)
+
+    def abspath(self, path=''):
+        """Return an absolute path for the tree."""
+        return self.tree.abspath(self.tree_path(path))
+
+    def reset(self):
+        """Reset - revert local changes, revive deleted files, remove added.
+        """
+        if self._dirty_tracker and not self._dirty_tracker.is_dirty():
+            return
+        reset_tree(self.tree, self.subpath)
+        if self._dirty_tracker is not None:
+            self._dirty_tracker.mark_clean()
+
+    def _stage(self):
+        if self._dirty_tracker:
+            relpaths = self._dirty_tracker.relpaths()
+            # Sort paths so that directories get added before the files they
+            # contain (on VCSes where it matters)
+            self.tree.add(
+                [p for p in sorted(relpaths)
+                 if self.tree.has_filename(p) and not
+                    self.tree.is_ignored(p)])
+            return [
+                p for p in relpaths
+                if self.tree.is_versioned(p)]
+        else:
+            self.tree.smart_add([self.tree.abspath(self.subpath)])
+            return [self.subpath] if self.subpath else None
+
+    def iter_changes(self):
+        with self.tree.lock_write():
+            specific_files = self._stage()
+            basis_tree = self.tree.basis_tree()
+            # TODO(jelmer): After Python 3.3, use 'yield from'
+            for change in self.tree.iter_changes(
+                    basis_tree, specific_files=specific_files,
+                    want_unversioned=False, require_versioned=True):
+                if change.kind[1] is None and change.versioned[1]:
+                    if change.path[0] is None:
+                        continue
+                    # "missing" path
+                    change = change.discard_new()
+                yield change
+
+    def commit(self, **kwargs):
+        """Create a commit.
+
+        See WorkingTree.commit() for documentation.
+        """
+        if 'specific_files' in kwargs:
+            raise NotImplementedError(self.commit)
+
+        with self.tree.lock_write():
+            specific_files = self._stage()
+
+            if self.tree.supports_setting_file_ids():
+                from .rename_map import RenameMap
+                basis_tree = self.tree.basis_tree()
+                RenameMap.guess_renames(
+                    basis_tree, self.tree, dry_run=False)
+
+            kwargs['specific_files'] = specific_files
+            revid = self.tree.commit(**kwargs)
+            if self._dirty_tracker:
+                self._dirty_tracker.mark_clean()
+            return revid

=== modified file 'byov.conf'
--- byov.conf	2020-05-30 01:48:46 +0000
+++ byov.conf	2020-07-27 22:52:34 +0000
@@ -30,7 +30,7 @@
 
 # FIXME: Arguably this should be vm.build_deps=brz but it requires either an
 # available package or at least a debian/ dir ? -- vila 2018-02-23
-brz.build_deps = gcc, debhelper, python, python-all-dev, python3-all-dev, python-configobj, python3-configobj, python-docutils, python3-docutils, python-paramiko, python3-paramiko, python-subunit, python3-subunit, python-testtools, python3-testtools, subunit, python-pip, python3-pip, python-setuptools, python3-setuptools, python-flake8, python3-flake8, python-sphinx, python3-sphinx, python-launchpadlib, python3-launchpadlib
+brz.build_deps = gcc, debhelper, python, python-all-dev, python3-all-dev, python-configobj, python3-configobj, python-docutils, python3-docutils, python-paramiko, python3-paramiko, python-subunit, python3-subunit, python-testtools, python3-testtools, subunit, python-pip, python3-pip, python-setuptools, python3-setuptools, python-flake8, python3-flake8, python-sphinx, python3-sphinx, python-launchpadlib, python3-launchpadlib, python-pyinotify, python3-pyinotify
 subunit.build_deps = python-testscenarios, python3-testscenarios, python-testtools, python3-testtools, cython, cython3, quilt
 vm.packages = {brz.build_deps}, {subunit.build_deps}, bzr, git, python-junitxml
 [brz-xenial]

=== modified file 'doc/en/release-notes/brz-3.1.txt'
--- doc/en/release-notes/brz-3.1.txt	2020-07-21 18:34:48 +0000
+++ doc/en/release-notes/brz-3.1.txt	2020-07-27 22:52:34 +0000
@@ -93,6 +93,10 @@
    is currently implemented for GitHub, GitLab and Launchpad.
    (Jelmer Vernooij)
 
+ * A new ``Workspace`` interface is now available for efficiently
+   making changes to large working trees from automation.
+   (Jelmer Vernooij)
+
 Testing
 *******
 

=== modified file 'setup.py'
--- setup.py	2020-06-21 11:53:38 +0000
+++ setup.py	2020-07-27 22:52:34 +0000
@@ -75,6 +75,7 @@
         'fastimport': [],
         'git': [],
         'launchpad': ['launchpadlib>=1.6.3'],
+        'workspace': ['pyinotify'],
         },
     'tests_require': [
         'testtools',