content_files = []
md5_match_hash = {}
- options = dispatch_conf.read_config(MANDATORY_OPTS)
+ options = portage.dispatch_conf.read_config(MANDATORY_OPTS)
for conf in sys.argv[1:]:
if not os.path.isabs(conf):
for conf in args:
archive = os.path.join(options['archive-dir'], conf.lstrip('/'))
if options['use-rcs'] == 'yes':
- dispatch_conf.rcs_archive(archive, conf, md5_match_hash[conf], '')
+ portage.dispatch_conf.rcs_archive(archive, conf, md5_match_hash[conf], '')
if md5_match_hash[conf]:
- dispatch_conf.rcs_archive_post_process(archive)
+ portage.dispatch_conf.rcs_archive_post_process(archive)
else:
- dispatch_conf.file_archive(archive, conf, md5_match_hash[conf], '')
+ portage.dispatch_conf.file_archive(archive, conf, md5_match_hash[conf], '')
if md5_match_hash[conf]:
- dispatch_conf.file_archive_post_process(archive)
+ portage.dispatch_conf.file_archive_post_process(archive)
# run
if len(sys.argv) > 1:
#!@PYTHON@ -O
# Copyright 1999-2006 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
-# $Id: /var/cvsroot/gentoo-src/portage/bin/clean_locks,v 1.1 2004/09/26 10:44:31 carpaski Exp $
+# $Id: clean_locks 5784 2007-01-25 17:25:47Z genone $
import os,sys,errno
try:
- import portage_locks
+ import portage.locks
except ImportError:
sys.path.insert(0, "@PORTAGE_BASE@/pym")
- import portage_locks
+ import portage.locks
-import portage_const
+from portage.const import EPREFIX
if not sys.argv[1:] or "--help" in sys.argv or "-h" in sys.argv:
+ import portage
print
print "You must specify directories with hardlink-locks to clean."
print "You may optionally specify --force, which will remove all"
print "of the locks, even if we can't establish if they are in use."
print "Please attempt cleaning without force first."
print
- print sys.argv[0]+" "+portage_const.EPREFIX+"/usr/portage/distfiles/.locks"
- print sys.argv[0]+" --force "+portage_const.EPREFIX+"/usr/portage/distfiles/.locks"
+ print "%s %s/.locks" % (sys.argv[0], portage.settings["DISTDIR"])
+ print "%s --force %s/.locks" % (sys.argv[0], portage.settings["DISTDIR"])
print
sys.exit(1)
for x in sys.argv[1:]:
if x == "--force":
continue
- for y in portage_locks.hardlock_cleanup(x, remove_all_locks=force):
- print y
- print
-
-
-
-
+ try:
+ for y in portage.locks.hardlock_cleanup(x, remove_all_locks=force):
+ print y
+ print
+
+ except OSError, e:
+ if e.errno in (errno.ENOENT, errno.ENOTDIR):
+ print "!!! %s is not a directory or does not exist" % x
+ else:
+ raise
+ sys.exit(e.errno)
import portage
import dispatch_conf, portage_const
-from portage_exec import find_binary
+from portage.process import find_binary
FIND_EXTANT_CONFIGS = "find '%s' %s -iname '._cfg????_%s'"
DIFF_CONTENTS = 'diff -Nu %s %s'
count = 0
- self.options = dispatch_conf.read_config(MANDATORY_OPTS)
+ self.options = portage.dispatch_conf.read_config(MANDATORY_OPTS)
if self.options.has_key("log-file"):
if os.path.isfile(self.options["log-file"]):
mrgconf = re.sub(r'\._cfg', '._mrg', conf['new'])
archive = os.path.join(self.options['archive-dir'], conf['current'].lstrip('/'))
if self.options['use-rcs'] == 'yes':
- mrgfail = dispatch_conf.rcs_archive(archive, conf['current'], conf['new'], mrgconf)
+ mrgfail = portage.dispatch_conf.rcs_archive(archive, conf['current'], conf['new'], mrgconf)
else:
- mrgfail = dispatch_conf.file_archive(archive, conf['current'], conf['new'], mrgconf)
+ mrgfail = portage.dispatch_conf.file_archive(archive, conf['current'], conf['new'], mrgconf)
if os.path.exists(archive + '.dist'):
unmodified = len(commands.getoutput(DIFF_CONTENTS % (conf['current'], archive + '.dist'))) == 0
else:
def post_process(self, curconf):
archive = os.path.join(self.options['archive-dir'], curconf.lstrip('/'))
if self.options['use-rcs'] == 'yes':
- dispatch_conf.rcs_archive_post_process(archive)
+ portage.dispatch_conf.rcs_archive_post_process(archive)
else:
- dispatch_conf.file_archive_post_process(archive)
+ portage.dispatch_conf.file_archive_post_process(archive)
def massage (self, newconfigs):
sys.path.insert(0, "@PORTAGE_BASE@/pym")
import portage
-import portage_util, portage_const
+import portage.util, portage.const
# do this _after_ 'import portage' to prevent unnecessary tracing
if debug and "python-trace" in portage.features:
- import portage_debug
- portage_debug.set_trace(True)
+ import portage.debug
+ portage.debug.set_trace(True)
if portage.settings["NOCOLOR"] in ("yes","true") or not sys.stdout.isatty():
import output
- output.nocolor()
+ portage.output.nocolor()
ebuild = pargs.pop(0)
if not os.path.isabs(ebuild):
print "!!! %s does not follow correct package syntax." % (cpv)
sys.exit(1)
-if ebuild.startswith(portage.root + portage_const.VDB_PATH):
+if ebuild.startswith(portage.root + portage.const.VDB_PATH):
mytree = "vartree"
portage_ebuild = portage.db[portage.root][mytree].dbapi.findname(cpv)
fetchlist_dict = portage.FetchlistDict(pkgdir, mysettings, mydbapi)
cat, pkg = pkgdir.split(os.sep)[-2:]
cpv = cat + "/" + os.path.basename(myebuild)[:-7]
- from portage_manifest import Manifest
+ from portage.manifest import Manifest
mf = Manifest(pkgdir, mysettings["DISTDIR"],
fetchlist_dict=fetchlist_dict)
mf.create(requiredDistfiles=None,
sys.path.insert(0, "@PORTAGE_BASE@/pym")
import portage
-import portage_const, portage_exception
+import portage.const, portage.exception
class WorldHandler(object):
def name():
self.invalid = []
self.not_installed = []
self.okay = []
- self.world_file = os.path.join("/", portage_const.WORLD_FILE)
+ self.world_file = os.path.join("/", portage.const.WORLD_FILE)
self.found = os.access(self.world_file, os.R_OK)
for atom in open(self.world_file).read().split():
errors = []
try:
portage.write_atomic(self.world_file, "\n".join(self.okay))
- except portage_exception.PortageException:
+ except portage.exception.PortageException:
errors.append(self.world_file + " could not be opened for writing")
return errors
self.keys = ["HOMEPAGE", "SRC_URI", "KEYWORDS", "DESCRIPTION"]
for p in self.list:
- mydir = os.path.join(os.sep, portage.settings["ROOT"], portage_const.VDB_PATH, p)+os.sep
+ mydir = os.path.join(os.sep, portage.settings["ROOT"], portage.const.VDB_PATH, p)+os.sep
ismissing = True
for k in self.keys:
if os.path.exists(mydir+k):
errors = []
for p in self.missing:
- mydir = os.path.join(os.sep, portage.settings["ROOT"], portage_const.VDB_PATH, p)+os.sep
+ mydir = os.path.join(os.sep, portage.settings["ROOT"], portage.const.VDB_PATH, p)+os.sep
if not os.access(mydir+"environment.bz2", os.R_OK):
errors.append("Can't access %s" % (mydir+"environment.bz2"))
elif not os.access(mydir, os.W_OK):
import portage
del os.environ["PORTAGE_LEGACY_GLOBALS"]
from portage import digraph, portdbapi
-from portage_const import NEWS_LIB_PATH
+from portage.const import NEWS_LIB_PATH
-import emergehelp, xpak, commands, errno, re, socket, time, types
+import portage.emergehelp, portage.xpak, commands, errno, re, socket, time, types
import output
-from output import blue, bold, colorize, darkblue, darkgreen, darkred, green, \
+from portage.output import blue, bold, colorize, darkblue, darkgreen, darkred, green, \
havecolor, nc_len, nocolor, red, teal, turquoise, white, xtermTitle, \
xtermTitleReset, yellow
-from output import create_color_func
+from portage.output import create_color_func
good = create_color_func("GOOD")
bad = create_color_func("BAD")
-import portage_dep
-import portage_util
-import portage_locks
-import portage_exception
-from portage_const import EPREFIX
-from portage_data import secpass
-from portage_util import normalize_path as normpath
+import portage.dep
+import portage.util
+import portage.locks
+import portage.exception
+from portage.const import EPREFIX
+from portage.data import secpass
+from portage.util import normalize_path as normpath
if not hasattr(__builtins__, "set"):
from sets import Set as set
try:
file_path = EPREFIX+"/var/log/emerge.log"
mylogfile = open(file_path, "a")
- portage_util.apply_secpass_permissions(file_path,
+ portage.util.apply_secpass_permissions(file_path,
uid=portage.portage_uid, gid=portage.portage_gid,
mode=0660)
mylock = None
try:
- mylock = portage_locks.lockfile(mylogfile)
+ mylock = portage.locks.lockfile(mylogfile)
# seek because we may have gotten held up by the lock.
# if so, we may not be positioned at the end of the file.
mylogfile.seek(0, 2)
mylogfile.flush()
finally:
if mylock:
- portage_locks.unlockfile(mylock)
+ portage.locks.unlockfile(mylock)
mylogfile.close()
- except (IOError,OSError,portage_exception.PortageException), e:
+ except (IOError,OSError,portage.exception.PortageException), e:
if secpass >= 1:
print >> sys.stderr, "emergelog():",e
libcver=[]
libclist = vardb.match("virtual/libc")
libclist += vardb.match("virtual/glibc")
- libclist = portage_util.unique_array(libclist)
+ libclist = portage.util.unique_array(libclist)
for x in libclist:
xs=portage.catpkgsplit(x)
if libcver:
mycpv = match + "-" + myversion
myebuild = self.portdb.findname(mycpv)
pkgdir = os.path.dirname(myebuild)
- import portage_manifest
- mf = portage_manifest.Manifest(
+ import portage.manifest
+ mf = portage.manifest.Manifest(
pkgdir, self.settings["DISTDIR"])
fetchlist = self.portdb.getfetchlist(mycpv,
mysettings=self.settings, all=True)[1]
def clean_world(vardb, cpv):
"""Remove a package from the world file when unmerged."""
world_filename = os.path.join(vardb.root, portage.WORLD_FILE)
- worldlist = portage_util.grabfile(world_filename)
+ worldlist = portage.util.grabfile(world_filename)
mykey = portage.cpv_getkey(cpv)
newworldlist = []
for x in worldlist:
#this doesn't match the package we're unmerging; keep it.
newworldlist.append(x)
- portage_util.ensure_dirs(os.path.join(vardb.root, portage.PRIVATE_PATH),
+ portage.util.ensure_dirs(os.path.join(vardb.root, portage.PRIVATE_PATH),
gid=portage.portage_gid, mode=02770)
- portage_util.write_atomic(world_filename, "\n".join(newworldlist))
+ portage.util.write_atomic(world_filename, "\n".join(newworldlist))
def genericdict(mylist):
mynewdict={}
vdb_path = os.path.join(self.root, portage.VDB_PATH)
try:
# At least the parent needs to exist for the lock file.
- portage_util.ensure_dirs(vdb_path)
- except portage_exception.PortageException:
+ portage.util.ensure_dirs(vdb_path)
+ except portage.exception.PortageException:
pass
vdb_lock = None
try:
if os.access(vdb_path, os.W_OK):
- vdb_lock = portage_locks.lockdir(vdb_path)
+ vdb_lock = portage.locks.lockdir(vdb_path)
mykeys = ["SLOT", "COUNTER", "PROVIDE", "USE", "IUSE",
"DEPEND", "RDEPEND", "PDEPEND"]
real_dbapi = real_vartree.dbapi
real_dbapi.flush_cache()
finally:
if vdb_lock:
- portage_locks.unlockdir(vdb_lock)
+ portage.locks.unlockdir(vdb_lock)
# Populate the old-style virtuals using the cached values.
if not self.settings.treeVirtuals:
- self.settings.treeVirtuals = portage_util.map_dictlist_vals(
+ self.settings.treeVirtuals = portage.util.map_dictlist_vals(
portage.getCPFromCPV, self.get_all_provides())
# Intialize variables needed for lazy cache pulls of the live ebuild
live_metadata = dict(izip(self._portdb_keys,
self._portdb.aux_get(pkg, self._portdb_keys)))
self.dbapi.aux_update(pkg, live_metadata)
- except (KeyError, portage_exception.PortageException):
+ except (KeyError, portage.exception.PortageException):
if self._global_updates is None:
self._global_updates = \
grab_global_updates(self._portdb.porttree_root)
return self._aux_get(pkg, wants)
def grab_global_updates(portdir):
- from portage_update import grab_updates, parse_updates
+ from portage.update import grab_updates, parse_updates
updpath = os.path.join(portdir, "profiles", "updates")
try:
rawupdates = grab_updates(updpath)
- except portage_exception.DirectoryNotFound:
+ except portage.exception.DirectoryNotFound:
rawupdates = []
upd_commands = []
for mykey, mystat, mycontent in rawupdates:
return upd_commands
def perform_global_updates(mycpv, mydb, mycommands):
- from portage_update import update_dbentries
+ from portage.update import update_dbentries
aux_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
aux_dict = dict(izip(aux_keys, mydb.aux_get(mycpv, aux_keys)))
updates = update_dbentries(mycommands, aux_dict)
if self._modified and \
secpass >= 2:
try:
- f = portage_util.atomic_ofstream(self._cache_filename)
+ f = portage.util.atomic_ofstream(self._cache_filename)
cPickle.dump(self._cache_data, f, -1)
f.close()
- portage_util.apply_secpass_permissions(
+ portage.util.apply_secpass_permissions(
self._cache_filename, gid=portage.portage_gid, mode=0644)
except (IOError, OSError), e:
pass
if slot_collision:
# Now add this node to the graph so that self.display()
- # can show use flags and --tree output. This node is
+ # can show use flags and --tree portage.output. This node is
# only being partially added to the graph. It must not be
# allowed to interfere with the other nodes that have been
# added. Do not overwrite data for existing nodes in
print "\n\n!!! Binary package '"+str(x)+"' does not exist."
print "!!! Please ensure the tbz2 exists as specified.\n"
sys.exit(1)
- mytbz2=xpak.tbz2(x)
+ mytbz2=portage.xpak.tbz2(x)
mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.splitext(os.path.basename(x))[0]
if os.path.realpath(x) != \
os.path.realpath(self.trees[myroot]["bintree"].getname(mykey)):
countdown(int(self.settings["EMERGE_WARNING_DELAY"]),
"Continuing...")
else:
- raise portage_exception.PackageNotFound(
+ raise portage.exception.PackageNotFound(
"%s is not in a valid portage tree hierarchy or does not exist" % x)
if not self.create(["ebuild", myroot, mykey],
None, "--onlydeps" not in self.myopts):
for myarg, myatom in arg_atoms:
try:
self.mysd = self.select_dep(myroot, myatom, arg=myarg)
- except portage_exception.MissingSignature, e:
+ except portage.exception.MissingSignature, e:
portage.writemsg("\n\n!!! A missing gpg signature is preventing portage from calculating the\n")
portage.writemsg("!!! required dependencies. This is a security feature enabled by the admin\n")
portage.writemsg("!!! to aid in the detection of malicious intent.\n\n")
portage.writemsg("!!! THIS IS A POSSIBLE INDICATION OF TAMPERED FILES -- CHECK CAREFULLY.\n")
portage.writemsg("!!! Affected file: %s\n" % (e), noiselevel=-1)
sys.exit(1)
- except portage_exception.InvalidSignature, e:
+ except portage.exception.InvalidSignature, e:
portage.writemsg("\n\n!!! An invalid gpg signature is preventing portage from calculating the\n")
portage.writemsg("!!! required dependencies. This is a security feature enabled by the admin\n")
portage.writemsg("!!! to aid in the detection of malicious intent.\n\n")
dependencies are satisfiable. """
try:
if myparent and p_status == "nomerge":
- portage_dep._dep_check_strict = False
+ portage.dep._dep_check_strict = False
mycheck = portage.dep_check(depstring, None,
pkgsettings, myuse=myuse,
use_binaries=("--usepkgonly" in self.myopts),
myroot=myroot, trees=self.trees)
finally:
- portage_dep._dep_check_strict = True
+ portage.dep._dep_check_strict = True
if not mycheck[0]:
if myparent:
# optimize dep_check calls by eliminating atoms via
# dep_wordreduce and dep_eval calls.
try:
- portage_dep._dep_check_strict = False
+ portage.dep._dep_check_strict = False
success, atoms = portage.dep_check(depstr,
final_db, pkgsettings, myuse=myuse,
trees=dep_check_trees, myroot=myroot)
finally:
- portage_dep._dep_check_strict = True
+ portage.dep._dep_check_strict = True
if not success:
slot_atom = "%s:%s" % (portage.dep_getkey(pkg),
vardb.aux_get(pkg, ["SLOT"])[0])
fetch_log = EPREFIX+"/var/log/emerge-fetch.log"
logfile = open(fetch_log, "w")
fd_pipes = {1:logfile.fileno(), 2:logfile.fileno()}
- portage_util.apply_secpass_permissions(fetch_log,
+ portage.util.apply_secpass_permissions(fetch_log,
uid=portage.portage_uid, gid=portage.portage_gid,
mode=0660)
fetch_env = os.environ.copy()
fetch_args.append(myopt)
else:
fetch_args.append(myopt +"="+ myarg)
- portage.portage_exec.spawn(fetch_args, env=fetch_env,
+ portage.process.spawn(fetch_args, env=fetch_env,
fd_pipes=fd_pipes, returnpid=True)
logfile.close() # belongs to the spawned process
portage.doebuild_environment(y, "setup", myroot,
pkgsettings, self.edebug, 1, portdb)
catdir = os.path.dirname(pkgsettings["PORTAGE_BUILDDIR"])
- portage_util.ensure_dirs(os.path.dirname(catdir),
+ portage.util.ensure_dirs(os.path.dirname(catdir),
uid=portage.portage_uid, gid=portage.portage_gid,
mode=070, mask=0)
builddir_lock = None
catdir_lock = None
try:
- catdir_lock = portage_locks.lockdir(catdir)
- portage_util.ensure_dirs(catdir,
+ catdir_lock = portage.locks.lockdir(catdir)
+ portage.util.ensure_dirs(catdir,
uid=portage.portage_uid, gid=portage.portage_gid,
mode=070, mask=0)
- builddir_lock = portage_locks.lockdir(
+ builddir_lock = portage.locks.lockdir(
pkgsettings["PORTAGE_BUILDDIR"])
try:
- portage_locks.unlockdir(catdir_lock)
+ portage.locks.unlockdir(catdir_lock)
finally:
catdir_lock = None
msg = " === (%s of %s) Cleaning (%s::%s)" % \
return retval
finally:
if builddir_lock:
- portage_locks.unlockdir(builddir_lock)
+ portage.locks.unlockdir(builddir_lock)
try:
if not catdir_lock:
# Lock catdir for removal if empty.
- catdir_lock = portage_locks.lockdir(catdir)
+ catdir_lock = portage.locks.lockdir(catdir)
finally:
if catdir_lock:
try:
if e.errno != errno.ENOTEMPTY:
raise
del e
- portage_locks.unlockdir(catdir_lock)
+ portage.locks.unlockdir(catdir_lock)
elif x[0]=="binary":
#merge the tbz2
try:
if "distlocks" in pkgsettings.features and \
os.access(pkgsettings["PKGDIR"], os.W_OK):
- portage_util.ensure_dirs(os.path.dirname(mytbz2))
- tbz2_lock = portage_locks.lockfile(mytbz2,
+ portage.util.ensure_dirs(os.path.dirname(mytbz2))
+ tbz2_lock = portage.locks.lockfile(mytbz2,
wantnewlockfile=1)
if self.trees[myroot]["bintree"].isremote(pkg_key):
msg = " --- (%s of %s) Fetching Binary (%s::%s)" %\
return 1
finally:
if tbz2_lock:
- portage_locks.unlockfile(tbz2_lock)
+ portage.locks.unlockfile(tbz2_lock)
if "--fetchonly" in self.myopts or \
"--fetch-all-uri" in self.myopts:
vdb_path = os.path.join(settings["ROOT"], portage.VDB_PATH)
try:
# At least the parent needs to exist for the lock file.
- portage_util.ensure_dirs(vdb_path)
- except portage_exception.PortageException:
+ portage.util.ensure_dirs(vdb_path)
+ except portage.exception.PortageException:
pass
vdb_lock = None
try:
if os.access(vdb_path, os.W_OK):
- vdb_lock = portage_locks.lockdir(vdb_path)
+ vdb_lock = portage.locks.lockdir(vdb_path)
realsyslist = getlist(settings, "system")
syslist = []
for x in realsyslist:
return 0
finally:
if vdb_lock:
- portage_locks.unlockdir(vdb_lock)
+ portage.locks.unlockdir(vdb_lock)
for x in pkgmap.keys():
for y in localtree.dep_match(x):
if y not in pkgmap[x]["omitted"] and \
1. The number of unread but relevant news items.
"""
- from portage_news import NewsManager
+ from portage.news import NewsManager
manager = NewsManager( root, NEWS_PATH, UNREAD_PATH )
return manager.getUnreadItems( repo_id, update=True )
def is_valid_package_atom(x):
try:
testkey = portage.dep_getkey(x)
- except portage_exception.InvalidData:
+ except portage.exception.InvalidData:
return False
if testkey.startswith("null/"):
testatom = x.replace(testkey[5:], "cat/"+testkey[5:])
tmpservertimestampfile = os.path.join(
settings["PORTAGE_TMPDIR"], "timestamp.chk")
- content = portage_util.grabfile(servertimestampfile)
+ content = portage.util.grabfile(servertimestampfile)
mytimestamp = 0
if content:
try:
mycommand.append(dosyncuri.rstrip("/") + \
"/metadata/timestamp.chk")
mycommand.append(tmpservertimestampfile)
- import portage_exec
+ import portage.process
try:
- exitcode = portage_exec.spawn(
+ exitcode = portage.process.spawn(
mycommand, env=settings.environ())
content = portage.grabfile(tmpservertimestampfile)
if content:
if myaction != "metadata":
if os.access(portage.USER_CONFIG_PATH + "/bin/post_sync", os.X_OK):
- retval = portage.portage_exec.spawn(
+ retval = portage.process.spawn(
[os.path.join(portage.USER_CONFIG_PATH, "bin", "post_sync"),
dosyncuri], env=settings.environ())
if retval != os.EX_OK:
cm = settings.load_best_module("portdbapi.metadbmodule")(
myportdir, "metadata/cache", portage.auxdbkeys[:])
- import cache.util
+ import portage.cache.util
- class percentage_noise_maker(cache.util.quiet_mirroring):
+ class percentage_noise_maker(portage.cache.util.quiet_mirroring):
def __init__(self, dbapi):
self.dbapi = dbapi
self.cp_all = dbapi.cp_all()
for y in portdb.cp_list(x):
yield y
source = quicky_cpv_generator(portdb.cp_all())
- noise_maker = cache.util.quiet_mirroring()
+ noise_maker = portage.cache.util.quiet_mirroring()
else:
noise_maker = source = percentage_noise_maker(portdb)
- cache.util.mirror_cache(source, cm, portdb.auxdb[myportdir],
+ portage.cache.util.mirror_cache(source, cm, portdb.auxdb[myportdir],
eclass_cache=ec, verbose_instance=noise_maker)
sys.stdout.flush()
pass
sys.stdout.flush()
mynodes = portdb.cp_all()
+ from portage.cache.cache_errors import CacheError
+ dead_nodes = {}
+ for mytree in portdb.porttrees:
+ try:
+ dead_nodes[mytree] = set(portdb.auxdb[mytree].iterkeys())
+ except CacheError, e:
+ print "\n error listing cache entries for " + \
+ "'%s': %s, continuing..." % (mytree, e)
+ del e
+ dead_nodes = None
+ break
for x in mynodes:
mymatches = portdb.xmatch("match-all",x)
portage.writemsg_stdout("processing %s\n" % x)
myvars = ["sys-devel/autoconf", "sys-devel/automake", "virtual/os-headers",
"sys-devel/binutils", "sys-devel/libtool", "dev-lang/python"]
- myvars += portage_util.grabfile(settings["PORTDIR"]+"/profiles/info_pkgs")
- myvars = portage_util.unique_array(myvars)
+ myvars += portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_pkgs")
+ myvars = portage.util.unique_array(myvars)
myvars.sort()
for x in myvars:
'ACCEPT_KEYWORDS', 'SYNC', 'FEATURES', 'EMERGE_DEFAULT_OPTS',
'EPREFIX']
- myvars.extend(portage_util.grabfile(settings["PORTDIR"]+"/profiles/info_vars"))
+ myvars.extend(portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_vars"))
- myvars = portage_util.unique_array(myvars)
+ myvars = portage.util.unique_array(myvars)
unset_vars = []
myvars.sort()
for x in myvars:
print "hard"
try:
- portage_dep._dep_check_strict = False
+ portage.dep._dep_check_strict = False
success, atoms = portage.dep_check(depstr, None, settings,
myuse=usedef, trees=dep_check_trees, myroot=myroot)
finally:
- portage_dep._dep_check_strict = True
+ portage.dep._dep_check_strict = True
if not success:
show_invalid_depstring_notice(
("installed", myroot, pkg, "nomerge"),
mydepgraph = depgraph(settings, trees, myopts, myparams, spinner)
try:
retval, favorites = mydepgraph.select_files(myfiles)
- except portage_exception.PackageNotFound, e:
+ except portage.exception.PackageNotFound, e:
portage.writemsg("\n!!! %s\n" % str(e), noiselevel=-1)
sys.exit(1)
if not retval:
settings.backup_changes("PORTAGE_DEBUG")
if settings.get("NOCOLOR") not in ("yes","true"):
- output.havecolor = 1
+ portage.output.havecolor = 1
"""The explicit --color < y | n > option overrides the NOCOLOR environment
variable and stdout auto-detection."""
if "--color" in myopts:
if "y" == myopts["--color"]:
- output.havecolor = 1
+ portage.output.havecolor = 1
settings["NOCOLOR"] = "false"
else:
- output.havecolor = 0
+ portage.output.havecolor = 0
settings["NOCOLOR"] = "true"
settings.backup_changes("NOCOLOR")
elif not sys.stdout.isatty() and settings.get("NOCOLOR") != "no":
- output.havecolor = 0
+ portage.output.havecolor = 0
settings["NOCOLOR"] = "true"
settings.backup_changes("NOCOLOR")
def emerge_main():
+ global portage # NFC why this is necessary now - genone
# Disable color until we're sure that it should be enabled (after
# EMERGE_DEFAULT_OPTS has been parsed).
- output.havecolor = 0
+ portage.output.havecolor = 0
# This first pass is just for options that need to be known as early as
# possible, such as --config-root. They will be parsed again later,
# together with EMERGE_DEFAULT_OPTS (which may vary depending on the
if ("--quiet" in myopts):
spinner.update = spinner.update_quiet
- portage_util.noiselimit = -1
+ portage.util.noiselimit = -1
# Always create packages if FEATURES=buildpkg
# Imply --buildpkg if --buildpkgonly
spinner.update = spinner.update_quiet
portage.debug=1
if "python-trace" in settings.features:
- import portage_debug
- portage_debug.set_trace(True)
+ import portage.debug
+ portage.debug.set_trace(True)
if ("--resume" in myopts):
if "--tree" in myopts:
trees[settings["ROOT"]]["vartree"].dbapi)
sys.exit(0)
elif "--help" in myopts:
- emergehelp.help(myaction, myopts, output.havecolor)
+ portage.emergehelp.help(myaction, myopts, portage.output.havecolor)
sys.exit(0)
if "--debug" in myopts:
print "myopts", myopts
if not myaction and not myfiles and "--resume" not in myopts:
- emergehelp.help(myaction, myopts, output.havecolor)
+ portage.emergehelp.help(myaction, myopts, portage.output.havecolor)
sys.exit(1)
# check if root user is the current user for the actions where emerge needs this
access_desc = "portage group"
# Always show portage_group_warning() when only portage group
# access is required but the user is not in the portage group.
- from portage_data import portage_group_warning
+ from portage.data import portage_group_warning
if "--ask" in myopts:
myopts["--pretend"] = True
del myopts["--ask"]
def emergeexitsig(signum, frame):
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
- portage_util.writemsg("\n\nExiting on signal %(signal)s\n" % {"signal":signum})
+ portage.util.writemsg("\n\nExiting on signal %(signal)s\n" % {"signal":signum})
sys.exit(100+signum)
signal.signal(signal.SIGINT, emergeexitsig)
signal.signal(signal.SIGTERM, emergeexitsig)
import portage
from stat import *
-from output import *
+from portage.output import *
from portage import lockfile,unlockfile,VDB_PATH,root
import portage_const
except ImportError:
sys.path.insert(0, "@PORTAGE_BASE@/pym")
import portage
-import portage_util
+import portage.util
def cstrip(mystr,mychars):
newstr = ""
continue
if mybn not in md5sums.keys():
- portage_util.writemsg("Missing md5sum: %s in %s\n" % (mybn, mycpv))
+ portage.util.writemsg("Missing md5sum: %s in %s\n" % (mybn, mycpv))
else:
if mybn in md5_list.keys():
if (md5_list[mybn]["MD5"] != md5sums[mybn]["MD5"]) or \
import portage
del os.environ["PORTAGE_LEGACY_GLOBALS"]
-import portage_checksum
-import portage_const
-import portage_dep
-import portage_exception
+import portage.checksum
+import portage.const
+import portage.dep
+import portage.exception
import cvstree
import time
import codecs
-from portage_manifest import Manifest
-from portage_exception import ParseError
-from portage_exec import spawn
+from portage.manifest import Manifest
+from portage.exception import ParseError
+from portage.process import spawn
-from output import bold, darkgreen, darkred, green, nocolor, red, turquoise, yellow
+from portage.output import bold, darkgreen, darkred, green, nocolor, red, turquoise, yellow
from commands import getstatusoutput
from fileinput import input
# A sane umask is needed for files that portage creates.
os.umask(022)
repoman_settings = portage.config(local_config=False,
- config_incrementals=portage_const.INCREMENTALS)
+ config_incrementals=portage.const.INCREMENTALS)
repoman_settings.lock()
if repoman_settings.get("NOCOLOR", "").lower() in ("yes", "true") or \
# Now that PORTDIR_OVERLAY is properly overridden, create the portdb.
repoman_settings = portage.config(local_config=False,
- config_incrementals=portage_const.INCREMENTALS)
+ config_incrementals=portage.const.INCREMENTALS)
trees = portage.create_trees()
trees["/"]["porttree"].settings = repoman_settings
portdb = trees["/"]["porttree"].dbapi
fails["digest.partial"].append(y+"::"+myf)
elif "assume-digests" not in repoman_settings.features:
if os.path.exists(myff):
- if not portage_checksum.verify_all(myff, mydigests[myf]):
+ if not portage.checksum.verify_all(myff, mydigests[myf]):
stats["digest.fail"] += 1
fails["digest.fail"].append(y+"::"+myf)
elif repolevel == 3:
# if x.startswith("no"):
# print "Bad RESTRICT value: %s" % x
- myaux["PROVIDE"] = portage_dep.use_reduce(portage_dep.paren_reduce(myaux["PROVIDE"]), matchall=1)
+ myaux["PROVIDE"] = portage.dep.use_reduce(portage.dep.paren_reduce(myaux["PROVIDE"]), matchall=1)
myaux["PROVIDE"] = " ".join(portage.flatten(myaux["PROVIDE"]))
for myprovide in myaux["PROVIDE"].split():
prov_cp = portage.dep_getkey(myprovide)
try:
# Missing closing parenthesis will result in a ValueError
- mydeplist = portage_dep.paren_reduce(mydepstr)
+ mydeplist = portage.dep.paren_reduce(mydepstr)
# Missing opening parenthesis will result in a final "" element
if "" in mydeplist or "(" in mydeplist:
raise ValueError
mydeplist = []
try:
- portage_dep.use_reduce(mydeplist, excludeall=myiuse)
- except portage_exception.InvalidDependString, e:
+ portage.dep.use_reduce(mydeplist, excludeall=myiuse)
+ except portage.exception.InvalidDependString, e:
badsyntax.append(str(e))
for token in operator_tokens:
else:
dep_settings = portage.config(
config_profile_path=profdir,
- config_incrementals=portage_const.INCREMENTALS,
+ config_incrementals=portage.const.INCREMENTALS,
local_config=False)
arch_caches[prof[0]] = dep_settings
while True:
myuse = myaux["LICENSE"]
# Parse the LICENSE variable, remove USE conditions and
# flatten it.
- myuse=portage_dep.use_reduce(portage_dep.paren_reduce(myuse), matchall=1)
+ myuse=portage.dep.use_reduce(portage.dep.paren_reduce(myuse), matchall=1)
myuse=portage.flatten(myuse)
# Check each entry to ensure that it exists in PORTDIR's
# license directory.
fails["ebuild.allmasked"].append(x)
#Pickle and save results for instant reuse in last and lfull
-if os.access(portage_const.CACHE_PATH, os.W_OK):
+if os.access(portage.const.CACHE_PATH, os.W_OK):
for myobj, fname in (stats, "repo.stats"), (fails, "repo.fails"):
- fpath = os.path.join(portage_const.CACHE_PATH, fname)
+ fpath = os.path.join(portage.const.CACHE_PATH, fname)
savef = open(fpath, 'w')
pickle.dump(myobj, savef)
savef.close()
if isCvs:
try:
- myvcstree=cvstree.getentries("./",recursive=1)
- myunadded=cvstree.findunadded(myvcstree,recursive=1,basedir="./")
+ myvcstree=portage.cvstree.getentries("./",recursive=1)
+ myunadded=portage.cvstree.findunadded(myvcstree,recursive=1,basedir="./")
except SystemExit, e:
raise # TODO propogate this
except:
sys.exit(retval)
if isCvs:
- mycvstree=cvstree.getentries("./",recursive=1)
- mychanged=cvstree.findchanged(mycvstree,recursive=1,basedir="./")
- mynew=cvstree.findnew(mycvstree,recursive=1,basedir="./")
- myremoved=cvstree.findremoved(mycvstree,recursive=1,basedir="./")
+ mycvstree=portage.cvstree.getentries("./",recursive=1)
+ mychanged=portage.cvstree.findchanged(mycvstree,recursive=1,basedir="./")
+ mynew=portage.cvstree.findnew(mycvstree,recursive=1,basedir="./")
+ myremoved=portage.cvstree.findremoved(mycvstree,recursive=1,basedir="./")
if isSvn:
svnstatus = os.popen("svn status").readlines()
mychanged = [ elem.rstrip()[7:] for elem in svnstatus if elem.startswith("M") ]
# Setup the GPG commands
def gpgsign(filename):
if "PORTAGE_GPG_KEY" not in repoman_settings:
- raise portage_exception.MissingParameter("PORTAGE_GPG_KEY is unset!")
+ raise portage.exception.MissingParameter("PORTAGE_GPG_KEY is unset!")
if "PORTAGE_GPG_DIR" not in repoman_settings:
if os.environ.has_key("HOME"):
repoman_settings["PORTAGE_GPG_DIR"] = os.path.join(os.environ["HOME"], ".gnupg")
if quiet < 1:
print "Automatically setting PORTAGE_GPG_DIR to",repoman_settings["PORTAGE_GPG_DIR"]
else:
- raise portage_exception.MissingParameter("PORTAGE_GPG_DIR is unset!")
+ raise portage.exception.MissingParameter("PORTAGE_GPG_DIR is unset!")
gpg_dir = repoman_settings["PORTAGE_GPG_DIR"]
if gpg_dir.startswith("~") and "HOME" in os.environ:
repoman_settings["PORTAGE_GPG_DIR"] = os.path.join(
os.environ["HOME"], gpg_dir[1:].lstrip(os.path.sep))
if not os.access(repoman_settings["PORTAGE_GPG_DIR"], os.X_OK):
- raise portage_exception.InvalidLocation(
+ raise portage.exception.InvalidLocation(
"Unable to access directory: PORTAGE_GPG_DIR='%s'" % \
repoman_settings["PORTAGE_GPG_DIR"])
gpgcmd = "gpg --sign --clearsign --yes "
if rValue == os.EX_OK:
os.rename(filename+".asc", filename)
else:
- raise portage_exception.PortageException("!!! gpg exited with '" + str(rValue) + "' status")
+ raise portage.exception.PortageException("!!! gpg exited with '" + str(rValue) + "' status")
manifest_commit_required = True
if myheaders or myupdates or myremoved or mynew:
mydone.append("/".join(xs[:2]))
repoman_settings["O"] = os.path.join(".", xs[0], xs[1])
gpgsign(os.path.join(repoman_settings["O"], "Manifest"))
- except portage_exception.PortageException, e:
+ except portage.exception.PortageException, e:
portage.writemsg("!!! %s\n" % str(e))
portage.writemsg("!!! Disabled FEATURES='sign'\n")
signed = False
bsd_chflags = None
try:
- from cache.cache_errors import CacheError
- import cvstree
- import xpak
- import getbinpkg
+ from portage.cache.cache_errors import CacheError
+ import portage.cvstree
+ import portage.xpak
+ import portage.getbinpkg
import portage.dep
from portage.dep import dep_getcpv, dep_getkey, get_operator, \
isjustname, isspecific, isvalidatom, \
match_from_list, match_to_list, best_match_to_list
# XXX: This needs to get cleaned up.
- import output
- from output import bold, colorize, green, red, yellow
+ import portage.output
+ from portage.output import bold, colorize, green, red, yellow
import portage.const
from portage.const import VDB_PATH, PRIVATE_PATH, CACHE_PATH, DEPCACHE_PATH, \
from portage.locks import unlockfile,unlockdir,lockfile,lockdir
import portage.checksum
from portage.checksum import perform_md5,perform_checksum,prelink_capable
- import eclass_cache
+ import portage.eclass_cache
from portage.localization import _
from portage.update import dep_transform, fixdbentries, grab_updates, \
parse_updates, update_config_files, update_dbentries
try:
# FIXME: ugly ad.hoc import code
# TODO: implement a common portage module loader
- logmodule = __import__("elog_modules.mod_"+s)
+ logmodule = __import__("portage.elog_modules.mod_"+s)
m = getattr(logmodule, "mod_"+s)
def timeout_handler(signum, frame):
raise portage.exception.PortageException(
if self.modules["user"] is None:
self.modules["user"] = {}
self.modules["default"] = {
- "portdbapi.metadbmodule": "cache.metadata.database",
- "portdbapi.auxdbmodule": "cache.flat_hash.database",
+ "portdbapi.metadbmodule": "portage.cache.metadata.database",
+ "portdbapi.auxdbmodule": "portage.cache.flat_hash.database",
}
self.usemask=[]
noiselevel=-1)
os.unlink(myfile_path)
else:
- eout = output.EOutput()
+ eout = portage.output.EOutput()
eout.quiet = \
mysettings.get("PORTAGE_QUIET", None) == "1"
for digest_name in mydigests[myfile]:
os.unlink(mysettings["DISTDIR"]+"/"+myfile)
fetched=0
else:
- eout = output.EOutput()
+ eout = portage.output.EOutput()
eout.quiet = mysettings.get("PORTAGE_QUIET", None) == "1"
for x_key in mydigests[myfile].keys():
eout.ebegin("%s %s ;-)" % (myfile, x_key))
cp = os.path.sep.join(mysettings["O"].split(os.path.sep)[-2:])
pkgs = myportdb.cp_list(cp, mytree=mytree)
pkgs.sort()
- writemsg_stdout(" digest.assumed" + output.colorize("WARN",
+ writemsg_stdout(" digest.assumed" + portage.output.colorize("WARN",
str(len(auto_assumed)).rjust(18)) + "\n")
for pkg_key in pkgs:
fetchlist = myportdb.getfetchlist(pkg_key,
if strict:
return 0
mf = Manifest(pkgdir, mysettings["DISTDIR"])
- eout = output.EOutput()
+ eout = portage.output.EOutput()
eout.quiet = mysettings.get("PORTAGE_QUIET", None) == "1"
try:
eout.ebegin("checking ebuild checksums ;-)")
# Allow color.map to control colors associated with einfo, ewarn, etc...
mycolors = []
for c in ("GOOD", "WARN", "BAD", "HILITE", "BRACKET"):
- mycolors.append("%s=$'%s'" % (c, output.codes[c]))
+ mycolors.append("%s=$'%s'" % (c, portage.output.codes[c]))
mysettings["PORTAGE_COLORMAP"] = "\n".join(mycolors)
def prepare_build_dirs(myroot, mysettings, cleanup):
mylist = []
tbz2name = mysplit[1]+".tbz2"
if self.bintree and not self.bintree.isremote(mycpv):
- tbz2 = xpak.tbz2(self.bintree.getname(mycpv))
+ tbz2 = portage.xpak.tbz2(self.bintree.getname(mycpv))
getitem = tbz2.getfile
else:
getitem = self.bintree.remotepkgs[tbz2name].get
tbz2path = self.bintree.getname(cpv)
if not os.path.exists(tbz2path):
raise KeyError(cpv)
- mytbz2 = xpak.tbz2(tbz2path)
+ mytbz2 = portage.xpak.tbz2(tbz2path)
mydata = mytbz2.get_data()
mydata.update(values)
- mytbz2.recompose_mem(xpak.xpak_mem(mydata))
+ mytbz2.recompose_mem(portage.xpak.xpak_mem(mydata))
def cp_list(self, *pargs, **kwargs):
if not self.bintree.populated:
if self.tmpfs and not os.access(self.tmpfs, os.R_OK):
self.tmpfs = None
- self.eclassdb = eclass_cache.cache(self.porttree_root,
+ self.eclassdb = portage.eclass_cache.cache(self.porttree_root,
overlays=self.mysettings["PORTDIR_OVERLAY"].split())
self.metadbmodule = self.mysettings.load_best_module("portdbapi.metadbmodule")
# ~harring
filtered_auxdbkeys = filter(lambda x: not x.startswith("UNUSED_0"), auxdbkeys)
if secpass < 1:
- from cache import metadata_overlay, volatile
+ from portage.cache import metadata_overlay, volatile
for x in self.porttrees:
db_ro = self.auxdbmodule(self.depcachedir, x,
filtered_auxdbkeys, gid=portage_gid, readonly=True)
#print ">>> Updating data in:",mycpv
writemsg_stdout("%")
- mytbz2 = xpak.tbz2(tbz2path)
+ mytbz2 = portage.xpak.tbz2(tbz2path)
mydata = mytbz2.get_data()
updated_items = update_dbentries([mylist], mydata)
mydata.update(updated_items)
mydata[mynewpkg+".ebuild"] = mydata[myoldpkg+".ebuild"]
del mydata[myoldpkg+".ebuild"]
mydata["PF"] = mynewpkg + "\n"
- mytbz2.recompose_mem(xpak.xpak_mem(mydata))
+ mytbz2.recompose_mem(portage.xpak.xpak_mem(mydata))
self.dbapi.cpv_remove(mycpv)
del self._pkg_paths[mycpv]
continue
#print ">>> Updating data in:",mycpv
- mytbz2 = xpak.tbz2(tbz2path)
+ mytbz2 = portage.xpak.tbz2(tbz2path)
mydata = mytbz2.get_data()
slot = mydata["SLOT"]
writemsg_stdout("S")
mydata["SLOT"] = newslot+"\n"
- mytbz2.recompose_mem(xpak.xpak_mem(mydata))
+ mytbz2.recompose_mem(portage.xpak.xpak_mem(mydata))
return 1
def update_ents(self, update_iter):
continue
#print ">>> Updating binary data:",mycpv
writemsg_stdout("*")
- mytbz2 = xpak.tbz2(tbz2path)
+ mytbz2 = portage.xpak.tbz2(tbz2path)
mydata = mytbz2.get_data()
updated_items = update_dbentries(update_iter, mydata)
if len(updated_items) > 0:
mydata.update(updated_items)
- mytbz2.recompose_mem(xpak.xpak_mem(mydata))
+ mytbz2.recompose_mem(portage.xpak.xpak_mem(mydata))
return 1
def prevent_collision(self, cpv):
dest_path = os.path.join(self.pkgdir, mypath)
if os.path.exists(dest_path):
# For invalid packages, other_cat could be None.
- other_cat = xpak.tbz2(dest_path).getfile("CATEGORY")
+ other_cat = portage.xpak.tbz2(dest_path).getfile("CATEGORY")
if other_cat:
other_cat = other_cat.strip()
self._move_from_all(other_cat + "/" + mypkg)
full_path = os.path.join(self.pkgdir, mypath)
if os.path.islink(full_path):
continue
- mytbz2 = xpak.tbz2(full_path)
+ mytbz2 = portage.xpak.tbz2(full_path)
# For invalid packages, mycat could be None.
mycat = mytbz2.getfile("CATEGORY")
mypf = mytbz2.getfile("PF")
chunk_size = 3000
writemsg(green("Fetching binary packages info...\n"))
- self.remotepkgs = getbinpkg.dir_get_metadata(
+ self.remotepkgs = portage.getbinpkg.dir_get_metadata(
self.settings["PORTAGE_BINHOST"], chunk_size=chunk_size)
writemsg(green(" -- DONE!\n\n"))
mysplit=pkgname.split("/")
if self.isremote(pkgname):
return self.remotepkgs[mysplit[1]+".tbz2"]["USE"][:].split()
- tbz2=xpak.tbz2(self.getname(pkgname))
+ tbz2=portage.xpak.tbz2(self.getname(pkgname))
return tbz2.getfile("USE").split()
def gettbz2(self,pkgname):
os.makedirs(mydest, 0775)
except (OSError, IOError):
pass
- return getbinpkg.file_get(
+ return portage.getbinpkg.file_get(
self.settings["PORTAGE_BINHOST"] + "/" + tbz2name,
mydest, fcmd=self.settings["RESUMECOMMAND"])
#tbz2_lock = portage.locks.lockfile(mytbz2, wantnewlockfile=1)
mypkg = os.path.basename(mytbz2)[:-5]
- xptbz2 = xpak.tbz2(mytbz2)
+ xptbz2 = portage.xpak.tbz2(mytbz2)
mycat = xptbz2.getfile("CATEGORY")
if not mycat:
writemsg("!!! CATEGORY info missing from info chunk, aborting...\n",
except ImportError:
import pickle
import os
-from cache import fs_template
-from cache import cache_errors
+from portage.cache import fs_template
+from portage.cache import cache_errors
class database(fs_template.FsBased):
# License: GPL2
# $Id: flat_list.py 1911 2005-08-25 03:44:21Z ferringb $
-from cache import fs_template
-from cache import cache_errors
+from portage.cache import fs_template
+from portage.cache import cache_errors
import errno, os, stat
-from cache.template import reconstruct_eclasses
+from portage.cache.template import reconstruct_eclasses
# store the current key order *here*.
class database(fs_template.FsBased):
-from cache import fs_template
-from cache import cache_errors
+from portage.cache import fs_template
+from portage.cache import cache_errors
import errno, os, stat
# store the current key order *here*.
# $Id: fs_template.py 1911 2005-08-25 03:44:21Z ferringb $
import os
-from cache import template
-from portage_data import portage_gid
+from portage.cache import template
+from portage.data import portage_gid
class FsBased(template.database):
"""template wrapping fs needed options, and providing _ensure_access as a way to
# $Id: metadata.py 1964 2005-09-03 00:16:16Z ferringb $
import os, stat
-from cache import flat_hash
-import eclass_cache
-from cache.template import reconstruct_eclasses
-from cache.mappings import ProtectedDict
+from portage.cache import flat_hash
+import portage.eclass_cache
+from portage.cache.template import reconstruct_eclasses
+from portage.cache.mappings import ProtectedDict
# this is the old cache format, flat_list. count maintained here.
magic_line_count = 22
loc = location
super(database, self).__init__(location, *args, **config)
self.location = os.path.join(loc, "metadata","cache")
- self.ec = eclass_cache.cache(loc)
+ self.ec = portage.eclass_cache.cache(loc)
def __getitem__(self, cpv):
return flat_hash.database.__getitem__(self, cpv)
import time
if not hasattr(__builtins__, "set"):
from sets import Set as set
-from cache import template
-from cache.cache_errors import CacheCorruption
-from cache.flat_hash import database as db_rw
-from cache.metadata import database as db_ro
+from portage.cache import template
+from portage.cache.cache_errors import CacheCorruption
+from portage.cache.flat_hash import database as db_rw
+from portage.cache.metadata import database as db_ro
class database(template.database):
# License: GPL2
# $Id: sql_template.py 1911 2005-08-25 03:44:21Z ferringb $
-from cache import template, cache_errors
-from cache.template import reconstruct_eclasses
+from portage.cache import template, cache_errors
+from portage.cache.template import reconstruct_eclasses
class SQLDatabase(template.database):
"""template class for RDBM based caches
# Distributed under the terms of the GNU General Public License v2
# $Header: $
-from cache import fs_template
-from cache import cache_errors
+from portage.cache import fs_template
+from portage.cache import cache_errors
import os
-from cache.template import reconstruct_eclasses
-from portage_util import writemsg, apply_secpass_permissions
-from portage_data import portage_gid
+from portage.cache.template import reconstruct_eclasses
+from portage.util import writemsg, apply_secpass_permissions
+from portage.data import portage_gid
try:
import sqlite3 as db_module # sqlite3 is optional with >=python-2.5
except ImportError:
# License: GPL2
# $Id: template.py 1911 2005-08-25 03:44:21Z ferringb $
-from cache import cache_errors
-from cache.cache_errors import InvalidRestriction
-from cache.mappings import ProtectedDict
+from portage.cache import cache_errors
+from portage.cache.cache_errors import InvalidRestriction
+from portage.cache.mappings import ProtectedDict
class database(object):
# this is for metadata/cache transfer.
if not hasattr(__builtins__, "set"):
from sets import Set as set
from itertools import chain
-from cache import cache_errors
+from portage.cache import cache_errors
def mirror_cache(valid_nodes_iterable, src_cache, trg_cache, eclass_cache=None, verbose_instance=None):
trg = None
try:
trg = trg_cache[x]
- if long(trg["_mtime_"]) == long(entry["_mtime_"]) and eclass_cache.is_eclass_data_valid(trg["_eclasses_"]):
+ if long(trg["_mtime_"]) == long(entry["_mtime_"]) and portage.eclass_cache.is_eclass_data_valid(trg["_eclasses_"]):
write_it = False
except (cache_errors.CacheError, KeyError):
pass
if not "_eclasses_" in entry:
noise.corruption(x,"missing _eclasses_ field")
continue
- if not eclass_cache.is_eclass_data_valid(entry["_eclasses_"]):
+ if not portage.eclass_cache.is_eclass_data_valid(entry["_eclasses_"]):
noise.eclass_stale(x)
continue
else:
- entry["_eclasses_"] = eclass_cache.get_eclass_data(entry["INHERITED"].split(), \
+ entry["_eclasses_"] = portage.eclass_cache.get_eclass_data(entry["INHERITED"].split(), \
from_master_only=True)
if not entry["_eclasses_"]:
noise.eclass_stale(x)
import copy
if not hasattr(__builtins__, "set"):
from sets import Set as set
-from cache import template
+from portage.cache import template
class database(template.database):
-# portage.checksum.py -- core Portage functionality
+# checksum.py -- core Portage functionality
# Copyright 1998-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id: portage_checksum.py 3835 2006-07-11 00:59:10Z zmedico $
-# portage.data.py -- Calculated/Discovered Data Values
+# data.py -- Calculated/Discovered Data Values
# Copyright 1998-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id: portage_data.py 4530 2006-09-25 21:16:32Z zmedico $
import os,pwd,grp
import portage.const
from portage.util import writemsg
-from output import green,red
-from output import create_color_func
+from portage.output import green,red
+from portage.output import create_color_func
bad = create_color_func("BAD")
ostype=os.uname()[0]
-import elog_modules.mod_save, portage_exec, portage_exception
+import portage.elog_modules.mod_save, portage.process, portage.exception
def process(mysettings, cpv, logentries, fulltext):
- elogfilename = elog_modules.mod_save.process(mysettings, cpv, logentries, fulltext)
+ elogfilename = portage.elog_modules.mod_save.process(mysettings, cpv, logentries, fulltext)
if (not "PORTAGE_ELOG_COMMAND" in mysettings.keys()) \
or len(mysettings["PORTAGE_ELOG_COMMAND"]) == 0:
- raise portage_exception.MissingParameter("!!! Custom logging requested but PORTAGE_ELOG_COMMAND is not defined")
+ raise portage.exception.MissingParameter("!!! Custom logging requested but PORTAGE_ELOG_COMMAND is not defined")
else:
mylogcmd = mysettings["PORTAGE_ELOG_COMMAND"]
mylogcmd = mylogcmd.replace("${LOGFILE}", elogfilename)
mylogcmd = mylogcmd.replace("${PACKAGE}", cpv)
- retval = portage_exec.spawn_bash(mylogcmd)
+ retval = portage.process.spawn_bash(mylogcmd)
if retval != 0:
- raise portage_exception.PortageException("!!! PORTAGE_ELOG_COMMAND failed with exitcode %d" % retval)
+ raise portage.exception.PortageException("!!! PORTAGE_ELOG_COMMAND failed with exitcode %d" % retval)
return
-import smtplib, email.Message, socket, portage_exception
+# portage.py -- core Portage functionality
+# Copyright 1998-2004 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Id: mod_mail.py 5781 2007-01-25 16:25:02Z genone $
+
+import portage.mail, socket
def process(mysettings, cpv, logentries, fulltext):
- mymailhost = "localhost"
- mymailport = 25
- mymailuser = ""
- mymailpasswd = ""
- myrecipient = "root@localhost"
-
- # Syntax for PORTAGE_LOG_MAILURI (if defined):
- # adress [[user:passwd@]mailserver[:port]]
- # where adress: recipient adress
- # user: username for smtp auth (defaults to none)
- # passwd: password for smtp auth (defaults to none)
- # mailserver: smtp server that should be used to deliver the mail (defaults to localhost)
- # port: port to use on the given smtp server (defaults to 25, values > 100000 indicate that starttls should be used on (port-100000))
- if " " in mysettings["PORTAGE_ELOG_MAILURI"]:
- myrecipient, mymailuri = mysettings["PORTAGE_ELOG_MAILURI"].split()
- if "@" in mymailuri:
- myauthdata, myconndata = mymailuri.rsplit("@", 1)
- try:
- mymailuser,mymailpasswd = myauthdata.split(":")
- except ValueError:
- print "!!! invalid SMTP AUTH configuration, trying unauthenticated ..."
- else:
- myconndata = mymailuri
- if ":" in myconndata:
- mymailhost,mymailport = myconndata.split(":")
- else:
- mymailhost = myconndata
+ if mysettings.has_key("PORTAGE_ELOG_MAILURI"):
+ myrecipient = mysettings["PORTAGE_ELOG_MAILURI"].split()[0]
else:
- myrecipient = mysettings["PORTAGE_ELOG_MAILURI"]
- try:
- myfrom = mysettings["PORTAGE_ELOG_MAILFROM"]
-
- mymessage = email.Message.Message()
- mymessage.set_unixfrom(myfrom)
- mymessage.set_payload(fulltext)
- mymessage["To"] = myrecipient
-
- mysubject = mysettings["PORTAGE_ELOG_MAILSUBJECT"]
- mysubject = mysubject.replace("${PACKAGE}", cpv)
- mysubject = mysubject.replace("${HOST}", socket.getfqdn())
-
- mymessage["Subject"] = mysubject
-
- if int(mymailport) > 100000:
- myconn = smtplib.SMTP(mymailhost, int(mymailport) - 100000)
- myconn.starttls()
- else:
- myconn = smtplib.SMTP(mymailhost, mymailport)
- if mymailuser != "" and mymailpasswd != "":
- myconn.login(mymailuser, mymailpasswd)
- myconn.sendmail(myfrom, myrecipient, mymessage.as_string())
- myconn.quit()
- except smtplib.SMTPException, e:
- raise portage_exception.PortageException("!!! An error occured while trying to send logmail:\n"+str(e))
- except socket.error, e:
- raise portage_exception.PortageException("!!! A network error occured while trying to send logmail:\n"+str(e)+"\nSure you configured PORTAGE_ELOG_MAILURI correctly?")
+ myrecipient = "root@localhost"
+
+ myfrom = mysettings["PORTAGE_ELOG_MAILFROM"]
+ mysubject = mysettings["PORTAGE_ELOG_MAILSUBJECT"]
+ mysubject = mysubject.replace("${PACKAGE}", cpv)
+ mysubject = mysubject.replace("${HOST}", socket.getfqdn())
+
+ mymessage = portage.mail.create_message(myfrom, myrecipient, mysubject, fulltext)
+ portage.mail.send_mail(mysettings, mymessage)
+
return
# Distributed under the terms of the GNU General Public License v2
# $Id: mod_mail.py 3484 2006-06-10 22:38:44Z genone $
-import portage_mail, socket, os, time
+import portage.mail, socket, os, time
from email.MIMEText import MIMEText as TextMessage
_items = {}
for cpv in _items.keys():
mybody += "- %s\n" % cpv
- mymessage = portage_mail.create_message(myfrom, myrecipient, mysubject, mybody, attachments=_items.values())
- portage_mail.send_mail(mysettings, mymessage)
+ mymessage = portage.mail.create_message(myfrom, myrecipient, mysubject, mybody, attachments=_items.values())
+ portage.mail.send_mail(mysettings, mymessage)
return
import os, time
-from portage_data import portage_uid, portage_gid
+from portage.data import portage_uid, portage_gid
def process(mysettings, cpv, logentries, fulltext):
cpv_path = cpv.replace("/", ":")
import os, time
-from portage_data import portage_uid, portage_gid
+from portage.data import portage_uid, portage_gid
def process(mysettings, cpv, logentries, fulltext):
if mysettings["PORT_LOGDIR"] != "":
import syslog
-from portage_const import EBUILD_PHASES
+from portage.const import EBUILD_PHASES
def process(mysettings, cpv, logentries, fulltext):
syslog.openlog("portage", syslog.LOG_ERR | syslog.LOG_WARNING | syslog.LOG_INFO | syslog.LOG_NOTICE, syslog.LOG_LOCAL5)
import os,sys
-from output import bold, turquoise, green
+from portage.output import bold, turquoise, green
def shorthelp():
print
if not hasattr(__builtins__, "set"):
from sets import Set as set
-from output import red, yellow, green
-import htmllib,HTMLParser,formatter,sys,os,xpak,time,tempfile,base64,urllib2
+from portage.output import red, yellow, green
+import htmllib,HTMLParser,formatter,sys,os,portage.xpak,time,tempfile,base64,urllib2
from portage_const import CACHE_PATH
try:
myid,myglob = data
mydict = {}
- for x in xpak.getindex_mem(myid):
- mydict[x] = xpak.getitem(data,x)
+ for x in portage.xpak.getindex_mem(myid):
+ mydict[x] = portage.xpak.getitem(data,x)
return mydict
raise TypeError, "Unknown protocol. '%s'" % protocol
if data:
- xpaksize = xpak.decodeint(data[-8:-4])
+ xpaksize = portage.xpak.decodeint(data[-8:-4])
if (xpaksize+8) > chunk_size:
myid = file_get_metadata(baseurl, conn, (xpaksize+8))
if not keepconnection:
xpak_data = data[len(data)-(xpaksize+8):-8]
del data
- myid = xpak.xsplit_mem(xpak_data)
+ myid = portage.xpak.xsplit_mem(xpak_data)
if not myid:
myid = None,None
del xpak_data
-# portage.gpg.py -- core Portage functionality
+# gpg.py -- core Portage functionality
# Copyright 2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id: portage_gpg.py 3483 2006-06-10 21:40:40Z genone $
trustLevel = UNTRUSTED
if result == 0:
trustLevel = TRUSTED
- #if output.find("WARNING") != -1:
+ #if portage.output.find("WARNING") != -1:
# trustLevel = MARGINAL
- if output.find("BAD") != -1:
+ if portage.output.find("BAD") != -1:
raise portage.exception.InvalidSignature, filename
elif result == 1:
trustLevel = EXISTS
- if output.find("BAD") != -1:
+ if portage.output.find("BAD") != -1:
raise portage.exception.InvalidSignature, filename
elif result == 2:
trustLevel = UNTRUSTED
- if output.find("could not be verified") != -1:
+ if portage.output.find("could not be verified") != -1:
raise portage.exception.MissingSignature, filename
- if output.find("public key not found") != -1:
+ if portage.output.find("public key not found") != -1:
if self.keyringIsTrusted: # We trust the ring, but not the key specifically.
trustLevel = MARGINAL
else:
-# portage.localization.py -- Code to manage/help portage localization.
+# localization.py -- Code to manage/help portage localization.
# Copyright 2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id: portage_localization.py 3483 2006-06-10 21:40:40Z genone $
-# portage.versions.py -- core Portage functionality
+# versions.py -- core Portage functionality
# Copyright 1998-2006 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id$
projects / portage.git / commitdiff