Merge lp:~gz/brz/no_pywin32 into lp:brz

[Martin Packman]

Remove win32 code using pywin32 library

Remove win32 code using pywin32 library

All Breezy supported Python versions have ctypes, so there's no need for
two implementations of win32 specific logic.

New ctypes implementation of set_file_attr_hidden.

Note that not all tests will actually be passing on Python 3 on windows.

[Jelmer Vernooij (jelmer)]

review: Approve

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

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

=== modified file 'breezy/lock.py'
--- breezy/lock.py	2018-11-12 01:41:38 +0000
+++ breezy/lock.py	2019-06-16 15:39:01 +0000
@@ -143,19 +143,10 @@
 except ImportError:
     have_fcntl = False
 
-have_pywin32 = False
 have_ctypes_win32 = False
 if sys.platform == 'win32':
     import msvcrt
     try:
-        import win32file
-        import pywintypes
-        import winerror
-        have_pywin32 = True
-    except ImportError:
-        pass
-
-    try:
         import ctypes
         have_ctypes_win32 = True
     except ImportError:
@@ -358,73 +349,6 @@
     _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
 
 
-if have_pywin32 and sys.platform == 'win32':
-    win32file_CreateFile = win32file.CreateFileW
-
-    class _w32c_FileLock(_OSLock):
-
-        def _open(self, filename, access, share, cflags, pymode):
-            self.filename = osutils.realpath(filename)
-            try:
-                self._handle = win32file_CreateFile(
-                    filename, access, share, None, win32file.OPEN_ALWAYS,
-                    win32file.FILE_ATTRIBUTE_NORMAL, None)
-            except pywintypes.error as e:
-                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
-                    raise errors.LockFailed(filename, e)
-                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
-                    raise errors.LockContention(filename, e)
-                raise
-            fd = win32file._open_osfhandle(self._handle, cflags)
-            self.f = os.fdopen(fd, pymode)
-            return self.f
-
-        def unlock(self):
-            self._clear_f()
-            self._handle = None
-
-    class _w32c_ReadLock(_w32c_FileLock):
-        def __init__(self, filename):
-            super(_w32c_ReadLock, self).__init__()
-            self._open(filename, win32file.GENERIC_READ,
-                       win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
-
-        def temporary_write_lock(self):
-            """Try to grab a write lock on the file.
-
-            On platforms that support it, this will upgrade to a write lock
-            without unlocking the file.
-            Otherwise, this will release the read lock, and try to acquire a
-            write lock.
-
-            :return: A token which can be used to switch back to a read lock.
-            """
-            # I can't find a way to upgrade a read lock to a write lock without
-            # unlocking first. So here, we do just that.
-            self.unlock()
-            try:
-                wlock = _w32c_WriteLock(self.filename)
-            except errors.LockError:
-                return False, _w32c_ReadLock(self.filename)
-            return True, wlock
-
-    class _w32c_WriteLock(_w32c_FileLock):
-        def __init__(self, filename):
-            super(_w32c_WriteLock, self).__init__()
-            self._open(filename,
-                       win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
-                       os.O_RDWR, "rb+")
-
-        def restore_read_lock(self):
-            """Restore the original ReadLock."""
-            # For win32 we had to completely let go of the original lock, so we
-            # just unlock and create a new read lock.
-            self.unlock()
-            return _w32c_ReadLock(self.filename)
-
-    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
-
-
 if have_ctypes_win32:
     from ctypes.wintypes import DWORD, LPWSTR
     LPSECURITY_ATTRIBUTES = ctypes.c_void_p  # used as NULL no need to declare
@@ -517,7 +441,7 @@
 
 if len(_lock_classes) == 0:
     raise NotImplementedError(
-        "We must have one of fcntl, pywin32, or ctypes available"
+        "We must have one of fcntl or ctypes available"
         " to support OS locking."
         )
 

=== modified file 'breezy/tests/test_bzrdir.py'
--- breezy/tests/test_bzrdir.py	2019-01-04 21:30:02 +0000
+++ breezy/tests/test_bzrdir.py	2019-06-16 15:39:01 +0000
@@ -1240,17 +1240,11 @@
         return out.splitlines()
 
     def test_dot_bzr_hidden(self):
-        if sys.platform == 'win32' and not win32utils.has_win32file:
-            raise TestSkipped(
-                'unable to make file hidden without pywin32 library')
         b = bzrdir.BzrDir.create('.')
         self.build_tree(['a'])
         self.assertEqual([b'a'], self.get_ls())
 
     def test_dot_bzr_hidden_with_url(self):
-        if sys.platform == 'win32' and not win32utils.has_win32file:
-            raise TestSkipped(
-                'unable to make file hidden without pywin32 library')
         b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
         self.build_tree(['a'])
         self.assertEqual([b'a'], self.get_ls())

=== modified file 'breezy/tests/test_win32utils.py'
--- breezy/tests/test_win32utils.py	2018-11-12 01:41:38 +0000
+++ breezy/tests/test_win32utils.py	2019-06-16 15:39:01 +0000
@@ -36,13 +36,7 @@
 
 
 Win32RegistryFeature = features.ModuleAvailableFeature('_winreg')
-CtypesFeature = features.ModuleAvailableFeature('ctypes')
-Win32comShellFeature = features.ModuleAvailableFeature('win32com.shell')
-Win32ApiFeature = features.ModuleAvailableFeature('win32api')
-
-
-# Tests
-# -----
+
 
 class TestWin32UtilsGlobExpand(TestCaseInTempDir):
 
@@ -187,9 +181,9 @@
         self.assertEqual('not-existing', p)
 
 
-class TestLocationsCtypes(TestCase):
+class TestLocations(TestCase):
 
-    _test_needs_features = [CtypesFeature, features.win32_feature]
+    _test_needs_features = [features.win32_feature]
 
     def assertPathsEqual(self, p1, p2):
         # TODO: The env var values in particular might return the "short"
@@ -233,20 +227,10 @@
             self.assertPathsEqual(lad, env.decode(encoding))
 
 
-class TestLocationsPywin32(TestLocationsCtypes):
-
-    _test_needs_features = [Win32comShellFeature]
-
-    def setUp(self):
-        super(TestLocationsPywin32, self).setUp()
-        # We perform the exact same tests after disabling the use of ctypes.
-        # This causes the implementation to fall back to pywin32.
-        self.overrideAttr(win32utils, 'has_ctypes', False)
-        # FIXME: this should be done by parametrization -- vila 100123
-
-
 class TestSetHidden(TestCaseInTempDir):
 
+    _test_needs_features = [features.win32_feature]
+
     def test_unicode_dir(self):
         # we should handle unicode paths without errors
         self.requireFeature(features.UnicodeFilenameFeature)
@@ -335,7 +319,7 @@
 class TestGetEnvironUnicode(tests.TestCase):
     """Tests for accessing the environment via the windows wide api"""
 
-    _test_needs_features = [CtypesFeature, features.win32_feature]
+    _test_needs_features = [features.win32_feature]
 
     def setUp(self):
         super(TestGetEnvironUnicode, self).setUp()

=== modified file 'breezy/win32utils.py'
--- breezy/win32utils.py	2018-11-12 01:41:38 +0000
+++ breezy/win32utils.py	2019-06-16 15:39:01 +0000
@@ -22,7 +22,6 @@
 from __future__ import absolute_import
 
 import glob
-import operator
 import os
 import struct
 import sys
@@ -32,37 +31,13 @@
     )
 from breezy.i18n import gettext
 
-# We can cope without it; use a separate variable to help pyflakes
-try:
-    import ctypes
-    has_ctypes = True
-except ImportError:
-    has_ctypes = False
-else:
-    create_buffer = ctypes.create_unicode_buffer
-    extract_buffer = operator.attrgetter("value")
-    suffix = 'W'
-try:
-    import pywintypes
-    has_pywintypes = True
-except ImportError:
-    has_pywintypes = has_win32file = has_win32api = False
-else:
-    try:
-        import win32file
-        has_win32file = True
-    except ImportError:
-        has_win32file = False
-    try:
-        import win32api
-        has_win32api = True
-    except ImportError:
-        has_win32api = False
+has_ctypes_win32 = False
+if sys.platform == 'win32':
+    try:
+        import ctypes
+    except ImportError:
+        has_ctypes_win32 = False
 
-# pulling in win32com.shell is a bit of overhead, and normally we don't need
-# it as ctypes is preferred and common.  lazy_imports and "optional"
-# modules don't work well, so we do our own lazy thing...
-has_win32com_shell = None  # Set to True or False once we know for sure...
 
 # Special Win32 API constants
 # Handles of std streams
@@ -89,7 +64,7 @@
 def debug_memory_win32api(message='', short=True):
     """Use trace.note() to dump the running memory info."""
     from breezy import trace
-    if has_ctypes:
+    if has_ctypes_win32:
         class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
             """Used by GetProcessMemoryInfo"""
             _fields_ = [('cb', ctypes.c_ulong),
@@ -123,12 +98,6 @@
                 'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
                 'PrivateUsage': mem_struct.PrivateUsage,
                 }
-    elif has_win32api:
-        import win32process
-        # win32process does not return PrivateUsage, because it doesn't use
-        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
-        proc = win32process.GetCurrentProcess()
-        info = win32process.GetProcessMemoryInfo(proc)
     else:
         trace.note(gettext('Cannot debug memory on win32 without ctypes'
                            ' or win32process'))
@@ -163,7 +132,7 @@
     console window and return tuple (sizex, sizey) if success,
     or default size (defaultx, defaulty) otherwise.
     """
-    if not has_ctypes:
+    if not has_ctypes_win32:
         # no ctypes is found
         return (defaultx, defaulty)
 
@@ -189,7 +158,7 @@
 
     Result is always unicode (or None).
     """
-    if has_ctypes:
+    if has_ctypes_win32:
         try:
             SHGetSpecialFolderPath = \
                 ctypes.windll.shell32.SHGetSpecialFolderPathW
@@ -199,23 +168,6 @@
             buf = ctypes.create_unicode_buffer(MAX_PATH)
             if SHGetSpecialFolderPath(None, buf, csidl, 0):
                 return buf.value
-
-    global has_win32com_shell
-    if has_win32com_shell is None:
-        try:
-            from win32com.shell import shell
-            has_win32com_shell = True
-        except ImportError:
-            has_win32com_shell = False
-    if has_win32com_shell:
-        # still need to bind the name locally, but this is fast.
-        from win32com.shell import shell
-        try:
-            return shell.SHGetSpecialFolderPath(0, csidl, 0)
-        except shell.error:
-            # possibly E_NOTIMPL meaning we can't load the function pointer,
-            # or E_FAIL meaning the function failed - regardless, just ignore it
-            pass
     return None
 
 
@@ -282,17 +234,17 @@
     """Return user name as login name.
     If name cannot be obtained return None.
     """
-    if has_ctypes:
+    if has_ctypes_win32:
         try:
             advapi32 = ctypes.windll.advapi32
-            GetUserName = getattr(advapi32, 'GetUserName' + suffix)
+            GetUserName = getattr(advapi32, 'GetUserNameW')
         except AttributeError:
             pass
         else:
-            buf = create_buffer(UNLEN + 1)
+            buf = ctypes.create_unicode_buffer(UNLEN + 1)
             n = ctypes.c_int(UNLEN + 1)
             if GetUserName(buf, ctypes.byref(n)):
-                return extract_buffer(buf)
+                return buf.value
     # otherwise try env variables
     return get_environ_unicode('USERNAME')
 
@@ -308,38 +260,21 @@
 
     :return: A unicode string representing the host name.
     """
-    if has_win32api:
-        try:
-            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
-        except (NotImplementedError, win32api.error):
-            # NotImplemented will happen on win9x...
-            pass
-    if has_ctypes:
+    if has_ctypes_win32:
         try:
             kernel32 = ctypes.windll.kernel32
         except AttributeError:
             pass  # Missing the module we need
         else:
-            buf = create_buffer(MAX_COMPUTERNAME_LENGTH + 1)
+            buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
             n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
 
             # Try GetComputerNameEx which gives a proper Unicode hostname
-            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx' + suffix,
-                                        None)
+            GetComputerNameEx = getattr(kernel32, 'GetComputerNameExW', None)
             if (GetComputerNameEx is not None
                 and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
                                       buf, ctypes.byref(n))):
-                return extract_buffer(buf)
-
-            # Try GetComputerName in case GetComputerNameEx wasn't found
-            # It returns the NETBIOS name, which isn't as good, but still ok.
-            # The first GetComputerNameEx might have changed 'n', so reset it
-            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
-            GetComputerName = getattr(kernel32, 'GetComputerName' + suffix,
-                                      None)
-            if (GetComputerName is not None
-                    and GetComputerName(buf, ctypes.byref(n))):
-                return extract_buffer(buf)
+                return buf.value
     return get_environ_unicode('COMPUTERNAME')
 
 
@@ -440,13 +375,18 @@
 
 def set_file_attr_hidden(path):
     """Set file attributes to hidden if possible"""
-    if has_win32file:
-        SetFileAttributes = win32file.SetFileAttributesW
-        try:
-            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
-        except pywintypes.error as e:
-            from . import trace
-            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
+    if not has_ctypes_win32:
+        return
+    from ctypes.wintypes import BOOL, DWORD, LPCWSTR
+    _kernel32 = ctypes.windll.kernel32
+    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
+    _SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
+        ("SetFileAttributesW", _kernel32))
+    FILE_ATTRIBUTE_HIDDEN = 2
+    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
+        e = ctypes.WinError()
+        from . import trace
+        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
 
 def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
@@ -491,7 +431,7 @@
     return args
 
 
-if has_ctypes:
+if has_ctypes_win32:
     def get_unicode_argv():
         prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
         GetCommandLineW = prototype(("GetCommandLineW",
@@ -513,8 +453,6 @@
 
         A large enough buffer will be allocated to retrieve the value, though
         it may take two calls to the underlying library function.
-
-        This needs ctypes because pywin32 does not expose the wide version.
         """
         cfunc = getattr(get_environ_unicode, "_c_function", None)
         if cfunc is None:
@@ -524,34 +462,19 @@
             get_environ_unicode._c_function = cfunc
         buffer_size = 256  # heuristic, 256 characters often enough
         while True:
-            buffer = ctypes.create_unicode_buffer(buffer_size)
-            length = cfunc(key, buffer, buffer_size)
+            buf = ctypes.create_unicode_buffer(buffer_size)
+            length = cfunc(key, buf, buffer_size)
             if not length:
                 code = ctypes.GetLastError()
                 if code == 203:  # ERROR_ENVVAR_NOT_FOUND
                     return default
                 raise ctypes.WinError(code)
             if buffer_size > length:
-                return buffer[:length]
+                return buf[:length]
             buffer_size = length
 
 
-if has_win32api:
-    def _pywin32_is_local_pid_dead(pid):
-        """True if pid doesn't correspond to live process on this machine"""
-        try:
-            handle = win32api.OpenProcess(1, False, pid)  # PROCESS_TERMINATE
-        except pywintypes.error as e:
-            if e[0] == 5:  # ERROR_ACCESS_DENIED
-                # Probably something alive we're not allowed to kill
-                return False
-            elif e[0] == 87:  # ERROR_INVALID_PARAMETER
-                return True
-            raise
-        handle.close()
-        return False
-    is_local_pid_dead = _pywin32_is_local_pid_dead
-elif has_ctypes and sys.platform == 'win32':
+if has_ctypes_win32:
     from ctypes.wintypes import BOOL, DWORD, HANDLE
     _kernel32 = ctypes.windll.kernel32
     _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
@@ -572,11 +495,5 @@
             raise ctypes.WinError(errorcode)
         _CloseHandle(handle)
         return False
+
     is_local_pid_dead = _ctypes_is_local_pid_dead
-
-
-def _is_pywintypes_error(evalue):
-    """True if exception instance is an error from pywin32"""
-    if has_pywintypes and isinstance(evalue, pywintypes.error):
-        return True
-    return False