class ProgressController(SubiquityTuiController):
def __init__(self, app):
super().__init__(app)
self.progress_view = ProgressView(self)
self.app_state = None
self.crash_report_ref = None
self.answers = app.answers.get("InstallProgress", {})
def event(self, event):
if event["SUBIQUITY_EVENT_TYPE"] == "start":
self.progress_view.event_start(
event["SUBIQUITY_CONTEXT_ID"],
event.get("SUBIQUITY_CONTEXT_PARENT_ID"),
event["MESSAGE"])
elif event["SUBIQUITY_EVENT_TYPE"] == "finish":
self.progress_view.event_finish(
event["SUBIQUITY_CONTEXT_ID"])
def log_line(self, event):
log_line = event['MESSAGE']
self.progress_view.add_log_line(log_line)
def cancel(self):
pass
def start(self):
self.app.aio_loop.create_task(self._wait_status())
def click_reboot(self):
self.app.aio_loop.create_task(self.send_reboot_and_wait())
async def send_reboot_and_wait(self):
try:
await self.app.client.reboot.POST()
except aiohttp.ClientError:
pass
self.app.exit()
@with_context()
async def _wait_status(self, context):
install_running = None
while True:
try:
app_status = await self.app.client.meta.status.GET(
cur=self.app_state)
except aiohttp.ClientError:
await asyncio.sleep(1)
continue
self.app_state = app_status.state
self.progress_view.update_for_state(self.app_state)
if self.ui.body is self.progress_view:
self.ui.set_header(self.progress_view.title)
if app_status.error is not None:
if self.crash_report_ref is None:
self.crash_report_ref = app_status.error
self.ui.set_body(self.progress_view)
self.app.show_error_report(self.crash_report_ref)
if self.app_state == ApplicationState.NEEDS_CONFIRMATION:
if self.showing:
self.app.show_confirm_install()
if self.app_state == ApplicationState.RUNNING:
if app_status.confirming_tty != self.app.our_tty:
install_running = InstallRunning(
self.app, app_status.confirming_tty)
self.app.add_global_overlay(install_running)
else:
if install_running is not None:
self.app.remove_global_overlay(install_running)
install_running = None
if self.app_state == ApplicationState.DONE:
if self.answers.get('reboot', False):
self.click_reboot()
def make_ui(self):
if self.app_state == ApplicationState.NEEDS_CONFIRMATION:
self.app.show_confirm_install()
return self.progress_view
def run_answers(self):
pass
class InstallProgressController(SubiquityTuiController):
def __init__(self, app):
super().__init__(app)
self.model = app.base_model
self.progress_view = ProgressView(self)
self.crash_report_ref = None
self._install_state = InstallState.NOT_STARTED
self.reboot_clicked = asyncio.Event()
if self.answers.get('reboot', False):
self.reboot_clicked.set()
self.unattended_upgrades_proc = None
self.unattended_upgrades_ctx = None
self._event_syslog_id = 'curtin_event.%s' % (os.getpid(), )
self.tb_extractor = TracebackExtractor()
self.curtin_event_contexts = {}
def event(self, event):
if event["SUBIQUITY_EVENT_TYPE"] == "start":
self.progress_view.event_start(
event["SUBIQUITY_CONTEXT_ID"],
event.get("SUBIQUITY_CONTEXT_PARENT_ID"), event["MESSAGE"])
elif event["SUBIQUITY_EVENT_TYPE"] == "finish":
self.progress_view.event_finish(event["SUBIQUITY_CONTEXT_ID"])
def log_line(self, event):
log_line = event['MESSAGE']
self.progress_view.add_log_line(log_line)
def interactive(self):
return self.app.interactive()
def start(self):
self.install_task = schedule_task(self.install())
@with_context()
async def apply_autoinstall_config(self, context):
await self.install_task
self.app.reboot_on_exit = True
@property
def install_state(self):
return self._install_state
def update_state(self, state):
self._install_state = state
self.progress_view.update_for_state(state)
def tpath(self, *path):
return os.path.join(self.model.target, *path)
def curtin_error(self):
kw = {}
if sys.exc_info()[0] is not None:
log.exception("curtin_error")
self.progress_view.add_log_line(traceback.format_exc())
if self.tb_extractor.traceback:
kw["Traceback"] = "\n".join(self.tb_extractor.traceback)
crash_report = self.app.make_apport_report(
ErrorReportKind.INSTALL_FAIL,
"install failed",
interrupt=False,
**kw)
if crash_report is not None:
self.crash_report_ref = crash_report.ref()
self.progress_view.finish_all()
self.progress_view.set_status(
('info_error', _("An error has occurred")))
if not self.showing:
self.app.controllers.index = self.controller_index - 1
self.app.next_screen()
self.update_state(InstallState.ERROR)
if self.crash_report_ref is not None:
self.app.show_error_report(self.crash_report_ref)
def logged_command(self, cmd):
return [
'systemd-cat', '--level-prefix=false',
'--identifier=' + self.app.log_syslog_id
] + cmd
def log_event(self, event):
self.curtin_log(event)
def curtin_event(self, event):
e = {
"EVENT_TYPE": "???",
"MESSAGE": "???",
"NAME": "???",
"RESULT": "???",
}
prefix = "CURTIN_"
for k, v in event.items():
if k.startswith(prefix):
e[k[len(prefix):]] = v
event_type = e["EVENT_TYPE"]
if event_type == 'start':
def p(name):
parts = name.split('/')
for i in range(len(parts), -1, -1):
yield '/'.join(parts[:i]), '/'.join(parts[i:])
curtin_ctx = None
for pre, post in p(e["NAME"]):
if pre in self.curtin_event_contexts:
parent = self.curtin_event_contexts[pre]
curtin_ctx = parent.child(post, e["MESSAGE"])
self.curtin_event_contexts[e["NAME"]] = curtin_ctx
break
if curtin_ctx:
curtin_ctx.enter()
if event_type == 'finish':
status = getattr(Status, e["RESULT"], Status.WARN)
curtin_ctx = self.curtin_event_contexts.pop(e["NAME"], None)
if curtin_ctx is not None:
curtin_ctx.exit(result=status)
def curtin_log(self, event):
self.tb_extractor.feed(event['MESSAGE'])
def _write_config(self, path, config):
with open(path, 'w') as conf:
datestr = '# Autogenerated by SUbiquity: {} UTC\n'.format(
str(datetime.datetime.utcnow()))
conf.write(datestr)
conf.write(yaml.dump(config))
def _get_curtin_command(self):
config_file_name = 'subiquity-curtin-install.conf'
if self.opts.dry_run:
config_location = os.path.join('.subiquity/', config_file_name)
log_location = '.subiquity/install.log'
event_file = "examples/curtin-events.json"
if 'install-fail' in self.app.debug_flags:
event_file = "examples/curtin-events-fail.json"
curtin_cmd = [
"python3",
"scripts/replay-curtin-log.py",
event_file,
self._event_syslog_id,
log_location,
]
else:
config_location = os.path.join('/var/log/installer',
config_file_name)
curtin_cmd = [
sys.executable, '-m', 'curtin', '--showtrace', '-c',
config_location, 'install'
]
log_location = INSTALL_LOG
self._write_config(
config_location,
self.model.render(syslog_identifier=self._event_syslog_id))
self.app.note_file_for_apport("CurtinConfig", config_location)
self.app.note_file_for_apport("CurtinLog", log_location)
self.app.note_file_for_apport("CurtinErrors", ERROR_TARFILE)
return curtin_cmd
@with_context(description="umounting /target dir")
async def unmount_target(self, *, context, target):
cmd = [
sys.executable,
'-m',
'curtin',
'unmount',
'-t',
target,
]
if self.opts.dry_run:
cmd = ['sleep', str(0.2 / self.app.scale_factor)]
await arun_command(cmd)
if not self.opts.dry_run:
shutil.rmtree(target)
@with_context(description="installing system",
level="INFO",
childlevel="DEBUG")
async def curtin_install(self, *, context):
log.debug('curtin_install')
self.curtin_event_contexts[''] = context
loop = self.app.aio_loop
fds = [
journald_listen(loop, [self.app.log_syslog_id], self.curtin_log),
journald_listen(loop, [self._event_syslog_id], self.curtin_event),
]
curtin_cmd = self._get_curtin_command()
log.debug('curtin install cmd: {}'.format(curtin_cmd))
async with self.app.install_lock_file.exclusive():
try:
our_tty = os.ttyname(0)
except OSError:
# This is a gross hack for testing in travis.
our_tty = "/dev/not a tty"
self.app.install_lock_file.write_content(our_tty)
journal.send("starting install", SYSLOG_IDENTIFIER="subiquity")
try:
cp = await arun_command(self.logged_command(curtin_cmd),
check=True)
finally:
for fd in fds:
loop.remove_reader(fd)
log.debug('curtin_install completed: %s', cp.returncode)
def cancel(self):
pass
@with_context()
async def install(self, *, context):
context.set('is-install-context', True)
try:
await asyncio.wait({e.wait() for e in self.model.install_events})
self.update_state(InstallState.NEEDS_CONFIRMATION)
await self.model.confirmation.wait()
self.update_state(InstallState.RUNNING)
if os.path.exists(self.model.target):
await self.unmount_target(context=context,
target=self.model.target)
await self.curtin_install(context=context)
self.update_state(InstallState.POST_WAIT)
await asyncio.wait(
{e.wait()
for e in self.model.postinstall_events})
await self.drain_curtin_events(context=context)
self.update_state(InstallState.POST_RUNNING)
await self.postinstall(context=context)
if self.model.network.has_network:
self.update_state(InstallState.UU_RUNNING)
await self.run_unattended_upgrades(context=context)
self.update_state(InstallState.DONE)
except Exception:
self.curtin_error()
if not self.interactive():
raise
async def move_on(self):
await self.install_task
self.app.next_screen()
async def drain_curtin_events(self, *, context):
waited = 0.0
while self.progress_view.ongoing and waited < 5.0:
await asyncio.sleep(0.1)
waited += 0.1
log.debug("waited %s seconds for events to drain", waited)
self.curtin_event_contexts.pop('', None)
@with_context(description="final system configuration",
level="INFO",
childlevel="DEBUG")
async def postinstall(self, *, context):
autoinstall_path = os.path.join(
self.app.root, 'var/log/installer/autoinstall-user-data')
autoinstall_config = "#cloud-config\n" + yaml.dump(
{"autoinstall": self.app.make_autoinstall()})
write_file(autoinstall_path, autoinstall_config, mode=0o600)
await self.configure_cloud_init(context=context)
packages = []
if self.model.ssh.install_server:
packages = ['openssh-server']
packages.extend(self.app.base_model.packages)
for package in packages:
await self.install_package(context=context, package=package)
await self.restore_apt_config(context=context)
@with_context(description="configuring cloud-init")
async def configure_cloud_init(self, context):
await run_in_thread(self.model.configure_cloud_init)
@with_context(name="install_{package}", description="installing {package}")
async def install_package(self, *, context, package):
if self.opts.dry_run:
cmd = ["sleep", str(2 / self.app.scale_factor)]
else:
cmd = [
sys.executable,
"-m",
"curtin",
"system-install",
"-t",
"/target",
"--",
package,
]
await arun_command(self.logged_command(cmd), check=True)
@with_context(description="restoring apt configuration")
async def restore_apt_config(self, context):
if self.opts.dry_run:
cmds = [["sleep", str(1 / self.app.scale_factor)]]
else:
cmds = [
["umount", self.tpath('etc/apt')],
]
if self.model.network.has_network:
cmds.append([
sys.executable,
"-m",
"curtin",
"in-target",
"-t",
"/target",
"--",
"apt-get",
"update",
])
else:
cmds.append(["umount", self.tpath('var/lib/apt/lists')])
for cmd in cmds:
await arun_command(self.logged_command(cmd), check=True)
@with_context(description="downloading and installing security updates")
async def run_unattended_upgrades(self, context):
target_tmp = os.path.join(self.model.target, "tmp")
os.makedirs(target_tmp, exist_ok=True)
apt_conf = tempfile.NamedTemporaryFile(dir=target_tmp,
delete=False,
mode='w')
apt_conf.write(uu_apt_conf)
apt_conf.close()
env = os.environ.copy()
env["APT_CONFIG"] = apt_conf.name[len(self.model.target):]
self.unattended_upgrades_ctx = context
if self.opts.dry_run:
self.unattended_upgrades_proc = await astart_command(
self.logged_command(["sleep",
str(5 / self.app.scale_factor)]),
env=env)
else:
self.unattended_upgrades_proc = await astart_command(
self.logged_command([
sys.executable,
"-m",
"curtin",
"in-target",
"-t",
"/target",
"--",
"unattended-upgrades",
"-v",
]),
env=env)
await self.unattended_upgrades_proc.communicate()
self.unattended_upgrades_proc = None
self.unattended_upgrades_ctx = None
os.remove(apt_conf.name)
async def stop_unattended_upgrades(self):
self.progress_view.event_finish(self.unattended_upgrades_ctx)
with self.unattended_upgrades_ctx.parent.child(
"stop_unattended_upgrades", "cancelling update"):
if self.opts.dry_run:
await asyncio.sleep(1)
self.unattended_upgrades_proc.terminate()
else:
await arun_command(self.logged_command([
'chroot',
'/target',
'/usr/share/unattended-upgrades/'
'unattended-upgrade-shutdown',
'--stop-only',
]),
check=True)
async def _click_reboot(self):
if self.unattended_upgrades_ctx is not None:
self.update_state(InstallState.UU_CANCELLING)
await self.stop_unattended_upgrades()
self.reboot_clicked.set()
def click_reboot(self):
schedule_task(self._click_reboot())
def make_ui(self):
schedule_task(self.move_on())
return self.progress_view
def run_answers(self):
pass
class InstallProgressController(SubiquityController):
def __init__(self, app):
super().__init__(app)
self.model = app.base_model
self.progress_view = ProgressView(self)
self.install_state = InstallState.NOT_STARTED
self.journal_listener_handle = None
self.reboot_clicked = asyncio.Event()
if self.answers.get('reboot', False):
self.reboot_clicked.set()
self.uu_running = False
self.uu = None
self._event_indent = ""
self._event_syslog_identifier = 'curtin_event.%s' % (os.getpid(), )
self._log_syslog_identifier = 'curtin_log.%s' % (os.getpid(), )
self.tb_extractor = TracebackExtractor()
self.curtin_context = None
def interactive(self):
return self.app.interactive()
def start(self):
self.install_task = schedule_task(self.install(self.context))
async def apply_autoinstall_config(self):
await self.install_task
self.app.reboot_on_exit = True
def tpath(self, *path):
return os.path.join(self.model.target, *path)
def curtin_error(self):
self.install_state = InstallState.ERROR
kw = {}
if sys.exc_info()[0] is not None:
log.exception("curtin_error")
self.progress_view.add_log_line(traceback.format_exc())
if self.tb_extractor.traceback:
kw["Traceback"] = "\n".join(self.tb_extractor.traceback)
crash_report = self.app.make_apport_report(
ErrorReportKind.INSTALL_FAIL,
"install failed",
interrupt=False,
**kw)
self.progress_view.spinner.stop()
self.progress_view.set_status(
('info_error', _("An error has occurred")))
self.start_ui()
self.progress_view.show_error(crash_report)
def logged_command(self, cmd):
return [
'systemd-cat', '--level-prefix=false',
'--identifier=' + self._log_syslog_identifier
] + cmd
def _journal_event(self, event):
if event['SYSLOG_IDENTIFIER'] == self._event_syslog_identifier:
self.curtin_event(event)
elif event['SYSLOG_IDENTIFIER'] == self._log_syslog_identifier:
self.curtin_log(event)
@contextlib.contextmanager
def install_context(self, context, name, description, level, childlevel):
self._install_event_start(description)
try:
subcontext = context.child(name, description, level, childlevel)
with subcontext:
yield subcontext
finally:
self._install_event_finish()
def _install_event_start(self, message):
self.progress_view.add_event(self._event_indent + message)
self._event_indent += " "
self.progress_view.spinner.start()
def _install_event_finish(self):
self._event_indent = self._event_indent[:-2]
self.progress_view.spinner.stop()
def curtin_event(self, event):
e = {
"EVENT_TYPE": "???",
"MESSAGE": "???",
"NAME": "???",
"RESULT": "???",
}
prefix = "CURTIN_"
for k, v in event.items():
if k.startswith(prefix):
e[k[len(prefix):]] = v
event_type = e["EVENT_TYPE"]
if event_type == 'start':
self._install_event_start(e["MESSAGE"])
if self.curtin_context is not None:
self.curtin_context.child(e["NAME"], e["MESSAGE"]).enter()
if event_type == 'finish':
self._install_event_finish()
status = getattr(Status, e["RESULT"], Status.WARN)
if self.curtin_context is not None:
self.curtin_context.child(e["NAME"], e["MESSAGE"]).exit(status)
def curtin_log(self, event):
log_line = event['MESSAGE']
self.progress_view.add_log_line(log_line)
self.tb_extractor.feed(log_line)
def start_journald_listener(self, identifiers, callback):
reader = journal.Reader()
args = []
for identifier in identifiers:
args.append("SYSLOG_IDENTIFIER={}".format(identifier))
reader.add_match(*args)
def watch():
if reader.process() != journal.APPEND:
return
for event in reader:
callback(event)
loop = asyncio.get_event_loop()
return loop.add_reader(reader.fileno(), watch)
def _write_config(self, path, config):
with open(path, 'w') as conf:
datestr = '# Autogenerated by SUbiquity: {} UTC\n'.format(
str(datetime.datetime.utcnow()))
conf.write(datestr)
conf.write(yaml.dump(config))
def _get_curtin_command(self):
config_file_name = 'subiquity-curtin-install.conf'
if self.opts.dry_run:
config_location = os.path.join('.subiquity/', config_file_name)
log_location = '.subiquity/install.log'
event_file = "examples/curtin-events.json"
if 'install-fail' in self.app.debug_flags:
event_file = "examples/curtin-events-fail.json"
curtin_cmd = [
"python3",
"scripts/replay-curtin-log.py",
event_file,
self._event_syslog_identifier,
log_location,
]
else:
config_location = os.path.join('/var/log/installer',
config_file_name)
curtin_cmd = [
sys.executable, '-m', 'curtin', '--showtrace', '-c',
config_location, 'install'
]
log_location = INSTALL_LOG
ident = self._event_syslog_identifier
self._write_config(config_location,
self.model.render(syslog_identifier=ident))
self.app.note_file_for_apport("CurtinConfig", config_location)
self.app.note_file_for_apport("CurtinLog", log_location)
self.app.note_file_for_apport("CurtinErrors", ERROR_TARFILE)
return curtin_cmd
@install_step("installing system", level="INFO", childlevel="DEBUG")
async def curtin_install(self, context):
log.debug('curtin_install')
self.install_state = InstallState.RUNNING
self.curtin_context = context
self.journal_listener_handle = self.start_journald_listener(
[self._event_syslog_identifier, self._log_syslog_identifier],
self._journal_event)
curtin_cmd = self._get_curtin_command()
log.debug('curtin install cmd: {}'.format(curtin_cmd))
cp = await arun_command(self.logged_command(curtin_cmd), check=True)
log.debug('curtin_install completed: %s', cp.returncode)
self.install_state = InstallState.DONE
log.debug('After curtin install OK')
def cancel(self):
pass
async def install(self, context):
try:
await asyncio.wait({e.wait() for e in self.model.install_events})
await self.curtin_install(context)
await asyncio.wait(
{e.wait()
for e in self.model.postinstall_events})
await self.drain_curtin_events(context)
await self.postinstall(context)
self.ui.set_header(_("Installation complete!"))
self.progress_view.set_status(_("Finished install!"))
self.progress_view.show_complete()
if self.model.network.has_network:
self.progress_view.update_running()
await self.run_unattended_upgrades(context)
self.progress_view.update_done()
await self.copy_logs_to_target(context)
except Exception:
self.curtin_error()
if not self.interactive():
raise
async def move_on(self):
await asyncio.wait({self.reboot_clicked.wait(), self.install_task})
self.app.reboot_on_exit = True
if not self.opts.dry_run and platform.machine() == 's390x':
run_command(["chreipl", "/target/boot"])
self.app.next_screen()
async def drain_curtin_events(self, context):
waited = 0.0
while self._event_indent and waited < 5.0:
await asyncio.sleep(0.1)
waited += 0.1
log.debug("waited %s seconds for events to drain", waited)
self.curtin_context = None
@install_step("final system configuration",
level="INFO",
childlevel="DEBUG")
async def postinstall(self, context):
await self.configure_cloud_init(context)
if self.model.ssh.install_server:
await self.install_openssh(context)
await self.restore_apt_config(context)
@install_step("configuring cloud-init")
async def configure_cloud_init(self, context):
await run_in_thread(self.model.configure_cloud_init)
@install_step("installing openssh")
async def install_openssh(self, context):
if self.opts.dry_run:
cmd = ["sleep", str(2 / self.app.scale_factor)]
else:
cmd = [
sys.executable,
"-m",
"curtin",
"system-install",
"-t",
"/target",
"--",
"openssh-server",
]
await arun_command(self.logged_command(cmd), check=True)
@install_step("restoring apt configuration")
async def restore_apt_config(self, context):
if self.opts.dry_run:
cmds = [["sleep", str(1 / self.app.scale_factor)]]
else:
cmds = [
["umount", self.tpath('etc/apt')],
]
if self.model.network.has_network:
cmds.append([
sys.executable,
"-m",
"curtin",
"in-target",
"-t",
"/target",
"--",
"apt-get",
"update",
])
else:
cmds.append(["umount", self.tpath('var/lib/apt/lists')])
for cmd in cmds:
await arun_command(self.logged_command(cmd), check=True)
@install_step("downloading and installing security updates")
async def run_unattended_upgrades(self, context):
target_tmp = os.path.join(self.model.target, "tmp")
os.makedirs(target_tmp, exist_ok=True)
apt_conf = tempfile.NamedTemporaryFile(dir=target_tmp,
delete=False,
mode='w')
apt_conf.write(uu_apt_conf)
apt_conf.close()
env = os.environ.copy()
env["APT_CONFIG"] = apt_conf.name[len(self.model.target):]
self.uu_running = True
if self.opts.dry_run:
self.uu = await astart_command(self.logged_command(
["sleep", str(5 / self.app.scale_factor)]),
env=env)
else:
self.uu = await astart_command(self.logged_command([
sys.executable,
"-m",
"curtin",
"in-target",
"-t",
"/target",
"--",
"unattended-upgrades",
"-v",
]),
env=env)
await self.uu.communicate()
self.uu_running = False
self.uu = None
os.remove(apt_conf.name)
async def stop_uu(self):
self._install_event_finish()
self._install_event_start("cancelling update")
if self.opts.dry_run:
await asyncio.sleep(1)
self.uu.terminate()
else:
await arun_command(
self.logged_command([
'chroot',
'/target',
'/usr/share/unattended-upgrades/unattended-upgrade-shutdown',
'--stop-only',
],
check=True))
@install_step("copying logs to installed system")
async def copy_logs_to_target(self, context):
if self.opts.dry_run:
if 'copy-logs-fail' in self.app.debug_flags:
raise PermissionError()
return
target_logs = self.tpath('var/log/installer')
await arun_command(['cp', '-aT', '/var/log/installer', target_logs])
try:
with open(os.path.join(target_logs, 'installer-journal.txt'),
'w') as output:
await arun_command(['journalctl'],
stdout=output,
stderr=subprocess.STDOUT)
except Exception:
log.exception("saving journal failed")
async def _click_reboot(self):
if self.uu_running:
await self.stop_uu()
self.reboot_clicked.set()
def click_reboot(self):
schedule_task(self._click_reboot())
def start_ui(self):
if self.install_state in [
InstallState.NOT_STARTED,
InstallState.RUNNING,
]:
self.progress_view.title = _("Installing system")
elif self.install_state == InstallState.DONE:
self.progress_view.title = _("Install complete!")
elif self.install_state == InstallState.ERROR:
self.progress_view.title = (
_('An error occurred during installation'))
self.ui.set_body(self.progress_view)
schedule_task(self.move_on())