9 files changed, 456 insertions, 253 deletions

diff --git a/archinstall/__init__.py b/archinstall/__init__.py
index 18c83a31..91e0cb12 100644
--- a/archinstall/__init__.py
+++ b/archinstall/__init__.py
@@ -1,4 +1,9 @@
 """Arch Linux installer - guided, templates etc."""
+import urllib.error
+import urllib.parse
+import urllib.request
+from argparse import ArgumentParser
+
 from .lib.disk import *
 from .lib.exceptions import *
 from .lib.general import *
@@ -13,24 +18,57 @@ from .lib.packages import *
 from .lib.profiles import *
 from .lib.services import *
 from .lib.storage import *
+from .lib.systemd import *
 from .lib.user_interaction import *
 
+parser = ArgumentParser()
+
 __version__ = "2.2.0.dev1"
 
-# Basic version of arg.parse() supporting:
-#  --key=value
-#  --boolean
-arguments = {}
-positionals = []
-for arg in sys.argv[1:]:
-	if '--' == arg[:2]:
-		if '=' in arg:
-			key, val = [x.strip() for x in arg[2:].split('=', 1)]
-		else:
-			key, val = arg[2:], True
-		arguments[key] = val
-	else:
-		positionals.append(arg)
+
+def initialize_arguments():
+	config = {}
+	parser.add_argument("--config", nargs="?", help="JSON configuration file or URL")
+	parser.add_argument("--silent", action="store_true",
+						help="Warning!!! No prompts, ignored if config is not passed")
+	parser.add_argument("--script", default="guided", nargs="?", help="Script to run for installation", type=str)
+	parser.add_argument("--vars",
+						metavar="KEY=VALUE",
+						nargs='?',
+						help="Set a number of key-value pairs "
+							 "(do not put spaces before or after the = sign). "
+							 "If a value contains spaces, you should define "
+							 "it with double quotes: "
+							 'foo="this is a sentence". Note that '
+							 "values are always treated as strings.")
+	args = parser.parse_args()
+	if args.config is not None:
+		try:
+			# First, let's check if this is a URL scheme instead of a filename
+			parsed_url = urllib.parse.urlparse(args.config)
+
+			if not parsed_url.scheme:  # The Profile was not a direct match on a remote URL, it must be a local file.
+				with open(args.config) as file:
+					config = json.load(file)
+			else:  # Attempt to load the configuration from the URL.
+				with urllib.request.urlopen(args.config) as response:
+					config = json.loads(response.read())
+		except Exception as e:
+			print(e)
+		# Installation can't be silent if config is not passed
+		config["silent"] = args.silent
+	if args.vars is not None:
+		try:
+			for var in args.vars.split(' '):
+				key, val = var.split("=")
+				config[key] = val
+		except Exception as e:
+			print(e)
+	config["script"] = args.script
+	return config
+
+
+arguments = initialize_arguments()
 
 
 # TODO: Learn the dark arts of argparse... (I summon thee dark spawn of cPython)
@@ -45,12 +83,8 @@ def run_as_a_module():
 
 	# Add another path for finding profiles, so that list_profiles() in Script() can find guided.py, unattended.py etc.
 	storage['PROFILE_PATH'].append(os.path.abspath(f'{os.path.dirname(__file__)}/examples'))
-
-	if len(sys.argv) == 1:
-		sys.argv.append('guided')
-
 	try:
-		script = Script(sys.argv[1])
+		script = Script(arguments.get('script', None))
 	except ProfileNotFound as err:
 		print(f"Couldn't find file: {err}")
 		sys.exit(1)
diff --git a/archinstall/lib/disk.py b/archinstall/lib/disk.py
index f8703ae3..8f67111a 100644
--- a/archinstall/lib/disk.py
+++ b/archinstall/lib/disk.py
@@ -1,6 +1,7 @@
 import glob
 import pathlib
 import re
+import time
 from collections import OrderedDict
 from typing import Optional
 
@@ -77,7 +78,7 @@ class BlockDevice:
 			raise DiskError(f'Could not locate backplane info for "{self.path}"')
 
 		if self.info['type'] == 'loop':
-			for drive in json.loads(b''.join(SysCommand(['losetup', '--json'], hide_from_log=True)).decode('UTF_8'))['loopdevices']:
+			for drive in json.loads(b''.join(SysCommand(['losetup', '--json'])).decode('UTF_8'))['loopdevices']:
 				if not drive['name'] == self.path:
 					continue
 
@@ -264,7 +265,9 @@ class Partition:
 			raise DiskError(f'Could not mount and check for content on {self.path} because: {b"".join(handle)}')
 
 		files = len(glob.glob(f"{temporary_mountpoint}/*"))
-		SysCommand(f'/usr/bin/umount {temporary_mountpoint}')
+		iterations = 0
+		while SysCommand(f"/usr/bin/umount -R {temporary_mountpoint}").exit_code != 0 and (iterations := iterations + 1) < 10:
+			time.sleep(1)
 
 		temporary_path.rmdir()
 
@@ -425,7 +428,7 @@ class Partition:
 		"""
 		try:
 			self.format(self.filesystem, '/dev/null', log_formatting=False, allow_formatting=True)
-		except SysCallError:
+		except (SysCallError, DiskError):
 			pass  # We supported it, but /dev/null is not formatable as expected so the mkfs call exited with an error code
 		except UnknownFilesystemFormat as err:
 			raise err
@@ -572,7 +575,7 @@ def all_disks(*args, **kwargs):
 	kwargs.setdefault("partitions", False)
 	drives = OrderedDict()
 	# for drive in json.loads(sys_command(f'losetup --json', *args, **lkwargs, hide_from_log=True)).decode('UTF_8')['loopdevices']:
-	for drive in json.loads(b''.join(SysCommand('lsblk --json -l -n -o path,size,type,mountpoint,label,pkname,model', *args, **kwargs, hide_from_log=True)).decode('UTF_8'))['blockdevices']:
+	for drive in json.loads(b''.join(SysCommand('lsblk --json -l -n -o path,size,type,mountpoint,label,pkname,model')).decode('UTF_8'))['blockdevices']:
 		if not kwargs['partitions'] and drive['type'] == 'part':
 			continue
 
@@ -603,13 +606,17 @@ def harddrive(size=None, model=None, fuzzy=False):
 		return collection[drive]
 
 
-def get_mount_info(path):
+def get_mount_info(path) -> dict:
 	try:
-		output = b''.join(SysCommand(f'/usr/bin/findmnt --json {path}'))
+		output = SysCommand(f'/usr/bin/findmnt --json {path}')
 	except SysCallError:
 		return {}
 
 	output = output.decode('UTF-8')
+
+	if not output:
+		return {}
+
 	output = json.loads(output)
 	if 'filesystems' in output:
 		if len(output['filesystems']) > 1:
@@ -618,15 +625,19 @@ def get_mount_info(path):
 		return output['filesystems'][0]
 
 
-def get_partitions_in_use(mountpoint):
+def get_partitions_in_use(mountpoint) -> list:
 	try:
-		output = b''.join(SysCommand(f'/usr/bin/findmnt --json -R {mountpoint}'))
+		output = SysCommand(f'/usr/bin/findmnt --json -R {mountpoint}')
 	except SysCallError:
-		return {}
+		return []
 
 	mounts = []
 
 	output = output.decode('UTF-8')
+
+	if not output:
+		return []
+
 	output = json.loads(output)
 	for target in output.get('filesystems', []):
 		mounts.append(Partition(target['source'], None, filesystem=target.get('fstype', None), mountpoint=target['target']))
diff --git a/archinstall/lib/general.py b/archinstall/lib/general.py
index 9fbf2654..81793cb8 100644
--- a/archinstall/lib/general.py
+++ b/archinstall/lib/general.py
@@ -4,6 +4,7 @@ import logging
 import os
 import pty
 import shlex
+import subprocess
 import sys
 import time
 from datetime import datetime, date
@@ -41,6 +42,8 @@ def locate_binary(name):
 					return os.path.join(root, file)
 			break  # Don't recurse
 
+	raise RequirementError(f"Binary {name} does not exist.")
+
 
 class JsonEncoder:
 	def _encode(obj):
@@ -84,108 +87,125 @@ class JSON(json.JSONEncoder, json.JSONDecoder):
 		return super(JSON, self).encode(self._encode(obj))
 
 
-class SysCommand:
-	"""
-	Stolen from archinstall_gui
-	"""
-
-	def __init__(self, cmd, callback=None, start_callback=None, peak_output=False, environment_vars=None, *args, **kwargs):
-		if environment_vars is None:
+class SysCommandWorker:
+	def __init__(self, cmd, callbacks=None, peak_output=False, environment_vars=None, logfile=None, working_directory='./'):
+		if not callbacks:
+			callbacks = {}
+		if not environment_vars:
 			environment_vars = {}
-		kwargs.setdefault("worker_id", gen_uid())
-		kwargs.setdefault("emulate", False)
-		kwargs.setdefault("suppress_errors", False)
 
-		self.log = kwargs.get('log', log)
+		if type(cmd) is str:
+			cmd = shlex.split(cmd)
 
-		if kwargs['emulate']:
-			self.log(f"Starting command '{cmd}' in emulation mode.", level=logging.DEBUG)
-
-		if type(cmd) is list:
-			# if we get a list of arguments
-			self.raw_cmd = shlex.join(cmd)
-			self.cmd = cmd
-		else:
-			# else consider it a single shell string
-			# this should only be used if really necessary
-			self.raw_cmd = cmd
-			try:
-				self.cmd = shlex.split(cmd)
-			except Exception as e:
-				raise ValueError(f'Incorrect string to split: {cmd}\n{e}')
+		if cmd[0][0] != '/' and cmd[0][:2] != './':
+			# "which" doesn't work as it's a builtin to bash.
+			# It used to work, but for whatever reason it doesn't anymore.
+			# We there for fall back on manual lookup in os.PATH
+			cmd[0] = locate_binary(cmd[0])
 
-		self.args = args
-		self.kwargs = kwargs
+		self.cmd = cmd
+		self.callbacks = callbacks
 		self.peak_output = peak_output
 		self.environment_vars = environment_vars
+		self.logfile = logfile
+		self.working_directory = working_directory
 
-		self.kwargs.setdefault("worker", None)
-		self.callback = callback
-		self.pid = None
 		self.exit_code = None
-		self.started = time.time()
+		self._trace_log = b''
+		self._trace_log_pos = 0
+		self.poll_object = epoll()
+		self.child_fd = None
+		self.started = None
 		self.ended = None
-		self.worker_id = kwargs['worker_id']
-		self.trace_log = b''
-		self.status = 'starting'
 
-		user_catalogue = os.path.expanduser('~')
+	def __contains__(self, key: bytes):
+		"""
+		Contains will also move the current buffert position forward.
+		This is to avoid re-checking the same data when looking for output.
+		"""
+		assert type(key) == bytes
 
-		if workdir := kwargs.get('workdir', None):
-			self.cwd = workdir
-			self.exec_dir = workdir
-		else:
-			self.cwd = f"{user_catalogue}/.cache/archinstall/workers/{kwargs['worker_id']}/"
-			self.exec_dir = f'{self.cwd}/{os.path.basename(self.cmd[0])}_workingdir'
+		if (contains := key in self._trace_log[self._trace_log_pos:]):
+			self._trace_log_pos += self._trace_log[self._trace_log_pos:].find(key) + len(key)
 
-		if not self.cmd[0][0] == '/':
-			# "which" doesn't work as it's a builtin to bash.
-			# It used to work, but for whatever reason it doesn't anymore. So back to square one..
+		return contains
+
+	def __iter__(self, *args, **kwargs):
+		for line in self._trace_log[self._trace_log_pos:self._trace_log.rfind(b'\n')].split(b'\n'):
+			if line:
+				yield line + b'\n'
 
-			# self.log('Worker command is not executed with absolute path, trying to find: {}'.format(self.cmd[0]), origin='spawn', level=5)
-			# self.log('This is the binary {} for {}'.format(o.decode('UTF-8'), self.cmd[0]), origin='spawn', level=5)
-			self.cmd[0] = locate_binary(self.cmd[0])
+		self._trace_log_pos = self._trace_log.rfind(b'\n')
 
-		if not os.path.isdir(self.exec_dir):
-			os.makedirs(self.exec_dir)
+	def __repr__(self):
+		self.make_sure_we_are_executing()
+		return str(self._trace_log)
 
-		if start_callback:
-			start_callback(self, *args, **kwargs)
-		self.run()
+	def __enter__(self):
+		return self
 
-	def __iter__(self, *args, **kwargs):
-		for line in self.trace_log.split(b'\n'):
-			yield line
+	def __exit__(self, *args):
+		# b''.join(sys_command('sync')) # No need to, since the underlying fs() object will call sync.
+		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
 
-	def __repr__(self, *args, **kwargs):
-		return f"{self.cmd, self.trace_log}"
+		if self.child_fd:
+			try:
+				os.close(self.child_fd)
+			except:
+				pass
 
-	def decode(self, fmt='UTF-8'):
-		return self.trace_log.decode(fmt)
+		if self.peak_output:
+			# To make sure any peaked output didn't leave us hanging
+			# on the same line we were on.
+			sys.stdout.write("\n")
+			sys.stdout.flush()
 
-	def dump(self):
-		return {
-			'status': self.status,
-			'worker_id': self.worker_id,
-			'worker_result': self.trace_log.decode('UTF-8'),
-			'started': self.started,
-			'ended': self.ended,
-			'started_pprint': '{}-{}-{} {}:{}:{}'.format(*time.localtime(self.started)),
-			'ended_pprint': '{}-{}-{} {}:{}:{}'.format(*time.localtime(self.ended)) if self.ended else None,
-			'exit_code': self.exit_code,
-		}
+		if len(args) >= 2 and args[1]:
+			log(args[1], level=logging.ERROR, fg='red')
+
+		if self.exit_code != 0:
+			raise SysCallError(f"{self.cmd} exited with abnormal exit code: {self.exit_code}")
+
+	def is_alive(self):
+		self.poll()
+
+		if self.started and self.ended is None:
+			return True
+
+		return False
+
+	def write(self, data: bytes, line_ending=True):
+		assert type(data) == bytes  # TODO: Maybe we can support str as well and encode it
+
+		self.make_sure_we_are_executing()
+
+		os.write(self.child_fd, data + (b'\n' if line_ending else b''))
+
+	def make_sure_we_are_executing(self):
+		if not self.started:
+			return self.execute()
+
+	def tell(self) -> int:
+		self.make_sure_we_are_executing()
+		return self._trace_log_pos
+
+	def seek(self, pos):
+		self.make_sure_we_are_executing()
+		# Safety check to ensure 0 < pos < len(tracelog)
+		self._trace_log_pos = min(max(0, pos), len(self._trace_log))
 
 	def peak(self, output: Union[str, bytes]) -> bool:
-		if type(output) == bytes:
-			try:
-				output = output.decode('UTF-8')
-			except UnicodeDecodeError:
+		if self.peak_output:
+			if type(output) == bytes:
+				try:
+					output = output.decode('UTF-8')
+				except UnicodeDecodeError:
+					return False
+
+			output = output.strip('\r\n ')
+			if len(output) <= 0:
 				return False
-		output = output.strip('\r\n ')
-		if len(output) <= 0:
-			return False
 
-		if self.peak_output:
 			from .user_interaction import get_terminal_width
 
 			# Move back to the beginning of the terminal
@@ -207,125 +227,127 @@ class SysCommand:
 			sys.stdout.flush()
 		return True
 
-	def run(self):
-		self.status = 'running'
-		old_dir = os.getcwd()
-		os.chdir(self.exec_dir)
-		self.pid, child_fd = pty.fork()
-		if not self.pid:  # Child process
-			# Replace child process with our main process
-			if not self.kwargs['emulate']:
-				try:
-					os.execve(self.cmd[0], self.cmd, {**os.environ, **self.environment_vars})
-				except FileNotFoundError:
-					self.status = 'done'
-					self.log(f"{self.cmd[0]} does not exist.", level=logging.DEBUG)
-					self.exit_code = 1
-					return False
-
-		os.chdir(old_dir)
-
-		poller = epoll()
-		poller.register(child_fd, EPOLLIN | EPOLLHUP)
-
-		if 'events' in self.kwargs and 'debug' in self.kwargs:
-			self.log(f'[D] Using triggers for command: {self.cmd}', level=logging.DEBUG)
-			self.log(json.dumps(self.kwargs['events']), level=logging.DEBUG)
+	def poll(self):
+		self.make_sure_we_are_executing()
 
-		alive = True
-		last_trigger_pos = 0
-		while alive and not self.kwargs['emulate']:
-			for fileno, event in poller.poll(0.1):
-				try:
-					output = os.read(child_fd, 8192)
-					self.peak(output)
-					self.trace_log += output
-				except OSError:
-					alive = False
-					break
-
-				if 'debug' in self.kwargs and self.kwargs['debug'] and len(output):
-					self.log(self.cmd, 'gave:', output.decode('UTF-8'), level=logging.DEBUG)
-
-				if 'on_output' in self.kwargs:
-					self.kwargs['on_output'](self.kwargs['worker'], output)
-
-				lower = output.lower()
-				broke = False
-				if 'events' in self.kwargs:
-					for trigger in list(self.kwargs['events']):
-						if type(trigger) != bytes:
-							original = trigger
-							trigger = bytes(original, 'UTF-8')
-							self.kwargs['events'][trigger] = self.kwargs['events'][original]
-							del self.kwargs['events'][original]
-						if type(self.kwargs['events'][trigger]) != bytes:
-							self.kwargs['events'][trigger] = bytes(self.kwargs['events'][trigger], 'UTF-8')
-
-						if trigger.lower() in self.trace_log[last_trigger_pos:].lower():
-							trigger_pos = self.trace_log[last_trigger_pos:].lower().find(trigger.lower())
-
-							if 'debug' in self.kwargs and self.kwargs['debug']:
-								self.log(f"Writing to subprocess {self.cmd[0]}: {self.kwargs['events'][trigger].decode('UTF-8')}", level=logging.DEBUG)
-								self.log(f"Writing to subprocess {self.cmd[0]}: {self.kwargs['events'][trigger].decode('UTF-8')}", level=logging.DEBUG)
-
-							last_trigger_pos = trigger_pos
-							os.write(child_fd, self.kwargs['events'][trigger])
-							del self.kwargs['events'][trigger]
-							broke = True
-							break
-
-					if broke:
-						continue
-
-					# Adding a exit trigger:
-					if len(self.kwargs['events']) == 0:
-						if 'debug' in self.kwargs and self.kwargs['debug']:
-							self.log(f"Waiting for last command {self.cmd[0]} to finish.", level=logging.DEBUG)
-
-						if bytes(']$'.lower(), 'UTF-8') in self.trace_log[0 - len(']$') - 5:].lower():
-							if 'debug' in self.kwargs and self.kwargs['debug']:
-								self.log(f"{self.cmd[0]} has finished.", level=logging.DEBUG)
-							alive = False
-							break
-
-		self.status = 'done'
-
-		if 'debug' in self.kwargs and self.kwargs['debug']:
-			self.log(f"{self.cmd[0]} waiting for exit code.", level=logging.DEBUG)
-
-		if not self.kwargs['emulate']:
+		got_output = False
+		for fileno, event in self.poll_object.poll(0.1):
+			try:
+				output = os.read(self.child_fd, 8192)
+				got_output = True
+				self.peak(output)
+				self._trace_log += output
+			except OSError as err:
+				self.ended = time.time()
+				break
+
+		if self.ended or (got_output is False and pid_exists(self.pid) is False):
+			self.ended = time.time()
 			try:
 				self.exit_code = os.waitpid(self.pid, 0)[1]
 			except ChildProcessError:
 				try:
-					self.exit_code = os.waitpid(child_fd, 0)[1]
+					self.exit_code = os.waitpid(self.child_fd, 0)[1]
 				except ChildProcessError:
 					self.exit_code = 1
-		else:
-			self.exit_code = 0
 
-		if 'debug' in self.kwargs and self.kwargs['debug']:
-			self.log(f"{self.cmd[0]} got exit code: {self.exit_code}", level=logging.DEBUG)
+	def execute(self) -> bool:
+		if (old_dir := os.getcwd()) != self.working_directory:
+			os.chdir(self.working_directory)
+
+		# Note: If for any reason, we get a Python exception between here
+		#   and until os.close(), the traceback will get locked inside
+		#   stdout of the child_fd object. `os.read(self.child_fd, 8192)` is the
+		#   only way to get the traceback without loosing it.
+		self.pid, self.child_fd = pty.fork()
+		os.chdir(old_dir)
+
+		if not self.pid:
+			try:
+				os.execve(self.cmd[0], self.cmd, {**os.environ, **self.environment_vars})
+			except FileNotFoundError:
+				log(f"{self.cmd[0]} does not exist.", level=logging.ERROR, fg="red")
+				self.exit_code = 1
+				return False
+
+		self.started = time.time()
+		self.poll_object.register(self.child_fd, EPOLLIN | EPOLLHUP)
+
+		return True
+
+	def decode(self, encoding='UTF-8'):
+		return self._trace_log.decode(encoding)
+
+
+class SysCommand:
+	def __init__(self, cmd, callback=None, start_callback=None, peak_output=False, environment_vars=None, working_directory='./'):
+		_callbacks = {}
+		if callback:
+			_callbacks['on_end'] = callback
+		if start_callback:
+			_callbacks['on_start'] = start_callback
+
+		self.cmd = cmd
+		self._callbacks = _callbacks
+		self.peak_output = peak_output
+		self.environment_vars = environment_vars
+		self.working_directory = working_directory
+
+		self.session = None
+		self.create_session()
+
+	def __enter__(self):
+		return self.session
+
+	def __exit__(self, *args, **kwargs):
+		# b''.join(sys_command('sync')) # No need to, since the underlying fs() object will call sync.
+		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
 
-		if 'ignore_errors' in self.kwargs:
-			self.exit_code = 0
+		if len(args) >= 2 and args[1]:
+			log(args[1], level=logging.ERROR, fg='red')
 
-		if self.exit_code != 0 and not self.kwargs['suppress_errors']:
-			# self.log(self.trace_log.decode('UTF-8'), level=logging.DEBUG)
-			# self.log(f"'{self.raw_cmd}' did not exit gracefully, exit code {self.exit_code}.", level=logging.ERROR)
-			raise SysCallError(
-				message=f"{self.trace_log.decode('UTF-8')}\n'{self.raw_cmd}' did not exit gracefully (trace log above), exit code: {self.exit_code}",
-				exit_code=self.exit_code)
+	def __iter__(self, *args, **kwargs):
+
+		for line in self.session:
+			yield line
+
+	def __repr__(self, *args, **kwargs):
+		return self.session._trace_log.decode('UTF-8')
+
+	def __json__(self):
+		return {
+			'cmd': self.cmd,
+			'callbacks': self._callbacks,
+			'peak': self.peak_output,
+			'environment_vars': self.environment_vars,
+			'session': True if self.session else False
+		}
 
-		self.ended = time.time()
-		with open(f'{self.cwd}/trace.log', 'wb') as fh:
-			fh.write(self.trace_log)
+	def create_session(self):
+		if self.session:
+			return True
 
 		try:
-			os.close(child_fd)
-		except:
-			pass
+			self.session = SysCommandWorker(self.cmd, callbacks=self._callbacks, peak_output=self.peak_output, environment_vars=self.environment_vars)
+
+			while self.session.ended is None:
+				self.session.poll()
+
+		except SysCallError:
+			return False
+
+		return True
+
+	def decode(self, fmt='UTF-8'):
+		return self.session._trace_log.decode(fmt)
+
+	@property
+	def exit_code(self):
+		return self.session.exit_code
+
+	@property
+	def trace_log(self):
+		return self.session._trace_log
 
 
 def prerequisite_check():
@@ -337,3 +359,10 @@ def prerequisite_check():
 
 def reboot():
 	o = b''.join(SysCommand("/usr/bin/reboot"))
+
+
+def pid_exists(pid: int):
+	try:
+		return any(subprocess.check_output(['/usr/bin/ps', '--no-headers', '-o', 'pid', '-p', str(pid)]).strip())
+	except subprocess.CalledProcessError:
+		return False
diff --git a/archinstall/lib/installer.py b/archinstall/lib/installer.py
index 61b0a3a1..29b3bc1a 100644
--- a/archinstall/lib/installer.py
+++ b/archinstall/lib/installer.py
@@ -1,8 +1,8 @@
 from .disk import *
 from .hardware import *
+from .locale_helpers import verify_x11_keyboard_layout
 from .mirrors import *
 from .storage import storage
-from .systemd import Networkd
 from .user_interaction import *
 
 # Any package that the Installer() is responsible for (optional and the default ones)
@@ -78,7 +78,6 @@ class Installer:
 		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
 
 		if len(args) >= 2 and args[1]:
-			# self.log(self.trace_log.decode('UTF-8'), level=logging.DEBUG)
 			self.log(args[1], level=logging.ERROR, fg='red')
 
 			self.sync_log_to_install_medium()
@@ -136,7 +135,7 @@ class Installer:
 		self.log(f'Installing packages: {packages}', level=logging.INFO)
 
 		if (sync_mirrors := SysCommand('/usr/bin/pacman -Syy')).exit_code == 0:
-			if (pacstrap := SysCommand(f'/usr/bin/pacstrap {self.target} {" ".join(packages)}', **kwargs)).exit_code == 0:
+			if (pacstrap := SysCommand(f'/usr/bin/pacstrap {self.target} {" ".join(packages)}', peak_output=True)).exit_code == 0:
 				return True
 			else:
 				self.log(f'Could not strap in packages: {pacstrap.exit_code}', level=logging.INFO)
@@ -149,9 +148,8 @@ class Installer:
 	def genfstab(self, flags='-pU'):
 		self.log(f"Updating {self.target}/etc/fstab", level=logging.INFO)
 
-		fstab = SysCommand(f'/usr/bin/genfstab {flags} {self.target}').trace_log
-		with open(f"{self.target}/etc/fstab", 'ab') as fstab_fh:
-			fstab_fh.write(fstab)
+		with open(f"{self.target}/etc/fstab", 'a') as fstab_fh:
+			fstab_fh.write(SysCommand(f'/usr/bin/genfstab {flags} {self.target}').decode())
 
 		if not os.path.isfile(f'{self.target}/etc/fstab'):
 			raise RequirementError(f'Could not generate fstab, strapping in packages most likely failed (disk out of space?)\n{fstab}')
@@ -215,6 +213,8 @@ class Installer:
 		subprocess.check_call(f"/usr/bin/arch-chroot {self.target}", shell=True)
 
 	def configure_nic(self, nic, dhcp=True, ip=None, gateway=None, dns=None, *args, **kwargs):
+		from .systemd import Networkd
+
 		if dhcp:
 			conf = Networkd(Match={"Name": nic}, Network={"DHCP": "yes"})
 		else:
@@ -514,11 +514,44 @@ class Installer:
 		o = b''.join(SysCommand(f"/usr/bin/arch-chroot {self.target} sh -c \"chsh -s {shell} {user}\""))
 		pass
 
-	def set_keyboard_language(self, language):
+	def set_keyboard_language(self, language: str) -> bool:
 		if len(language.strip()):
-			with open(f'{self.target}/etc/vconsole.conf', 'w') as vconsole:
-				vconsole.write(f'KEYMAP={language}\n')
-				vconsole.write('FONT=lat9w-16\n')
+			if not verify_keyboard_layout(language):
+				self.log(f"Invalid keyboard language specified: {language}", fg="red", level=logging.ERROR)
+				return False
+
+			# In accordance with https://github.com/archlinux/archinstall/issues/107#issuecomment-841701968
+			# Setting an empty keymap first, allows the subsequent call to set layout for both console and x11.
+			from .systemd import Boot
+
+			with Boot(self) as session:
+				session.SysCommand(["localectl", "set-keymap", '""'])
+
+				if (output := session.SysCommand(["localectl", "set-keymap", language])).exit_code != 0:
+					raise ServiceException(f"Unable to set locale '{language}' for console: {output}")
+
+				self.log(f"Keyboard language for this installation is now set to: {language}")
 		else:
 			self.log('Keyboard language was not changed from default (no language specified).', fg="yellow", level=logging.INFO)
+
+		return True
+
+	def set_x11_keyboard_language(self, language: str) -> bool:
+		"""
+		A fallback function to set x11 layout specifically and separately from console layout.
+		This isn't strictly necessary since .set_keyboard_language() does this as well.
+		"""
+		if len(language.strip()):
+			if not verify_x11_keyboard_layout(language):
+				self.log(f"Invalid x11-keyboard language specified: {language}", fg="red", level=logging.ERROR)
+				return False
+
+			with Boot(self) as session:
+				session.SysCommand(["localectl", "set-x11-keymap", '""'])
+
+				if (output := session.SysCommand(["localectl", "set-x11-keymap", language])).exit_code != 0:
+					raise ServiceException(f"Unable to set locale '{language}' for X11: {output}")
+		else:
+			self.log(f'X11-Keyboard language was not changed from default (no language specified).', fg="yellow", level=logging.INFO)
+
 		return True
diff --git a/archinstall/lib/locale_helpers.py b/archinstall/lib/locale_helpers.py
index 2db429fd..36228edc 100644
--- a/archinstall/lib/locale_helpers.py
+++ b/archinstall/lib/locale_helpers.py
@@ -1,23 +1,18 @@
-import os
-import subprocess
+import logging
 
-from .exceptions import *
-
-
-# from .general import sys_command
+from .exceptions import ServiceException
+from .general import SysCommand
+from .output import log
 
 
 def list_keyboard_languages():
-	locale_dir = '/usr/share/kbd/keymaps/'
-
-	if not os.path.isdir(locale_dir):
-		raise RequirementError(f'Directory containing locales does not exist: {locale_dir}')
+	for line in SysCommand("localectl --no-pager list-keymaps", environment_vars={'SYSTEMD_COLORS': '0'}):
+		yield line.decode('UTF-8').strip()
 
-	for root, folders, files in os.walk(locale_dir):
 
-		for file in files:
-			if os.path.splitext(file)[1] == '.gz':
-				yield file.strip('.gz').strip('.map')
+def list_x11_keyboard_languages():
+	for line in SysCommand("localectl --no-pager list-x11-keymap-layouts", environment_vars={'SYSTEMD_COLORS': '0'}):
+		yield line.decode('UTF-8').strip()
 
 
 def verify_keyboard_layout(layout):
@@ -27,11 +22,28 @@ def verify_keyboard_layout(layout):
 	return False
 
 
-def search_keyboard_layout(layout_filter):
+def verify_x11_keyboard_layout(layout):
+	for language in list_x11_keyboard_languages():
+		if layout.lower() == language.lower():
+			return True
+	return False
+
+
+def search_keyboard_layout(layout):
 	for language in list_keyboard_languages():
-		if layout_filter.lower() in language.lower():
+		if layout.lower() in language.lower():
 			yield language
 
 
 def set_keyboard_language(locale):
-	return subprocess.call(['loadkeys', locale]) == 0
+	if len(locale.strip()):
+		if not verify_keyboard_layout(locale):
+			log(f"Invalid keyboard locale specified: {locale}", fg="red", level=logging.ERROR)
+			return False
+
+		if (output := SysCommand(f'localectl set-keymap {locale}')).exit_code != 0:
+			raise ServiceException(f"Unable to set locale '{locale}' for console: {output}")
+
+		return True
+
+	return False
diff --git a/archinstall/lib/networking.py b/archinstall/lib/networking.py
index dbd510dd..0643c9cf 100644
--- a/archinstall/lib/networking.py
+++ b/archinstall/lib/networking.py
@@ -1,4 +1,5 @@
 import fcntl
+import logging
 import os
 import socket
 import struct
@@ -6,6 +7,7 @@ from collections import OrderedDict
 
 from .exceptions import *
 from .general import SysCommand
+from .output import log
 from .storage import storage
 
 
@@ -27,11 +29,12 @@ def list_interfaces(skip_loopback=True):
 
 
 def check_mirror_reachable():
-	try:
-		check = SysCommand("pacman -Sy")
-		return check.exit_code == 0
-	except:
-		return False
+	if (exit_code := SysCommand("pacman -Sy").exit_code) == 0:
+		return True
+	elif exit_code == 256:
+		log("check_mirror_reachable() uses 'pacman -Sy' which requires root.", level=logging.ERROR, fg="red")
+
+	return False
 
 
 def enrich_iface_types(interfaces: dict):
diff --git a/archinstall/lib/output.py b/archinstall/lib/output.py
index 20b0df8d..595e9693 100644
--- a/archinstall/lib/output.py
+++ b/archinstall/lib/output.py
@@ -155,7 +155,7 @@ def log(*args, **kwargs):
 			log("Deprecated level detected in log message, please use new logging.<level> instead for the following log message:", fg="red", level=logging.ERROR, force=True)
 			kwargs['level'] = logging.DEBUG
 
-		if kwargs['level'] > storage.get('LOG_LEVEL', logging.INFO) and 'force' not in kwargs:
+		if kwargs['level'] < storage.get('LOG_LEVEL', logging.INFO) and 'force' not in kwargs:
 			# Level on log message was Debug, but output level is set to Info.
 			# In that case, we'll drop it.
 			return None
diff --git a/archinstall/lib/systemd.py b/archinstall/lib/systemd.py
index 5607250b..383f1f17 100644
--- a/archinstall/lib/systemd.py
+++ b/archinstall/lib/systemd.py
@@ -1,3 +1,11 @@
+import logging
+
+from .general import SysCommand, SysCommandWorker, locate_binary
+from .installer import Installer
+from .output import log
+from .storage import storage
+
+
 class Ini:
 	def __init__(self, *args, **kwargs):
 		"""
@@ -36,3 +44,78 @@ class Networkd(Systemd):
 	"""
 	Placeholder class to do systemd-network specific setups.
 	"""
+
+
+class Boot:
+	def __init__(self, installation: Installer):
+		self.instance = installation
+		self.container_name = 'archinstall'
+		self.session = None
+		self.ready = False
+
+	def __enter__(self):
+		if (existing_session := storage.get('active_boot', None)) and existing_session.instance != self.instance:
+			raise KeyError("Archinstall only supports booting up one instance, and a active session is already active and it is not this one.")
+
+		if existing_session:
+			self.session = existing_session.session
+			self.ready = existing_session.ready
+		else:
+			self.session = SysCommandWorker([
+				'/usr/bin/systemd-nspawn',
+				'-D', self.instance.target,
+				'-b',
+				'--machine', self.container_name
+			])
+
+		if not self.ready:
+			while self.session.is_alive():
+				if b' login:' in self.session:
+					self.ready = True
+					break
+
+		storage['active_boot'] = self
+		return self
+
+	def __exit__(self, *args, **kwargs):
+		# b''.join(sys_command('sync')) # No need to, since the underlying fs() object will call sync.
+		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
+
+		if len(args) >= 2 and args[1]:
+			log(args[1], level=logging.ERROR, fg='red')
+			log(f"The error above occured in a temporary boot-up of the installation {self.instance}", level=logging.ERROR, fg="red")
+
+		SysCommand(f'machinectl shell {self.container_name} /bin/bash -c "shutdown now"')
+
+	def __iter__(self):
+		if self.session:
+			for value in self.session:
+				yield value
+
+	def __contains__(self, key: bytes):
+		if self.session is None:
+			return False
+
+		return key in self.session
+
+	def is_alive(self):
+		if self.session is None:
+			return False
+
+		return self.session.is_alive()
+
+	def SysCommand(self, cmd: list, *args, **kwargs):
+		if cmd[0][0] != '/' and cmd[0][:2] != './':
+			# This check is also done in SysCommand & SysCommandWorker.
+			# However, that check is done for `machinectl` and not for our chroot command.
+			# So this wrapper for SysCommand will do this additionally.
+
+			cmd[0] = locate_binary(cmd[0])
+
+		return SysCommand(["machinectl", "shell", self.container_name, *cmd], *args, **kwargs)
+
+	def SysCommandWorker(self, cmd: list, *args, **kwargs):
+		if cmd[0][0] != '/' and cmd[0][:2] != './':
+			cmd[0] = locate_binary(cmd[0])
+
+		return SysCommandWorker(["machinectl", "shell", self.container_name, *cmd], *args, **kwargs)
diff --git a/archinstall/lib/user_interaction.py b/archinstall/lib/user_interaction.py
index 5f849607..50c62aa9 100644
--- a/archinstall/lib/user_interaction.py
+++ b/archinstall/lib/user_interaction.py
@@ -591,7 +591,7 @@ def select_profile(options):
 		raise RequirementError("Selecting profiles require a least one profile to be given as an option.")
 
 
-def select_language(options, show_only_country_codes=True):
+def select_language(options, show_only_country_codes=True, input_text='Select one of the above keyboard languages (by number or full name): '):
 	"""
 	Asks the user to select a language from the `options` dictionary parameter.
 	Usually this is combined with :ref:`archinstall.list_keyboard_languages`.
@@ -613,14 +613,13 @@ def select_language(options, show_only_country_codes=True):
 		languages = sorted(list(options))
 
 	if len(languages) >= 1:
-		for index, language in enumerate(languages):
-			print(f"{index}: {language}")
+		print_large_list(languages, margin_bottom=4)
 
 		print(" -- You can choose a layout that isn't in this list, but whose name you know --")
-		print(" -- Also, you can enter '?' or 'help' to search for more languages, or skip to use US layout --")
+		print(f" -- Also, you can enter '?' or 'help' to search for more languages, or skip to use {default_keyboard_language} layout --")
 
 		while True:
-			selected_language = input('Select one of the above keyboard languages (by name or full name): ')
+			selected_language = input(input_text)
 			if not selected_language:
 				return default_keyboard_language
 			elif selected_language.lower() in ('?', 'help'):
@@ -705,8 +704,7 @@ def select_driver(options=AVAILABLE_GFX_DRIVERS):
 	default_option = options["All open-source (default)"]
 
 	if drivers:
-		lspci = SysCommand('/usr/bin/lspci')
-		for line in lspci.trace_log.split(b'\r\n'):
+		for line in SysCommand('/usr/bin/lspci'):
 			if b' vga ' in line.lower():
 				if b'nvidia' in line.lower():
 					print(' ** nvidia card detected, suggested driver: nvidia **')