__init__.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import time
 
from robot.utils import Sortable, secs_to_timestr, timestr_to_secs, WINDOWS
from robot.errors import TimeoutError, DataError, FrameworkError
 
if WINDOWS:
    from .windows import Timeout
else:
    from .posix import Timeout
 
 
class _Timeout(Sortable):
 
    def __init__(self, timeout=None, variables=None):
        self.stringstring = timeout or ''
        self.secssecs = -1
        self.starttimestarttime = -1
        self.errorerror = None
        if variables:
            self.replace_variablesreplace_variables(variables)
 
    @property
    active = property
    
    def active(self):
        return self.starttimestarttime > 0
 
    def replace_variables(self, variables):
        try:
            self.stringstring = variables.replace_string(self.stringstring)
            if not self:
                return
            self.secssecs = timestr_to_secs(self.stringstring)
            self.stringstring = secs_to_timestr(self.secssecs)
        except (DataError, ValueError) as err:
            self.secssecs = 0.000001  # to make timeout active
            self.errorerror = ('Setting %s timeout failed: %s' % (self.type.lower(), err))
 
    def start(self):
        if self.secssecs > 0:
            self.starttimestarttime = time.time()
 
    def time_left(self):
        if not self.activeactiveactive:
            return -1
        elapsed = time.time() - self.starttimestarttime
        # Timeout granularity is 1ms. Without rounding some timeout tests fail
        # intermittently on Windows, probably due to threading.Event.wait().
        return round(self.secssecs - elapsed, 3)
 
    def timed_out(self):
        return self.activeactiveactive and self.time_lefttime_left() <= 0
 
    def run(self, runnable, args=None, kwargs=None):
        if self.errorerror:
            raise DataError(self.errorerror)
        if not self.activeactiveactive:
            raise FrameworkError('Timeout is not active')
        timeout = self.time_lefttime_left()
        error = TimeoutError(self._timeout_error_timeout_error_timeout_error,
                             test_timeout=isinstance(self, TestTimeout))
        if timeout <= 0:
            raise error
        executable = lambda: runnable(*(args or ()), **(kwargs or {}))
        return Timeout(timeout, error).execute(executable)
 
    def get_message(self):
        if not self.activeactiveactive:
            return '%s timeout not active.' % self.type
        if not self.timed_outtimed_out():
            return '%s timeout %s active. %s seconds left.' \
                % (self.type, self.stringstring, self.time_lefttime_left())
        return self._timeout_error_timeout_error_timeout_error
 
    @property
    _timeout_error = property
    
    def _timeout_error(self):
        return '%s timeout %s exceeded.' % (self.type, self.stringstring)
 
    def __str__(self):
        return self.stringstring
 
    def __bool__(self):
        return bool(self.stringstring and self.stringstring.upper() != 'NONE')
 
    @property
    _sort_key = property
    
    def _sort_key(self):
        return not self.activeactiveactive, self.time_lefttime_left()
 
    def __eq__(self, other):
        return self is other
 
    def __hash__(self):
        return id(self)
 
 
class TestTimeout(_Timeout):
    type = 'Test'
    
    _keyword_timeout_occurred = False
 
    def __init__(self, timeout=None, variables=None, rpa=False):
        if rpa:
            self.typetypetype = 'Task'
        _Timeout.__init__(self, timeout, variables)
 
    def set_keyword_timeout(self, timeout_occurred):
        if timeout_occurred:
            self._keyword_timeout_occurred_keyword_timeout_occurred_keyword_timeout_occurred = True
 
    def any_timeout_occurred(self):
        return self.timed_outtimed_out() or self._keyword_timeout_occurred_keyword_timeout_occurred_keyword_timeout_occurred
 
 
class KeywordTimeout(_Timeout):
    type = 'Keyword'