Merge lp:~jelmer/brz/win-symlink-warning into lp:brz

[Jelmer Vernooij]

Allow symbolic links to exist when checking out trees on Windows.

Allow symbolic links to exist when checking out trees on Windows.

Warnings are printed for the symbolic links, but the rest of the tree is still
checked out. Operations that work across the tree and require on-disk access
(e.g. "commit", "diff", "status") will warn about the symbolic links but not
otherwise prentend that the files are missing.

[Martin Packman (gz)]

Looks reasonable, see some inline comments.

review: Approve

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/320/

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

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

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

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

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

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

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

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

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2018-11-18 19:48:57 +0000
+++ breezy/bzr/dirstate.py	2019-06-03 23:46:01 +0000
@@ -366,7 +366,8 @@
     HEADER_FORMAT_2 = b'#bazaar dirstate flat format 2\n'
     HEADER_FORMAT_3 = b'#bazaar dirstate flat format 3\n'
 
-    def __init__(self, path, sha1_provider, worth_saving_limit=0):
+    def __init__(self, path, sha1_provider, worth_saving_limit=0,
+                 use_filesystem_for_exec=True):
         """Create a  DirState object.
 
         :param path: The path at which the dirstate file on disk should live.
@@ -375,6 +376,8 @@
             entries is known, only bother saving the dirstate if more than
             this count of entries have changed.
             -1 means never save hash changes, 0 means always save hash changes.
+        :param use_filesystem_for_exec: Whether to trust the filesystem
+            for executable bit information
         """
         # _header_state and _dirblock_state represent the current state
         # of the dirstate metadata and the per-row data respectiely.
@@ -423,6 +426,7 @@
         self._worth_saving_limit = worth_saving_limit
         self._config_stack = config.LocationStack(urlutils.local_path_to_url(
             path))
+        self._use_filesystem_for_exec = use_filesystem_for_exec
 
     def __repr__(self):
         return "%s(%r)" % \
@@ -1949,14 +1953,10 @@
 
     def _is_executable(self, mode, old_executable):
         """Is this file executable?"""
-        return bool(S_IEXEC & mode)
-
-    def _is_executable_win32(self, mode, old_executable):
-        """On win32 the executable bit is stored in the dirstate."""
-        return old_executable
-
-    if sys.platform == 'win32':
-        _is_executable = _is_executable_win32
+        if self._use_filesystem_for_exec:
+            return bool(S_IEXEC & mode)
+        else:
+            return old_executable
 
     def _read_link(self, abspath, old_link):
         """Read the target of a symlink"""
@@ -2403,7 +2403,8 @@
         return len(self._parents) - len(self._ghosts)
 
     @classmethod
-    def on_file(cls, path, sha1_provider=None, worth_saving_limit=0):
+    def on_file(cls, path, sha1_provider=None, worth_saving_limit=0,
+                use_filesystem_for_exec=True):
         """Construct a DirState on the file at path "path".
 
         :param path: The path at which the dirstate file on disk should live.
@@ -2412,12 +2413,15 @@
         :param worth_saving_limit: when the exact number of hash changed
             entries is known, only bother saving the dirstate if more than
             this count of entries have changed. -1 means never save.
+        :param use_filesystem_for_exec: Whether to trust the filesystem
+            for executable bit information
         :return: An unlocked DirState object, associated with the given path.
         """
         if sha1_provider is None:
             sha1_provider = DefaultSHA1Provider()
         result = cls(path, sha1_provider,
-                     worth_saving_limit=worth_saving_limit)
+                     worth_saving_limit=worth_saving_limit,
+                     use_filesystem_for_exec=use_filesystem_for_exec)
         return result
 
     def _read_dirblocks_if_needed(self):

=== modified file 'breezy/bzr/inventorytree.py'
--- breezy/bzr/inventorytree.py	2019-02-14 03:30:18 +0000
+++ breezy/bzr/inventorytree.py	2019-06-03 23:46:01 +0000
@@ -573,7 +573,7 @@
         # expand any symlinks in the directory part, while leaving the
         # filename alone
         # only expanding if symlinks are supported avoids windows path bugs
-        if osutils.has_symlinks():
+        if self.tree.supports_symlinks():
             file_list = list(map(osutils.normalizepath, file_list))
 
         user_dirs = {}

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2019-06-02 21:29:09 +0000
+++ breezy/bzr/workingtree.py	2019-06-03 23:46:01 +0000
@@ -96,6 +96,7 @@
 # impossible as there is no clear relationship between the working tree format
 # and the conflict list file format.
 CONFLICT_HEADER_1 = b"BZR conflict list format 1"
+ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
 
 
 class InventoryWorkingTree(WorkingTree, MutableInventoryTree):

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2019-02-04 19:39:30 +0000
+++ breezy/bzr/workingtree_4.py	2019-06-03 23:46:01 +0000
@@ -256,7 +256,8 @@
         local_path = self.controldir.get_workingtree_transport(
             None).local_abspath('dirstate')
         self._dirstate = dirstate.DirState.on_file(
-            local_path, self._sha1_provider(), self._worth_saving_limit())
+            local_path, self._sha1_provider(), self._worth_saving_limit(),
+            self._supports_executable())
         return self._dirstate
 
     def _sha1_provider(self):

=== modified file 'breezy/commit.py'
--- breezy/commit.py	2018-11-25 20:44:56 +0000
+++ breezy/commit.py	2019-06-03 23:46:01 +0000
@@ -64,6 +64,7 @@
                      StrictCommitFailed
                      )
 from .osutils import (get_user_encoding,
+                      has_symlinks,
                       is_inside_any,
                       minimum_path_selection,
                       )
@@ -709,6 +710,10 @@
                 # 'missing' path
                 if report_changes:
                     reporter.missing(new_path)
+                if change[6][0] == 'symlink' and not self.work_tree.supports_symlinks():
+                    trace.warning('Ignoring "%s" as symlinks are not '
+                                  'supported on this filesystem.' % (change[1][0],))
+                    continue
                 deleted_paths.append(change[1][1])
                 # Reset the new path (None) and new versioned flag (False)
                 change = (change[0], (change[1][0], None), change[2],

=== modified file 'breezy/delta.py'
--- breezy/delta.py	2018-11-11 04:08:32 +0000
+++ breezy/delta.py	2019-06-03 23:46:01 +0000
@@ -18,11 +18,11 @@
 
 from breezy import (
     osutils,
+    trace,
     )
 from .sixish import (
     StringIO,
     )
-from .trace import is_quiet
 
 
 class TreeDelta(object):
@@ -141,7 +141,12 @@
             if fully_present[1] is True:
                 delta.added.append((path[1], file_id, kind[1]))
             else:
-                delta.removed.append((path[0], file_id, kind[0]))
+                if kind[0] == 'symlink' and not new_tree.supports_symlinks():
+                    trace.warning(
+                        'Ignoring "%s" as symlinks '
+                        'are not supported on this filesystem.' % (path[0],))
+                else:
+                    delta.removed.append((path[0], file_id, kind[0]))
         elif fully_present[0] is False:
             delta.missing.append((path[1], file_id, kind[1]))
         elif name[0] != name[1] or parent_id[0] != parent_id[1]:
@@ -253,7 +258,7 @@
         :param kind: A pair of file kinds, as generated by Tree.iter_changes.
             None indicates no file present.
         """
-        if is_quiet():
+        if trace.is_quiet():
             return
         if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
             return

=== modified file 'breezy/diff.py'
--- breezy/diff.py	2019-05-28 23:22:20 +0000
+++ breezy/diff.py	2019-06-03 23:46:01 +0000
@@ -1050,6 +1050,11 @@
             # is, missing) in both trees are skipped as well.
             if parent == (None, None) or kind == (None, None):
                 continue
+            if kind[0] == 'symlink' and not self.new_tree.supports_symlinks():
+                warning(
+                    'Ignoring "%s" as symlinks are not '
+                    'supported on this filesystem.' % (paths[0],))
+                continue
             oldpath, newpath = paths
             oldpath_encoded = get_encoded_path(paths[0])
             newpath_encoded = get_encoded_path(paths[1])

=== modified file 'breezy/errors.py'
--- breezy/errors.py	2019-02-15 18:57:38 +0000
+++ breezy/errors.py	2019-06-03 23:46:01 +0000
@@ -2303,21 +2303,6 @@
             ' (See brz shelve --list).%(more)s')
 
 
-class UnableCreateSymlink(BzrError):
-
-    _fmt = 'Unable to create symlink %(path_str)son this platform'
-
-    def __init__(self, path=None):
-        path_str = ''
-        if path:
-            try:
-                path_str = repr(str(path))
-            except UnicodeEncodeError:
-                path_str = repr(path)
-            path_str += ' '
-        self.path_str = path_str
-
-
 class UnableEncodePath(BzrError):
 
     _fmt = ('Unable to encode %(kind)s path %(path)r in '

=== modified file 'breezy/git/memorytree.py'
--- breezy/git/memorytree.py	2019-03-04 00:35:52 +0000
+++ breezy/git/memorytree.py	2019-06-03 23:46:01 +0000
@@ -58,6 +58,9 @@
         self._lock_mode = None
         self._populate_from_branch()
 
+    def _supports_executable(self):
+        return True
+
     @property
     def controldir(self):
         return self.branch.controldir

=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2019-06-02 05:13:10 +0000
+++ breezy/git/tree.py	2019-06-03 23:46:01 +0000
@@ -1447,6 +1447,7 @@
     # Report dirified directories to commit_tree first, so that they can be
     # replaced with non-empty directories if they have contents.
     dirified = []
+    trust_executable = target._supports_executable()
     for path, index_entry in target._recurse_index_entries():
         try:
             live_entry = target._live_entry(path)
@@ -1472,6 +1473,12 @@
                 dirified.append((path, Tree().id, stat.S_IFDIR))
                 store.add_object(Tree())
             else:
+                mode = live_entry.mode
+                if not trust_executable:
+                    if mode_is_executable(index_entry.mode):
+                        mode |= 0o111
+                    else:
+                        mode &= ~0o111
                 blobs[path] = (live_entry.sha, cleanup_mode(live_entry.mode))
     if want_unversioned:
         for e in target.extras():

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2019-06-02 21:32:43 +0000
+++ breezy/git/workingtree.py	2019-06-03 23:46:01 +0000
@@ -414,7 +414,7 @@
         # expand any symlinks in the directory part, while leaving the
         # filename alone
         # only expanding if symlinks are supported avoids windows path bugs
-        if osutils.has_symlinks():
+        if self.supports_symlinks():
             file_list = list(map(osutils.normalizepath, file_list))
 
         conflicts_related = set()
@@ -742,8 +742,7 @@
 
     def is_executable(self, path):
         with self.lock_read():
-            if getattr(self, "_supports_executable",
-                       osutils.supports_executable)():
+            if self._supports_executable():
                 mode = self._lstat(path).st_mode
             else:
                 (index, subpath) = self._lookup_index(path.encode('utf-8'))
@@ -754,10 +753,8 @@
             return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
     def _is_executable_from_path_and_stat(self, path, stat_result):
-        if getattr(self, "_supports_executable",
-                   osutils.supports_executable)():
-            return self._is_executable_from_path_and_stat_from_stat(
-                path, stat_result)
+        if self._supports_executable():
+            return self._is_executable_from_path_and_stat_from_stat(path, stat_result)
         else:
             return self._is_executable_from_path_and_stat_from_basis(
                 path, stat_result)
@@ -1165,7 +1162,8 @@
             self.store,
             None
             if self.branch.head is None
-            else self.store[self.branch.head].tree)
+            else self.store[self.branch.head].tree,
+            honor_filemode=self._supports_executable())
 
     def reset_state(self, revision_ids=None):
         """Reset the state of the working tree.

=== modified file 'breezy/memorytree.py'
--- breezy/memorytree.py	2019-02-16 21:12:42 +0000
+++ breezy/memorytree.py	2019-06-03 23:46:01 +0000
@@ -51,6 +51,9 @@
         self._locks = 0
         self._lock_mode = None
 
+    def supports_symlinks(self):
+        return True
+
     def get_config_stack(self):
         return self.branch.get_config_stack()
 

=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2018-11-18 00:25:19 +0000
+++ breezy/mutabletree.py	2019-06-03 23:46:01 +0000
@@ -197,15 +197,35 @@
             if _from_tree is None:
                 _from_tree = self.basis_tree()
             changes = self.iter_changes(_from_tree)
-            try:
-                change = next(changes)
-                # Exclude root (talk about black magic... --vila 20090629)
-                if change[4] == (None, None):
+            if self.supports_symlinks():
+                # Fast path for has_changes.
+                try:
                     change = next(changes)
+                    # Exclude root (talk about black magic... --vila 20090629)
+                    if change[4] == (None, None):
+                        change = next(changes)
+                    return True
+                except StopIteration:
+                    # No changes
+                    return False
+            else:
+                # Slow path for has_changes.
+                # Handle platforms that do not support symlinks in the
+                # conditional below. This is slower than the try/except
+                # approach below that but we don't have a choice as we
+                # need to be sure that all symlinks are removed from the
+                # entire changeset. This is because in platforms that
+                # do not support symlinks, they show up as None in the
+                # working copy as compared to the repository.
+                # Also, exclude root as mention in the above fast path.
+                changes = filter(
+                    lambda c: c[6][0] != 'symlink' and c[4] != (None, None),
+                    changes)
+                try:
+                    next(iter(changes))
+                except StopIteration:
+                    return False
                 return True
-            except StopIteration:
-                # No changes
-                return False
 
     def check_changed_or_out_of_date(self, strict, opt_name,
                                      more_error, more_warning):

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2019-03-06 14:03:19 +0000
+++ breezy/osutils.py	2019-06-03 23:46:01 +0000
@@ -1662,8 +1662,40 @@
     _terminal_size = _ioctl_terminal_size
 
 
-def supports_executable():
-    return sys.platform != "win32"
+def supports_executable(path):
+    """Return if filesystem at path supports executable bit.
+
+    :param path: Path for which to check the file system
+    :return: boolean indicating whether executable bit can be stored/relied upon
+    """
+    if sys.platform == 'win32':
+        return False
+    try:
+        fs_type = get_fs_type(path)
+    except errors.DependencyNotPresent as e:
+        trace.mutter('Unable to get fs type for %r: %s', path, e)
+    else:
+        if fs_type in ('vfat', 'ntfs'):
+            # filesystems known to not support executable bit
+            return False
+    return True
+
+
+def supports_symlinks(path):
+    """Return if the filesystem at path supports the creation of symbolic links.
+
+    """
+    if not has_symlinks():
+        return False
+    try:
+        fs_type = get_fs_type(path)
+    except errors.DependencyNotPresent as e:
+        trace.mutter('Unable to get fs type for %r: %s', path, e)
+    else:
+        if fs_type in ('vfat', 'ntfs'):
+            # filesystems known to not support symlinks
+            return False
+    return True
 
 
 def supports_posix_readonly():
@@ -2602,6 +2634,29 @@
     return False
 
 
+def get_fs_type(path):
+    """Return the filesystem type for the partition a path is in.
+
+    :param path: Path to search filesystem type for
+    :return: A FS type, as string. E.g. "ext2"
+    """
+    # TODO(jelmer): It would be nice to avoid an extra dependency here, but the only
+    # alternative is reading platform-specific files under /proc :(
+    try:
+        import psutil
+    except ImportError as e:
+        raise errors.DependencyNotPresent('psutil', e)
+
+    if not PY3 and not isinstance(path, str):
+        path = path.encode(_fs_enc)
+
+    for part in sorted(psutil.disk_partitions(), key=lambda x: len(x.mountpoint), reverse=True):
+        if is_inside(part.mountpoint, path):
+            return part.fstype
+    # Unable to parse the file? Since otherwise at least the entry for / should match..
+    return None
+
+
 if PY3:
     perf_counter = time.perf_counter
 else:

=== modified file 'breezy/tests/per_tree/test_symlinks.py'
--- breezy/tests/per_tree/test_symlinks.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_tree/test_symlinks.py	2019-06-03 23:46:01 +0000
@@ -18,8 +18,10 @@
 
 
 from breezy import (
+    osutils,
     tests,
     )
+from breezy.git.branch import GitBranch
 from breezy.tests import (
     per_tree,
     )
@@ -35,6 +37,13 @@
     return next(tree.iter_entries_by_dir(specific_files=[path]))[1]
 
 
+class TestSymlinkSupportFunction(per_tree.TestCaseWithTree):
+
+    def test_supports_symlinks(self):
+        self.tree = self.make_branch_and_tree('.')
+        self.assertIn(self.tree.supports_symlinks(), [True, False])
+
+
 class TestTreeWithSymlinks(per_tree.TestCaseWithTree):
 
     _test_needs_features = [features.SymlinkFeature]
@@ -65,3 +74,34 @@
         entry = get_entry(self.tree, 'symlink')
         self.assertEqual(entry.kind, 'symlink')
         self.assertEqual(None, entry.text_size)
+
+
+class TestTreeWithoutSymlinks(per_tree.TestCaseWithTree):
+
+    def setUp(self):
+        super(TestTreeWithoutSymlinks, self).setUp()
+        self.branch = self.make_branch('a')
+        mem_tree = self.branch.create_memorytree()
+        with mem_tree.lock_write():
+            mem_tree._file_transport.symlink('source', 'symlink')
+            mem_tree.add(['', 'symlink'])
+            rev1 = mem_tree.commit('rev1')
+        self.assertPathDoesNotExist('a/symlink')
+
+    def test_clone_skips_symlinks(self):
+        if isinstance(self.branch, (GitBranch,)):
+            # TODO(jelmer): Fix this test for git repositories
+            raise TestSkipped(
+                'git trees do not honor osutils.supports_symlinks yet')
+        self.overrideAttr(osutils, 'supports_symlinks', lambda p: False)
+        # This should not attempt to create any symlinks
+        result_dir = self.branch.controldir.sprout('b')
+        result_tree = result_dir.open_workingtree()
+        self.assertFalse(result_tree.supports_symlinks())
+        self.assertPathDoesNotExist('b/symlink')
+        basis_tree = self.branch.basis_tree()
+        self.assertTrue(basis_tree.has_filename('symlink'))
+        with result_tree.lock_read():
+            self.assertEqual(
+                [('symlink', 'symlink')],
+                [c[1] for c in result_tree.iter_changes(basis_tree)])

=== modified file 'breezy/tests/test__dirstate_helpers.py'
--- breezy/tests/test__dirstate_helpers.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test__dirstate_helpers.py	2019-06-03 23:46:01 +0000
@@ -1200,11 +1200,13 @@
         state, entry = self.get_state_with_a()
         self.build_tree(['a'])
 
-        # Make sure we are using the win32 implementation of _is_executable
-        state._is_executable = state._is_executable_win32
+        # Make sure we are using the version of _is_executable that doesn't
+        # check the filesystem mode.
+        state._use_filesystem_for_exec = False
 
         # The file on disk is not executable, but we are marking it as though
-        # it is. With _is_executable_win32 we ignore what is on disk.
+        # it is. With _use_filesystem_for_exec disabled we ignore what is on
+        # disk.
         entry[1][0] = (b'f', b'', 0, True, dirstate.DirState.NULLSTAT)
 
         stat_value = os.lstat('a')

=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2018-11-29 23:42:41 +0000
+++ breezy/tests/test_commit.py	2019-06-03 23:46:01 +0000
@@ -16,12 +16,14 @@
 
 
 import os
+from io import BytesIO
 
 import breezy
 from .. import (
     config,
     controldir,
     errors,
+    trace,
     )
 from ..branch import Branch
 from ..bzr.bzrdir import BzrDirMetaFormat1
@@ -676,6 +678,35 @@
         finally:
             basis.unlock()
 
+    def test_unsupported_symlink_commit(self):
+        self.requireFeature(SymlinkFeature)
+        tree = self.make_branch_and_tree('.')
+        self.build_tree(['hello'])
+        tree.add('hello')
+        tree.commit('added hello', rev_id=b'hello_id')
+        os.symlink('hello', 'foo')
+        tree.add('foo')
+        tree.commit('added foo', rev_id=b'foo_id')
+        log = BytesIO()
+        trace.push_log_file(log)
+        os_symlink = getattr(os, 'symlink', None)
+        os.symlink = None
+        try:
+            # At this point as bzr thinks symlinks are not supported
+            # we should get a warning about symlink foo and bzr should
+            # not think its removed.
+            os.unlink('foo')
+            self.build_tree(['world'])
+            tree.add('world')
+            tree.commit('added world', rev_id=b'world_id')
+        finally:
+            if os_symlink:
+                os.symlink = os_symlink
+        self.assertContainsRe(
+            log.getvalue(),
+            b'Ignoring "foo" as symlinks are not '
+            b'supported on this filesystem\\.')
+
     def test_commit_kind_changes(self):
         self.requireFeature(SymlinkFeature)
         tree = self.make_branch_and_tree('.')

=== modified file 'breezy/tests/test_dirstate.py'
--- breezy/tests/test_dirstate.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test_dirstate.py	2019-06-03 23:46:01 +0000
@@ -1826,9 +1826,11 @@
 class InstrumentedDirState(dirstate.DirState):
     """An DirState with instrumented sha1 functionality."""
 
-    def __init__(self, path, sha1_provider, worth_saving_limit=0):
-        super(InstrumentedDirState, self).__init__(path, sha1_provider,
-                                                   worth_saving_limit=worth_saving_limit)
+    def __init__(self, path, sha1_provider, worth_saving_limit=0,
+                 use_filesystem_for_exec=True):
+        super(InstrumentedDirState, self).__init__(
+            path, sha1_provider, worth_saving_limit=worth_saving_limit,
+            use_filesystem_for_exec=use_filesystem_for_exec)
         self._time_offset = 0
         self._log = []
         # member is dynamically set in DirState.__init__ to turn on trace

=== modified file 'breezy/tests/test_errors.py'
--- breezy/tests/test_errors.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test_errors.py	2019-06-03 23:46:01 +0000
@@ -388,20 +388,6 @@
             "you wish to keep, and delete it when you are done.",
             str(err))
 
-    def test_unable_create_symlink(self):
-        err = errors.UnableCreateSymlink()
-        self.assertEqual(
-            "Unable to create symlink on this platform",
-            str(err))
-        err = errors.UnableCreateSymlink(path=u'foo')
-        self.assertEqual(
-            "Unable to create symlink 'foo' on this platform",
-            str(err))
-        err = errors.UnableCreateSymlink(path=u'\xb5')
-        self.assertEqual(
-            "Unable to create symlink %s on this platform" % repr(u'\xb5'),
-            str(err))
-
     def test_invalid_url_join(self):
         """Test the formatting of InvalidURLJoin."""
         e = urlutils.InvalidURLJoin('Reason', 'base path', ('args',))

=== modified file 'breezy/tests/test_osutils.py'
--- breezy/tests/test_osutils.py	2018-11-17 18:49:41 +0000
+++ breezy/tests/test_osutils.py	2019-06-03 23:46:01 +0000
@@ -62,6 +62,8 @@
 
 term_ios_feature = features.ModuleAvailableFeature('termios')
 
+psutil_feature = features.ModuleAvailableFeature('psutil')
+
 
 def _already_unicode(s):
     return s
@@ -2340,3 +2342,22 @@
         import pywintypes
         self.assertTrue(osutils.is_environment_error(
             pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))
+
+
+class SupportsExecutableTests(tests.TestCaseInTempDir):
+
+    def test_returns_bool(self):
+        self.assertIsInstance(osutils.supports_executable(self.test_dir), bool)
+
+
+class SupportsSymlinksTests(tests.TestCaseInTempDir):
+
+    def test_returns_bool(self):
+        self.assertIsInstance(osutils.supports_symlinks(self.test_dir), bool)
+
+
+class GetFsTypeTests(tests.TestCaseInTempDir):
+
+    def test_returns_string(self):
+        self.requireFeature(psutil_feature)
+        self.assertIsInstance(osutils.get_fs_type(self.test_dir), str)

=== modified file 'breezy/tests/test_transform.py'
--- breezy/tests/test_transform.py	2019-02-04 19:39:30 +0000
+++ breezy/tests/test_transform.py	2019-06-03 23:46:01 +0000
@@ -16,6 +16,7 @@
 
 import codecs
 import errno
+from io import BytesIO, StringIO
 import os
 import sys
 import time
@@ -806,22 +807,18 @@
                             u'\N{Euro Sign}wizard2',
                             u'b\N{Euro Sign}hind_curtain')
 
-    def test_unable_create_symlink(self):
+    def test_unsupported_symlink_no_conflict(self):
         def tt_helper():
             wt = self.make_branch_and_tree('.')
-            tt = TreeTransform(wt)  # TreeTransform obtains write lock
-            try:
-                tt.new_symlink('foo', tt.root, 'bar')
-                tt.apply()
-            finally:
-                wt.unlock()
+            tt = TreeTransform(wt)
+            self.addCleanup(tt.finalize)
+            tt.new_symlink('foo', tt.root, 'bar')
+            result = tt.find_conflicts()
+            self.assertEqual([], result)
         os_symlink = getattr(os, 'symlink', None)
         os.symlink = None
         try:
-            err = self.assertRaises(errors.UnableCreateSymlink, tt_helper)
-            self.assertEqual(
-                "Unable to create symlink 'foo' on this platform",
-                str(err))
+            tt_helper()
         finally:
             if os_symlink:
                 os.symlink = os_symlink
@@ -1598,6 +1595,24 @@
         self.addCleanup(wt.unlock)
         self.assertEqual(wt.kind("foo"), "symlink")
 
+    def test_file_to_symlink_unsupported(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['foo'])
+        wt.add(['foo'])
+        wt.commit("one")
+        self.overrideAttr(osutils, 'supports_symlinks', lambda p: False)
+        tt = TreeTransform(wt)
+        self.addCleanup(tt.finalize)
+        foo_trans_id = tt.trans_id_tree_path("foo")
+        tt.delete_contents(foo_trans_id)
+        log = BytesIO()
+        trace.push_log_file(log)
+        tt.create_symlink("bar", foo_trans_id)
+        tt.apply()
+        self.assertContainsRe(
+            log.getvalue(),
+            b'Unable to create symlink "foo" on this filesystem')
+
     def test_dir_to_file(self):
         wt = self.make_branch_and_tree('.')
         self.build_tree(['foo/', 'foo/bar'])
@@ -2809,6 +2824,35 @@
         # 3 lines of diff administrivia
         self.assertEqual(lines[4], b"+content B")
 
+    def test_unsupported_symlink_diff(self):
+        self.requireFeature(SymlinkFeature)
+        tree = self.make_branch_and_tree('.')
+        self.build_tree_contents([('a', 'content 1')])
+        tree.set_root_id(b'TREE_ROOT')
+        tree.add('a', b'a-id')
+        os.symlink('a', 'foo')
+        tree.add('foo', b'foo-id')
+        tree.commit('rev1', rev_id=b'rev1')
+        revision_tree = tree.branch.repository.revision_tree(b'rev1')
+        preview = TransformPreview(revision_tree)
+        self.addCleanup(preview.finalize)
+        preview.delete_versioned(preview.trans_id_tree_path('foo'))
+        preview_tree = preview.get_preview_tree()
+        out = StringIO()
+        log = BytesIO()
+        trace.push_log_file(log)
+        os_symlink = getattr(os, 'symlink', None)
+        os.symlink = None
+        try:
+            show_diff_trees(revision_tree, preview_tree, out)
+            lines = out.getvalue().splitlines()
+        finally:
+            if os_symlink:
+                os.symlink = os_symlink
+        self.assertContainsRe(
+            log.getvalue(),
+            b'Ignoring "foo" as symlinks are not supported on this filesystem')
+
     def test_transform_conflicts(self):
         revision_tree = self.create_tree()
         preview = TransformPreview(revision_tree)

=== modified file 'breezy/tests/test_workingtree.py'
--- breezy/tests/test_workingtree.py	2019-06-02 21:21:39 +0000
+++ breezy/tests/test_workingtree.py	2019-06-03 23:46:01 +0000
@@ -15,9 +15,13 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
+from io import BytesIO
+import os
+
 from .. import (
     conflicts,
     errors,
+    trace,
     transport,
     workingtree,
     )
@@ -37,6 +41,7 @@
     TreeLink,
     )
 
+from .features import SymlinkFeature
 
 class TestTreeDirectory(TestCaseWithTransport):
 
@@ -443,6 +448,34 @@
                          resolved)
         self.assertPathDoesNotExist('this/hello.BASE')
 
+    def test_unsupported_symlink_auto_resolve(self):
+        self.requireFeature(SymlinkFeature)
+        base = self.make_branch_and_tree('base')
+        self.build_tree_contents([('base/hello', 'Hello')])
+        base.add('hello', b'hello_id')
+        base.commit('commit 0')
+        other = base.controldir.sprout('other').open_workingtree()
+        self.build_tree_contents([('other/hello', 'Hello')])
+        os.symlink('other/hello', 'other/foo')
+        other.add('foo', b'foo_id')
+        other.commit('commit symlink')
+        this = base.controldir.sprout('this').open_workingtree()
+        self.assertPathExists('this/hello')
+        self.build_tree_contents([('this/hello', 'Hello')])
+        this.commit('commit 2')
+        log = BytesIO()
+        trace.push_log_file(log)
+        os_symlink = getattr(os, 'symlink', None)
+        os.symlink = None
+        try:
+            this.merge_from_branch(other.branch)
+        finally:
+            if os_symlink:
+                os.symlink = os_symlink
+        self.assertContainsRe(
+            log.getvalue(),
+            b'Unable to create symlink "foo" on this filesystem')
+
     def test_auto_resolve_dir(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/hello/'])

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2019-02-02 15:13:30 +0000
+++ breezy/transform.py	2019-06-03 23:46:01 +0000
@@ -52,17 +52,16 @@
 """)
 from .errors import (DuplicateKey, MalformedTransform,
                      ReusingTransform, CantMoveRoot,
-                     ImmortalLimbo, NoFinalPath,
-                     UnableCreateSymlink)
+                     ImmortalLimbo, NoFinalPath)
 from .filters import filtered_output_bytes, ContentFilterContext
 from .mutabletree import MutableTree
 from .osutils import (
     delete_any,
     file_kind,
-    has_symlinks,
     pathjoin,
     sha_file,
     splitpath,
+    supports_symlinks,
     )
 from .progress import ProgressPhase
 from .sixish import (
@@ -653,6 +652,9 @@
         conflicts = []
         for trans_id in self._new_id:
             kind = self.final_kind(trans_id)
+            if kind == 'symlink' and not self._tree.supports_symlinks():
+                # Ignore symlinks as they are not supported on this platform
+                continue
             if kind is None:
                 conflicts.append(('versioning no contents', trans_id))
                 continue
@@ -1201,8 +1203,7 @@
 class DiskTreeTransform(TreeTransformBase):
     """Tree transform storing its contents on disk."""
 
-    def __init__(self, tree, limbodir, pb=None,
-                 case_sensitive=True):
+    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
         """Constructor.
         :param tree: The tree that will be transformed, but not necessarily
             the output tree.
@@ -1226,6 +1227,7 @@
         # List of transform ids that need to be renamed from limbo into place
         self._needs_rename = set()
         self._creation_mtime = None
+        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
 
     def finalize(self):
         """Release the working tree lock, if held, clean up limbo dir.
@@ -1263,8 +1265,7 @@
 
     def _limbo_supports_executable(self):
         """Check if the limbo path supports the executable bit."""
-        # FIXME: Check actual file system capabilities of limbodir
-        return osutils.supports_executable()
+        return osutils.supports_executable(self._limbodir)
 
     def _limbo_name(self, trans_id):
         """Generate the limbo name of a file"""
@@ -1396,15 +1397,19 @@
         target is a bytestring.
         See also new_symlink.
         """
-        if has_symlinks():
+        if self._create_symlinks:
             os.symlink(target, self._limbo_name(trans_id))
-            unique_add(self._new_contents, trans_id, 'symlink')
         else:
             try:
                 path = FinalPaths(self).get_path(trans_id)
             except KeyError:
                 path = None
-            raise UnableCreateSymlink(path=path)
+            trace.warning(
+                'Unable to create symlink "%s" on this filesystem.' % (path,))
+        # We add symlink to _new_contents even if they are unsupported
+        # and not created. These entries are subsequently used to avoid
+        # conflicts on platforms that don't support symlink
+        unique_add(self._new_contents, trans_id, 'symlink')
 
     def cancel_creation(self, trans_id):
         """Cancel the creation of new file contents."""

=== modified file 'breezy/transport/local.py'
--- breezy/transport/local.py	2018-11-11 04:08:32 +0000
+++ breezy/transport/local.py	2019-06-03 23:46:01 +0000
@@ -532,7 +532,7 @@
             except (IOError, OSError) as e:
                 self._translate_error(e, source)
 
-    if osutils.has_symlinks():
+    if getattr(os, 'symlink', None) is not None:
         def symlink(self, source, link_name):
             """See Transport.symlink."""
             abs_link_dirpath = urlutils.dirname(self.abspath(link_name))

=== modified file 'breezy/tree.py'
--- breezy/tree.py	2019-05-12 09:46:22 +0000
+++ breezy/tree.py	2019-06-03 23:46:01 +0000
@@ -141,6 +141,11 @@
         """
         return True
 
+    def supports_symlinks(self):
+        """Does this tree support symbolic links?
+        """
+        return osutils.has_symlinks()
+
     def changes_from(self, other, want_unchanged=False, specific_files=None,
                      extra_trees=None, require_versioned=False, include_root=False,
                      want_unversioned=False):
@@ -181,7 +186,8 @@
         """See InterTree.iter_changes"""
         intertree = InterTree.get(from_tree, self)
         return intertree.iter_changes(include_unchanged, specific_files, pb,
-                                      extra_trees, require_versioned, want_unversioned=want_unversioned)
+                                      extra_trees, require_versioned,
+                                      want_unversioned=want_unversioned)
 
     def conflicts(self):
         """Get a list of the conflicts in the tree.

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2019-06-02 21:29:09 +0000
+++ breezy/workingtree.py	2019-06-03 23:46:01 +0000
@@ -71,9 +71,6 @@
 from .trace import mutter, note
 
 
-ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
-
-
 class SettingFileIdUnsupported(errors.BzrError):
 
     _fmt = "This format does not support setting file ids."
@@ -129,6 +126,9 @@
     def control_transport(self):
         return self._transport
 
+    def supports_symlinks(self):
+        return osutils.supports_symlinks(self.basedir)
+
     def is_control_filename(self, filename):
         """True if filename is the name of a control file in this tree.
 
@@ -159,10 +159,7 @@
         return self._format.supports_merge_modified
 
     def _supports_executable(self):
-        if sys.platform == 'win32':
-            return False
-        # FIXME: Ideally this should check the file system
-        return True
+        return osutils.supports_executable(self.basedir)
 
     def break_lock(self):
         """Break a lock if one is present from another instance.

=== modified file 'doc/en/release-notes/brz-3.0.txt'
--- doc/en/release-notes/brz-3.0.txt	2019-06-02 05:13:10 +0000
+++ doc/en/release-notes/brz-3.0.txt	2019-06-03 23:46:01 +0000
@@ -223,6 +223,11 @@
    ``RevisionTree.annotate_iter`` have been added. (Jelmer Vernooij,
    #897781)
 
+ * Branches with symlinks are now supported on Windows. Symlinks are
+   ignored by operations like branch, diff etc. with a warning as Symlinks
+   are not created on Windows.
+   (Parth Malwankar, #81689)
+
  * New ``lp+bzr://`` URL scheme for Bazaar-only branches on Launchpad.
    (Jelmer Vernooij)