in src/buildstream/_frontend/app.py [0:0]
def initialized(self, *, session_name=None):
directory = self._main_options["directory"]
config = self._main_options["config"]
self._session_name = session_name
# Instantiate Context
with Context() as context:
self.context = context
#
# Load the configuration
#
try:
self.context.load(config)
except BstError as e:
self._error_exit(e, "Error loading user configuration")
# Override things in the context from our command line options,
# the command line when used, trumps the config files.
#
override_map = {
"strict": "_strict_build_plan",
"debug": "log_debug",
"verbose": "log_verbose",
"error_lines": "log_error_lines",
"message_lines": "log_message_lines",
"on_error": "sched_error_action",
"fetchers": "sched_fetchers",
"builders": "sched_builders",
"pushers": "sched_pushers",
"max_jobs": "build_max_jobs",
"network_retries": "sched_network_retries",
"pull_buildtrees": "pull_buildtrees",
"cache_buildtrees": "cache_buildtrees",
}
for cli_option, context_attr in override_map.items():
option_value = self._main_options.get(cli_option)
if option_value is not None:
setattr(self.context, context_attr, option_value)
try:
self.context.platform
except BstError as e:
self._error_exit(e, "Error instantiating platform")
# Create the stream right away, we'll need to pass it around.
self.stream = Stream(
self.context,
self._session_start,
session_start_callback=self.session_start_cb,
interrupt_callback=self._interrupt_handler,
ticker_callback=self._render_cached_messages,
)
self._state = self.stream.get_state()
# Register callbacks with the State
self._state.register_task_failed_callback(self._job_failed)
# Create the logger right before setting the message handler
self.logger = LogLine(
self.context,
self._state,
self._content_profile,
self._format_profile,
self._success_profile,
self._error_profile,
self._detail_profile,
indent=INDENT,
)
# Propagate pipeline feedback to the user
self.context.messenger.set_message_handler(self._message_handler)
# Check if throttling frontend updates to tick rate
self._cache_messages = self.context.log_throttle_updates
# Allow the Messenger to write status messages
self.context.messenger.set_render_status_cb(self._render_status)
# Preflight the artifact cache after initializing logging,
# this can cause messages to be emitted.
try:
self.context.artifactcache.preflight()
except BstError as e:
self._error_exit(e, "Error instantiating artifact cache")
# Now that we have a logger and message handler,
# we can override the global exception hook.
sys.excepthook = self._global_exception_handler
# Initialize the parts of Stream that have side-effects
self.stream.init()
# Create our status printer, only available in interactive
self._status = Status(
self.context,
self._state,
self._content_profile,
self._format_profile,
self._success_profile,
self._error_profile,
self.stream,
)
# Mark the beginning of the session
if session_name:
self._message(MessageType.START, session_name)
#
# Load the Project
#
try:
self.project = Project(
directory,
self.context,
cli_options=self._main_options["option"],
default_mirror=self._main_options.get("default_mirror"),
fetch_subprojects=self.stream.fetch_subprojects,
)
except LoadError as e:
# If there was no project.conf at all then there was just no project found.
#
# Don't error out in this case, as Stream() supports some operations which
# do not require a project. If Stream() requires a project and it is missing,
# then it will raise an error.
#
if e.reason != LoadErrorReason.MISSING_PROJECT_CONF:
self._error_exit(e, "Error loading project")
except BstError as e:
self._error_exit(e, "Error loading project")
# Set the project on the Stream, this can be None if there is no project.
#
self.stream.set_project(self.project)
# Run the body of the session here, once everything is loaded
try:
yield
except BstError as e:
# Check that any cached messages are printed
self._render_cached_messages()
# Print a nice summary if this is a session
if session_name:
elapsed = self._state.elapsed_time()
if isinstance(e, StreamError) and e.terminated: # pylint: disable=no-member
self._message(MessageType.WARN, session_name + " Terminated", elapsed=elapsed)
else:
self._message(MessageType.FAIL, session_name, elapsed=elapsed)
# Notify session failure
self._notify("{} failed".format(session_name), e)
if self._started:
self._print_summary()
# Exit with the error
self._error_exit(e)
except RecursionError:
# Check that any cached messages are printed
self._render_cached_messages()
click.echo(
"RecursionError: Dependency depth is too large. Maximum recursion depth exceeded.", err=True
)
sys.exit(-1)
else:
# Check that any cached messages are printed
self._render_cached_messages()
# No exceptions occurred, print session time and summary
if session_name:
self._message(MessageType.SUCCESS, session_name, elapsed=self._state.elapsed_time())
if self._started:
self._print_summary()
# Notify session success
self._notify("{} succeeded".format(session_name), "")