+ BuildRequires: python3-filelock

+ Requires:   python3-filelock

+     def check_processed(self, delete_if_not=True):

+         already processed.  When 'delete_if_not=True, we delete the self.key

+         from Redis even if the task is not yet processed (meaning that caller

+         plans to finish the task right away).

+         status = self.redis.hget(self.key, "status") == "success"

+         self.log.debug("Has already a status? %s", status)

+ 

+         try:

+             if not status:

+                 # not yet processed

+                 return False

+         finally:

+             # This is atomic operation, other processes may not re-start doing this

+             # task again.  https://github.com/redis/redis/issues/9531

+             if status or delete_if_not:

+                 self.redis.delete(self.key)

+         return status

+ import filelock

+ class LockTimeout(OSError):

+     """ Raised for lock() timeout, if timeout= option is set to value >= 0 """

+ 

+ def lock(opts, timeout=-1):

+     lock_basename = opts.directory.replace("/", "_@_") + '.lock'

+     lock_filename = os.path.join(lock_path, lock_basename)

+     try:

+         with filelock.FileLock(lock_filename, timeout=timeout):

+             opts.log.debug("acquired lock")

+             yield

+     except filelock.Timeout as err:

+         opts.log.debug("lock timeouted")

+         raise LockTimeout("Timeouted on lock file: {}".format(lock_path)) from err

+     """

+     Main method, executed under lock.

+     """

+ def main_try_lock(opts, batch):

+     """

+     Periodically try to acquire the lock, and execute the main_locked() method.

+     """

+ 

+     while True:

+ 

+         # We don't have fair locking (locks-first => processes-first).  So to

+         # avoid potential indefinite waiting (see issue #1423) we check if the

+         # task isn't already processed _without_ having the lock.

+ 

+         if batch.check_processed(delete_if_not=False):

+             opts.log.info("Task processed by other process (no-lock)")

+             return

+ 

+         try:

+             with lock(opts, timeout=5):

+                 main_locked(opts, batch, opts.log)

+                 # skip commit if main_locked() raises exception

+                 batch.commit()

+                 # Unless there's an exception, the bash.commit() is done and we are

+                 # done.

+                 opts.log.debug("Metadata built by this process")

+                 break

+         except LockTimeout:

+             continue  # Try again...

+ 

+         # we never loop, only upon timeout

+         assert False

+ 

+ 

+         main_try_lock(opts, batch)

+             "Has already a status? False",

+ import time

+ 

+     @pytest.mark.parametrize('run_bg', [True, False])

+     @mock.patch.dict(os.environ, {'COPR_TESTSUITE_NO_OUTPUT': '1'})

+     def test_copr_repo_timeouted_check(self, f_second_build, run_bg):

+         _unused = self

+         ctx = f_second_build

+         chroot = ctx.chroots[0]

+         chrootdir = os.path.join(ctx.empty_dir, chroot)

+         repodata = os.path.join(chrootdir, 'repodata')

+ 

+         # empty repodata at the beginning

+         empty_repodata = load_primary_xml(repodata)

+         assert empty_repodata['names'] == set()

+ 

+         pid = os.fork()

+         if not pid:

+             # give parent some time to lock the repo

+             time.sleep(1)

+             # Run the blocked (by parent) createrepo, it must finish soon

+             # anway because parent will claim the task is done.

+             assert call_copr_repo(chrootdir, add=[ctx.builds[1]])

+             # sys.exit() can not be used in testsuite

+             os._exit(0)  # pylint: disable=protected-access

+ 

+         with _lock(chrootdir):

+             # give the child some time to fill its Redis keys

+             sleeper = 1

+             while True:

+                 if len(self.redis.keys()) > 0:

+                     break

+                 sleeper += 1

+                 time.sleep(0.1)

+                 assert sleeper < 10*15  # 15s

+ 

+             assert len(self.redis.keys()) == 1

+             key = self.redis.keys()[0]

+ 

+             # Claim we did that task (even if not) and check that the child

+             # finishes after some time.

+             if not run_bg:

+                 self.redis.hset(key, "status", "success")

+                 assert os.wait()[1] == 0

+                 assert self.redis.get(key) is None

+ 

+         if run_bg:

+             # actually process the background job!

+             assert os.wait()[1] == 0

+ 

+         repodata = load_primary_xml(repodata)

+         if run_bg:

+             assert repodata['names'] == {'example'}

+         else:

+             assert repodata['names'] == set()