Bug 1943382 - Obsolete mozbuild.lock in favor of filelock r=glandium,geckoview-reviewers,calu

Differential Revision: https://phabricator.services.mozilla.com/D235335

config/MozZipFile.py

@@ -7,7 +7,7 @@ import time
 import zipfile
 
 import six
-from mozbuild.lock import lock_file
+from filelock import SoftFileLock
 
 
 class ZipFile(zipfile.ZipFile):
@@ -20,7 +20,8 @@ class ZipFile(zipfile.ZipFile):
     def __init__(self, file, mode="r", compression=zipfile.ZIP_STORED, lock=False):
         if lock:
             assert isinstance(file, six.text_type)
-            self.lockfile = lock_file(file + ".lck")
+            self.lockfile = SoftFileLock(file + ".lck")
+            self.lockfile.acquire()
         else:
             self.lockfile = None
 
@@ -105,7 +106,9 @@ class ZipFile(zipfile.ZipFile):
         if not self._remove:
             # we don't have anything special to do, let's just call base
             r = zipfile.ZipFile.close(self)
-            self.lockfile = None
+            if self.lockfile is not None:
+                self.lockfile.release()
+                self.lockfile = None
             return r
 
         if self.fp.mode != "r+b":
@@ -140,4 +143,6 @@ class ZipFile(zipfile.ZipFile):
             to_pos += length
         self.fp.truncate()
         zipfile.ZipFile.close(self)
-        self.lockfile = None
+        if self.lockfile is not None:
+            self.lockfile.release()
+            self.lockfile = None

mobile/android/gradle.py

@@ -9,8 +9,8 @@ import time
 from contextlib import contextmanager
 
 import mozpack.path as mozpath
+from filelock import SoftFileLock
 from mozbuild.dirutils import ensureParentDir
-from mozbuild.lock import lock_file
 
 
 @contextmanager
@@ -20,12 +20,8 @@ def gradle_lock(topobjdir, max_wait_seconds=600):
     # steps.
     lock_path = "{}/gradle/mach_android.lockfile".format(topobjdir)
     ensureParentDir(lock_path)
-    lock_instance = lock_file(lock_path, max_wait=max_wait_seconds)
-
-    try:
+    with SoftFileLock(lock_path, timeout=max_wait_seconds):
         yield
-    finally:
-        del lock_instance
 
 
 def android(verb, *args):

python/mozbuild/mozbuild/lock.py

@@ -1,99 +0,0 @@
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this file,
-# You can obtain one at http://mozilla.org/MPL/2.0/.
-
-# This file contains miscellaneous utility functions that don't belong anywhere
-# in particular.
-
-import errno
-import os
-import stat
-import sys
-import time
-
-
-class LockFile(object):
-    """LockFile is used by the lock_file method to hold the lock.
-
-    This object should not be used directly, but only through
-    the lock_file method below.
-    """
-
-    def __init__(self, lockfile):
-        self.lockfile = lockfile
-
-    def __del__(self):
-        while True:
-            try:
-                os.remove(self.lockfile)
-                break
-            except OSError as e:
-                if e.errno == errno.EACCES:
-                    # Another process probably has the file open, we'll retry.
-                    # Just a short sleep since we want to drop the lock ASAP
-                    # (but we need to let some other process close the file
-                    # first).
-                    time.sleep(0.1)
-                else:
-                    # Re-raise unknown errors
-                    raise
-
-
-def lock_file(lockfile, max_wait=600):
-    """Create and hold a lockfile of the given name, with the given timeout.
-
-    To release the lock, delete the returned object.
-    """
-
-    # FUTURE This function and object could be written as a context manager.
-
-    while True:
-        try:
-            fd = os.open(lockfile, os.O_EXCL | os.O_RDWR | os.O_CREAT)
-            # We created the lockfile, so we're the owner
-            break
-        except OSError as e:
-            if e.errno == errno.EEXIST or (
-                sys.platform == "win32" and e.errno == errno.EACCES
-            ):
-                pass
-            else:
-                # Should not occur
-                raise
-
-        try:
-            # The lock file exists, try to stat it to get its age
-            # and read its contents to report the owner PID
-            f = open(lockfile, "r")
-            s = os.stat(lockfile)
-        except EnvironmentError as e:
-            if e.errno == errno.ENOENT or e.errno == errno.EACCES:
-                # We didn't create the lockfile, so it did exist, but it's
-                # gone now. Just try again
-                continue
-
-            raise Exception(
-                "{0} exists but stat() failed: {1}".format(lockfile, e.strerror)
-            )
-
-        # We didn't create the lockfile and it's still there, check
-        # its age
-        now = int(time.time())
-        if now - s[stat.ST_MTIME] > max_wait:
-            pid = f.readline().rstrip()
-            raise Exception(
-                "{0} has been locked for more than "
-                "{1} seconds (PID {2})".format(lockfile, max_wait, pid)
-            )
-
-        # It's not been locked too long, wait a while and retry
-        f.close()
-        time.sleep(1)
-
-    # if we get here. we have the lockfile. Convert the os.open file
-    # descriptor into a Python file object and record our PID in it
-    f = os.fdopen(fd, "w")
-    f.write("{0}\n".format(os.getpid()))
-    f.close()
-
-    return LockFile(lockfile)