class depgraph:
- def __init__(self,myaction,myopts):
- self.pkgsettings = portage.config(clone=portage.settings)
+ def __init__(self, settings, portdb, trees, myaction, myopts, myparams,
+ edebug, spinner):
+ self.settings = settings
+ self.portdb = portdb
+ self.trees = trees
+ self.myopts = myopts
+ self.myparams = myparams
+ self.edebug = edebug
+ self.spinner = spinner
+ self.pkgsettings = portage.config(clone=settings)
if not self.pkgsettings["ARCH"]:
portage.writemsg(red("\a!!! ARCH is not set... Are you missing the /etc/make.profile symlink?\n"),
noiselevel=-1)
self.outdatedpackages=[]
self.mydbapi={}
self.mydbapi["/"] = portage.fakedbapi()
- if "empty" not in myparams or portage.root != "/":
- for pkg in portage.db["/"]["vartree"].getallcpv():
+ if "empty" not in self.myparams or settings["ROOT"] != "/":
+ for pkg in self.trees["/"]["vartree"].getallcpv():
self.mydbapi["/"].cpv_inject(pkg)
- if portage.root != "/":
- self.mydbapi[portage.root] = portage.fakedbapi()
- if "empty" not in myparams:
- for pkg in portage.db[portage.root]["vartree"].getallcpv():
- self.mydbapi[portage.root].cpv_inject(pkg)
+ if settings["ROOT"] != "/":
+ self.mydbapi[settings["ROOT"]] = portage.fakedbapi()
+ if "empty" not in self.myparams:
+ for pkg in self.trees[settings["ROOT"]]["vartree"].getallcpv():
+ self.mydbapi[settings["ROOT"]].cpv_inject(pkg)
- if "--usepkg" in myopts:
- portage.db["/"]["bintree"].populate(("--getbinpkg" in myopts), ("--getbinpkgonly" in myopts))
+ if "--usepkg" in self.myopts:
+ trees["/"]["bintree"].populate(
+ "--getbinpkg" in self.myopts, "--getbinpkgonly" in self.myopts)
def create(self,mybigkey,myparent=None,addme=1,myuse=None):
"""creates the actual digraph of packages to merge. return 1 on success, 0 on failure
#this conditional is needed to prevent infinite recursion on already-processed deps
return 1
- spinner.update()
+ self.spinner.update()
mytype,myroot,mykey=mybigkey
# select the correct /var database that we'll be checking against
- vardbapi=portage.db[myroot]["vartree"].dbapi
+ vardbapi = self.trees[myroot]["vartree"].dbapi
# if the package is already on the system, we add a "nomerge"
# directive, otherwise we add a "merge" directive.
if mytype=="blocks":
# we've encountered a "blocks" node. We will totally ignore this
# node and not add it to our digraph if it doesn't apply to us.
- if addme and "--buildpkgonly" not in myopts and myparent and (self.mydbapi[myroot].match(mykey) or vardbapi.match(mykey)):
+ if addme and "--buildpkgonly" not in self.myopts and myparent and \
+ (self.mydbapi[myroot].match(mykey) or vardbapi.match(mykey)):
mybigkey.append(myparent.split()[2])
self.digraph.addnode(string.join(mybigkey),myparent)
return 1
# this is where we add the node to the list of packages to merge
if not myparent:
# command-line specified or part of a world list...
- if ("self" not in myparams) or (("selective" in myparams) and vardbapi.cpv_exists(mykey)):
+ if "self" not in self.myparams or \
+ ("selective" in self.myparams and \
+ vardbapi.cpv_exists(mykey)):
# the package is on the system, so don't merge it.
merging=0
- elif ("selective" in myparams) and vardbapi.cpv_exists(mykey):
+ elif "selective" in self.myparams and vardbapi.cpv_exists(mykey):
merging=0
- if (merging==0 and "--newuse" in myopts and vardbapi.cpv_exists(mykey)):
+ if merging == 0 and "--newuse" in self.myopts and \
+ vardbapi.cpv_exists(mykey):
old_use = vardbapi.aux_get(mykey, ["USE"])[0].split()
if mytype == "binary":
- iuses = portage.db["/"]["bintree"].dbapi.aux_get(mykey, ["IUSE"])[0].split()
+ iuses = self.trees["/"]["bintree"].dbapi.aux_get(
+ mykey, ["IUSE"])[0].split()
else:
- iuses = portage.db["/"]["porttree"].dbapi.aux_get(mykey, ["IUSE"])[0].split()
+ iuses = self.trees["/"]["porttree"].dbapi.aux_get(
+ mykey, ["IUSE"])[0].split()
for x in iuses:
if (old_use.count(x) and not myuse.count(x)) or (not old_use.count(x) and myuse.count(x)):
merging=1
# whatever the case, we need to add the node to our digraph so
# that children can depend upon it.
self.digraph.addnode(string.join(mybigkey),myparent)
- if ("deep" not in myparams) and (not merging):
+ if "deep" not in self.myparams and not merging:
return 1
- elif "recurse" not in myparams:
+ elif "recurse" not in self.myparams:
return 1
edepend={}
if mytype=="binary":
mypkgparts=portage.catpkgsplit(mykey)
tbz2name = string.split(mykey, "/")[1]+".tbz2"
- if tbz2name in portage.db[portage.root]["bintree"].invalids:
+ if tbz2name in self.trees[
+ self.settings["ROOT"]]["bintree"].invalids:
sys.stderr.write("\nINVALID PACKAGE (is required to continue): "+str(mykey)+"\n")
sys.exit(1)
- if portage.db[portage.root]["bintree"].isremote(mykey):
- edepend = portage.db[portage.root]["bintree"].remotepkgs[tbz2name]
+ if self.trees[self.settings["ROOT"]]["bintree"].isremote(mykey):
+ edepend = self.trees[
+ self.settings["ROOT"]]["bintree"].remotepkgs[tbz2name]
edepend["DEPEND"] =""
edepend["RDEPEND"]=string.join(string.split(edepend["RDEPEND"])," ")
edepend["PDEPEND"]=string.join(string.split(edepend["PDEPEND"])," ")
edepend["SLOT"] =string.strip(edepend["SLOT"])
#portage.db[portage.root]["bintree"].gettbz2(mykey)
else: # It's local.
- mytbz2=xpak.tbz2(portage.db[portage.root]["bintree"].getname(mykey))
+ mytbz2 = xpak.tbz2(self.trees[
+ self.settings["ROOT"]]["bintree"].getname(mykey))
edepend["DEPEND"] =""
edepend["RDEPEND"]=string.join(mytbz2.getelements("RDEPEND")," ")
edepend["PDEPEND"]=string.join(mytbz2.getelements("PDEPEND")," ")
elif mytype=="ebuild":
try:
mymeta = ["DEPEND","RDEPEND","PDEPEND"]
- myfoo = portage.portdb.aux_get(mykey, mymeta)
+ myfoo = self.portdb.aux_get(mykey, mymeta)
for index in range(0,len(mymeta)):
edepend[mymeta[index]] = myfoo[index]
- if "--buildpkgonly" in myopts:
+ if "--buildpkgonly" in self.myopts:
edepend["RDEPEND"] = ""
edepend["PDEPEND"] = ""
except (KeyError,IOError):
"!!! This binary package cannot be installed: '%s'\n" % \
mykey, noiselevel=-1)
elif mytype == "ebuild":
- myebuild, mylocation = portage.portdb.findname2(mykey)
+ myebuild, mylocation = self.portdb.findname2(mykey)
portage.writemsg("!!! This ebuild cannot be installed: " + \
"'%s'\n" % myebuild, noiselevel=-1)
portage.writemsg("!!! Please notify the package maintainer " + \
sys.exit(1)
mytbz2=xpak.tbz2(x)
mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.splitext(os.path.basename(x))[0]
- if os.path.realpath(portage.db["/"]["bintree"].getname(mykey)) != os.path.realpath(x):
+ if os.path.realpath(x) != \
+ os.path.realpath(self.trees["/"]["bintree"].getname(mykey)):
print red("\n*** You need to adjust PKGDIR to emerge this package.\n")
sys.exit(1)
- if not self.create(["binary",portage.root,mykey],None,"--onlydeps" not in myopts):
+ if not self.create(["binary", self.settings["ROOT"], mykey],
+ None, "--onlydeps" not in self.myopts):
return (0,myfavorites)
- elif not "--oneshot" in myopts:
+ elif not "--oneshot" in self.myopts:
myfavorites.append(mykey)
elif ext==".ebuild":
x = os.path.realpath(x)
mykey=os.path.basename(os.path.normpath(x+"/../.."))+"/"+os.path.splitext(os.path.basename(x))[0]
- ebuild_path = portage.db["/"]["porttree"].dbapi.findname(mykey)
+ ebuild_path = self.trees["/"]["porttree"].dbapi.findname(mykey)
if ebuild_path:
if os.path.realpath(ebuild_path) != x:
print red("\n*** You need to adjust PORTDIR or PORTDIR_OVERLAY to emerge this package.\n")
sys.exit(1)
- if mykey not in portage.db["/"]["porttree"].dbapi.xmatch("match-visible", portage.dep_getkey(mykey)):
+ if mykey not in self.trees["/"]["porttree"].dbapi.xmatch(
+ "match-visible", portage.dep_getkey(mykey)):
print red("\n*** You are emerging a masked package. It is MUCH better to use")
print red("*** /etc/portage/package.* to accomplish this. See portage(5) man")
print red("*** page for details.")
else:
raise portage_exception.PackageNotFound(
"%s is not in a valid portage tree hierarchy or does not exist" % x)
- if not self.create(["ebuild",portage.root,mykey],None,"--onlydeps" not in myopts):
+ if not self.create(["ebuild", self.settings["ROOT"], mykey],
+ None, "--onlydeps" not in self.myopts):
return (0,myfavorites)
- elif not "--oneshot" in myopts:
+ elif not "--oneshot" in self.myopts:
myfavorites.append(mykey)
else:
if not is_valid_package_atom(x):
portage.writemsg("!!! (Did you specify a version but forget to prefix with '='?)\n")
return (0,[])
try:
- mykey=portage.dep_expand(x,mydb=portage.portdb)
+ mykey = portage.dep_expand(x, mydb=self.portdb)
except ValueError, errpkgs:
print "\n\n!!! The short ebuild name \"" + x + "\" is ambiguous. Please specify"
print "!!! one of the following fully-qualified ebuild names instead:\n"
sys.stderr.flush()
try:
- self.mysd = self.select_dep(portage.root,mykey,arg=x)
+ self.mysd = self.select_dep(
+ self.settings["ROOT"], mykey, arg=x)
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")
except SystemExit, e:
raise # Needed else can't exit
except Exception, e:
- if "--debug" in myopts:
+ if "--debug" in self.myopts:
raise
print "\n\n!!! Problem in",mykey,"dependencies."
print "!!!",str(e),e.__module__
if not self.mysd:
return (0,myfavorites)
- elif not "--oneshot" in myopts:
+ elif not "--oneshot" in self.myopts:
myfavorites.append(portage.dep_getkey(mykey))
missing=0
- if "--usepkgonly" in myopts:
+ if "--usepkgonly" in self.myopts:
for x in self.digraph.dict.keys():
xs=string.split(x," ")
if (xs[0] != "binary") and (xs[3]=="merge"):
def is_newer_ver_installed(self,myroot,pkg,pkgver):
"if there is a version of pkg installed newer than pkgver, return it"
- vardbapi=portage.db[myroot]["vartree"].dbapi
+ vardbapi = self.trees[myroot]["vartree"].dbapi
- matches=portage.db[myroot]["vartree"].dbapi.match(pkg)
+ matches = self.trees[myroot]["vartree"].dbapi.match(pkg)
if matches:
- myslot=portage.db["/"]["porttree"].getslot(pkgver)
+ myslot = self.trees["/"]["porttree"].getslot(pkgver)
for match in matches:
if portage.pkgcmp(portage.catpkgsplit(pkgver)[1:], portage.catpkgsplit(match)[1:]) < 0:
- curslot=portage.db[myroot]["vartree"].getslot(match)
+ curslot = self.trees[myroot]["vartree"].getslot(match)
if curslot == myslot:
return match
def select_dep(self,myroot,depstring,myparent=None,arg=None,myuse=None,raise_on_missing=False):
"given a dependency string, create the appropriate depgraph and return 1 on success and 0 on failure"
- if "--debug" in myopts:
+ if "--debug" in self.myopts:
print
print "Parent: ",myparent
print "Depstring:",depstring
if not arg:
#processing dependencies
- mycheck=portage.dep_check(depstring,self.mydbapi[myroot],self.pkgsettings,myuse=myuse,use_binaries=("--usepkgonly" in myopts),myroot=myroot)
+ mycheck = portage.dep_check(depstring, self.mydbapi[myroot],
+ self.pkgsettings, myuse=myuse,
+ use_binaries=("--usepkgonly" in self.myopts),
+ myroot=myroot)
if not mycheck[0]:
mymerge=[]
if myp[3]=="merge":
self.mydbapi[myroot].cpv_inject(myp[2])
if myp[0]=="binary":
- self.pkgsettings.setinst(myp[2],portage.db["/"]["bintree"].dbapi)
+ self.pkgsettings.setinst(
+ myp[2], self.trees["/"]["bintree"].dbapi)
else:
- self.pkgsettings.setinst(myp[2],portage.db[myroot]["porttree"].dbapi)
+ self.pkgsettings.setinst(
+ myp[2], self.trees[myroot]["porttree"].dbapi)
if not mymerge:
return 1
- if "--debug" in myopts:
+ if "--debug" in self.myopts:
print "Candidates:",mymerge
for x in mymerge:
myk=None
binpkguseflags=None
if x[0]=="!":
# if this package is myself, don't append it to block list.
- if "--debug" in myopts:
+ if "--debug" in self.myopts:
print "Myparent",myparent
if (myparent):
- if myparent.split()[2] in portage.portdb.xmatch("match-all", x[1:]):
+ if myparent.split()[2] in self.portdb.xmatch(
+ "match-all", x[1:]):
# myself, so exit.
continue
# adding block
else:
#We are not processing a blocker but a normal dependency
myeb=None
- myeb_matches = portage.portdb.xmatch("match-visible",x)
- if ("--usepkgonly" not in myopts):
+ myeb_matches = self.portdb.xmatch("match-visible", x)
+ if "--usepkgonly" not in self.myopts:
myeb=portage.best(myeb_matches)
myeb_pkg=None
- if ("--usepkg" in myopts):
+ if "--usepkg" in self.myopts:
# The next line assumes the binarytree has been populated.
# XXX: Need to work out how we use the binary tree with roots.
- myeb_pkg_matches=portage.db["/"]["bintree"].dbapi.match(x)
- if ("--usepkgonly" not in myopts):
+ myeb_pkg_matches=self.trees["/"]["bintree"].dbapi.match(x)
+ if "--usepkgonly" not in self.myopts:
# Remove any binary package entries that are masked in the portage tree (#55871)
for idx in range(len(myeb_pkg_matches)-1,-1,-1):
if myeb_pkg_matches[idx] not in myeb_matches:
if not myeb_pkg:
myeb_pkg = None
- elif ("--newuse" in myopts):
- iuses=string.split(portage.db["/"]["bintree"].dbapi.aux_get(myeb_pkg, ["IUSE"])[0])
- old_use=string.split(portage.db["/"]["bintree"].dbapi.aux_get(myeb_pkg, ["USE"])[0])
+ elif "--newuse" in self.myopts:
+ iuses = self.trees["/"]["bintree"].dbapi.aux_get(
+ myeb_pkg, ["IUSE"])[0].split()
+ old_use = self.trees["/"]["bintree"].dbapi.aux_get(
+ myeb_pkg, ["USE"])[0].split()
self.pkgsettings.setcpv(myeb_pkg)
now_use=string.split(self.pkgsettings["USE"])
for x in iuses:
xinfo='"'+arg+'"'
if myparent:
xfrom = '(dependency required by '+green('"'+myparent.split()[2]+'"')+red(' ['+myparent.split()[0]+"]")+')'
- alleb=portage.portdb.xmatch("match-all",x)
+ alleb = self.portdb.xmatch("match-all", x)
if alleb:
- if "--usepkgonly" not in myopts:
+ if "--usepkgonly" not in self.myopts:
print "\n!!! "+red("All ebuilds that could satisfy ")+green(xinfo)+red(" have been masked.")
print "!!! One of the following masked packages is required to complete your request:"
oldcomment = ""
print
return 0
- if "--debug" in myopts:
+ if "--debug" in self.myopts:
print "ebuild:",myeb
print "binpkg:",myeb_pkg
if myeb:
myk=["ebuild",myroot,myeb]
elif myeb_pkg:
- binpkguseflags=portage.db[portage.root]["bintree"].get_use(myeb_pkg)
+ binpkguseflags = self.trees[
+ self.settings["ROOT"]]["bintree"].get_use(myeb_pkg)
myk=["binary",myroot,myeb_pkg]
else:
sys.stderr.write("!!! Confused... Don't know what's being used for dependency info. :(\n")
else:
#if mysource is not set, then we are a command-line dependency and should not be added
#if --onlydeps is specified.
- if not self.create(myk,myparent,"--onlydeps" not in myopts,myuse=binpkguseflags):
+ if not self.create(myk, myparent,
+ "--onlydeps" not in self.myopts, myuse=binpkguseflags):
return 0
- if "--debug" in myopts:
+ if "--debug" in self.myopts:
print "Exiting...",myparent
return 1
mygraph=self.digraph.copy()
dolist=["/"]
retlist=[]
- for x in portage.db.keys():
- portage.db[x]["merge"]=[]
+ for x in self.trees.keys():
+ self.trees[x]["merge"] = []
if x not in dolist:
dolist.append(x)
while (not mygraph.empty()):
# if not portage.db["/"]["vartree"].exists_specific(splitski[2]):
# portage.db["/"]["merge"].append(splitski)
#else:
- portage.db[splitski[1]]["merge"].append(splitski)
+ self.trees[splitski[1]]["merge"].append(splitski)
mygraph.delnode(mycurkey)
for x in dolist:
- for y in portage.db[x]["merge"]:
+ for y in self.trees[x]["merge"]:
retlist.append(y)
return retlist
def xcreate(self,mode="system"):
- global syslist
world_problems = False
if mode=="system":
- mylist=syslist
+ mylist = getlist("system")
else:
#world mode
worldlist=getlist("world")
for x in worlddict.keys():
if not portage.isvalidatom(x):
world_problems = True
- elif not portage.db["/"]["vartree"].dbapi.match(x):
+ elif not self.trees["/"]["vartree"].dbapi.match(x):
world_problems = True
else:
sysdict[x]=worlddict[x]
missing_atoms = []
for mydep in mylist:
try:
- if not self.select_dep(portage.root, mydep, raise_on_missing=True):
+ if not self.select_dep(
+ self.settings["ROOT"], mydep, raise_on_missing=True):
print "\n\n!!! Problem resolving dependencies for", mydep
return 0
except ValueError:
print "\n!!! Problems have been detected with your world file"
print "!!! Please run "+green("emaint --check world")+"\n"
- if missing_atoms and "--verbose" in myopts:
+ if missing_atoms and "--verbose" in self.myopts:
print "\n!!! Packages for the following atoms are either all"
print "!!! masked or don't exist:"
print " ".join(missing_atoms) + "\n"
return 1
- def match(self,mydep,myroot=portage.root,mykey=None):
+ def match(self, mydep, myroot=None, mykey=None):
# support mutual exclusive deps
+ if myroot is None:
+ myroot = self.settings["ROOT"]
mydep2=mydep
if mydep2[0]=="!":
mydep2=mydep[1:]
#add our blocker; it will be ignored later if necessary (if we are remerging the same pkg, for example)
myk="blocks "+myroot+" "+mydep2
else:
- myeb=portage.db[portage.root]["porttree"].dep_bestmatch(mydep2)
+ myeb = self.trees[
+ self.settings["ROOT"]]["porttree"].dep_bestmatch(mydep2)
if not myeb:
if not mykey:
print "\n!!! Error: couldn't find match for",mydep
print
sys.exit(1)
- if "--usepkg" in myopts:
- mypk=portage.db[portage.root]["bintree"].dep_bestmatch(mydep)
+ if "--usepkg" in self.myopts:
+ mypk = self.trees[
+ self.settings["ROOT"]]["bintree"].dep_bestmatch(mydep)
if myeb==mypk:
- myk="binary "+portage.root+" "+mypk
+ myk = " ".join(("binary", self.settings["ROOT"], mypk))
else:
- myk="ebuild "+myroot+" "+myeb
+ myk = " ".join(("ebuild", myroot, myeb))
else:
myk="ebuild "+myroot+" "+myeb
return myk
- def display(self,mylist,verbosity=("--quiet" in myopts and 1 or "--verbose" in myopts and 3 or 2 )):
+ def display(self,mylist,verbosity=None):
+ if verbosity is None:
+ verbosity = ("--quiet" in self.myopts and 1 or \
+ "--verbose" in self.myopts and 3 or 2)
changelogs=[]
p=[]
totalsize=0
def create_use_string(*args):
return ""
else:
- def create_use_string(name, cur_iuse, cur_use, old_iuse, old_use, is_new,
- all_flags=(verbosity == 3), alphabetical=("--alphabetical" in myopts)):
+ def create_use_string(name, cur_iuse, cur_use, old_iuse, old_use,
+ is_new, all_flags=(verbosity == 3),
+ alphabetical=("--alphabetical" in self.myopts)):
enabled = []
if alphabetical:
disabled = enabled
overlays_real = [os.path.realpath(t) \
for t in self.pkgsettings["PORTDIR_OVERLAY"].split()]
- if "--tree" in myopts:
+ if "--tree" in self.myopts:
mylist.reverse()
mygraph=self.digraph.copy()
i = 0
while i < len(mylist):
if mylist[i][-1]=="nomerge":
- if not ("--tree" in myopts):
+ if "--tree" not in self.myopts:
# we don't care about this elements
mylist.pop(i)
continue
pkg_key = x[2]
if pkg_key not in self.applied_useflags:
if "binary" == pkg_type:
- self.applied_useflags[pkg_key] = portage.db["/"]["bintree"].dbapi.aux_get(pkg_key, ["USE"])[0].split()
+ self.applied_useflags[pkg_key] = \
+ self.trees["/"]["bintree"].dbapi.aux_get(
+ pkg_key, ["USE"])[0].split()
elif "ebuild" == pkg_type:
self.pkgsettings.setcpv(pkg_key)
self.applied_useflags[pkg_key] = self.pkgsettings["USE"].split()
if x[0]=="blocks":
addl=""+red("B")+" "+fetch+" "
- resolved=portage.db[x[1]]["vartree"].resolve_key(x[2])
+ resolved = self.trees[x[1]]["vartree"].resolve_key(x[2])
print "["+x[0]+" "+addl+"]",red(resolved),
if resolved!=x[2]:
if x[3]:
else:
print
else:
- if (x[0]!="binary") and ("fetch" in string.split(portage.portdb.aux_get(x[2],["RESTRICT"])[0])):
+ if x[0] != "binary" and \
+ "fetch" in self.portdb.aux_get(
+ x[2], ["RESTRICT"])[0].split():
fetch = red("F")
- if portage.portdb.fetch_check(x[2], self.applied_useflags[x[2]]):
+ if self.portdb.fetch_check(
+ x[2], self.applied_useflags[x[2]]):
fetch = green("f")
#we need to use "--emptrytree" testing here rather than "empty" param testing because "empty"
#param is used for -u, where you still *do* want to see when something is being upgraded.
myoldbest=""
- if (not "--emptytree" in myopts) and portage.db[x[1]]["vartree"].exists_specific(x[2]):
+ if "--emptytree" not in self.myopts and \
+ self.trees[x[1]]["vartree"].exists_specific(x[2]):
addl=" "+yellow("R")+fetch+" "
- elif (not "--emptytree" in myopts) and portage.db[x[1]]["vartree"].exists_specific_cat(x[2]):
+ elif "--emptytree" not in self.myopts and \
+ self.trees[x[1]]["vartree"].exists_specific_cat(x[2]):
if x[0] == "binary":
- mynewslot=portage.db["/"]["bintree"].getslot(x[2])
+ mynewslot = self.trees["/"]["bintree"].getslot(x[2])
elif x[0] == "ebuild":
- mynewslot=portage.db["/"]["porttree"].getslot(x[2])
- myoldlist=portage.db[x[1]]["vartree"].dbapi.match(portage.pkgsplit(x[2])[0])
- myinslotlist=filter((lambda p: portage.db[portage.root]["vartree"].getslot(p)==mynewslot),myoldlist)
+ mynewslot = self.trees["/"]["porttree"].getslot(x[2])
+ myoldlist = self.trees[x[1]]["vartree"].dbapi.match(
+ portage.pkgsplit(x[2])[0])
+ myinslotlist = [p for p in myoldlist if mynewslot == \
+ self.trees[self.settings["ROOT"]]["vartree"].getslot(p)]
if myinslotlist:
myoldbest=portage.best(myinslotlist)
addl=" "+fetch
# New slot, mark it new.
addl=" "+green("NS")+fetch+" "
- if "--changelog" in myopts:
+ if "--changelog" in self.myopts:
changelogs.extend(self.calc_changelog(
- portage.portdb.findname(x[2]),
- portage.db[x[1]]["vartree"].dep_bestmatch('/'.join(portage.catpkgsplit(x[2])[:2])),
- x[2]
- ))
+ self.portdb.findname(x[2]),
+ self.trees[x[1]]["vartree"].dep_bestmatch(
+ '/'.join(portage.catpkgsplit(x[2])[:2])), x[2]))
else:
addl=" "+green("N")+" "+fetch+" "
if x[2] in self.applied_useflags:
# USE flag display
if x[0] == "binary":
- cur_iuse = string.split(portage.db["/"]["bintree"].dbapi.aux_get(x[2],["IUSE"])[0])
+ cur_iuse = self.trees["/"]["bintree"].dbapi.aux_get(
+ x[2],["IUSE"])[0].split()
elif x[0] == "ebuild":
- cur_iuse = string.split(portage.portdb.aux_get(x[2],["IUSE"])[0])
+ cur_iuse = self.portdb.aux_get(
+ x[2], ["IUSE"])[0].split()
else:
cur_iuse = []
cur_iuse = portage.unique_array(cur_iuse)
- cur_iuse = [flag for flag in cur_iuse if flag not in portage.settings.usemask]
+ cur_iuse = [flag for flag in cur_iuse
+ if flag not in self.settings.usemask]
cur_iuse.sort()
cur_use = self.applied_useflags[x[2]]
cur_use = [flag for flag in cur_use if flag in cur_iuse]
pkg = myoldbest
else:
pkg = x[2]
- if portage.db[x[1]]["vartree"].dbapi.cpv_exists(pkg):
- (old_iuse, old_use) = portage.db[x[1]]["vartree"].dbapi.aux_get(pkg, ["IUSE", "USE"])
+ if self.trees[x[1]]["vartree"].dbapi.cpv_exists(pkg):
+ old_iuse, old_use = \
+ self.trees[x[1]]["vartree"].dbapi.aux_get(
+ pkg, ["IUSE", "USE"])
old_iuse = portage.unique_array(old_iuse.split())
old_iuse.sort()
old_use = old_use.split()
old_iuse = []
old_use = []
is_new = True
- old_iuse = [flag for flag in old_iuse if flag not in portage.settings.usemask]
+ old_iuse = [flag for flag in old_iuse
+ if flag not in self.settings.usemask]
old_use = [flag for flag in old_use if flag in old_iuse]
- use_expand = portage.settings["USE_EXPAND"].lower().split()
+ use_expand = self.settings["USE_EXPAND"].lower().split()
use_expand.sort()
use_expand.reverse()
- use_expand_hidden = portage.settings["USE_EXPAND_HIDDEN"].lower().split()
+ use_expand_hidden = \
+ self.settings["USE_EXPAND_HIDDEN"].lower().split()
def map_to_use_expand(myvals):
ret = {}
# size verbose
mysize=0
if x[0] == "ebuild" and x[-1]!="nomerge":
- myfilesdict=portage.portdb.getfetchsizes(x[2], useflags=self.applied_useflags[x[2]], debug=edebug)
+ myfilesdict = self.portdb.getfetchsizes(
+ x[2], useflags=self.applied_useflags[x[2]],
+ debug=self.edebug)
if myfilesdict is None:
myfilesdict="[empty/missing/bad digest]"
else:
# overlay verbose
# XXX: Invalid binaries have caused tracebacks here. 'if file_name'
# x = ['binary', '/', 'sys-apps/pcmcia-cs-3.2.7.2.6', 'merge']
- file_name=portage.portdb.findname(x[2])
+ file_name = self.portdb.findname(x[2])
if file_name: # It might not exist in the tree
dir_name=os.path.abspath(os.path.dirname(file_name)+"/../..")
if (overlays_real.count(dir_name)>0):
newlp=oldlp-30
indent=""
- if ("--tree" in myopts):
+ if "--tree" in self.myopts:
indent=" "*mygraph.depth(string.join(x))
if myoldbest:
if x[1]!="/":
if myoldbest:
myoldbest +=" "
- if "--columns" in myopts:
- if "--quiet" in myopts:
+ if "--columns" in self.myopts:
+ if "--quiet" in self.myopts:
myprint=addl+" "+indent+darkgreen(xs[0])
myprint=myprint+darkblue(" "+xs[1]+xs[2])+" "
myprint=myprint+myoldbest
else:
myprint="["+x[0]+" "+addl+"] "+darkgreen(x[2])+" "+myoldbest+darkgreen("to "+x[1])+" "+verboseadd
else:
- if "--columns" in myopts:
- if "--quiet" in myopts:
+ if "--columns" in self.myopts:
+ if "--quiet" in self.myopts:
myprint=addl+" "+indent+darkgreen(xs[0])
myprint=myprint+" "+green(xs[1]+xs[2])+" "
myprint=myprint+myoldbest
p.append(myprint)
mysplit = portage.pkgsplit(x[2])
- if "--tree" not in myopts and mysplit and len(mysplit) == 3 and \
- mysplit[0] == "sys-apps/portage" and x[1] == "/":
+ if "--tree" not in self.myopts and mysplit and \
+ len(mysplit) == 3 and mysplit[0] == "sys-apps/portage" and \
+ x[1] == "/":
if mysplit[2] == "r0":
myversion = mysplit[1]
myversion = "%s-%s" % (mysplit[1], mysplit[2])
if myversion != portage.VERSION :
- if "--emptytree" in myopts:
+ if "--emptytree" in self.myopts:
p.append(red("***")+" Please update portage to the above version before proceeding.")
p.append(" Failure to do so may result in failed or improper merges.")
p.append(" A simple '"+green("emerge portage")+"' is sufficient.")
p.append("")
elif mylist.index(x) < len(mylist) - 1 and \
- "livecvsportage" not in portage.settings.features:
+ "livecvsportage" not in self.settings.features:
p.append(red("*** Portage will stop merging at this point and reload itself,"))
p.append(red(" then resume the merge."))
print
y=y+1
print " "+teal("["+str(y)+"]"),x
- if "--changelog" in myopts:
+ if "--changelog" in self.myopts:
print
for revision,text in changelogs:
print bold('*'+revision)
def outdated(self):
return self.outdatedpackages
- def merge(self,mylist):
+ def merge(self, mylist, favorites):
returnme=0
mymergelist=[]
#check for blocking dependencies
- if ("--fetchonly" not in myopts) and ("--buildpkgonly" not in myopts):
+ if "--fetchonly" not in self.myopts and \
+ "--buildpkgonly" not in self.myopts:
for x in mylist:
if x[0]=="blocks":
print "\n!!! Error: the "+x[2]+" package conflicts with another package;"
print "!!! the two packages cannot be installed on the same system together."
print "!!! Please use 'emerge --pretend' to determine blockers."
print
- if ("--pretend" not in myopts):
+ if "--pretend" not in self.myopts:
try:
del portage.mtimedb["resume"]
except KeyError:
#buildsyspkg: I need mysysdict also on resume (moved from the else block)
mysysdict=genericdict(syslist)
- if ("--resume" in myopts):
+ if "--resume" in self.myopts:
# We're resuming.
print green("*** Resuming merge...")
emergelog(" *** Resuming merge...")
mymergelist=portage.mtimedb["resume"]["mergelist"][:]
- if ("--skipfirst" in myopts) and mymergelist:
+ if "--skipfirst" in self.myopts and mymergelist:
del portage.mtimedb["resume"]["mergelist"][0]
del mymergelist[0]
validate_merge_list(mymergelist)
else:
- myfavs = portage.grabfile(os.path.join(portage.root, portage.WORLD_FILE))
+ myfavs = portage.grabfile(
+ os.path.join(self.settings["ROOT"], portage.WORLD_FILE))
myfavdict=genericdict(myfavs)
for x in range(len(mylist)):
if mylist[x][3]!="nomerge":
mymergelist.append(mylist[x])
else:
myfavkey=portage.cpv_getkey(mylist[x][2])
- if "--onlydeps" in myopts:
+ if "--onlydeps" in self.myopts:
continue
# Add to the world file. Since we won't be able to later.
- if (not "--fetchonly" in myopts) and (myfavkey in favorites):
+ if "--fetchonly" not in self.myopts and \
+ myfavkey in favorites:
#don't record if already in system profile or already recorded
if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
#we don't have a favorites entry for this package yet; add one
myfavdict[myfavkey]=myfavkey
print ">>> Recording",myfavkey,"in \"world\" favorites file..."
- if not "--fetchonly" in myopts:
+ if "--fetchonly" not in self.myopts:
portage.write_atomic(
- os.path.join(portage.root, portage.WORLD_FILE),
+ os.path.join(self.settings["ROOT"], portage.WORLD_FILE),
"\n".join(myfavdict.values()))
portage.mtimedb["resume"]["mergelist"]=mymergelist[:]
self.pkgsettings["FEATURES"]=string.join(myfeat)
- if "parallel-fetch" in myfeat and not ("--ask" in myopts or "--pretend" in myopts or "--fetchonly" in myopts):
+ if "parallel-fetch" in myfeat and \
+ not ("--ask" in self.myopts or "--pretend" in self.myopts or \
+ "--fetchonly" in self.myopts):
if "distlocks" not in myfeat:
print red("!!!")
print red("!!!")+" parallel-fetching requires the distlocks feature enabled"
self.pkgsettings.reset()
self.pkgsettings.setcpv(x[2])
try:
- ret = portage.doebuild(portage.portdb.findname(x[2]), "fetch", x[1], self.pkgsettings,
+ ret = portage.doebuild(self.portdb.findname(x[2]),
+ "fetch", x[1], self.pkgsettings,
cleanup=0, fetchonly=True, tree="porttree")
except SystemExit:
raise
pkgindex=2
if x[0]=="blocks":
pkgindex=3
- y=portage.portdb.findname(x[pkgindex])
- if not "--pretend" in myopts:
+ y = self.portdb.findname(x[pkgindex])
+ if "--pretend" not in self.myopts:
print ">>> Emerging ("+str(mergecount)+" of "+str(len(mymergelist))+")",x[pkgindex],"to",x[1]
emergelog(" >>> emerge ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" to "+x[1])
issyspkg = ("buildsyspkg" in myfeat) \
and x[0] != "blocks" \
and mysysdict.has_key(portage.cpv_getkey(x[2])) \
- and not ("--buildpkg" in myopts)
+ and "--buildpkg" not in self.myopts
if x[0] in ["ebuild","blocks"]:
- if (x[0]=="blocks") and ("--fetchonly" not in myopts):
+ if x[0] == "blocks" and "--fetchonly" not in self.myopts:
raise Exception, "Merging a blocker"
- elif ("--fetchonly" in myopts) or ("--fetch-all-uri" in myopts):
- if ("--fetch-all-uri" in myopts):
- retval=portage.doebuild(y,"fetch",myroot,self.pkgsettings,edebug,("--pretend" in myopts),fetchonly=1,fetchall=1,tree="porttree")
+ elif "--fetchonly" in self.myopts or \
+ "--fetch-all-uri" in self.myopts:
+ if "--fetch-all-uri" in self.myopts:
+ retval = portage.doebuild(y, "fetch", myroot,
+ self.pkgsettings, self.edebug,
+ "--pretend" in self.myopts, fetchonly=1,
+ fetchall=1, tree="porttree")
else:
- retval=portage.doebuild(y,"fetch",myroot,self.pkgsettings,edebug,("--pretend" in myopts),fetchonly=1,tree="porttree")
+ retval = portage.doebuild(y, "fetch", myroot,
+ self.pkgsettings, self.edebug,
+ "--pretend" in self.myopts, fetchonly=1,
+ tree="porttree")
if (retval is None) or retval:
print
print "!!! Fetch for",y,"failed, continuing..."
print
returnme=1
continue
- elif "--buildpkg" in myopts or issyspkg:
+ elif "--buildpkg" in self.myopts or issyspkg:
#buildsyspkg: Sounds useful to display something, but I don't know if we should also log it
if issyspkg:
print ">>> This is a system package, let's pack a rescue tarball."
#create pkg, then merge pkg
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Clean"
emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Cleaning ("+x[pkgindex]+"::"+y+")", short_msg=short_msg)
- retval=portage.doebuild(y,"clean",myroot,self.pkgsettings,edebug,cleanup=1,tree="porttree")
+ retval = portage.doebuild(y, "clean", myroot,
+ self.pkgsettings, self.edebug, cleanup=1,
+ tree="porttree")
if (retval is None):
portage_util.writemsg("Unable to run required binary.\n",
noiselevel=-1)
sys.exit(retval)
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Compile"
emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Compiling/Packaging ("+x[pkgindex]+"::"+y+")", short_msg=short_msg)
- retval=portage.doebuild(y,"package",myroot,self.pkgsettings,edebug,tree="porttree")
+ retval = portage.doebuild(y, "package", myroot,
+ self.pkgsettings, self.edebug, tree="porttree")
if (retval is None):
portage_util.writemsg("Unable to run required binary.\n",
noiselevel=-1)
if retval:
sys.exit(retval)
#dynamically update our database
- if "--buildpkgonly" not in myopts:
- portage.db[portage.root]["bintree"].inject(x[2])
- mytbz2=portage.db[portage.root]["bintree"].getname(x[2])
+ if "--buildpkgonly" not in self.myopts:
+ self.trees[
+ self.settings["ROOT"]]["bintree"].inject(x[2])
+ mytbz2 = self.trees[
+ self.settings["ROOT"]]["bintree"].getname(x[2])
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Merge"
emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Merging ("+x[pkgindex]+"::"+y+")", short_msg=short_msg)
sys.exit(1)
elif "noclean" not in self.pkgsettings.features:
portage.doebuild(y, "clean", myroot, self.pkgsettings,
- edebug, tree="porttree")
+ self.edebug, tree="porttree")
else:
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Clean"
emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Cleaning ("+x[pkgindex]+"::"+y+")", short_msg=short_msg)
- retval=portage.doebuild(y,"clean",myroot,self.pkgsettings,edebug,cleanup=1,tree="porttree")
+ retval = portage.doebuild(y, "clean", myroot,
+ self.pkgsettings, self.edebug, cleanup=1,
+ tree="porttree")
if (retval is None):
portage_util.writemsg("Unable to run required binary.\n",
noiselevel=-1)
sys.exit(retval)
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Compile"
emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Compiling/Merging ("+x[pkgindex]+"::"+y+")", short_msg=short_msg)
- retval=portage.doebuild(y,"merge",myroot,self.pkgsettings,edebug,tree="porttree")
+ retval = portage.doebuild(y, "merge", myroot,
+ self.pkgsettings, self.edebug, tree="porttree")
if (retval is None):
portage_util.writemsg("Unable to run required binary.\n",
noiselevel=-1)
#dynamically update our database
elif x[0]=="binary":
#merge the tbz2
- mytbz2=portage.db[portage.root]["bintree"].getname(x[2])
- if portage.db[portage.root]["bintree"].isremote(x[2]):
+ mytbz2 = self.trees[
+ self.settings["ROOT"]]["bintree"].getname(x[2])
+ if self.trees[self.settings["ROOT"]]["bintree"].isremote(x[2]):
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Fetch"
emergelog(" --- ("+str(mergecount)+" of "+str(len(mymergelist))+") Fetching Binary ("+x[pkgindex]+"::"+mytbz2+")", short_msg=short_msg)
- if not portage.db[portage.root]["bintree"].gettbz2(x[2]):
+ if not self.trees[
+ self.settings["ROOT"]]["bintree"].gettbz2(x[2]):
sys.exit(1)
- if ("--fetchonly" in myopts) or ("--fetch-all-uri" in myopts):
+ if "--fetchonly" in self.myopts or \
+ "--fetch-all-uri" in self.myopts:
continue
short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Merge Binary"
if retval is None:
sys.exit(1)
#need to check for errors
- if "--buildpkgonly" not in myopts:
- portage.db[x[1]]["vartree"].inject(x[2])
+ if "--buildpkgonly" not in self.myopts:
+ self.trees[x[1]]["vartree"].inject(x[2])
myfavkey=portage.cpv_getkey(x[2])
- if "--fetchonly" not in myopts and "--fetch-all-uri" not in myopts and myfavkey in favorites:
+ if "--fetchonly" not in self.myopts and \
+ "--fetch-all-uri" not in self.myopts and \
+ myfavkey in favorites:
myfavs = portage.grabfile(os.path.join(myroot, portage.WORLD_FILE))
myfavdict=genericdict(myfavs)
mysysdict=genericdict(syslist)
os.path.join(myroot, portage.WORLD_FILE),
"\n".join(myfavdict.values()))
- if ("--pretend" not in myopts) and ("--fetchonly" not in myopts) and ("--fetch-all-uri" not in myopts):
+ if "--pretend" not in self.myopts and \
+ "--fetchonly" not in self.myopts and \
+ "--fetch-all-uri" not in self.myopts:
# Clean the old package that we have merged over top of it.
if self.pkgsettings["AUTOCLEAN"]=="yes":
xsplit=portage.pkgsplit(x[2])
emergelog(" >>> AUTOCLEAN: "+xsplit[0])
- if x[1] == portage.settings["ROOT"]:
+ if x[1] == self.settings["ROOT"]:
# Compare against portage.settings["ROOT"] because
# the value of self.pkgsettings["ROOT"] does not
# match the original value!
retval = unmerge("clean", [xsplit[0]])
else:
retval = unmerge_overlapping(x[2], x[1],
- self.pkgsettings, portage.db[x[1]]["vartree"])
+ self.pkgsettings, self.trees[x[1]]["vartree"])
if not retval:
emergelog(" --- AUTOCLEAN: Nothing unmerged.")
else:
if myver[-3:]=='-r0':
myver=myver[:-3]
if (myver != portage.VERSION) and \
- ("livecvsportage" not in portage.settings.features):
+ "livecvsportage" not in self.settings.features:
if len(mymergelist) > mergecount:
emergelog(" ::: completed emerge ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[2]+" to "+x[1])
emergelog(" *** RESTARTING emerge via exec() after change of portage version.")
portage.run_exitfuncs()
mynewargv=[sys.argv[0],"--resume"]
badlongopts = ("--ask","--tree","--changelog","--skipfirst","--resume")
- for arg in myopts:
+ for arg in self.myopts:
if arg in badlongopts:
continue
mynewargv.append(arg)
os.environ["PORTAGE_NICENESS"] = "0"
os.execv(mynewargv[0], mynewargv)
- if ("--pretend" not in myopts) and ("--fetchonly" not in myopts) and ("--fetch-all-uri" not in myopts):
- if "noclean" not in portage.settings.features:
+ if "--pretend" not in self.myopts and \
+ "--fetchonly" not in self.myopts and \
+ "--fetch-all-uri" not in self.myopts:
+ if "noclean" not in self.settings.features:
short_msg = "emerge: (%s of %s) %s Clean Post" % \
(mergecount, len(mymergelist), x[pkgindex])
emergelog(" === (%s of %s) Post-Build Cleaning (%s::%s)" % \
if portage.mtimedb.has_key("resume"):
del portage.mtimedb["resume"]
- if ("--pretend" not in myopts):
- if ("--fetchonly" not in myopts) and ("--fetch-all-uri" not in myopts):
+ if "--pretend" not in self.myopts:
+ if "--fetchonly" not in self.myopts and \
+ "--fetch-all-uri" not in self.myopts:
if (mergecount>0):
if retval:
portage.env_update()
#by doing an exit this way, --fetchonly can continue to try to
#fetch everything even if a particular download fails.
- if "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
+ if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:
if returnme:
print "\n\n!!! Some fetch errors were encountered. Please see above for details.\n\n"
sys.exit(returnme)
if not "--pretend" in myopts: #just check pretend, since --ask implies pretend
emergelog(" >>> depclean")
- mydepgraph=depgraph(myaction,myopts)
+ mydepgraph = depgraph(portage.settings, portage.portdb, portage.db,
+ myaction, myopts, myparams, edebug, spinner)
if not ("--quiet" in myopts):
print "\nCalculating dependencies ",
if myopt not in myresumeopts:
myresumeopts.append(myopt)
myopts=myresumeopts
- mydepgraph=depgraph("resume",myopts)
+ mydepgraph = depgraph(portage.settings, portage.portdb, portage.db,
+ "resume", myopts, myparams, edebug, spinner)
if "--resume" not in myopts:
myopts+=["--resume"]
else:
print darkgreen("emerge: It seems we have nothing to resume...")
sys.exit(0)
- mydepgraph=depgraph(myaction,myopts)
+ mydepgraph = depgraph(portage.settings, portage.portdb, portage.db,
+ myaction, myopts, myparams, edebug, spinner)
if myaction in ["system","world"]:
if not ("--quiet" in myopts):
print "Calculating",myaction,"dependencies ",
if ("--resume" in myopts):
favorites=portage.mtimedb["resume"]["favorites"]
- mydepgraph.merge(portage.mtimedb["resume"]["mergelist"])
+ mydepgraph.merge(portage.mtimedb["resume"]["mergelist"], favorites)
else:
if "resume" in portage.mtimedb and \
"mergelist" in portage.mtimedb["resume"] and \
pkglist.append(pkg)
else:
pkglist = mydepgraph.altlist()
- mydepgraph.merge(pkglist)
+ mydepgraph.merge(pkglist, favorites)
if portage.mtimedb.has_key("resume"):
del portage.mtimedb["resume"]
projects / portage.git / commitdiff