def test_install_pending_order(self): """Installation order of pending requests are respected""" done_callback = Mock() done_callback.side_effect = self.done_callback done_callback0 = Mock() done_callback0.side_effect = self.done_callback ordered_progress_callback = Mock() progress_callback = Mock() progress_callback.side_effect = ordered_progress_callback progress_callback0 = Mock() progress_callback0.side_effect = ordered_progress_callback self.handler.install_bucket(["testpackage"], progress_callback, done_callback) self.handler.install_bucket(["testpackage0"], progress_callback0, done_callback0) self.wait_for_callback(done_callback) self.wait_for_callback(done_callback0) self.assertEqual(self.done_callback.call_args_list, [ call( RequirementsHandler.RequirementsResult(bucket=['testpackage'], error=None)), call( RequirementsHandler.RequirementsResult(bucket=['testpackage0'], error=None)) ]) # we will get progress with 0, 1 (first bucket), 0, 1 (second bucket). So 4 progress signal status change current_status = RequirementsHandler.STATUS_DOWNLOADING current_status_change_count = 1 calls = ordered_progress_callback.call_args_list for current_call in calls[1:]: if current_call[0][0]['step'] != current_status: current_status = current_call[0][0]['step'] current_status_change_count += 1 self.assertEqual(current_status_change_count, 4)
def is_installable(self): """Return if the framework can be installed on that arch""" if self.only_for_removal: return False try: if len(self.only_on_archs) > 0: # we have some restricted archs, check we support it current_arch = get_current_arch() if current_arch not in self.only_on_archs: logger.debug( "{} only supports {} archs and you are on {}.".format( self.name, self.only_on_archs, current_arch)) return False if self.only_ubuntu: # set framework installable only on ubuntu if get_current_distro_id() != "ubuntu": return False if len(self.only_ubuntu_version) > 0: current_version = get_current_distro_version() if current_version not in self.only_ubuntu_version: logger.debug( "{} only supports {} and you are on {}.".format( self.name, self.only_ubuntu_version, current_version)) return False if not RequirementsHandler().is_bucket_available( self.packages_requirements): return False except: logger.error( "An error occurred when detecting platform, don't register {}". format(self.name)) return False return True
def is_installed(self): """Method call to know if the framework is installed""" if not os.path.isdir(self.install_path): return False if not RequirementsHandler().is_bucket_installed(self.packages_requirements): return False return True
def setUpClass(cls): super().setUpClass() cls.handler = RequirementsHandler() apt.apt_pkg.config.set("Dir::Cache::pkgcache", "") apt.apt_pkg.config.set("Dir::Cache::srcpkgcache", "") apt.apt_pkg.config.clear("APT::Update::Post-Invoke") apt.apt_pkg.config.clear("APT::Update::Post-Invoke-Success") apt.apt_pkg.config.clear("DPkg::Post-Invoke") cls.apt_package_dir = os.path.join(get_data_dir(), "apt") cls.apt_status_dir = os.path.join(cls.apt_package_dir, "states")
def start_download_and_install(self): self.last_progress_download = None self.last_progress_requirement = None self.balance_requirement_download = None self.pkg_size_download = 0 self.result_requirement = None self.result_download = None self._download_done_callback_called = False UI.display(DisplayMessage("Downloading and installing requirements")) self.pbar = ProgressBar().start() self.pkg_to_install = RequirementsHandler().install_bucket(self.packages_requirements, self.get_progress_requirement, self.requirement_done) DownloadCenter(urls=self.download_requests, on_done=self.download_done, report=self.get_progress_download)
def __init__(self, name, description, category, logo_path=None, is_category_default=False, install_path_dir=None, only_on_archs=None, only_ubuntu_version=None, packages_requirements=None): self.name = name self.description = description self.logo_path = None self.category = category self.is_category_default = is_category_default self.only_on_archs = [] if only_on_archs is None else only_on_archs self.only_ubuntu_version = [] if only_ubuntu_version is None else only_ubuntu_version self.packages_requirements = [] if packages_requirements is None else packages_requirements self.packages_requirements.extend(self.category.packages_requirements) # don't detect anything for completion mode (as we need to be quick), so avoid opening apt cache and detect # if it's installed. if is_completion_mode(): category.register_framework(self) return self.need_root_access = False with suppress(KeyError): self.need_root_access = not RequirementsHandler().is_bucket_installed(self.packages_requirements) if self.is_category_default: if self.category == BaseCategory.main_category: logger.error("Main category can't have default framework as {} requires".format(name)) self.is_category_default = False elif self.category.default_framework is not None: logger.error("Can't set {} as default for {}: this category already has a default framework ({}). " "Don't set any as default".format(category.name, name, self.category.default_framework.name)) self.is_category_default = False self.category.default_framework.is_category_default = False if not install_path_dir: install_path_dir = os.path.join("" if category.is_main_category else category.prog_name, self.prog_name) self.default_install_path = os.path.join(DEFAULT_INSTALL_TOOLS_PATH, install_path_dir) self.install_path = self.default_install_path # check if we have an install path previously set config = ConfigHandler().config try: self.install_path = config["frameworks"][category.prog_name][self.prog_name]["path"] except (TypeError, KeyError, FileNotFoundError): pass # This requires install_path and will register need_root or not if not self.is_installed and not self.is_installable: logger.info("Don't register {} as it's not installable on this configuration.".format(name)) return category.register_framework(self)
def test_singleton(self): """Ensure we are delivering a singleton for RequirementsHandler""" other = RequirementsHandler() self.assertEqual(self.handler, other)
def setUpClass(cls): super().setUpClass() cls.handler = RequirementsHandler()