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