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()