Revert "Use locking for concurrent file access (#52567)" (#54547)

This reverts commit e152b277cf.

lib/ansible/module_utils/common/file.py

@@ -1,21 +1,24 @@
-# -*- coding: utf-8 -*-
-
-# Copyright: (c) 2018, Ansible Project
+# Copyright (c) 2018, Ansible Project
 # Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)
 
 from __future__ import (absolute_import, division, print_function)
 __metaclass__ = type
 
-import fcntl
+import errno
 import os
-import re
 import stat
-import sys
+import re
+import pwd
+import grp
 import time
+import shutil
+import traceback
+import fcntl
+import sys
 
 from contextlib import contextmanager
-from ansible.module_utils._text import to_bytes
-from ansible.module_utils.six import PY3
+from ansible.module_utils._text import to_bytes, to_native, to_text
+from ansible.module_utils.six import b, binary_type
 
 try:
     import selinux
@@ -59,13 +62,6 @@ _EXEC_PERM_BITS = 0o0111     # execute permission bits
 _DEFAULT_PERM = 0o0666       # default file permission bits
 
 
-# Ensure we use flock on e.g. FreeBSD, MacOSX and Solaris
-if sys.platform.startswith('linux'):
-    filelock = fcntl.lockf
-else:
-    filelock = fcntl.flock
-
-
 def is_executable(path):
     # This function's signature needs to be repeated
     # as the first line of its docstring.
@@ -118,88 +114,89 @@ class LockTimeout(Exception):
     pass
 
 
-# NOTE: Using the open_locked() context manager it is absolutely mandatory
-#       to not open or close the same file within the existing context.
-#       It is essential to reuse the returned file descriptor only.
-@contextmanager
-def open_locked(path, check_mode=False, lock_timeout=15):
+class FileLock:
     '''
-    Context managed for opening files with lock acquisition
-
-    :kw path: Path (file) to lock
-    :kw lock_timeout:
-        Wait n seconds for lock acquisition, fail if timeout is reached.
-        0 = Do not wait, fail if lock cannot be acquired immediately,
-        Less than 0 or None = wait indefinitely until lock is released
-        Default is wait 15s.
-    :returns: file descriptor
+    Currently FileLock is implemented via fcntl.flock on a lock file, however this
+    behaviour may change in the future. Avoid mixing lock types fcntl.flock,
+    fcntl.lockf and module_utils.common.file.FileLock as it will certainly cause
+    unwanted and/or unexpected behaviour
     '''
-    if check_mode:
-        b_path = to_bytes(path, errors='surrogate_or_strict')
-        fd = open(b_path, 'ab+')
-        fd.seek(0)  # Due to a difference in behavior between PY2 and PY3 we need to seek(0) on PY3
-    else:
-        fd = lock(path, check_mode, lock_timeout)
-    yield fd
-    fd.close()
+    def __init__(self):
+        self.lockfd = None
 
+    @contextmanager
+    def lock_file(self, path, tmpdir, lock_timeout=None):
+        '''
+        Context for lock acquisition
+        '''
+        try:
+            self.set_lock(path, tmpdir, lock_timeout)
+            yield
+        finally:
+            self.unlock()
 
-def lock(path, check_mode=False, lock_timeout=15):
-    '''
-    Set lock on given path via fcntl.flock(), note that using
-    locks does not guarantee exclusiveness unless all accessing
-    processes honor locks.
+    def set_lock(self, path, tmpdir, lock_timeout=None):
+        '''
+        Create a lock file based on path with flock to prevent other processes
+        using given path.
+        Please note that currently file locking only works when it's executed by
+        the same user, I.E single user scenarios
 
-    :kw path: Path (file) to lock
-    :kw lock_timeout:
-        Wait n seconds for lock acquisition, fail if timeout is reached.
-        0 = Do not wait, fail if lock cannot be acquired immediately,
-        Less than 0 or None = wait indefinitely until lock is released
-        Default is wait 15s.
-    :returns: file descriptor
-    '''
-    b_path = to_bytes(path, errors='surrogate_or_strict')
-    wait = 0.1
+        :kw path: Path (file) to lock
+        :kw tmpdir: Path where to place the temporary .lock file
+        :kw lock_timeout:
+            Wait n seconds for lock acquisition, fail if timeout is reached.
+            0 = Do not wait, fail if lock cannot be acquired immediately,
+            Default is None, wait indefinitely until lock is released.
+        :returns: True
+        '''
+        lock_path = os.path.join(tmpdir, 'ansible-{0}.lock'.format(os.path.basename(path)))
+        l_wait = 0.1
+        r_exception = IOError
+        if sys.version_info[0] == 3:
+            r_exception = BlockingIOError
 
-    lock_exception = IOError
-    if PY3:
-        lock_exception = OSError
+        self.lockfd = open(lock_path, 'w')
 
-    if not os.path.exists(b_path):
-        raise IOError('{0} does not exist'.format(path))
+        if lock_timeout <= 0:
+            fcntl.flock(self.lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            os.chmod(lock_path, stat.S_IWRITE | stat.S_IREAD)
+            return True
 
-    if lock_timeout is None or lock_timeout < 0:
-        fd = open(b_path, 'ab+')
-        fd.seek(0)  # Due to a difference in behavior between PY2 and PY3 we need to seek(0) on PY3
-        filelock(fd, fcntl.LOCK_EX)
-        return fd
+        if lock_timeout:
+            e_secs = 0
+            while e_secs < lock_timeout:
+                try:
+                    fcntl.flock(self.lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    os.chmod(lock_path, stat.S_IWRITE | stat.S_IREAD)
+                    return True
+                except r_exception:
+                    time.sleep(l_wait)
+                    e_secs += l_wait
+                    continue
 
-    if lock_timeout >= 0:
-        total_wait = 0
-        while total_wait <= lock_timeout:
-            fd = open(b_path, 'ab+')
-            fd.seek(0)  # Due to a difference in behavior between PY2 and PY3 we need to seek(0) on PY3
-            try:
-                filelock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                return fd
-            except lock_exception:
-                fd.close()
-                time.sleep(wait)
-                total_wait += wait
-                continue
+            self.lockfd.close()
+            raise LockTimeout('{0} sec'.format(lock_timeout))
 
-        fd.close()
-        raise LockTimeout('Waited {0} seconds for lock on {1}'.format(total_wait, path))
+        fcntl.flock(self.lockfd, fcntl.LOCK_EX)
+        os.chmod(lock_path, stat.S_IWRITE | stat.S_IREAD)
 
+        return True
 
-def unlock(fd):
-    '''
-    Make sure lock file is available for everyone and Unlock the file descriptor
-    locked by set_lock
+    def unlock(self):
+        '''
+        Make sure lock file is available for everyone and Unlock the file descriptor
+        locked by set_lock
 
-    :kw fd: File descriptor of file to unlock
-    '''
-    try:
-        filelock(fd, fcntl.LOCK_UN)
-    except ValueError:  # File was not opened, let context manager fail gracefully
-        pass
+        :returns: True
+        '''
+        if not self.lockfd:
+            return True
+
+        try:
+            fcntl.flock(self.lockfd, fcntl.LOCK_UN)
+            self.lockfd.close()
+        except ValueError:  # file wasn't opened, let context manager fail gracefully
+            pass
+
+        return True