Python Examples of oslo_utils.timeutils.StopWatch

Source File: loopingcall.py From oslo.service with Apache License 2.0

6 votes

def _start(self, idle_for, initial_delay=None, stop_on_exception=True):
        """Start the looping

        :param idle_for: Callable that takes two positional arguments, returns
                         how long to idle for. The first positional argument is
                         the last result from the function being looped and the
                         second positional argument is the time it took to
                         calculate that result.
        :param initial_delay: How long to delay before starting the looping.
                              Value is in seconds.
        :param stop_on_exception: Whether to stop if an exception occurs.
        :returns: eventlet event instance
        """
        if self._thread is not None:
            raise RuntimeError(self._RUN_ONLY_ONE_MESSAGE)
        self.done = event.Event()
        self._abort.clear()
        self._thread = greenthread.spawn(
            self._run_loop, idle_for,
            initial_delay=initial_delay, stop_on_exception=stop_on_exception)
        self._thread.link(self._on_done)
        return self.done

    # NOTE(bnemec): This is just a wrapper function we can mock so we aren't
    # affected by other users of the StopWatch class.

Source File: health_manager.py From senlin with Apache License 2.0

6 votes

def _wait_for_action(self, ctx, action_id, timeout):
        req = objects.ActionGetRequest(identity=action_id)
        action = {}
        with timeutils.StopWatch(timeout) as timeout_watch:
            while not timeout_watch.expired():
                action = self.rpc_client.call(ctx, 'action_get', req)
                if action['status'] in [consts.ACTION_SUCCEEDED,
                                        consts.ACTION_FAILED,
                                        consts.ACTION_CANCELLED]:
                    break
                eventlet.sleep(2)

        if not action:
            return False, "Failed to retrieve action."

        elif action['status'] == consts.ACTION_SUCCEEDED:
            return True, ""

        elif (action['status'] == consts.ACTION_FAILED or
              action['status'] == consts.ACTION_CANCELLED):
            return False, "Cluster check action failed or cancelled"

        return False, ("Timeout while waiting for node recovery action to "
                       "finish")

Source File: impl_zookeeper.py From taskflow with Apache License 2.0

6 votes

def wait(self, timeout=None):
        # Wait until timeout expires (or forever) for jobs to appear.
        watch = timeutils.StopWatch(duration=timeout)
        watch.start()
        with self._job_cond:
            while True:
                if not self._known_jobs:
                    if watch.expired():
                        raise excp.NotFound("Expired waiting for jobs to"
                                            " arrive; waited %s seconds"
                                            % watch.elapsed())
                    # This is done since the given timeout can not be provided
                    # to the condition variable, since we can not ensure that
                    # when we acquire the condition that there will actually
                    # be jobs (especially if we are spuriously awaken), so we
                    # must recalculate the amount of time we really have left.
                    self._job_cond.wait(watch.leftover(return_none=True))
                else:
                    curr_jobs = self._fetch_jobs()
                    fetch_func = lambda ensure_fresh: curr_jobs
                    removal_func = lambda a_job: self._remove_job(a_job.path)
                    return base.JobBoardIterator(
                        self, LOG, board_fetch_func=fetch_func,
                        board_removal_func=removal_func)

Source File: latch.py From taskflow with Apache License 2.0

6 votes

def wait(self, timeout=None):
        """Waits until the latch is released.

        :param timeout: wait until the timeout expires
        :type timeout: number
        :returns: true if the latch has been released before the
                  timeout expires otherwise false
        :rtype: boolean
        """
        watch = timeutils.StopWatch(duration=timeout)
        watch.start()
        with self._cond:
            while self._count > 0:
                if watch.expired():
                    return False
                else:
                    self._cond.wait(watch.leftover(return_none=True))
            return True

Source File: protocol.py From taskflow with Apache License 2.0

6 votes

def __init__(self, task, uuid, action,
                 arguments, timeout=REQUEST_TIMEOUT, result=NO_RESULT,
                 failures=None):
        self._action = action
        self._event = ACTION_TO_EVENT[action]
        self._arguments = arguments
        self._result = result
        self._failures = failures
        self._watch = timeutils.StopWatch(duration=timeout).start()
        self._lock = threading.Lock()
        self._machine = build_a_machine()
        self._machine.initialize()
        self.task = task
        self.uuid = uuid
        self.created_on = timeutils.now()
        self.future = futurist.Future()
        self.future.atom = task

Source File: types.py From taskflow with Apache License 2.0

6 votes

def wait_for_workers(self, workers=1, timeout=None):
        """Waits for geq workers to notify they are ready to do work.

        NOTE(harlowja): if a timeout is provided this function will wait
        until that timeout expires, if the amount of workers does not reach
        the desired amount of workers before the timeout expires then this will
        return how many workers are still needed, otherwise it will
        return zero.
        """
        if workers <= 0:
            raise ValueError("Worker amount must be greater than zero")
        watch = timeutils.StopWatch(duration=timeout)
        watch.start()
        with self._cond:
            while self.total_workers < workers:
                if watch.expired():
                    return max(0, workers - self.total_workers)
                self._cond.wait(watch.leftover(return_none=True))
            return 0