mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-25 11:51:26 -07:00
bd072fe83a
* Revert "allow caller to deal with timeout (#49449)"
This reverts commit 63279823a7.
Flawed on many levels
* Adds poor API to a public function
* Papers over the fact that the public function is doing something bad
by catching exceptions it cannot handle in the first place
* Papers over the real cause of the issue which is a bug in the timeout
decorator
* Doesn't reraise properly
* Catches the wrong exception
Fixes #49824
Fixes #49817
* Make the timeout decorator properly raise an exception outside of the function's scope
signal handlers which raise exceptions will never work well because the
exception can be raised anywhere in the called code. This leads to
exception race conditions where the exceptions could end up being
hanlded by unintended pieces of the called code.
The timeout decorator was using just that idiom. It was especially bad
because the decorator syntactically occurs outside of the called code
but because of the signal handler, the exception was being raised inside
of the called code.
This change uses a thread instead of a signal to manage the timeout in
parallel to the execution of the decorated function. Since raising of
the exception happens inside of the decorator, now, instead of inside of
a signal handler, the timeout exception is raised from outside of the
called code as expected which makes reasoning about where exceptions are
to be expected intuitive again.
Fixes #43884
* Add a common case test.
Adding an integration test driven from our unittests. Most of the time
we'll timeout in run_command which is running things in a subprocess.
Create a test for that specific case in case anything funky comes up
between threading and execve.
* Don't use OSError-based TimeoutError as a base class
Unlike most standard exceptions, OSError has a specific parameter list
with specific meanings. Instead follow the example of other stdlib
functions, concurrent.futures and multiprocessing and define a separate
TimeoutException.
* Add comment and docstring to point out that this is not hte Python3 TimeoutError
68 lines
2.4 KiB
Python
68 lines
2.4 KiB
Python
# This file is part of Ansible
|
|
#
|
|
# Ansible is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ansible is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from __future__ import (absolute_import, division, print_function)
|
|
__metaclass__ = type
|
|
|
|
import multiprocessing
|
|
import multiprocessing.pool as mp
|
|
|
|
# timeout function to make sure some fact gathering
|
|
# steps do not exceed a time limit
|
|
|
|
GATHER_TIMEOUT = None
|
|
DEFAULT_GATHER_TIMEOUT = 10
|
|
|
|
|
|
class TimeoutError(Exception):
|
|
pass
|
|
|
|
|
|
def timeout(seconds=None, error_message="Timer expired"):
|
|
"""
|
|
Timeout decorator to expire after a set number of seconds. This raises an
|
|
ansible.module_utils.facts.TimeoutError if the timeout is hit before the
|
|
function completes.
|
|
"""
|
|
def decorator(func):
|
|
def wrapper(*args, **kwargs):
|
|
timeout_value = seconds
|
|
if timeout_value is None:
|
|
timeout_value = globals().get('GATHER_TIMEOUT') or DEFAULT_GATHER_TIMEOUT
|
|
|
|
pool = mp.ThreadPool(processes=1)
|
|
res = pool.apply_async(func, args, kwargs)
|
|
pool.close()
|
|
try:
|
|
return res.get(timeout_value)
|
|
except multiprocessing.TimeoutError:
|
|
# This is an ansible.module_utils.common.facts.timeout.TimeoutError
|
|
raise TimeoutError('Timer expired after %s seconds' % timeout_value)
|
|
|
|
return wrapper
|
|
|
|
# If we were called as @timeout, then the first parameter will be the
|
|
# function we are to wrap instead of the number of seconds. Detect this
|
|
# and correct it by setting seconds to our default value and return the
|
|
# inner decorator function manually wrapped around the function
|
|
if callable(seconds):
|
|
func = seconds
|
|
seconds = None
|
|
return decorator(func)
|
|
|
|
# If we were called as @timeout([...]) then python itself will take
|
|
# care of wrapping the inner decorator around the function
|
|
|
|
return decorator
|