def upgrade_base(A = set()): installdb = pisilinux.db.installdb.InstallDB() componentdb = pisilinux.db.componentdb.ComponentDB() if not ctx.config.values.general.ignore_safety and not ctx.get_option('ignore_safety'): if componentdb.has_component('system.base'): systembase = set(componentdb.get_union_component('system.base').packages) extra_installs = [x for x in systembase - set(A) if not installdb.has_package(x)] extra_installs = pisilinux.blacklist.exclude_from(extra_installs, ctx.const.blacklist) if extra_installs: ctx.ui.warning(_("Safety switch forces the installation of " "following packages:")) ctx.ui.info(util.format_by_columns(sorted(extra_installs))) G_f, install_order = operations.install.plan_install_pkg_names(extra_installs) extra_upgrades = [x for x in systembase - set(install_order) if is_upgradable(x)] upgrade_order = [] extra_upgrades = pisilinux.blacklist.exclude_from(extra_upgrades, ctx.const.blacklist) if ctx.get_option('exclude_from'): extra_upgrades = pisilinux.blacklist.exclude_from(extra_upgrades, ctx.get_option('exclude_from')) if ctx.get_option('exclude'): extra_upgrades = pisilinux.blacklist.exclude(extra_upgrades, ctx.get_option('exclude')) if extra_upgrades: ctx.ui.warning(_("Safety switch forces the upgrade of " "following packages:")) ctx.ui.info(util.format_by_columns(sorted(extra_upgrades))) G_f, upgrade_order = plan_upgrade(extra_upgrades, force_replaced=False) # return packages that must be added to any installation return set(install_order + upgrade_order) else: ctx.ui.warning(_('Safety switch: The component system.base cannot be found.')) return set()
def run(self): self.init(database = True, write = False) build_host = ctx.get_option("with_build_host") if build_host is None: installed = self.installdb.list_installed() else: installed = self.installdb.list_installed_with_build_host(build_host) component = ctx.get_option('component') if component: #FIXME: pisilinux api is insufficient to do this component_pkgs = self.componentdb.get_union_packages(component, walk=True) installed = list(set(installed) & set(component_pkgs)) installed.sort() # Resize the first column according to the longest package name if installed: maxlen = max([len(_p) for _p in installed]) if self.options.install_info: ctx.ui.info(_('Package Name |St| Version| Rel.| Distro| Date')) print('===========================================================================') for pkg in installed: package = self.installdb.get_package(pkg) inst_info = self.installdb.get_info(pkg) if self.options.long: ctx.ui.info(str(package)) ctx.ui.info(str(inst_info)) elif self.options.install_info: ctx.ui.info('%-20s |%s' % (package.name, inst_info.one_liner())) else: package.name = package.name + ' ' * (maxlen - len(package.name)) ctx.ui.info('%s - %s' % (package.name, str(package.summary)))
def run(self): if self.options.fetch_only: self.init(database=True, write=False) else: self.init() if not ctx.get_option('bypass_update_repo'): ctx.ui.info(_('Updating repositories')) repos = pisilinux.api.list_repos() pisilinux.api.update_repos(repos) else: ctx.ui.info(_('Will not update repositories')) repository = ctx.get_option('repository') components = ctx.get_option('component') packages = [] if components: componentdb = pisilinux.db.componentdb.ComponentDB() for name in components: if componentdb.has_component(name): if repository: packages.extend(componentdb.get_packages(name, walk=True, repo=repository)) else: packages.extend(componentdb.get_union_packages(name, walk=True)) packages.extend(self.args) pisilinux.api.upgrade(packages, repository)
def run(self): self.init(database=False, write=False) if self.options.package_format == "help": ctx.ui.info(_("Supported package formats:")) for format in pisilinux.package.Package.formats: if format == pisilinux.package.Package.default_format: ctx.ui.info(_(" %s (default)") % format) else: ctx.ui.info(" %s" % format) return new_package = ctx.get_option("newest_package") if new_package: old_packages = self.args else: if len(self.args) < 2: self.help() return new_package = self.args[-1] old_packages = self.args[:-1] if not ctx.get_option('output_dir'): ctx.config.options.output_dir = '.' from pisilinux.operations.delta import create_delta_packages create_delta_packages(old_packages, new_package)
def run(self): self.init(write=False) if not ctx.get_option("installed"): # Graph from package database packagedb = pisilinux.db.packagedb.PackageDB() if ctx.get_option("repository"): repo = ctx.get_option("repository") ctx.ui.info(_("Plotting packages in repository %s") % repo) else: repo = None ctx.ui.info(_("Plotting a graph of relations among all repository packages")) if self.args: a = self.args else: a = pisilinux.api.list_available(repo) else: # Graph from installed packages database packagedb = pisilinux.db.installdb.InstallDB() if self.args: a = self.args else: # if A is empty, then graph all packages ctx.ui.info(_("Plotting a graph of relations among all installed packages")) a = pisilinux.api.list_installed() g = pisilinux.api.package_graph( a, packagedb, ignore_installed=ctx.get_option("ignore_installed"), reverse=ctx.get_option("reverse") ) g.write_graphviz(file(ctx.get_option("output"), "w"))
def remove(A, ignore_dep = False, ignore_safety = False): """remove set A of packages from system (A is a list of package names)""" componentdb = pisilinux.db.componentdb.ComponentDB() installdb = pisilinux.db.installdb.InstallDB() A = [str(x) for x in A] # filter packages that are not installed A_0 = A = set(A) if not ctx.get_option('ignore_safety') and not ctx.config.values.general.ignore_safety and not ignore_safety: if componentdb.has_component('system.base'): systembase = set(componentdb.get_union_component('system.base').packages) refused = A.intersection(systembase) if refused: raise pisilinux.Error(_("Safety switch prevents the removal of " "following packages:\n") + util.format_by_columns(sorted(refused))) A = A - systembase else: ctx.ui.warning(_("Safety switch: The component system.base cannot be found.")) Ap = [] for x in A: if installdb.has_package(x): Ap.append(x) else: ctx.ui.info(_('Package %s does not exist. Cannot remove.') % x) A = set(Ap) if len(A)==0: ctx.ui.info(_('No packages to remove.')) return False if not ctx.config.get_option('ignore_dependency') and not ignore_dep: G_f, order = plan_remove(A) else: G_f = None order = A ctx.ui.info(_("""The following list of packages will be removed in the respective order to satisfy dependencies: """) + util.strlist(order)) if len(order) > len(A_0): if not ctx.ui.confirm(_('Do you want to continue?')): ctx.ui.warning(_('Package removal declined')) return False if ctx.get_option('dry_run'): return ctx.ui.notify(ui.packagestogo, order = order) for x in order: if installdb.has_package(x): atomicoperations.remove_single(x) else: ctx.ui.info(_('Package %s is not installed. Cannot remove.') % x)
def find_upgrades(packages, replaces): packagedb = pisilinux.db.packagedb.PackageDB() installdb = pisilinux.db.installdb.InstallDB() debug = ctx.config.get_option("debug") security_only = ctx.get_option('security_only') comparesha1sum = ctx.get_option('compare_sha1sum') Ap = [] ds = [] for i_pkg in packages: if i_pkg in list(replaces.keys()): # Replaced packages will be forced for upgrade, cause replaced packages are marked as obsoleted also. So we # pass them. continue if i_pkg.endswith(ctx.const.package_suffix): ctx.ui.debug(_("Warning: package *name* ends with '.pisilinux'")) if not installdb.has_package(i_pkg): ctx.ui.info(_('Package %s is not installed.') % i_pkg, True) continue if not packagedb.has_package(i_pkg): ctx.ui.info(_('Package %s is not available in repositories.') % i_pkg, True) continue pkg = packagedb.get_package(i_pkg) hash = installdb.get_install_tar_hash(i_pkg) (version, release, build, distro, distro_release) = installdb.get_version_and_distro_release(i_pkg) if security_only and not pkg.has_update_type("security", release): continue if pkg.distribution == distro and \ pisilinux.version.make_version(pkg.distributionRelease) > pisilinux.version.make_version(distro_release): Ap.append(i_pkg) else: if int(release) < int(pkg.release): Ap.append(i_pkg) elif comparesha1sum and \ int(release) == int(pkg.release) and \ not pkg.installTarHash == hash: Ap.append(i_pkg) ds.append(i_pkg) else: ctx.ui.info(_('Package %s is already at the latest release %s.') % (pkg.name, pkg.release), True) if debug and ds: ctx.ui.status(_('The following packages have different sha1sum:')) ctx.ui.info(util.format_by_columns(sorted(ds))) return Ap
def run(self): self.init(database = False, write = False) if ctx.get_option('snapshot'): self.take_snapshot() return elif ctx.get_option('takeback'): opno = ctx.get_option('takeback') if opno != -1: self.takeback(opno) return self.redirect_output(self.print_history)
def add_path(path): # add the files under material path for fpath, fhash in util.get_file_hashes(path, collisions, install_dir): if ( ctx.get_option("create_static") and fpath.endswith(ctx.const.ar_file_suffix) and not package.name.endswith(ctx.const.static_name_suffix) and util.is_ar_file(fpath) ): # if this is an ar file, and this package is not a static package, # don't include this file into the package. continue frpath = util.removepathprefix(install_dir, fpath) # relative path ftype, permanent = get_file_type(frpath, package.files) fsize = int(util.dir_size(fpath)) if not os.path.islink(fpath): st = os.stat(fpath) else: st = os.lstat(fpath) d[frpath] = pisilinux.files.FileInfo( path=frpath, type=ftype, permanent=permanent, size=fsize, hash=fhash, uid=str(st.st_uid), gid=str(st.st_gid), mode=oct(stat.S_IMODE(st.st_mode)), ) if stat.S_IMODE(st.st_mode) & stat.S_ISUID: ctx.ui.warning(_("/%s has suid bit set") % frpath)
def check_path_collision(package, pkgList): """This function will check for collision of paths in a package with the paths of packages in pkgList. The return value will be the list containing the paths that collide.""" create_static = ctx.get_option("create_static") create_debug = ctx.config.values.build.generatedebug ar_suffix = ctx.const.ar_file_suffix debug_suffix = ctx.const.debug_file_suffix collisions = [] for pinfo in package.files: for pkg in pkgList: if pkg is package: continue for path in pkg.files: # if pinfo.path is a subpath of path.path like # the example below. path.path is marked as a # collide. Exp: # pinfo.path: /usr/share # path.path: /usr/share/doc if (create_static and path.path.endswith(ar_suffix)) or ( create_debug and path.path.endswith(debug_suffix) ): # don't throw collision error for these files. # we'll handle this in gen_files_xml.. continue if util.subpath(pinfo.path, path.path): collisions.append(path.path.rstrip("/")) ctx.ui.debug(_("Path %s belongs in multiple packages") % path.path) return collisions
def run(self): self.init(database = True, write = False) upgradable_pkgs = pisilinux.api.list_upgradable() component = ctx.get_option('component') if component: #FIXME: pisilinux api is insufficient to do this component_pkgs = self.componentdb.get_union_packages(component, walk=True) upgradable_pkgs = list(set(upgradable_pkgs) & set(component_pkgs)) upgradable_pkgs = pisilinux.blacklist.exclude_from(upgradable_pkgs, ctx.const.blacklist) if not upgradable_pkgs: ctx.ui.info(_('No packages to upgrade.')) return upgradable_pkgs.sort() # Resize the first column according to the longest package name maxlen = max([len(_p) for _p in upgradable_pkgs]) if self.options.install_info: ctx.ui.info(_('Package Name |St| Version| Rel.| Distro| Date')) print('===========================================================================') for pkg in upgradable_pkgs: package = self.installdb.get_package(pkg) inst_info = self.installdb.get_info(pkg) if self.options.long: ctx.ui.info(package) print(inst_info) elif self.options.install_info: ctx.ui.info('%-20s |%s ' % (package.name, inst_info.one_liner())) else: package.name = package.name + ' ' * (maxlen - len(package.name)) ctx.ui.info('%s - %s' % (package.name, str(package.summary)))
def print_packages(self, repo): component = ctx.get_option('component') if component: try: l = self.componentdb.get_packages(component, repo=repo, walk=True) except Exception as e: return else: l = pisilinux.api.list_available(repo) installed_list = pisilinux.api.list_installed() # maxlen is defined dynamically from the longest package name (#9021) if l: maxlen = max([len(_p) for _p in l]) l.sort() for p in l: if ctx.config.get_option('uninstalled') and p in installed_list: continue package = self.packagedb.get_package(p, repo) if p in installed_list: package.name = util.colorize(package.name, 'green') else: package.name = util.colorize(package.name, 'brightwhite') if self.options.long: ctx.ui.info(str(package)+'\n') else: package.name += ' ' * max(0, maxlen - len(p)) ctx.ui.info('%s - %s ' % (package.name, str(package.summary)))
def generate_pending_order(A): # returns pending package list in reverse topological order of dependency installdb = pisilinux.db.installdb.InstallDB() G_f = pgraph.PGraph(installdb) # construct G_f for x in A: G_f.add_package(x) B = A while len(B) > 0: Bp = set() for x in B: pkg = installdb.get_package(x) for dep in pkg.runtimeDependencies(): if dep.package in G_f.vertices(): G_f.add_dep(x, dep) B = Bp if ctx.get_option('debug'): import sys G_f.write_graphviz(sys.stdout) order = G_f.topological_sort() order.reverse() componentdb = pisilinux.db.componentdb.ComponentDB() # Bug 4211 if componentdb.has_component('system.base'): order = reorder_base_packages(order) return order
def run(self): self.init(database=True, write=False) from pisilinux.api import index from pisilinux.file import File ctypes = {"bz2": File.COMPRESSION_TYPE_BZ2, "xz": File.COMPRESSION_TYPE_XZ} compression = 0 for type_str in ctx.get_option("compression_types").split(","): compression |= ctypes.get(type_str, 0) index(self.args or ["."], ctx.get_option('output'), skip_sources=ctx.get_option('skip_sources'), skip_signing=ctx.get_option('skip_signing'), compression=compression)
def run_action_function(self, func, mandatory=False): """Calls the corresponding function in actions.py. If mandatory parameter is True, and function is not present in actionLocals pisilinux.build.Error will be raised.""" # we'll need our working directory after actionscript # finished its work in the archive source directory. curDir = os.getcwd() src_dir = self.pkg_src_dir() if os.path.exists(src_dir): os.chdir(src_dir) else: raise Error(_("ERROR: WorkDir (%s) does not exist\n") % src_dir) if func in self.actionLocals: if ( ctx.get_option("ignore_sandbox") or not ctx.config.values.build.enablesandbox or "emul32" in self.build_type ): self.actionLocals[func]() else: import catbox ctx.ui.info(_("Sandbox enabled build...")) # Configure allowed paths from sandbox.conf valid_paths = [self.pkg_dir()] conf_file = ctx.const.sandbox_conf if os.path.exists(conf_file): for line in file(conf_file): line = line.strip() if len(line) > 0 and not line.startswith("#"): if line.startswith("~"): line = os.environ["HOME"] + line[1:] valid_paths.append(line) # Extra path for ccache when needed if ctx.config.values.build.buildhelper == "ccache": valid_paths.append(os.environ.get("CCACHE_DIR", "/root/.ccache")) ret = catbox.run(self.actionLocals[func], valid_paths, logger=self.log_sandbox_violation) # Retcode can be 0 while there is a sanbox violation, so only # look for violations to correctly handle it if ret.violations != []: ctx.ui.error(_("Sandbox violation result:")) for result in ret.violations: ctx.ui.error("%s (%s -> %s)" % (result[0], result[1], result[2])) raise Error(_("Sandbox violations!")) if ret.code == 1: raise ActionScriptException else: if mandatory: raise Error(_("unable to call function from actions: %s") % func) os.chdir(curDir) return True
def run(self): if self.options.fetch_only: self.init(database=True, write=False) else: self.init() components = ctx.get_option('component') if not components and not self.args: self.help() return packages = [] if components: for name in components: if self.componentdb.has_component(name): repository = ctx.get_option('repository') if repository: packages.extend(self.componentdb.get_packages(name, walk=True, repo=repository)) else: packages.extend(self.componentdb.get_union_packages(name, walk=True)) else: ctx.ui.info(_('There is no component named %s') % name) packages.extend(self.args) if ctx.get_option('exclude_from'): packages = pisilinux.blacklist.exclude_from(packages, ctx.get_option('exclude_from')) if ctx.get_option('exclude'): packages = pisilinux.blacklist.exclude(packages, ctx.get_option('exclude')) reinstall = bool(packages) and packages[0].endswith(ctx.const.package_suffix) pisilinux.api.install(packages, ctx.get_option('reinstall') or reinstall)
def warning(self, msg, verbose = False): msg = str(msg) self.warnings += 1 if ctx.log: ctx.log.warning(msg) if ctx.get_option('no_color'): self.output(_('Warning: ') + msg + '\n', err=True, verbose=verbose) else: self.output(pisilinux.util.colorize(msg + '\n', 'brightyellow'), err=True, verbose=verbose)
def error(self, msg): msg = str(msg) self.errors += 1 if ctx.log: ctx.log.error(msg) if ctx.get_option('no_color'): self.output(_('Error: ') + msg + '\n', err=True) else: self.output(pisilinux.util.colorize(msg + '\n', 'brightred'), err=True)
def run(self): self.init(database = True) if self.args: repos = self.args else: repos = pisilinux.api.list_repos() pisilinux.api.update_repos(repos, ctx.get_option('force'))
def print_specdata(self, spec, sourcedb=None): src = spec.source if ctx.get_option('short'): ctx.ui.formatted_output(" - ".join((src.name, str(src.summary)))) else: ctx.ui.formatted_output(str(spec)) if sourcedb: revdeps = [name for name, dep in sourcedb.get_rev_deps(spec.source.name)] print(_('Reverse Build Dependencies:'), util.strlist(revdeps)) print()
def print_metadata(self, metadata, packagedb=None): if ctx.get_option('short'): pkg = metadata.package ctx.ui.formatted_output(" - ".join((pkg.name, str(pkg.summary)))) else: ctx.ui.formatted_output(str(metadata.package)) if packagedb: revdeps = [name for name, dep in packagedb.get_rev_deps(metadata.package.name)] ctx.ui.formatted_output(" ".join((_("Reverse Dependencies:"), util.strlist(revdeps)))) print()
def run(self): self.init(database = True, write = False) if not self.args: self.help() return cs = ctx.get_option("case_sensitive") replace = re.compile("(%s)" % "|".join(self.args), 0 if cs else re.I) lang = ctx.get_option('language') repo = ctx.get_option('repository') name = ctx.get_option('name') summary = ctx.get_option('summary') desc = ctx.get_option('description') fields = None if name or summary or desc: fields = {'name': name, 'summary': summary, 'desc': desc} if ctx.get_option('installdb'): db = pisilinux.db.installdb.InstallDB() pkgs = db.search_package(self.args, lang, fields, cs) get_info = db.get_package get_name_sum = lambda pkg:(pkg.name, pkg.summary) elif ctx.get_option('sourcedb'): db = pisilinux.db.sourcedb.SourceDB() pkgs = db.search_spec(self.args, lang, repo, fields, cs) get_info = db.get_spec get_name_sum = lambda pkg:(pkg.source.name, pkg.source.summary) else: db = pisilinux.db.packagedb.PackageDB() pkgs = db.search_package(self.args, lang, repo, fields, cs) get_info = db.get_package get_name_sum = lambda pkg:(pkg.name, pkg.summary) if pkgs: maxlen = max([len(_pkg) for _pkg in pkgs]) for pkg in pkgs: pkg_info = get_info(pkg) name, summary = get_name_sum(pkg_info) lenp = len(name) name = replace.sub(pisilinux.util.colorize(r"\1", "brightred"), name) if lang and lang in summary: summary = replace.sub(pisilinux.util.colorize(r"\1", "brightred"), str(summary[lang])) else: summary = replace.sub(pisilinux.util.colorize(r"\1", "brightred"), str(summary)) name += ' ' * max(0, maxlen - lenp) ctx.ui.info('%s - %s' % (name, summary))
def check_operation(self): self.old_pkginfo = None pkg = self.pkginfo if self.installdb.has_package(pkg.name): # is this a reinstallation? ipkg = self.installdb.get_package(pkg.name) (iversion_s, irelease_s, ibuild) = self.installdb.get_version(pkg.name) # determine if same version if pkg.release == irelease_s: if self.ask_reinstall: if not ctx.ui.confirm(_('Re-install same version package?')): raise Error(_('Package re-install declined')) self.operation = REINSTALL else: pkg_version = pisi.version.make_version(pkg.version) iversion = pisi.version.make_version(iversion_s) if ctx.get_option('store_lib_info') and pkg_version > iversion: self.store_old_paths = os.path.join(ctx.config.old_paths_cache_dir(), pkg.name) ctx.ui.info(_('Storing old paths info')) open(self.store_old_paths, "w").write("Version: %s\n" % iversion_s) pkg_release = int(pkg.release) irelease = int(irelease_s) # is this an upgrade? # determine and report the kind of upgrade: version, release if pkg_version > iversion: ctx.ui.info(_('Upgrading to new upstream version')) self.operation = UPGRADE elif pkg_release > irelease: ctx.ui.info(_('Upgrading to new distribution release')) self.operation = UPGRADE # is this a downgrade? confirm this action. if not self.operation == UPGRADE: if pkg_version < iversion: #x = _('Downgrade to old upstream version?') x = None elif pkg_release < irelease: x = _('Downgrade to old distribution release?') else: x = None if self.ask_reinstall and x and not ctx.ui.confirm(x): raise Error(_('Package downgrade declined')) self.operation = DOWNGRADE # schedule for reinstall self.old_files = self.installdb.get_files(pkg.name) self.old_pkginfo = self.installdb.get_info(pkg.name) self.old_path = self.installdb.pkg_dir(pkg.name, iversion_s, irelease_s) self.remove_old = Remove(pkg.name, store_old_paths = self.store_old_paths) self.remove_old.run_preremove() self.remove_old.run_postremove()
def emerge(A): # A was a list, remove duplicates and expand components A = [str(x) for x in A] A_0 = A = pisilinux.operations.helper.expand_src_components(set(A)) ctx.ui.debug('A = %s' % str(A)) if len(A)==0: ctx.ui.info(_('No packages to emerge.')) return #A |= upgrade_base(A) # FIXME: Errr... order_build changes type conditionally and this # is not good. - baris if not ctx.config.get_option('ignore_dependency'): G_f, order_inst, order_build = plan_emerge(A) else: G_f = None order_inst = [] order_build = A if order_inst: ctx.ui.info(_("""The following list of packages will be installed from repository in the respective order to satisfy dependencies: """) + util.strlist(order_inst)) ctx.ui.info(_("""The following list of packages will be built and installed in the respective order to satisfy dependencies: """) + util.strlist(order_build)) if ctx.get_option('dry_run'): return if len(order_inst) + len(order_build) > len(A_0): if not ctx.ui.confirm(_('There are extra packages due to dependencies. Do you want to continue?')): return False ctx.ui.notify(ui.packagestogo, order = order_inst) for x in order_inst: atomicoperations.install_single_name(x) #ctx.ui.notify(ui.packagestogo, order = order_build) for x in order_build: package_names = atomicoperations.build(x).new_packages pisilinux.operations.install.install_pkg_files(package_names, reinstall=True) # handle inter-package deps here # reset counts between builds ctx.ui.errors = ctx.ui.warnings = 0 # FIXME: take a look at the fixme above :(, we have to be sure # that order_build is a known type... U = set(order_build) U.update(order_inst)
def run(self): self.init(database = True) component = ctx.get_option('component') if not self.args and not component: self.help() return if component: componentdb = pisilinux.db.componentdb.ComponentDB() sources = componentdb.get_union_sources(component, walk=True) else: sources = self.args if ctx.get_option('output_dir'): ctx.ui.info(_('Output directory: %s') % ctx.config.options.output_dir) else: ctx.ui.info(_('Outputting binary packages in the package cache.')) ctx.config.options.output_dir = ctx.config.cached_packages_dir() pisilinux.api.emerge(sources)
def run(self): self.init(database=False, write=False) if not self.args: self.help() return for package in self.args: if self.installdb.has_package(package): pkg = self.installdb.get_package(package) release = ctx.get_option('release') if not release and not ctx.get_option('all'): self.print_package_info(pkg) elif ctx.get_option('all'): for hno, update in enumerate(pkg.history): self.print_package_info(pkg, hno) else: for hno, update in enumerate(pkg.history): if int(update.release) == release: self.print_package_info(pkg, hno) return
def remove_file(fileinfo, package_name, remove_permanent=False, store_old_paths=None): if fileinfo.permanent and not remove_permanent: return fpath = pisi.util.join_path(ctx.config.dest_dir(), fileinfo.path) historydb = pisi.db.historydb.HistoryDB() # we should check if the file belongs to another # package (this can legitimately occur while upgrading # two packages such that a file has moved from one package to # another as in #2911) pkg, existing_file = ctx.filesdb.get_file(fileinfo.path) if pkg and not pkg == package_name: ctx.ui.warning(_('Not removing conflicted file : %s') % fpath) return if fileinfo.type == ctx.const.conf: # config files are precious, leave them as they are # unless they are the same as provided by package. # remove symlinks as they are, cause if the hash of the # file it links has changed, it will be kept as is, # and when the package is reinstalled the symlink will # link to that changed file again. try: if os.path.islink(fpath) or pisi.util.sha1_file(fpath) == fileinfo.hash: os.unlink(fpath) else: # keep changed file in history historydb.save_config(package_name, fpath) # after saving to history db, remove the config file any way if ctx.get_option("purge"): os.unlink(fpath) except pisi.util.FileError: pass else: if os.path.isfile(fpath) or os.path.islink(fpath): os.unlink(fpath) if store_old_paths: open(store_old_paths, "a").write("%s\n" % fpath) elif os.path.isdir(fpath) and not os.listdir(fpath): os.rmdir(fpath) else: ctx.ui.warning(_('Installed file %s does not exist on system [Probably you manually deleted]') % fpath) return # remove emptied directories dpath = os.path.dirname(fpath) while dpath != '/' and not os.listdir(dpath): os.rmdir(dpath) dpath = os.path.dirname(dpath)
def build(self): """Build the package in one shot.""" architecture = ctx.config.values.general.architecture if architecture in self.spec.source.excludeArch: raise ExcludedArchitectureException( _("pspec.xml avoids this package from building for '%s'") % architecture ) ctx.ui.status(_("Building source package: %s") % self.spec.source.name) self.compile_comar_script() # check if all patch files exists, if there are missing no need # to unpack! self.check_patches() self.check_build_dependencies() self.fetch_component() self.fetch_source_archives() for build_type in self.build_types: self.set_build_type(build_type) self.unpack_source_archives() if self.has_ccache: ctx.ui.info(_("ccache detected...")) if self.has_icecream: ctx.ui.info(_("IceCream detected. Make sure your daemon " "is up and running...")) self.run_setup_action() self.run_build_action() if ctx.get_option("debug") and not ctx.get_option("ignore_check"): self.run_check_action() self.run_install_action() # after all, we are ready to build/prepare the packages self.build_packages()
def install(packages, reinstall=False, ignore_file_conflicts=False, ignore_package_conflicts=False): """ Returns True if no errors occured during the operation @param packages: list of package names -> list_of_strings @param reinstall: reinstalls already installed packages else ignores @param ignore_file_conflicts: Ignores file conflicts during the installation and continues to install packages. @param ignore_package_conflicts: Ignores package conflicts during the installation and continues to install packages. """ pisilinux.db.historydb.HistoryDB().create_history("install") if not ctx.get_option('ignore_file_conflicts'): ctx.set_option('ignore_file_conflicts', ignore_file_conflicts) if not ctx.get_option('ignore_package_conflicts'): ctx.set_option('ignore_package_conflicts', ignore_package_conflicts) # Install pisilinux package files or pisilinux packages from a repository if packages and packages[0].endswith(ctx.const.package_suffix): return pisilinux.operations.install.install_pkg_files(packages, reinstall) else: return pisilinux.operations.install.install_pkg_names(packages, reinstall)
def print_history(self): for operation in self.historydb.get_last(ctx.get_option('last')): print(_("Operation #%d: %s") % (operation.no, opttrans[operation.type])) print(_("Date: %s %s") % (operation.date, operation.time)) print() if operation.type == "snapshot": print(_(" * There are %d packages in this snapshot.") % len(operation.packages)) elif operation.type == "repoupdate": for repo in operation.repos: print(" *", repo) else: for pkg in operation.packages: print(" *", pkg) print()