More UNC path handling and unittests

Adds uncpath.py, a py2 compatible utility for working with UNC paths

Signed-off-by: javrin <[email protected]>

Author: Jawabiscuit

src/rez/tests/test_utils.py

@@ -6,12 +6,25 @@
 test 'utils' modules
 """
 import os
+import sys
 
 from rez.config import config
 from rez.tests.util import TestBase, platform_dependent
 from rez.utils import cygpath, filesystem
 from rez.utils.platform_ import Platform, platform_
 
+if platform_.name == "windows":
+    from rez.utils import uncpath
+    uncpath_available = True
+else:
+    uncpath_available = False
+
+if sys.version_info[:2] >= (3, 3):
+    from unittest.mock import patch
+    patch_available = True
+else:
+    patch_available = False
+
 
 class TestCanonicalPath(TestBase):
     class CaseSensitivePlatform(Platform):
@@ -198,6 +211,12 @@ def test_windows_unc_paths(self):
         self.assertEqual(cygpath.to_posix_path(
             "\\\\server\\share\\folder\\file.txt"), "//server/share/folder/file.txt"
         )
+        self.assertEqual(cygpath.to_posix_path(
+            "\\\\server\\share/folder/file.txt"), "//server/share/folder/file.txt"
+        )
+        self.assertEqual(cygpath.to_posix_path(
+            r"\\server\share/folder\//file.txt"), "//server/share/folder/file.txt"
+        )
 
     @platform_dependent(["windows"])
     def test_windows_long_paths(self):
@@ -357,14 +376,6 @@ def test_paths_with_no_drive_letter(self):
             '\\foo\\bar'
         )
 
-        self.assertRaisesRegex(
-            ValueError,
-            "Cannot convert path to mixed path: '.*' "
-            "Please ensure that the path is absolute",
-            cygpath.to_mixed_path,
-            '\\\\my_folder\\my_file.txt'
-        )
-
         self.assertRaisesRegex(
             ValueError,
             "Cannot convert path to mixed path: '.*' "
@@ -394,3 +405,62 @@ def test_dotted_paths(self):
             cygpath.to_posix_path,
             "./projects/python"
         )
+
+    @platform_dependent(["windows"])
+    def test_windows_unc_paths(self):
+        self.assertRaisesRegex(
+            ValueError,
+            "Cannot convert path to mixed path: '.*' "
+            "Unmapped UNC paths are not supported",
+            cygpath.to_mixed_path,
+            '\\\\my_folder\\my_file.txt'
+        )
+        self.assertRaisesRegex(
+            ValueError,
+            "Cannot convert path to mixed path: '.*' "
+            "Unmapped UNC paths are not supported",
+            cygpath.to_mixed_path,
+            "\\\\Server\\Share\\folder"
+        )
+        self.assertRaisesRegex(
+            ValueError,
+            "Cannot convert path to mixed path: '.*' "
+            "Unmapped UNC paths are not supported",
+            cygpath.to_mixed_path,
+            "\\\\server\\share\\folder\\file.txt"
+        )
+        self.assertRaisesRegex(
+            ValueError,
+            "Cannot convert path to mixed path: '.*' "
+            "Unmapped UNC paths are not supported",
+            cygpath.to_mixed_path,
+            "\\\\server\\share/folder/file.txt"
+        )
+        self.assertRaisesRegex(
+            ValueError,
+            "Cannot convert path to mixed path: '.*' "
+            "Unmapped UNC paths are not supported",
+            cygpath.to_mixed_path,
+            r"\\server\share/folder\//file.txt"
+        )
+
+    @platform_dependent(["windows"])
+    def test_windows_mapped_unc_paths(self):
+        if not patch_available:
+            raise self.skipTest("Patching not available")
+        with patch.object(cygpath, 'to_mapped_drive', return_value="X:"):
+            self.assertEqual(
+                cygpath.to_mixed_path('\\\\server\\share\\folder'), 'X:/folder'
+            )
+
+
+class TestToMappedDrive(TestBase):
+
+    @platform_dependent(["windows"])
+    def test_already_mapped_drive(self):
+        if not uncpath_available:
+            raise self.skipTest("UNC path util not available")
+        if not patch_available:
+            raise self.skipTest("Unittest patch not available")
+        with patch.object(uncpath, 'to_drive', return_value="X:"):
+            self.assertEqual(cygpath.to_mapped_drive('\\\\server\\share'), 'X:')

src/rez/utils/cygpath.py

@@ -13,8 +13,15 @@
 import re
 
 from rez.config import config
+from rez.utils import platform_
 from rez.utils.logging_ import print_debug
 
+if platform_.name == "windows":
+    from rez.utils import uncpath
+    uncpath_available = True
+else:
+    uncpath_available = False
+
 
 def log(*msg):
     if config.debug("cygpath"):
@@ -78,20 +85,27 @@ def convert(path, mode=None, env_var_seps=None):
 def to_posix_path(path):
     r"""Convert (eg) 'C:\foo' to '/c/foo'
 
+    Note: Especially for UNC paths, and as opposed mixed path conversion, this
+    function will return a path that is not guaranteed to exist.
+
     Args:
         path (str): Path to convert.
 
     Returns:
         str: Converted path.
+
+    Raises:
+        ValueError: If the path is not absolute or path is malformed
     """
     # Handle Windows long paths
     if path.startswith("\\\\?\\"):
         path = path[4:]
 
-    unc, path = os.path.splitunc(path)
-    if unc:
-        path = unc.replace("\\", "/") + path.replace("\\", "/")
-        return path
+    # Handle UNC paths
+    unc, unc_path = os.path.splitdrive(path)
+    if unc and unc.startswith("\\\\"):
+        unc_path = unc.replace("\\", "/") + slashify(unc_path)
+        return unc_path
 
     drive = to_cygdrive(path)
 
@@ -125,12 +139,35 @@ def to_posix_path(path):
 def to_mixed_path(path):
     r"""Convert (eg) 'C:\foo\bin' to 'C:/foo/bin'
 
+    Note: Especially in the case of UNC paths, this function will return a path
+    that is practically guaranteed to exist but it is not verified.
+
     Args:
         path (str): Path to convert.
 
     Returns:
         str: Converted path.
+
+    Raises:
+        ValueError: If the path is not absolute or drive letter is not mapped
+            to a UNC path.
     """
+    # Handle Windows long paths
+    if path.startswith("\\\\?\\"):
+        path = path[4:]
+
+    # Handle UNC paths
+    # Return mapped drive letter if any, else raise
+    unc, unc_path = os.path.splitdrive(path)
+    if unc and unc.startswith("\\\\"):
+        drive = to_mapped_drive(path)
+        if drive:
+            return drive.upper() + slashify(unc_path)
+        raise ValueError(
+            "Cannot convert path to mixed path: {!r} "
+            "Unmapped UNC paths are not supported".format(path)
+        )
+
     drive, path = os.path.splitdrive(path)
 
     if not drive:
@@ -152,6 +189,14 @@ def to_mixed_path(path):
 
 
 def slashify(path):
+    """Ensures path only contains forward slashes.
+
+    Args:
+        path (str): Path to convert.
+
+    Returns:
+        str: Converted path.
+    """
     # Remove double backslashes and dots
     path = os.path.normpath(path)
     # Normalize slashes
@@ -179,9 +224,13 @@ def to_cygdrive(path):
     # Normalize forward backslashes to slashes
     path = path.replace("\\", "/")
 
-    # UNC paths are not supported
-    unc, _ = os.path.splitunc(path)
-    if unc:
+    # Handle UNC paths
+    # Return mapped drive letter if any, else return ""
+    unc, _ = os.path.splitdrive(path)
+    if unc and unc.startswith("\\\\"):
+        drive = to_mapped_drive(path)
+        if drive:
+            return posixpath.sep + drive.lower() + posixpath.sep
         return ""
 
     if (
@@ -204,3 +253,21 @@ def to_cygdrive(path):
 
     # Most likely a relative path
     return ""
+
+
+def to_mapped_drive(path):
+    r"""Convert a UNC path to an NT drive if possible.
+
+    (eg) '\\\\server\\share\\folder' -> 'X:'
+
+    Args:
+        path (str): UNC path.
+
+    Returns:
+        str: Drive mapped to UNC, if any.
+    """
+    if not uncpath_available:
+        return
+    unc, _ = os.path.splitdrive(path)
+    if unc and unc.startswith("\\\\"):
+        return uncpath.to_drive(unc)

src/rez/utils/uncpath.py

@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Contributors to the Rez Project
+
+
+"""Get full UNC path from a network drive letter if it exists
+Adapted from: https://stackoverflow.com/a/34809340
+
+Example:
+
+    drive_mapping = get_connections()
+
+    # Result:
+    {
+        'H:': u'\\\\server\\share\\username',
+        'U:': u'\\\\server\\share\\simcache',
+        'T:': u'\\\\server\\share',
+        'C:': None,
+        'Y:': u'\\\\server\\share\\reference',
+        'Z:': u'\\\\server\\share\\production'
+        'K:': u'\\\\server\\share2\\junk'
+        'L:': u'\\\\server\\share\\library'
+        'W:': u'\\\\server\\share\\mango'
+    }
+
+    unc = to_unc('H:')
+    # Result: u'\\\\server\\share\\username'
+
+    drive = to_drive('\\\\server\\share\\username')
+    # Result: u'H:')
+
+"""
+import ctypes
+from ctypes import wintypes
+import os
+import string
+
+from rez.backport.lru_cache import lru_cache
+
+mpr = ctypes.WinDLL('mpr')
+
+ERROR_SUCCESS = 0x0000
+ERROR_MORE_DATA = 0x00EA
+
+wintypes.LPDWORD = ctypes.POINTER(wintypes.DWORD)
+mpr.WNetGetConnectionW.restype = wintypes.DWORD
+mpr.WNetGetConnectionW.argtypes = (
+    wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.LPDWORD
+)
+
+
+@lru_cache()
+def get_connections():
+    """Get all available drive mappings
+
+    Note: This function is cached, so it only runs once per session.
+
+    Returns:
+        dict: Drive mappings
+    """
+    available_drives = [
+        '%s:' % d for d in string.ascii_uppercase if os.path.exists('%s:' % d)
+    ]
+    return dict([d, _get_connection(d)] for d in available_drives)
+
+
+def to_drive(unc):
+    """Get drive letter from a UNC path
+
+    Args:
+        unc (str): UNC path
+
+    Returns:
+        str: Drive letter
+    """
+    connections = get_connections()
+    drive = next(iter(k for k, v in connections.items() if v == unc), None)
+    return drive
+
+
+def to_unc(drive):
+    """Get UNC path from a drive letter
+
+    Args:
+        drive (str): Drive letter
+
+    Returns:
+        str: UNC path
+    """
+    connections = get_connections()
+    unc = connections.get(drive, None)
+    return unc
+
+
+def _get_connection(local_name, verbose=None):
+    """Get full UNC path from a network drive letter if it exists
+
+    Args:
+        local_name (str): Drive letter name
+        verbose (bool): Print errors
+
+    Returns:
+        str: Full UNC path to connection
+    """
+    length = (wintypes.DWORD * 1)()
+    result = mpr.WNetGetConnectionW(local_name, None, length)
+    if result != ERROR_MORE_DATA:
+        if verbose:
+            print(ctypes.WinError(result))
+        return
+    remote_name = (wintypes.WCHAR * length[0])()
+    result = mpr.WNetGetConnectionW(local_name, remote_name, length)
+    if result != ERROR_SUCCESS:
+        if verbose:
+            print(ctypes.WinError(result))
+        return
+    return remote_name.value