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

[Jelmer Vernooij]

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.

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2018-11-18 19:48:57 +0000
+++ breezy/bzr/dirstate.py	2019-03-04 01:57:09 +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-03-04 01:57:09 +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	2018-12-11 00:51:46 +0000
+++ breezy/bzr/workingtree.py	2019-03-04 01:57:09 +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-03-04 01:57:09 +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-03-04 01:57:09 +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-03-04 01:57:09 +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,11 @@
             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 +257,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	2018-11-25 21:48:55 +0000
+++ breezy/diff.py	2019-03-04 01:57:09 +0000
@@ -982,6 +982,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	2018-11-11 04:08:32 +0000
+++ breezy/errors.py	2019-03-04 01:57:09 +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	2018-11-18 00:25:19 +0000
+++ breezy/git/memorytree.py	2019-03-04 01:57:09 +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
@@ -258,3 +261,7 @@
     def kind(self, p):
         stat_value = self._file_transport.stat(p)
         return osutils.file_kind_from_stat_mode(stat_value.st_mode)
+
+    def get_symlink_target(self, path):
+        with self.lock_read():
+            return self._file_transport.readlink(path)

=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2018-12-18 20:55:37 +0000
+++ breezy/git/tree.py	2019-03-04 01:57:09 +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)
@@ -1465,7 +1466,13 @@
             else:
                 raise
         else:
-            blobs[path] = (live_entry.sha, cleanup_mode(live_entry.mode))
+            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(mode))
     if want_unversioned:
         for e in target.extras():
             st = target._lstat(e)

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2019-02-05 04:00:02 +0000
+++ breezy/git/workingtree.py	2019-03-04 01:57:09 +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()
@@ -743,8 +743,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'))
@@ -755,10 +754,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)
@@ -1166,7 +1163,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	2018-11-18 00:25:19 +0000
+++ breezy/memorytree.py	2019-03-04 01:57:09 +0000
@@ -22,6 +22,7 @@
 from __future__ import absolute_import
 
 import os
+import stat
 
 from . import (
     errors,
@@ -50,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()
 
@@ -62,7 +66,15 @@
         with self.lock_tree_write():
             for f, file_id, kind in zip(files, ids, kinds):
                 if kind is None:
-                    kind = 'file'
+                    st_mode = self._file_transport.stat(f).st_mode
+                    if stat.S_ISREG(st_mode):
+                        kind = 'file'
+                    elif stat.S_ISLNK(st_mode):
+                        kind = 'symlink'
+                    elif stat.S_ISDIR(st_mode):
+                        kind = 'directory'
+                    else:
+                        raise AssertionError('Unknown file kind')
                 if file_id is None:
                     self._inventory.add_path(f, kind=kind)
                 else:
@@ -127,7 +139,7 @@
             # memory tree does not support nested trees yet.
             return kind, None, None, None
         elif kind == 'symlink':
-            raise NotImplementedError('symlink support')
+            return kind, None, None, self._inventory[id].symlink_target
         else:
             raise NotImplementedError('unknown kind')
 
@@ -148,8 +160,7 @@
         return self._inventory.get_entry_by_path(path).executable
 
     def kind(self, path):
-        file_id = self.path2id(path)
-        return self._inventory[file_id].kind
+        return self._inventory.get_entry_by_path(path).kind
 
     def mkdir(self, path, file_id=None):
         """See MutableTree.mkdir()."""
@@ -227,6 +238,8 @@
                 continue
             if entry.kind == 'directory':
                 self._file_transport.mkdir(path)
+            elif entry.kind == 'symlink':
+                self._file_transport.symlink(entry.symlink_target, path)
             elif entry.kind == 'file':
                 self._file_transport.put_file(
                     path, self._basis_tree.get_file(path))
@@ -302,6 +315,10 @@
             else:
                 raise
 
+    def get_symlink_target(self, path):
+        with self.lock_read():
+            return self._file_transport.readlink(path)
+
     def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
         """See MutableTree.set_parent_trees()."""
         if len(parents_list) == 0:

=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2018-11-18 00:25:19 +0000
+++ breezy/mutabletree.py	2019-03-04 01:57:09 +0000
@@ -197,14 +197,32 @@
             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)
-                return True
-            except StopIteration:
-                # No 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 plantforms 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)
+                if len(changes) > 0:
+                    return True
                 return False
 
     def check_changed_or_out_of_date(self, strict, opt_name,

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2019-03-02 23:49:52 +0000
+++ breezy/osutils.py	2019-03-04 01:57:09 +0000
@@ -1662,8 +1662,42 @@
     _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:
+        # TODO(jelmer): Warn here?
+        pass
+    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:
+        # TODO(jelmer): Warn here?
+        pass
+    else:
+        if fs_type in ('vfat', 'ntfs'):
+            # filesystems known to not support executable bit
+            return False
+    return True
 
 
 def supports_posix_readonly():
@@ -2602,6 +2636,25 @@
     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)
+    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-03-04 01:57:09 +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_commit.py'
--- breezy/tests/test_commit.py	2018-11-29 23:42:41 +0000
+++ breezy/tests/test_commit.py	2019-03-04 01:57:09 +0000
@@ -16,12 +16,14 @@
 
 
 import os
+from StringIO import StringIO
 
 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='hello_id')
+        os.symlink('hello', 'foo')
+        tree.add('foo')
+        tree.commit('added foo', rev_id='foo_id')
+        log = StringIO()
+        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='world_id')
+        finally:
+            if os_symlink:
+                os.symlink = os_symlink
+        self.assertContainsRe(
+            log.getvalue(),
+                'Ignoring "foo" as symlinks are not '
+                'supported on this filesystem.')
+
     def test_commit_kind_changes(self):
         self.requireFeature(SymlinkFeature)
         tree = self.make_branch_and_tree('.')

=== 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-03-04 01:57:09 +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_memorytree.py'
--- breezy/tests/test_memorytree.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test_memorytree.py	2019-03-04 01:57:09 +0000
@@ -46,21 +46,17 @@
         rev_id = tree.commit('first post')
         tree.unlock()
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_read()
-        self.assertEqual([rev_id], tree.get_parent_ids())
-        with tree.get_file('foo') as f:
-            self.assertEqual(b'contents of foo\n', f.read())
-        tree.unlock()
+        with tree.lock_read():
+            self.assertEqual([rev_id], tree.get_parent_ids())
+            with tree.get_file('foo') as f:
+                self.assertEqual(b'contents of foo\n', f.read())
 
     def test_get_root_id(self):
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             tree.add([''])
             self.assertIsNot(None, tree.get_root_id())
-        finally:
-            tree.unlock()
 
     def test_lock_tree_write(self):
         """Check we can lock_tree_write and unlock MemoryTrees."""
@@ -73,9 +69,8 @@
         """Check that we error when trying to upgrade a read lock to write."""
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_read()
-        self.assertRaises(errors.ReadOnlyError, tree.lock_tree_write)
-        tree.unlock()
+        with tree.lock_read():
+            self.assertRaises(errors.ReadOnlyError, tree.lock_tree_write)
 
     def test_lock_write(self):
         """Check we can lock_write and unlock MemoryTrees."""
@@ -88,58 +83,63 @@
         """Check that we error when trying to upgrade a read lock to write."""
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_read()
-        self.assertRaises(errors.ReadOnlyError, tree.lock_write)
-        tree.unlock()
+        with tree.lock_read():
+            self.assertRaises(errors.ReadOnlyError, tree.lock_write)
 
     def test_add_with_kind(self):
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        tree.add(['', 'afile', 'adir'], None,
-                 ['directory', 'file', 'directory'])
-        self.assertEqual('afile', tree.id2path(tree.path2id('afile')))
-        self.assertEqual('adir', tree.id2path(tree.path2id('adir')))
-        self.assertFalse(tree.has_filename('afile'))
-        self.assertFalse(tree.has_filename('adir'))
-        tree.unlock()
+        with tree.lock_write():
+            tree.add(['', 'afile', 'adir'], None,
+                     ['directory', 'file', 'directory'])
+            self.assertEqual('afile', tree.id2path(tree.path2id('afile')))
+            self.assertEqual('adir', tree.id2path(tree.path2id('adir')))
+            self.assertFalse(tree.has_filename('afile'))
+            self.assertFalse(tree.has_filename('adir'))
 
     def test_put_new_file(self):
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
-                 kinds=['directory', 'file'])
-        tree.put_file_bytes_non_atomic('foo', b'barshoom')
-        self.assertEqual(b'barshoom', tree.get_file('foo').read())
-        tree.unlock()
+        with tree.lock_write():
+            tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
+                     kinds=['directory', 'file'])
+            tree.put_file_bytes_non_atomic('foo', b'barshoom')
+            with tree.get_file('foo') as f:
+                self.assertEqual(b'barshoom', f.read())
 
     def test_put_existing_file(self):
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
-                 kinds=['directory', 'file'])
-        tree.put_file_bytes_non_atomic('foo', b'first-content')
-        tree.put_file_bytes_non_atomic('foo', b'barshoom')
-        self.assertEqual(b'barshoom', tree.get_file('foo').read())
-        tree.unlock()
+        with tree.lock_write():
+            tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
+                     kinds=['directory', 'file'])
+            tree.put_file_bytes_non_atomic('foo', b'first-content')
+            tree.put_file_bytes_non_atomic('foo', b'barshoom')
+            self.assertEqual(b'barshoom', tree.get_file('foo').read())
 
     def test_add_in_subdir(self):
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        self.addCleanup(tree.unlock)
-        tree.add([''], [b'root-id'], ['directory'])
-        # Unfortunately, the only way to 'mkdir' is to call 'tree.mkdir', but
-        # that *always* adds the directory as well. So if you want to create a
-        # file in a subdirectory, you have to split out the 'mkdir()' calls
-        # from the add and put_file_bytes_non_atomic calls. :(
-        tree.mkdir('adir', b'dir-id')
-        tree.add(['adir/afile'], [b'file-id'], ['file'])
-        self.assertEqual('adir/afile', tree.id2path(b'file-id'))
-        self.assertEqual('adir', tree.id2path(b'dir-id'))
-        tree.put_file_bytes_non_atomic('adir/afile', b'barshoom')
+        with tree.lock_write():
+            tree.add([''], [b'root-id'], ['directory'])
+            # Unfortunately, the only way to 'mkdir' is to call 'tree.mkdir', but
+            # that *always* adds the directory as well. So if you want to create a
+            # file in a subdirectory, you have to split out the 'mkdir()' calls
+            # from the add and put_file_bytes_non_atomic calls. :(
+            tree.mkdir('adir', b'dir-id')
+            tree.add(['adir/afile'], [b'file-id'], ['file'])
+            self.assertEqual('adir/afile', tree.id2path(b'file-id'))
+            self.assertEqual('adir', tree.id2path(b'dir-id'))
+            tree.put_file_bytes_non_atomic('adir/afile', b'barshoom')
+
+    def test_add_symlink(self):
+        branch = self.make_branch('branch')
+        tree = MemoryTree.create_on_branch(branch)
+        with tree.lock_write():
+            tree._file_transport.symlink('bar', 'foo')
+            tree.add(['', 'foo'])
+            self.assertEqual('symlink', tree.kind('foo'))
+            self.assertEqual('bar', tree.get_symlink_target('foo'))
 
     def test_commit_trivial(self):
         """Smoke test for commit on a MemoryTree.
@@ -149,40 +149,35 @@
         """
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
-                 kinds=['directory', 'file'])
-        tree.put_file_bytes_non_atomic('foo', b'barshoom')
-        revision_id = tree.commit('message baby')
-        # the parents list for the tree should have changed.
-        self.assertEqual([revision_id], tree.get_parent_ids())
-        tree.unlock()
+        with tree.lock_write():
+            tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
+                     kinds=['directory', 'file'])
+            tree.put_file_bytes_non_atomic('foo', b'barshoom')
+            revision_id = tree.commit('message baby')
+            # the parents list for the tree should have changed.
+            self.assertEqual([revision_id], tree.get_parent_ids())
         # and we should have a revision that is accessible outside the tree lock
         revtree = tree.branch.repository.revision_tree(revision_id)
-        revtree.lock_read()
-        self.addCleanup(revtree.unlock)
-        with revtree.get_file('foo') as f:
+        with revtree.lock_read(), revtree.get_file('foo') as f:
             self.assertEqual(b'barshoom', f.read())
 
     def test_unversion(self):
         """Some test for unversion of a memory tree."""
         branch = self.make_branch('branch')
         tree = MemoryTree.create_on_branch(branch)
-        tree.lock_write()
-        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
-                 kinds=['directory', 'file'])
-        tree.unversion(['foo'])
-        self.assertFalse(tree.is_versioned('foo'))
-        self.assertFalse(tree.has_id(b'foo-id'))
-        tree.unlock()
+        with tree.lock_write():
+            tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
+                     kinds=['directory', 'file'])
+            tree.unversion(['foo'])
+            self.assertFalse(tree.is_versioned('foo'))
+            self.assertFalse(tree.has_id(b'foo-id'))
 
     def test_last_revision(self):
         """There should be a last revision method we can call."""
         tree = self.make_branch_and_memory_tree('branch')
-        tree.lock_write()
-        tree.add('')
-        rev_id = tree.commit('first post')
-        tree.unlock()
+        with tree.lock_write():
+            tree.add('')
+            rev_id = tree.commit('first post')
         self.assertEqual(rev_id, tree.last_revision())
 
     def test_rename_file(self):

=== 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-03-04 01:57:09 +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-03-04 01:57:09 +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(),
+            '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('TREE_ROOT')
+        tree.add('a', 'a-id')
+        os.symlink('a', 'foo')
+        tree.add('foo', 'foo-id')
+        tree.commit('rev1', rev_id='rev1')
+        revision_tree = tree.branch.repository.revision_tree('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(),
+            '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	2018-11-12 01:41:38 +0000
+++ breezy/tests/test_workingtree.py	2019-03-04 01:57:09 +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', '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', '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-03-04 01:57:09 +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-03-04 01:57:09 +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/transport/memory.py'
--- breezy/transport/memory.py	2018-11-17 16:53:10 +0000
+++ breezy/transport/memory.py	2019-03-04 01:57:09 +0000
@@ -26,9 +26,10 @@
 from io import (
     BytesIO,
     )
+import itertools
 import os
 import errno
-from stat import S_IFREG, S_IFDIR, S_IFLNK
+from stat import S_IFREG, S_IFDIR, S_IFLNK, S_ISDIR
 
 from .. import (
     transport,
@@ -50,20 +51,16 @@
 
 class MemoryStat(object):
 
-    def __init__(self, size, kind, perms):
+    def __init__(self, size, kind, perms=None):
         self.st_size = size
-        if kind == 'file':
+        if not S_ISDIR(kind):
             if perms is None:
                 perms = 0o644
-            self.st_mode = S_IFREG | perms
-        elif kind == 'directory':
+            self.st_mode = kind | perms
+        else:
             if perms is None:
                 perms = 0o755
-            self.st_mode = S_IFDIR | perms
-        elif kind == 'symlink':
-            self.st_mode = S_IFLNK | 0o644
-        else:
-            raise AssertionError('unknown kind %r' % kind)
+            self.st_mode = kind | perms
 
 
 class MemoryTransport(transport.Transport):
@@ -80,7 +77,7 @@
         self._scheme = url[:split]
         self._cwd = url[split:]
         # dictionaries from absolute path to file mode
-        self._dirs = {'/': None}
+        self._dirs = {'/':None}
         self._symlinks = {}
         self._files = {}
         self._locks = {}
@@ -111,7 +108,7 @@
 
     def append_file(self, relpath, f, mode=None):
         """See Transport.append_file()."""
-        _abspath = self._abspath(relpath)
+        _abspath = self._resolve_symlinks(relpath)
         self._check_parent(_abspath)
         orig_content, orig_mode = self._files.get(_abspath, (b"", None))
         if mode is None:
@@ -128,16 +125,20 @@
     def has(self, relpath):
         """See Transport.has()."""
         _abspath = self._abspath(relpath)
-        return ((_abspath in self._files)
-                or (_abspath in self._dirs)
-                or (_abspath in self._symlinks))
+        for container in (self._files, self._dirs, self._symlinks):
+            if _abspath in container.keys():
+                return True
+        return False
 
     def delete(self, relpath):
         """See Transport.delete()."""
         _abspath = self._abspath(relpath)
-        if _abspath not in self._files:
+        if _abspath in self._files:
+            del self._files[_abspath]
+        elif _abspath in self._symlinks:
+            del self._symlinks[_abspath]
+        else:
             raise NoSuchFile(relpath)
-        del self._files[_abspath]
 
     def external_url(self):
         """See breezy.transport.Transport.external_url."""
@@ -147,8 +148,8 @@
 
     def get(self, relpath):
         """See Transport.get()."""
-        _abspath = self._abspath(relpath)
-        if _abspath not in self._files:
+        _abspath = self._resolve_symlinks(relpath)
+        if not _abspath in self._files:
             if _abspath in self._dirs:
                 return LateReadError(relpath)
             else:
@@ -157,15 +158,20 @@
 
     def put_file(self, relpath, f, mode=None):
         """See Transport.put_file()."""
-        _abspath = self._abspath(relpath)
+        _abspath = self._resolve_symlinks(relpath)
         self._check_parent(_abspath)
         raw_bytes = f.read()
         self._files[_abspath] = (raw_bytes, mode)
         return len(raw_bytes)
 
+    def symlink(self, source, target):
+        _abspath = self._resolve_symlinks(target)
+        self._check_parent(_abspath)
+        self._symlinks[_abspath] = self._abspath(source)
+
     def mkdir(self, relpath, mode=None):
         """See Transport.mkdir()."""
-        _abspath = self._abspath(relpath)
+        _abspath = self._resolve_symlinks(relpath)
         self._check_parent(_abspath)
         if _abspath in self._dirs:
             raise FileExists(relpath)
@@ -183,13 +189,13 @@
         return True
 
     def iter_files_recursive(self):
-        for file in self._files:
+        for file in itertools.chain(self._files, self._symlinks):
             if file.startswith(self._cwd):
                 yield urlutils.escape(file[len(self._cwd):])
 
     def list_dir(self, relpath):
         """See Transport.list_dir()."""
-        _abspath = self._abspath(relpath)
+        _abspath = self._resolve_symlinks(relpath)
         if _abspath != '/' and _abspath not in self._dirs:
             raise NoSuchFile(relpath)
         result = []
@@ -197,7 +203,7 @@
         if not _abspath.endswith('/'):
             _abspath += '/'
 
-        for path_group in self._files, self._dirs:
+        for path_group in self._files, self._dirs, self._symlinks:
             for path in path_group:
                 if path.startswith(_abspath):
                     trailing = path[len(_abspath):]
@@ -207,8 +213,8 @@
 
     def rename(self, rel_from, rel_to):
         """Rename a file or directory; fail if the destination exists"""
-        abs_from = self._abspath(rel_from)
-        abs_to = self._abspath(rel_to)
+        abs_from = self._resolve_symlinks(rel_from)
+        abs_to = self._resolve_symlinks(rel_to)
 
         def replace(x):
             if x == abs_from:
@@ -233,21 +239,25 @@
         # fail differently depending on dict order. So work on copy, fail on
         # error on only replace dicts if all goes well.
         renamed_files = self._files.copy()
+        renamed_symlinks = self._symlinks.copy()
         renamed_dirs = self._dirs.copy()
         do_renames(renamed_files)
+        do_renames(renamed_symlinks)
         do_renames(renamed_dirs)
         # We may have been cloned so modify in place
         self._files.clear()
         self._files.update(renamed_files)
+        self._symlinks.clear()
+        self._symlinks.update(renamed_symlinks)
         self._dirs.clear()
         self._dirs.update(renamed_dirs)
 
     def rmdir(self, relpath):
         """See Transport.rmdir."""
-        _abspath = self._abspath(relpath)
+        _abspath = self._resolve_symlinks(relpath)
         if _abspath in self._files:
             self._translate_error(IOError(errno.ENOTDIR, relpath), relpath)
-        for path in self._files:
+        for path in itertools.chain(self._files, self._symlinks):
             if path.startswith(_abspath + '/'):
                 self._translate_error(IOError(errno.ENOTEMPTY, relpath),
                                       relpath)
@@ -262,13 +272,13 @@
     def stat(self, relpath):
         """See Transport.stat()."""
         _abspath = self._abspath(relpath)
-        if _abspath in self._files:
-            return MemoryStat(len(self._files[_abspath][0]), 'file',
+        if _abspath in self._files.keys():
+            return MemoryStat(len(self._files[_abspath][0]), S_IFREG,
                               self._files[_abspath][1])
-        elif _abspath in self._dirs:
-            return MemoryStat(0, 'directory', self._dirs[_abspath])
-        elif _abspath in self._symlinks:
-            return MemoryStat(0, 'symlink', 0)
+        elif _abspath in self._dirs.keys():
+            return MemoryStat(0, S_IFDIR, self._dirs[_abspath])
+        elif _abspath in self._symlinks.keys():
+            return MemoryStat(0, S_IFLNK)
         else:
             raise NoSuchFile(_abspath)
 
@@ -280,6 +290,12 @@
         """See Transport.lock_write()."""
         return _MemoryLock(self._abspath(relpath), self)
 
+    def _resolve_symlinks(self, relpath):
+        path = self._abspath(relpath)
+        while path in self._symlinks.keys():
+            path = self._symlinks[path]
+        return path
+
     def _abspath(self, relpath):
         """Generate an internal absolute path."""
         relpath = urlutils.unescape(relpath)
@@ -336,6 +352,7 @@
     def start_server(self):
         self._dirs = {'/': None}
         self._files = {}
+        self._symlinks = {}
         self._locks = {}
         self._scheme = "memory+%s:///" % id(self)
 
@@ -344,6 +361,7 @@
             result = memory.MemoryTransport(url)
             result._dirs = self._dirs
             result._files = self._files
+            result._symlinks = self._symlinks
             result._locks = self._locks
             return result
         self._memory_factory = memory_factory

=== modified file 'breezy/tree.py'
--- breezy/tree.py	2019-02-02 15:13:30 +0000
+++ breezy/tree.py	2019-03-04 01:57:09 +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-02-14 22:18:59 +0000
+++ breezy/workingtree.py	2019-03-04 01:57:09 +0000
@@ -65,9 +65,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."
@@ -123,6 +120,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.
 
@@ -153,10 +153,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-03-02 22:31:28 +0000
+++ doc/en/release-notes/brz-3.0.txt	2019-03-04 01:57:09 +0000
@@ -158,6 +158,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)