def list_sessions(self):
repo = SessionStorageRepository()
storage = None
for storage in repo.get_storage_list():
if self.ns.only_ids:
print(storage.id)
continue
data = storage.load_checkpoint()
if len(data) > 0:
metadata = SessionPeekHelper().peek(data)
print(
_("session {0} app:{1}, flags:{2!r}, title:{3!r}").format(
storage.id, metadata.app_id, sorted(metadata.flags),
metadata.title))
else:
print(_("session {0} (not saved yet)").format(storage.id))
if not self.ns.only_ids and storage is None:
print(_("There are no stored sessions"))
def __init__(self, provider_list=None, repository_list=None):
"""
Initialize a new Explorer
:param provider_list:
List of providers that this explorer will know about.
Defaults to nothing (BYOP - bring your own providers)
:param repository_list:
List of session storage repositories. Defaults to the
single default repository.
"""
if provider_list is None:
provider_list = []
self.provider_list = provider_list
if repository_list is None:
repo = SessionStorageRepository()
repository_list = [repo]
self.repository_list = repository_list
def get_resume_candidates(self):
"""
Look at all of the suspended sessions and pick a list of candidates
that could be used to resume the session now.
"""
storage_list = []
for storage in SessionStorageRepository().get_storage_list():
data = storage.load_checkpoint()
if len(data) == 0:
continue
try:
metadata = SessionPeekHelper().peek(data)
except SessionResumeError as exc:
logger.warning(_("Corrupted session %s: %s"), storage.id, exc)
else:
if (metadata.app_id == self.expected_app_id
and metadata.title == self.expected_session_title
and SessionMetaData.FLAG_INCOMPLETE in metadata.flags):
storage_list.append(storage)
return storage_list
def run(self):
ns = self.ns
job_list = self.get_job_list(ns)
previous_session_file = SessionStorageRepository().get_last_storage()
resume_in_progress = False
if previous_session_file:
if self.is_interactive:
if self.ask_for_resume():
resume_in_progress = True
manager = SessionManager.load_session(
job_list, previous_session_file)
self._maybe_skip_last_job_after_resume(manager)
else:
resume_in_progress = True
manager = SessionManager.load_session(job_list,
previous_session_file)
if not resume_in_progress:
# Create a session that handles most of the stuff needed to run
# jobs
try:
manager = SessionManager.create_with_job_list(job_list,
legacy_mode=True)
except DependencyDuplicateError as exc:
# Handle possible DependencyDuplicateError that can happen if
# someone is using plainbox for job development.
print("The job database you are currently using is broken")
print("At least two jobs contend for the name {0}".format(
exc.job.id))
print("First job defined in: {0}".format(exc.job.origin))
print("Second job defined in: {0}".format(
exc.duplicate_job.origin))
raise SystemExit(exc)
manager.state.metadata.title = " ".join(sys.argv)
if self.is_interactive:
if self.display is None:
self.display = get_display()
if self.settings['welcome_text']:
self.display.run(ShowWelcome(
self.settings['welcome_text']))
if not self.whitelists:
whitelists = []
for p in self.provider_list:
if p.name in self.settings['default_providers']:
whitelists.extend(
[w.name for w in p.get_builtin_whitelists()])
selection = self.display.run(
ShowMenu("Suite selection", whitelists))
if not selection:
raise SystemExit('No whitelists selected, aborting...')
for s in selection:
self.whitelists.append(
get_whitelist_by_name(self.provider_list,
whitelists[s]))
else:
self.whitelists.append(
get_whitelist_by_name(self.provider_list,
self.settings['default_whitelist']))
manager.checkpoint()
if self.is_interactive and not resume_in_progress:
# Pre-run all local jobs
desired_job_list = select_jobs(manager.state.job_list, [
CompositeQualifier(self.whitelists +
[NonLocalJobQualifier(inclusive=False)])
])
self._update_desired_job_list(manager, desired_job_list)
# Ask the password before anything else in order to run local jobs
# requiring privileges
if self._auth_warmup_needed(manager):
print("[ Authentication ]".center(80, '='))
return_code = authenticate_warmup()
if return_code:
raise SystemExit(return_code)
self._local_only = True
self._run_jobs(ns, manager)
self._local_only = False
if not resume_in_progress:
# Run the rest of the desired jobs
desired_job_list = select_jobs(manager.state.job_list,
self.whitelists)
self._update_desired_job_list(manager, desired_job_list)
if self.is_interactive:
# Ask the password before anything else in order to run jobs
# requiring privileges
if self._auth_warmup_needed(manager):
print("[ Authentication ]".center(80, '='))
return_code = authenticate_warmup()
if return_code:
raise SystemExit(return_code)
tree = SelectableJobTreeNode.create_tree(
manager.state.run_list, legacy_mode=True)
title = 'Choose tests to run on your system:'
if self.display is None:
self.display = get_display()
self.display.run(ScrollableTreeNode(tree, title))
self._update_desired_job_list(manager, tree.selection)
estimated_duration_auto, estimated_duration_manual = \
manager.state.get_estimated_duration()
if estimated_duration_auto:
print(
"Estimated duration is {:.2f} "
"for automated jobs.".format(estimated_duration_auto))
else:
print("Estimated duration cannot be "
"determined for automated jobs.")
if estimated_duration_manual:
print("Estimated duration is {:.2f} "
"for manual jobs.".format(estimated_duration_manual))
else:
print("Estimated duration cannot be "
"determined for manual jobs.")
self._run_jobs(ns, manager)
manager.destroy()
# FIXME: sensible return value
return 0
def _lookup_storage(self, session_id):
repo = SessionStorageRepository()
for storage in repo.get_storage_list():
if storage.id == session_id:
return storage