portage._emirrordist.MirrorDistTask module¶
- class portage._emirrordist.MirrorDistTask.MirrorDistTask(config)¶
Bases:
_emerge.CompositeTask.CompositeTask
- _TASK_QUEUED = -1¶
- _assert_current(task)¶
Raises an AssertionError if the given task is not the same one as self._current_task. This can be useful for detecting bugs.
- _async_wait()¶
Override _async_wait to call self._cleanup().
- _cancel()¶
Subclasses should implement this, as a template method to be called by AsynchronousTask.cancel().
- _cancelled_returncode = -2¶
- _cleanup()¶
Cleanup any callbacks that have been registered with the global event loop.
- _config¶
- _current_task¶
- _default_exit(task)¶
Calls _assert_current() on the given task and then sets the composite returncode attribute if task.returncode != os.EX_OK. If the task failed then self._current_task will be set to None. Subclasses can use this as a generic task exit callback.
- Return type
int
- Returns
The task.returncode attribute.
- _default_final_exit(task)¶
This calls _final_exit() and then wait().
Subclasses can use this as a generic final task exit callback.
- _deletion_exit(deletion)¶
- _exit_listener_cb(listener)¶
- _exit_listener_handles¶
- _exit_listeners¶
- _fetch_exit(fetch)¶
- _fetch_iterator¶
- _final_exit(task)¶
Assumes that task is the final task of this composite task. Calls _default_exit() and sets self.returncode to the task’s returncode and sets self._current_task to None.
- _poll()¶
This does a loop calling self._current_task.poll() repeatedly as long as the value of self._current_task keeps changing. It calls poll() a maximum of one time for a given self._current_task instance. This is useful since calling poll() on a task can trigger advance to the next task could eventually lead to the returncode being set in cases when polling only a single task would not have the same effect.
- _post_deletion()¶
- _scheduled_deletion_log()¶
- _start()¶
- _start_hook()¶
- _start_listeners¶
- _start_task(task, exit_handler)¶
Register exit handler for the given task, set it as self._current_task, and call task.start().
Subclasses can use this as a generic way to start a task.
- _summary()¶
- _task_queued(task)¶
- _task_queued_start_handler(task)¶
- _task_queued_wait()¶
- _term_callback()¶
- _term_callback_handle¶
- _term_rlock¶
- _update_recycle_db()¶
- _wait_hook()¶
Call this method after the task completes, just before returning the returncode from wait() or poll(). This hook is used to trigger exit listeners when the returncode first becomes available.
- _was_cancelled()¶
If cancelled, set returncode if necessary and return True. Otherwise, return False.
- addExitListener(f)¶
The function will be called with one argument, a reference to self.
- addStartListener(f)¶
The function will be called with one argument, a reference to self.
- async_wait()¶
Wait for returncode asynchronously. Notification is available via the add_done_callback method of the returned Future instance.
- Returns
Future, result is self.returncode
- background¶
- cancel()¶
Cancel the task, but do not wait for exit status. If asynchronous exit notification is desired, then use addExitListener to add a listener before calling this method. NOTE: Synchronous waiting for status is not supported, since it would be vulnerable to hitting the recursion limit when a large number of tasks need to be terminated simultaneously, like in bug #402335.
- cancelled¶
- copy()¶
Create a new instance and copy all attributes defined from __slots__ (including those from inherited classes).
- isAlive()¶
- poll()¶
- removeExitListener(f)¶
- removeStartListener(f)¶
- returncode¶
- scheduler¶
- start()¶
Start an asynchronous task and then return as soon as possible.
- terminate()¶
- wait()¶
Wait for the returncode attribute to become ready, and return it. If the returncode is not ready and the event loop is already running, then the async_wait() method should be used instead of wait(), because wait() will raise asyncio.InvalidStateError in this case.
- Return type
int
- Returns
the value of self.returncode