def __init__(self):
super().__init__()
self._module_manager = ModuleManager()
self._kickstart_manager = KickstartManager()
self._install_manager = InstallManager()
self._module_manager.module_observers_changed.connect(
self._kickstart_manager.on_module_observers_changed)
self._module_manager.module_observers_changed.connect(
self._install_manager.on_module_observers_changed)
def setUp(self):
self._manager = ModuleManager()
self._message_bus = Mock()
self._message_bus.proxy.ListActivatableNames.return_value = [
"org.fedoraproject.Anaconda.Boss",
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Addons.C",
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
"org.fedoraproject.InitialSetup.Modules.A",
"org.fedoraproject.InitialSetup.Modules.B",
"org.fedoraproject.InitialSetup.Modules.C",
]
def __init__(self, module_manager=None, install_manager=None, kickstart_manager=None):
super().__init__()
self._module_manager = module_manager or ModuleManager()
self._install_manager = install_manager or InstallManager()
self._kickstart_manager = kickstart_manager or KickstartManager()
self._setup_install_manager()
self._setup_kickstart_manager()
class Boss(BaseModule):
def __init__(self):
super().__init__()
self._dbus_name = dbus_constants.DBUS_BOSS_NAME
self._module_manager = ModuleManager()
def run(self):
log.info("looking for addons")
self._module_manager.find_addons()
# schedule publishing
GLib.idle_add(self.publish_module)
# then schedule module startup
GLib.idle_add(self._module_manager.start_modules)
# start the mainloop
log.info("starting mainloop")
self._loop.run()
def Quit(self):
"""Stop all modules and then stops Boss."""
self._module_manager.stop_modules()
super().Quit()
class Boss(Service):
"""The Boss service."""
def __init__(self):
super().__init__()
self._module_manager = ModuleManager()
self._kickstart_manager = KickstartManager()
self._install_manager = InstallManager()
self._ui_module = UIModule()
self._module_manager.module_observers_changed.connect(
self._kickstart_manager.on_module_observers_changed)
self._module_manager.module_observers_changed.connect(
self._install_manager.on_module_observers_changed)
def publish(self):
"""Publish the boss."""
TaskContainer.set_namespace(BOSS.namespace)
# Publish submodules.
self._ui_module.publish()
DBus.publish_object(BOSS.object_path, BossInterface(self))
DBus.register_service(BOSS.service_name)
def get_modules(self):
"""Get service names of running modules.
Get a list of all running DBus modules (including addons)
that were discovered and started by the boss.
:return: a list of service names
"""
return self._module_manager.get_service_names()
def start_modules_with_task(self):
"""Start the modules with the task."""
return self._module_manager.start_modules_with_task()
def stop(self):
"""Stop all modules and then stop the boss."""
self._module_manager.stop_modules()
super().stop()
def read_kickstart_file(self, path):
"""Read the specified kickstart file.
:param path: a path to a file
:returns: a kickstart report
"""
log.info("Reading a kickstart file at %s.", path)
return self._kickstart_manager.read_kickstart_file(path)
def generate_kickstart(self):
"""Return a kickstart representation of modules.
:return: a kickstart string
"""
log.info("Generating kickstart data...")
return self._kickstart_manager.generate_kickstart()
def collect_requirements(self):
"""Collect requirements of the modules.
:return: a list of requirements
"""
return self._install_manager.collect_requirements()
def collect_configure_runtime_tasks(self):
"""Collect tasks for configuration of the runtime environment.
FIXME: This method temporarily uses only addons.
:return: a list of task proxies
"""
return self._install_manager.collect_configure_runtime_tasks()
def collect_configure_bootloader_tasks(self, kernel_versions):
"""Collect tasks for configuration of the bootloader.
FIXME: This method temporarily uses only addons.
FIXME: This is a temporary workaround. The method might change.
:param kernel_versions: a list of kernel versions
:return: a list of task proxies
"""
return self._install_manager.collect_configure_bootloader_tasks(
kernel_versions)
def collect_install_system_tasks(self):
"""Collect tasks for installation of the system.
FIXME: This method temporarily uses only addons.
:return: a list of task proxies
"""
return self._install_manager.collect_install_system_tasks()
def set_locale(self, locale):
"""Set locale of boss and all modules.
:param str locale: locale to set
"""
log.info("Setting locale of all modules to %s.", locale)
super().set_locale(locale)
self._module_manager.set_modules_locale(locale)
def finish_installation_with_tasks(self):
"""Finish installation with tasks.
:return: a list of installation tasks
"""
return [
SetContextsTask(conf.target.system_root),
CopyLogsTask(conf.target.system_root)
]
class Boss(Service):
"""The Boss service."""
def __init__(self):
super().__init__()
self._module_manager = ModuleManager()
self._kickstart_manager = KickstartManager()
self._install_manager = InstallManager()
self._module_manager.module_observers_changed.connect(
self._kickstart_manager.on_module_observers_changed)
self._module_manager.module_observers_changed.connect(
self._install_manager.on_module_observers_changed)
def publish(self):
"""Publish the boss."""
TaskContainer.set_namespace(BOSS.namespace)
DBus.publish_object(BOSS.object_path, BossInterface(self))
DBus.register_service(BOSS.service_name)
def start_modules_with_task(self):
"""Start the modules with the task."""
return self._module_manager.start_modules_with_task()
def stop(self):
"""Stop all modules and then stop the boss."""
self._module_manager.stop_modules()
super().stop()
def read_kickstart_file(self, path):
"""Read the specified kickstart file.
:param path: a path to a file
:returns: a kickstart report
"""
log.info("Reading a kickstart file at %s.", path)
return self._kickstart_manager.read_kickstart_file(path)
def generate_kickstart(self):
"""Return a kickstart representation of modules.
:return: a kickstart string
"""
log.info("Generating kickstart data...")
return self._kickstart_manager.generate_kickstart()
def install_system_with_task(self):
"""Install the system.
:return: the main installation task
"""
return self._install_manager.install_system_with_task()
def set_locale(self, locale):
"""Set locale of boss and all modules.
:param str locale: locale to set
"""
log.info("Setting locale of all modules to %s.", locale)
super().set_locale(locale)
self._module_manager.set_modules_locale(locale)
class Boss(Service):
"""The Boss service."""
def __init__(self):
super().__init__()
self._module_manager = ModuleManager()
self._kickstart_manager = KickstartManager()
self._install_manager = InstallManager()
self._module_manager.module_observers_changed.connect(
self._kickstart_manager.on_module_observers_changed)
self._module_manager.module_observers_changed.connect(
self._install_manager.on_module_observers_changed)
def publish(self):
"""Publish the boss."""
TaskContainer.set_namespace(BOSS.namespace)
DBus.publish_object(BOSS.object_path, BossInterface(self))
DBus.register_service(BOSS.service_name)
def get_modules(self):
"""Get service names of running modules.
Get a list of all running DBus modules (including addons)
that were discovered and started by the boss.
:return: a list of service names
"""
return self._module_manager.get_service_names()
def start_modules_with_task(self):
"""Start the modules with the task."""
return self._module_manager.start_modules_with_task()
def stop(self):
"""Stop all modules and then stop the boss."""
self._module_manager.stop_modules()
super().stop()
def read_kickstart_file(self, path):
"""Read the specified kickstart file.
:param path: a path to a file
:returns: a kickstart report
"""
log.info("Reading a kickstart file at %s.", path)
return self._kickstart_manager.read_kickstart_file(path)
def generate_kickstart(self):
"""Return a kickstart representation of modules.
:return: a kickstart string
"""
log.info("Generating kickstart data...")
return self._kickstart_manager.generate_kickstart()
def collect_requirements(self):
"""Collect requirements of the modules.
:return: a list of requirements
"""
return self._install_manager.collect_requirements()
def configure_runtime_with_task(self):
"""Configure the runtime environment.
FIXME: This method temporarily uses only addons.
:return: a task
"""
return self._install_manager.configure_runtime_with_task()
def install_system_with_task(self):
"""Install the system.
FIXME: This method temporarily uses only addons.
:return: a task
"""
return self._install_manager.install_system_with_task()
def set_locale(self, locale):
"""Set locale of boss and all modules.
:param str locale: locale to set
"""
log.info("Setting locale of all modules to %s.", locale)
super().set_locale(locale)
self._module_manager.set_modules_locale(locale)
def __init__(self, module_manager=None, install_manager=None):
super().__init__()
self._module_manager = module_manager or ModuleManager()
self._install_manager = install_manager or InstallManager()
def setUp(self):
self._manager = ModuleManager()
self._message_bus = Mock()
class ModuleManagerTestCase(unittest.TestCase):
"""Test the module manager of the Boss module."""
def setUp(self):
self._manager = ModuleManager()
self._message_bus = Mock()
def _check_started_modules(self, task, service_names):
"""Check the started modules."""
def call():
return DBUS_START_REPLY_SUCCESS
def fake_callbacks(fake_observer):
for observer in task._module_observers:
observer._is_service_available = True
task._start_service_by_name_callback(call, observer)
task._service_available_callback(observer)
task._callbacks.put((None, fake_callbacks))
observers = task.run()
self.assertEqual([o.service_name for o in observers], service_names)
return observers
def test_start_no_modules(self):
"""Start no modules."""
task = StartModulesTask(self._message_bus, [], addons_enabled=False)
self._check_started_modules(task, [])
@patch("dasbus.client.observer.Gio")
def test_start_one_module(self, gio):
"""Start one module."""
service_names = ["org.fedoraproject.Anaconda.Modules.A"]
task = StartModulesTask(self._message_bus,
service_names,
addons_enabled=False)
(observer, ) = self._check_started_modules(task, service_names) # pylint: disable=unbalanced-tuple-unpacking
bus_proxy = self._message_bus.proxy
bus_proxy.StartServiceByName.assert_called_once_with(
"org.fedoraproject.Anaconda.Modules.A",
DBUS_FLAG_NONE,
callback=task._start_service_by_name_callback,
callback_args=(observer, ))
gio.bus_watch_name_on_connection.assert_called_once()
observer.proxy.Ping.assert_called_once_with()
@patch("dasbus.client.observer.Gio")
def test_start_modules(self, gio):
"""Start modules."""
service_names = [
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(self._message_bus,
service_names,
addons_enabled=False)
self._check_started_modules(task, service_names)
@patch("dasbus.client.observer.Gio")
def test_start_addons(self, gio):
"""Start addons."""
service_names = [
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Addons.C"
]
bus_proxy = self._message_bus.proxy
bus_proxy.ListActivatableNames.return_value = [
*service_names,
"org.fedoraproject.Anaconda.D",
"org.fedoraproject.E",
]
task = StartModulesTask(self._message_bus, [], addons_enabled=True)
self._check_started_modules(task, service_names)
def test_start_module_failed(self):
"""Fail to start a module."""
service_names = [
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(self._message_bus,
service_names,
addons_enabled=False)
def call():
raise DBusError("Fake error!")
def fake_callbacks(fake_observer):
for observer in task._module_observers:
task._start_service_by_name_callback(call, observer)
task._callbacks.put((None, fake_callbacks))
with self.assertRaises(UnavailableModuleError) as cm:
task.run()
expected = "Service org.fedoraproject.Anaconda.Modules.A has failed to start: Fake error!"
self.assertEqual(str(cm.exception), expected)
@patch("dasbus.client.observer.Gio")
def test_start_addon_failed(self, gio):
"""Fail to start an add-on."""
service_names = [
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Addons.C"
]
bus_proxy = self._message_bus.proxy
bus_proxy.ListActivatableNames.return_value = [
*service_names,
"org.fedoraproject.Anaconda.D",
"org.fedoraproject.E",
]
task = StartModulesTask(self._message_bus, [], addons_enabled=True)
self._check_started_modules(task, service_names)
def call():
raise DBusError("Fake error!")
def fake_callbacks(fake_observer):
for observer in task._module_observers:
task._start_service_by_name_callback(call, observer)
task._callbacks.put((None, fake_callbacks))
self.assertEqual(task.run(), [])
@patch("dasbus.client.observer.Gio")
def test_get_service_names(self, gio):
"""Get service names of running modules."""
self.assertEqual(self._manager.get_service_names(), [])
service_names = [
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(self._message_bus,
service_names,
addons_enabled=False)
observers = self._check_started_modules(task, service_names)
self._manager.set_module_observers(observers)
self.assertEqual(self._manager.get_service_names(), service_names)
def __init__(self):
super().__init__()
self._dbus_name = dbus_constants.DBUS_BOSS_NAME
self._module_manager = ModuleManager()
class ModuleManagerTestCase(unittest.TestCase):
"""Test the module manager of the Boss module."""
def setUp(self):
self._manager = ModuleManager()
self._message_bus = Mock()
self._message_bus.proxy.ListActivatableNames.return_value = [
"org.fedoraproject.Anaconda.Boss",
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Addons.C",
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
"org.fedoraproject.InitialSetup.Modules.A",
"org.fedoraproject.InitialSetup.Modules.B",
"org.fedoraproject.InitialSetup.Modules.C",
]
def _check_started_modules(self, task, service_names):
"""Check the started modules."""
def call():
return DBUS_START_REPLY_SUCCESS
def fake_callbacks(fake_observer):
for observer in task._module_observers:
observer._is_service_available = True
task._start_service_by_name_callback(call, observer)
task._service_available_callback(observer)
task._callbacks.put((None, fake_callbacks))
observers = task.run()
assert [o.service_name for o in observers] == service_names
return observers
def test_start_no_modules(self):
"""Start no modules."""
task = StartModulesTask(self._message_bus, [], [], [])
self._check_started_modules(task, [])
@patch("dasbus.client.observer.Gio")
def test_start_one_module(self, gio):
"""Start one module."""
service_names = ["org.fedoraproject.Anaconda.Modules.A"]
task = StartModulesTask(self._message_bus, service_names, [], [])
(observer, ) = self._check_started_modules(task, service_names) # pylint: disable=unbalanced-tuple-unpacking
bus_proxy = self._message_bus.proxy
bus_proxy.StartServiceByName.assert_called_once_with(
"org.fedoraproject.Anaconda.Modules.A",
DBUS_FLAG_NONE,
callback=task._start_service_by_name_callback,
callback_args=(observer, ))
gio.bus_watch_name_on_connection.assert_called_once()
observer.proxy.Ping.assert_called_once_with()
@patch("dasbus.client.observer.Gio")
def test_start_modules(self, gio):
"""Start modules."""
service_names = [
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(self._message_bus, service_names, [], [])
observers = self._check_started_modules(task, service_names)
for observer in observers:
assert observer.is_addon == False
@patch("dasbus.client.observer.Gio")
def test_start_addons(self, gio):
"""Start addons."""
service_namespaces = ["org.fedoraproject.Anaconda.Addons.*"]
service_names = [
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Addons.C"
]
task = StartModulesTask(self._message_bus, service_namespaces, [], [])
observers = self._check_started_modules(task, service_names)
for observer in observers:
assert observer.is_addon == True
@patch("dasbus.client.observer.Gio")
def test_start_modules_forbidden(self, gio):
"""Try to start forbidden modules."""
service_namespaces = [
"org.fedoraproject.Anaconda.Modules.*",
"org.fedoraproject.Anaconda.Addons.*",
"org.fedoraproject.InitialSetup.Modules.*",
]
forbidden_names = [
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Addons.C",
"org.fedoraproject.InitialSetup.*",
]
service_names = [
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(message_bus=self._message_bus,
activatable=service_namespaces,
forbidden=forbidden_names,
optional=[])
self._check_started_modules(task, service_names)
def test_start_module_failed(self):
"""Fail to start a module."""
service_names = [
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(self._message_bus, service_names, [], [])
def call():
raise DBusError("Fake error!")
def fake_callbacks(fake_observer):
for observer in task._module_observers:
task._start_service_by_name_callback(call, observer)
task._callbacks.put((None, fake_callbacks))
with pytest.raises(UnavailableModuleError) as cm:
task.run()
expected = "Service org.fedoraproject.Anaconda.Modules.A has failed to start: Fake error!"
assert str(cm.value) == expected
@patch("dasbus.client.observer.Gio")
def test_start_addon_failed(self, gio):
"""Fail to start an add-on."""
service_namespaces = ["org.fedoraproject.Anaconda.Addons.*"]
service_names = [
"org.fedoraproject.Anaconda.Addons.A",
"org.fedoraproject.Anaconda.Addons.B",
"org.fedoraproject.Anaconda.Addons.C"
]
task = StartModulesTask(message_bus=self._message_bus,
activatable=service_namespaces,
optional=service_namespaces,
forbidden=[])
self._check_started_modules(task, service_names)
def call():
raise DBusError("Fake error!")
def fake_callbacks(fake_observer):
for observer in task._module_observers:
task._start_service_by_name_callback(call, observer)
task._callbacks.put((None, fake_callbacks))
assert task.run() == []
@patch("dasbus.client.observer.Gio")
def test_get_service_names(self, gio):
"""Get service names of running modules."""
assert self._manager.get_service_names() == []
service_names = [
"org.fedoraproject.Anaconda.Modules.A",
"org.fedoraproject.Anaconda.Modules.B",
"org.fedoraproject.Anaconda.Modules.C",
]
task = StartModulesTask(self._message_bus, service_names, [], [])
observers = self._check_started_modules(task, service_names)
self._manager.set_module_observers(observers)
assert self._manager.get_service_names() == service_names
