return 1
;;
esac
- # Note: Even though the message is split on $'\n' here, it's still
- # not entirely safe to use it as a delimiter in the log file since
- # there can still be escaped newlines that will be expanded due to
- # the echo -e parameter.
echo -e "$@" | while read line ; do
- echo -ne "${messagetype} ${line}\n\0" >> \
+ echo "${messagetype} ${line}" >> \
"${T}/logging/${EBUILD_PHASE:-other}"
done
return 0
[installed category packages]
class = portage.sets.dbapi.CategorySet
multiset = true
- repository = vartree
name_pattern = $category/*
+ intersect = installed
</programlisting>
</para>
<!-- TODO: reference list of available set handler classes here -->
<listitem><varname>category</varname>: Required. The name of an existing ebuild
category which should be used to create the package set.
</listitem>
- <listitem><varname>repository</varname>: Optional, defaults to
- <parameter>porttree</parameter>. It determines which repository class should
- be used to create the package set. Valid values for this option are:
- <parameter>porttree</parameter> (normal ebuild repository),
- <parameter>vartree</parameter> (installed package repository)
- and <parameter>bintree</parameter> (local binary package repository).
- </listitem>
<listitem><varname>only_visible</varname>: Optional, defaults to <parameter>true</parameter>.
When set to <parameter>true</parameter> the set will only include visible packages,
when set to <parameter>false</parameter> it will also include masked packages.
values that must not be contained within the specified
variable.
</listitem>
+ <listitem><varname>metadata-source</varname>: Optional, defaults to
+ "vartree". Specifies the repository to use for getting the metadata
+ to check.</listitem>
</itemizedlist>
</para>
</sect2>
from portage import manifest
mf = manifest.Manifest(
pkgdir, self.settings["DISTDIR"])
- fetchlist = self.portdb.getFetchMap(mycpv)
try:
- mysum[0] = mf.getDistfilesSize(fetchlist)
- except KeyError, e:
- file_size_str = "Unknown (missing digest for %s)" % \
- str(e)
+ uri_map = self.portdb.getFetchMap(mycpv)
+ except portage.exception.InvalidDependString, e:
+ file_size_str = "Unknown (%s)" % (e,)
+ del e
+ else:
+ try:
+ mysum[0] = mf.getDistfilesSize(uri_map)
+ except KeyError, e:
+ file_size_str = "Unknown (missing " + \
+ "digest for %s)" % (e,)
+ del e
available = False
for db in self._dbs:
self._match = self.dbapi.match
self.dbapi.match = self._match_wrapper
self._aux_get_history = set()
- self._portdb_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
+ self._portdb_keys = ["EAPI", "DEPEND", "RDEPEND", "PDEPEND"]
self._portdb = portdb
self._global_updates = None
# Use the live ebuild metadata if possible.
live_metadata = dict(izip(self._portdb_keys,
self._portdb.aux_get(pkg, self._portdb_keys)))
+ if not portage.eapi_is_supported(live_metadata["EAPI"]):
+ raise KeyError(pkg)
self.dbapi.aux_update(pkg, live_metadata)
except (KeyError, portage.exception.PortageException):
if self._global_updates is None:
favorites_set = InternalPackageSet(favorites)
oneshot = "--oneshot" in self.myopts or \
"--onlydeps" in self.myopts
+ columns = "--columns" in self.myopts
changelogs=[]
p=[]
blockers = []
addl += colorize(blocker_style,
" (is blocking %s)") % block_parents
if isinstance(x, Blocker) and x.satisfied:
+ if columns:
+ continue
p.append(addl)
else:
blockers.append(addl)
(pkgprint(pkg_type), addl, indent,
pkgprint(pkg.cpv), myoldbest)
+ if columns and pkg.operation == "uninstall":
+ continue
p.append((myprint, verboseadd, repoadd))
if "--tree" not in self.myopts and \
logentries[msgfunction] = []
lastmsgtype = None
msgcontent = []
- for l in open(filename, "r").read().split("\0"):
+ for l in open(filename, "rb"):
if not l:
continue
try:
self.errors = []
if not setname in self.psets:
options["name"] = setname
+ options["world-candidate"] = "False"
# for the unlikely case that there is already a section with the requested setname
import random
try:
setclass = load_mod(classname)
except (ImportError, AttributeError):
- self.errors.append("Could not import '%s' for section '%s'" % (classname, sname))
- continue
+ try:
+ setclass = load_mod("portage.sets."+classname)
+ except (ImportError, AttributeError):
+ self.errors.append("Could not import '%s' for section '%s'" % (classname, sname))
+ continue
# prepare option dict for the current section
optdict = {}
for oname in self.options(sname):
def write(self):
pass
+class DummyPackageSet(PackageSet):
+ def __init__(self, atoms=None):
+ super(DummyPackageSet, self).__init__()
+ if atoms:
+ self._setAtoms(atoms)
+
+ def load(self):
+ pass
+
+ def singleBuilder(cls, options, settings, trees):
+ atoms = options.get("packages", "").split()
+ return DummyPackageSet(atoms=atoms)
+ singleBuilder = classmethod(singleBuilder)
# Distributed under the terms of the GNU General Public License v2
# $Id$
-from portage.versions import catpkgsplit, catsplit, pkgcmp
+from portage.versions import catpkgsplit, catsplit, pkgcmp, best
from portage.dep import Atom
from portage.sets.base import PackageSet
from portage.sets import SetConfigError, get_boolean
description = "Package set which contains all packages " + \
"that match specified values of a specified variable."
- def __init__(self, vardb, portdb=None, variable=None, includes=None, excludes=None):
+ def __init__(self, vardb, metadatadb=None, variable=None, includes=None, excludes=None):
super(VariableSet, self).__init__(vardb)
- self._portdb = portdb
+ self._metadatadb = metadatadb
self._variable = variable
self._includes = includes
self._excludes = excludes
def _filter(self, atom):
- ebuild = self._portdb.xmatch("bestmatch-visible", atom)
+ ebuild = best(self._metadatadb.match(atom))
if not ebuild:
return False
- values, = self._portdb.aux_get(ebuild, [self._variable])
+ values, = self._metadatadb.aux_get(ebuild, [self._variable])
values = values.split()
if self._includes and not self._includes.intersection(values):
return False
if not (includes or excludes):
raise SetConfigError("no includes or excludes given")
+
+ metadatadb = options.get("metadata-source", "vartree")
+ if not metadatadb in trees.keys():
+ raise SetConfigError("invalid value '%s' for option metadata-source" % metadatadb)
return cls(trees["vartree"].dbapi,
- portdb=trees["porttree"].dbapi,
+ metadatadb=trees[metadatadb].dbapi,
excludes=frozenset(excludes.split()),
includes=frozenset(includes.split()),
variable=variable)
myatoms.append(cp)
self._setAtoms(myatoms)
- def _builderGetRepository(cls, options, repositories):
- repository = options.get("repository", "porttree")
- if not repository in repositories:
- raise SetConfigError("invalid repository class '%s'" % repository)
- return repository
- _builderGetRepository = classmethod(_builderGetRepository)
-
def _builderGetVisible(cls, options):
return get_boolean(options, "only_visible", True)
_builderGetVisible = classmethod(_builderGetVisible)
if not category in settings.categories:
raise SetConfigError("invalid category name '%s'" % category)
- repository = cls._builderGetRepository(options, trees.keys())
visible = cls._builderGetVisible(options)
- return CategorySet(category, dbapi=trees[repository].dbapi, only_visible=visible)
+ return CategorySet(category, dbapi=trees["porttree"].dbapi, only_visible=visible)
singleBuilder = classmethod(singleBuilder)
def multiBuilder(cls, options, settings, trees):
else:
categories = settings.categories
- repository = cls._builderGetRepository(options, trees.keys())
visible = cls._builderGetVisible(options)
name_pattern = options.get("name_pattern", "$category/*")
raise SetConfigError("name_pattern doesn't include $category placeholder")
for cat in categories:
- myset = CategorySet(cat, trees[repository].dbapi, only_visible=visible)
+ myset = CategorySet(cat, trees["porttree"].dbapi, only_visible=visible)
myname = name_pattern.replace("$category", cat)
myname = myname.replace("${category}", cat)
rValue[myname] = myset
projects / portage.git / commitdiff