def run(self): """ Go, go, go! """ ### Sanity checks for pkg in self.args.packages: if not self.pm.installed(recipe.get_recipe(pkg)): self.log.error("Package {0} is not installed into current prefix. Aborting.".format(pkg)) exit(1) ### Make install tree rb_tree = dep_manager.DepManager().make_dep_tree( self.args.packages, lambda x: bool( (x in self.args.packages) or \ (self.args.deps and self.pm.installed(recipe.get_recipe(x))) ) ) self.log.debug("Install tree:") if self.log.getEffectiveLevel() <= 20 or self.args.print_tree: rb_tree.pretty_print() ### Recursively rebuild, starting at the leaf nodes while not rb_tree.empty(): pkg = rb_tree.pop_leaf_node() rec = recipe.get_recipe(pkg) self.log.info("Rebuilding package: {0}".format(pkg)) if not self.pm.rebuild( rec, make_clean=self.args.clean, nuke_builddir=not self.args.keep_build ): self.log.error("Error rebuilding package {0}. Aborting.".format(pkg)) exit(1) self.log.info("Rebuild successful.")
def run(self): """ Go, go, go! """ ### Sanity checks for pkg in self.args.packages: if not self.is_installed(pkg): self.log.error("Package {0} is not installed into current prefix. Aborting.".format(pkg)) return -1 ### Make install tree rb_tree = dep_manager.DepManager().make_dep_tree( self.args.packages, lambda x: bool( (x in self.args.packages) or \ (self.args.deps and self.is_installed(x)) ) ) if self.log.getEffectiveLevel() <= 10 or self.args.print_tree: print("Rebuild tree:") rb_tree.pretty_print() ### Recursively rebuild, starting at the leaf nodes node_cache = [] while not rb_tree.empty(): pkg = rb_tree.pop_leaf_node() if pkg in node_cache: continue rec = recipe.get_recipe(pkg) self.log.info("Rebuilding package: {0}".format(pkg)) if not self.pm.rebuild( rec, make_clean=self.args.clean, nuke_builddir=not (self.args.keep_build or bool(self.cfg.get('keep_builddir', False))) ): self.log.error("Error rebuilding package {0}. Aborting.".format(pkg)) return 1 self.log.info("Rebuild successful.")
def install( self, packages, mode, # install / update fail_if_not_exists=False, update_if_exists=False, quiet=False, print_tree=False, deps_only=False, no_deps=False, verify=False, static=False, ): """ Install packages. """ def _check_if_pkg_goes_into_tree(pkg): " Return True if pkg has a legitimate right to be in the tree. " if fail_if_not_exists: return bool(self.pm.installed(pkg)) return update_if_exists or not self.pm.installed(pkg) ### Sanity checks if fail_if_not_exists: for pkg in packages: if not self.pm.installed(pkg): self.log.error( "Package {0} is not installed. Aborting.".format(pkg)) return False ### Make install tree install_tree = dep_manager.DepManager(self.pm).make_dep_tree( packages, _check_if_pkg_goes_into_tree if not no_deps else lambda x: bool(x in packages)) if len(install_tree) == 0 and not quiet: self.log.info("No packages to install.") return True if (self.log.getEffectiveLevel() <= 20 or print_tree) and not quiet: print("Install tree:") install_tree.pretty_print() ### Recursively install/update, starting at the leaf nodes for pkg in install_tree.serialize(): if mode == 'install' and deps_only and pkg in packages: self.log.debug( "Skipping `{0}' because only deps are requested.") continue if self.pm.installed(pkg): self.log.info("Updating package: {0}".format(pkg)) if not self.pm.update(pkg, verify=verify): self.log.error( "Error updating package {0}. Aborting.".format(pkg)) return False self.log.info("Update successful.") else: self.log.info("Installing package: {0}".format(pkg)) if not self.pm.install(pkg, static=static, verify=verify): self.log.error( "Error installing package {0}. Aborting.".format(pkg)) return False self.log.info("Installation successful.") return True
def run(self): """ Go, go, go! """ ### Sanity checks if self.fail_if_not_exists: for pkg in self.args.packages: if not self.pm.installed(pkg): self.log.error("Package {0} is not installed. Aborting.".format(pkg)) exit(1) ### Make install tree install_tree = dep_manager.DepManager().make_dep_tree( self.args.packages, self._check_if_pkg_goes_into_tree if not self.args.no_deps else lambda x: bool(x in self.args.packages) ) if len(install_tree) == 0 and not hasattr(self.args, 'quiet_install'): self.log.info("No packages to install.") return 0 self.log.debug("Install tree:") if self.log.getEffectiveLevel() <= 20 or self.args.print_tree: install_tree.pretty_print() ### Recursively install/update, starting at the leaf nodes install_cache = [] while len(install_tree): pkg = install_tree.pop_leaf_node() if pkg in install_cache: continue install_cache.append(pkg) if self.cmd == 'install' and self.args.deps_only and pkg in self.args.packages: self.log.debug("Skipping `{0}' because only deps are requested.") continue if self.pm.installed(pkg): self.log.info("Updating package: {0}".format(pkg)) if not self.pm.update(pkg, verify=self.args.verify): self.log.error("Error updating package {0}. Aborting.".format(pkg)) exit(1) self.log.info("Update successful.") else: self.log.info("Installing package: {0}".format(pkg)) if not self.pm.install(pkg, static=self.args.static, verify=self.args.verify): self.log.error("Error installing package {0}. Aborting.".format(pkg)) exit(1) self.log.info("Installation successful.")
def run(self): """ Go, go, go! """ ### Sanity checks for pkg in self.args.packages: if not self.is_installed(pkg): self.log.error("Package {0} is not installed. Aborting.".format(pkg)) return 1 dep_tree = dep_manager.DepManager().make_dep_tree( self.args.packages, lambda x: bool(x in self.args.packages), ) ### Remove packages for pkg in reversed(dep_tree.serialize()): self.log.info("Removing package {0}.".format(pkg)) # Uninstall: self.log.debug("Uninstalling.") if not self.pm.uninstall(pkg): self.log.warn("Could not uninstall {0} from prefix.".format(pkg)) # Remove entry from inventory: self.log.debug("Removing package from inventory.") self.inventory.remove(pkg) self.inventory.save()
def install( self, packages, mode, # install / update fail_if_not_exists=False, # Fail if any package in `packages' is not already installed update_if_exists=False, quiet=False, print_tree=False, deps_only=False, no_deps=False, verify=False, static=False, install_type=None): """ Install packages. """ def _check_if_pkg_goes_into_tree(pkg): " Return True if pkg has a legitimate right to be in the tree. " if fail_if_not_exists: return bool(self.pm.installed(pkg)) if no_deps and pkg not in packages: return False if not self.pm.installed(pkg): # If it's not installed, we'll try a binary install... self.log.debug( "Testing binary install for package {pkg}.".format( pkg=pkg)) if self.pm.install(pkg, install_type="binary", static=static, verify=verify, fail_silently=True): # ...and if that worked, it doesn't have to go into the tree. return False # Now it's still not installed, so it has to go into the tree: return True else: # If a package is already installed, but not flagged for # updating, it does not go into the tree: if not update_if_exists or not pkg in packages: return False # OK, so it needs updating. But only if it's a source package: if self.pm.installed(pkg, install_type="source"): return True # Otherwise, we should give it a shot: self.pm.update(pkg, install_type="binary") assert False # Should never reach this line ####### install() starts here ######### ### Sanity checks if fail_if_not_exists: for pkg in packages: if not self.pm.installed(pkg): self.log.error( "Package {0} is not installed. Aborting.".format(pkg)) return False extra_info_logger = self.log.info if not quiet else self.log.debug ### Make install tree and install binary packages extra_info_logger( "Phase 1: Creating install tree and installing binary packages:") install_tree = dep_manager.DepManager(self.pm).make_dep_tree( packages, _check_if_pkg_goes_into_tree) if len(install_tree) == 0 and not quiet: self.log.info("No packages to install.") return True if (self.log.getEffectiveLevel() <= 20 or print_tree) and not quiet: print("Install tree:") install_tree.pretty_print() if len(install_tree) > 0 and install_type == "binary": self.log.error( "Install method was `binary', but source packages are left over!" ) return False ### Recursively install/update source packages, starting at the leaf nodes extra_info_logger( "Phase 2: Recursively installing source packages to prefix:") for pkg in install_tree.serialize(): if mode == 'install' and deps_only and pkg in packages: self.log.debug( "Skipping `{0}' because only deps are requested.") continue if self.pm.installed(pkg): self.log.info("Updating package: {0}".format(pkg)) if not self.pm.update( pkg, install_type="source", verify=verify): self.log.error( "Error updating package {0}. Aborting.".format(pkg)) return False self.log.info("Update successful.") else: self.log.info("Installing package: {0}".format(pkg)) if not self.pm.install( pkg, install_type="source", static=static, verify=verify): self.log.error( "Error installing package {0}. Aborting.".format(pkg)) return False self.log.info("Installation successful.") return True
def install( self, packages, mode, # install / update fail_if_not_exists=False, # Fail if any package in `packages' is not already installed update_if_exists=False, quiet=False, print_tree=False, deps_only=False, no_deps=False, verify=False, static=False, install_type=None): """ Install packages. """ def _check_if_pkg_goes_into_tree(pkg): " Return True if pkg has a legitimate right to be in the tree. " self.log.trace( "Checking if package `{pkg}' goes into tree...".format( pkg=pkg)) if fail_if_not_exists and not bool(self.pm.installed(pkg)): self.log.trace( "Only installed packages need to into tree, and this one is not." ) return False if no_deps and pkg not in packages: self.log.trace("Not installing, because it's not in the list.") return False if not self.pm.exists(pkg): self.log.error( "Package has no install method: {0}".format(pkg)) raise PBException("Unresolved install path.") if not self.pm.installed(pkg): # If it's not installed, we'll try a binary install... self.log.debug( "Testing binary install for package {pkg}.".format( pkg=pkg)) if self.pm.install(pkg, install_type="binary", static=static, verify=verify, fail_silently=True): self.log.trace( "Binary install successful, so we don't put it into tree." ) # ...and if that worked, it doesn't have to go into the tree. return False self.log.trace("Not installed: It goes into tree.") # Now it's still not installed, so it has to go into the tree: return True else: # If a package is already installed, but not flagged for # updating, it does not go into the tree: if not update_if_exists or pkg not in packages: self.log.trace( "Installed, but no update requested. Does not go into tree." ) return False # OK, so it needs updating. But only if it's a source package: if self.pm.installed(pkg, install_type="source"): self.log.trace( "Package was source-installed, and needs update.") return True # Otherwise, we should give it a shot: self.log.trace( "Doesn't go into tree, but we'll try a packager update.") self.pm.update(pkg, install_type="binary") return False assert False # Should never reach this line _checker_cache = {} def _cached_check_if_pkg_goes_into_tree(pkg, check_callback): if pkg in _checker_cache: return _checker_cache[pkg] ret_val = check_callback(pkg) _checker_cache[pkg] = ret_val return ret_val ####### install() starts here ######### ### Sanity checks if fail_if_not_exists: for pkg in packages: if not self.pm.installed(pkg): self.log.error( "Package {0} is not installed. Aborting.".format(pkg)) return False extra_info_logger = self.log.info if not quiet else self.log.debug ### Make install tree and install binary packages extra_info_logger( "Phase 1: Creating install tree and installing binary packages:") install_tree = dep_manager.DepManager().make_dep_tree( packages, lambda pkg: _cached_check_if_pkg_goes_into_tree( pkg, _check_if_pkg_goes_into_tree)) if len(install_tree) == 0 and not quiet: extra_info_logger("No packages to install.") return True if (self.log.getEffectiveLevel() <= 20 or print_tree) and not quiet: print("Install tree:") install_tree.pretty_print() if len(install_tree) > 0 and install_type == "binary": self.log.error( "Install method was `binary', but source packages are left over!" ) return False extra_info_logger( "Phase 1 complete: All binary dependencies installed.") ### Recursively install/update source packages, starting at the leaf nodes extra_info_logger( "Phase 2: Recursively installing source packages to prefix:") for pkg in install_tree.serialize(): if mode == 'install' and deps_only and pkg in packages: self.log.debug( "Skipping `{0}' because only deps are requested.") continue if self.pm.installed(pkg): self.log.info("Updating package: {0}".format(pkg)) if not self.pm.update( pkg, install_type="source", verify=verify): self.log.error( "Error updating package {0}. Aborting.".format(pkg)) return False self.log.info("Update successful.") else: self.log.info("Installing package: {0}".format(pkg)) if not self.pm.install( pkg, install_type="source", static=static, verify=verify): self.log.error( "Error installing package {0}. Aborting.".format(pkg)) return False self.log.info("Installation successful.") extra_info_logger("Phase 2 complete: All source packages installed.") return True
def run(self): self.pid = os.getpid() self.pid_info.emit(self.pid) instaman = install_manager.InstallManager() if 'install' in self.package_list: install_list = self.package_list.get('install') for package in install_list: self.worker_log.info('Preparing {} for installation'.format(package)) if instaman.install([package], 'install'): self.worker_log.info("Install {} successful".format(package)) pkg_index = install_list.index(package)+1 progress = (pkg_index/len(install_list))* 100.0 self.progress_tick.emit(pkg_index, progress, len(install_list), 'install') else: self.worker_log.error("Install Failed") self.error_info.emit('install', "Install {} failed. Check logs !".format(package)) if 'update' in self.package_list: update_list = self.package_list.get('update') for package in update_list: self.worker_log.info("Preparing {} to update".format(package)) if instaman.install([package], 'update', update_if_exists=True): self.worker_log.info("Update {} successful".format(package)) pkg_index = update_list.index(package)+1 progress = (pkg_index/len(update_list))* 100.0 self.progress_tick.emit(pkg_index, progress, len(update_list), 'update') else: self.worker_log.error("Update Failed") self.error_info.emit( "Update {} failed. Check logs !".format(package)) if 'remove' in self.package_list: remove_list = self.package_list.get('remove') pm = package_manager.PackageManager() dep_tree = dep_manager.DepManager().make_dep_tree( self.package_list.get('remove'), lambda x: bool(x in self.package_list.get('remove'))) remove = reversed(dep_tree.serialize()) ### Remove packages for pkg in remove: #Uninstall: self.worker_log.info("Preparing {} to remove".format(pkg)) if pm.uninstall(pkg): self.worker_log.info("Uninstall {} successful !".format(pkg)) pkg_index = remove_list.index(pkg)+1 progress = (pkg_index/len(remove_list))* 100.0 self.progress_tick.emit(pkg_index, progress, len(remove_list), 'remove') #Remove entry from inventory: self.inventory.remove(pkg) self.inventory.save() else: self.worker_log.error("Failed to remove {}".format(pkg)) self.error_info.emit( "Removing {} unsuccessful. Check logs !".format(pkg)) self.info_tick.emit("Tasks Completed successfully !") return