|
|
|---|
# recurse: go into the dependencies | # recurse: go into the dependencies |
# deep: go into the dependencies of already merged packages | # deep: go into the dependencies of already merged packages |
# empty: pretend nothing is merged | # empty: pretend nothing is merged |
myparams=["self","recurse"] |
myparams=["self","recurse","selective"] |
add=[] | add=[] |
sub=[] | sub=[] |
if "--update" in myopts or myaction in ("system", "world"): | if "--update" in myopts or myaction in ("system", "world"): |
add.extend(["selective","empty"]) |
add.extend(["empty"]) |
if "--emptytree" in myopts: | if "--emptytree" in myopts: |
add.extend(["empty"]) | add.extend(["empty"]) |
sub.extend(["selective"]) | sub.extend(["selective"]) |
if "--nodeps" in myopts: | if "--nodeps" in myopts: |
sub.extend(["recurse"]) | sub.extend(["recurse"]) |
if "--noreplace" in myopts: |
|
add.extend(["selective"]) |
|
if "--deep" in myopts: | if "--deep" in myopts: |
add.extend(["deep"]) | add.extend(["deep"]) |
if "--selective" in myopts: |
|
add.extend(["selective"]) |
|
if myaction in ["world","system"]: |
|
add.extend(["selective"]) |
|
elif myaction in ["depclean"]: | elif myaction in ["depclean"]: |
add.extend(["empty"]) | add.extend(["empty"]) |
sub.extend(["selective"]) | sub.extend(["selective"]) |
|
|
|---|
"--getbinpkg" in self.myopts, | "--getbinpkg" in self.myopts, |
"--getbinpkgonly" in self.myopts) | "--getbinpkgonly" in self.myopts) |
| |
def create(self,mybigkey,myparent=None,addme=1,myuse=None): |
def create(self,mybigkey,myparent=None,addme=1,myuse=None,soft_dep=False,arg=None): |
""" | """ |
Fills the digraph with nodes comprised of packages to merge. | Fills the digraph with nodes comprised of packages to merge. |
mybigkey is the package spec of the package to merge. | mybigkey is the package spec of the package to merge. |
|
|
|---|
if addme and jbigkey != myparent: | if addme and jbigkey != myparent: |
# Refuse to make a node depend on itself so that the we don't | # Refuse to make a node depend on itself so that the we don't |
# don't create a bogus circular dependency in self.altlist(). | # don't create a bogus circular dependency in self.altlist(). |
self.digraph.addnode(jbigkey, myparent) |
self.digraph.addnode(jbigkey, myparent, soft_dep=soft_dep) |
return 1 | return 1 |
jbigkey = " ".join(mybigkey) + " nomerge" | jbigkey = " ".join(mybigkey) + " nomerge" |
if self.digraph.hasnode(jbigkey): | if self.digraph.hasnode(jbigkey): |
|
self.digraph.addnode(jbigkey, myparent, soft_dep=soft_dep) |
return 1 | return 1 |
| |
self.spinner.update() | self.spinner.update() |
|
|
|---|
if self.mydbapi[parent_root].match(mykey) or \ | if self.mydbapi[parent_root].match(mykey) or \ |
self.trees[parent_root]["vartree"].dbapi.match(mykey): | self.trees[parent_root]["vartree"].dbapi.match(mykey): |
mybigkey.append(myparent.split()[2]) | mybigkey.append(myparent.split()[2]) |
self.digraph.addnode(" ".join(mybigkey), myparent) |
self.digraph.addnode(" ".join(mybigkey), myparent, soft_dep=soft_dep) |
return 1 | return 1 |
else: | else: |
mydbapi = self.trees[myroot][self.pkg_tree_map[mytype]].dbapi | mydbapi = self.trees[myroot][self.pkg_tree_map[mytype]].dbapi |
|
|
|---|
installed we skip merging it.""" | installed we skip merging it.""" |
if "self" not in self.myparams or \ | if "self" not in self.myparams or \ |
("selective" in self.myparams and \ | ("selective" in self.myparams and \ |
vardbapi.cpv_exists(mykey)): |
not arg and vardbapi.cpv_exists(mykey)): |
merging=0 | merging=0 |
elif "selective" in self.myparams and vardbapi.cpv_exists(mykey): | elif "selective" in self.myparams and vardbapi.cpv_exists(mykey): |
merging=0 | merging=0 |
|
|
|---|
""" At this point, we have either hit a blocker and returned, found the package in the | """ At this point, we have either hit a blocker and returned, found the package in the |
depgraph already and returned, or we are here. Whether we are merging or not; we must | depgraph already and returned, or we are here. Whether we are merging or not; we must |
add the package to the depgraph; so we do that here. """ | add the package to the depgraph; so we do that here. """ |
self.digraph.addnode(string.join(mybigkey),myparent) |
self.digraph.addnode(string.join(mybigkey),myparent,soft_dep=soft_dep) |
| |
""" This section determines whether we go deeper into dependencies or not. | """ This section determines whether we go deeper into dependencies or not. |
We want to go deeper on a few occasions: | We want to go deeper on a few occasions: |
|
|
|---|
""" We have retrieve the dependency information, now we need to recursively | """ We have retrieve the dependency information, now we need to recursively |
process them. DEPEND gets processed for root = "/", {R,P}DEPEND in myroot. """ | process them. DEPEND gets processed for root = "/", {R,P}DEPEND in myroot. """ |
| |
mydep={} |
|
mp=string.join(mybigkey) | mp=string.join(mybigkey) |
| |
try: | try: |
if myroot=="/": |
if not self.select_dep("/",edepend["DEPEND"],myparent=mp,myuse=myuse): |
mydep["/"]=edepend["DEPEND"]+" "+edepend["RDEPEND"] |
return 0 |
if not self.select_dep("/",mydep["/"],myparent=mp,myuse=myuse): |
if not self.select_dep(myroot,edepend["RDEPEND"],myparent=mp,myuse=myuse,soft_deps=True): |
return 0 |
return 0 |
else: |
|
mydep["/"]=edepend["DEPEND"] |
|
mydep[myroot]=edepend["RDEPEND"] |
|
if not self.select_dep("/",mydep["/"],myparent=mp,myuse=myuse): |
|
return 0 |
|
if not self.select_dep(myroot,mydep[myroot],myparent=mp,myuse=myuse): |
|
return 0 |
|
|
|
if edepend.has_key("PDEPEND") and edepend["PDEPEND"]: | if edepend.has_key("PDEPEND") and edepend["PDEPEND"]: |
# Post Depend -- Add to the list without a parent, as it depends | # Post Depend -- Add to the list without a parent, as it depends |
# on a package being present AND must be built after that package. | # on a package being present AND must be built after that package. |
if not self.select_dep(myroot,edepend["PDEPEND"],myuse=myuse): |
if not self.select_dep(myroot,edepend["PDEPEND"],myuse=myuse,soft_deps=True): |
return 0 | return 0 |
except ValueError, e: | except ValueError, e: |
pkgs = e.args[0] | pkgs = e.args[0] |
|
|
|---|
sys.stderr.flush() | sys.stderr.flush() |
| |
try: | try: |
self.mysd = self.select_dep(myroot, mykey, arg=x) |
if "--noreplace" in self.myopts: |
|
arg = None |
|
else: |
|
arg = x |
|
self.mysd = self.select_dep(myroot, mykey, arg=arg) |
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("\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("!!! required dependencies. This is a security feature enabled by the admin\n") |
|
|
|---|
| |
missing=0 | missing=0 |
if "--usepkgonly" in self.myopts: | if "--usepkgonly" in self.myopts: |
for x in self.digraph.dict.keys(): |
for x in self.digraph.all_nodes(): |
xs=string.split(x," ") | xs=string.split(x," ") |
if (xs[0] != "binary") and (xs[3]=="merge"): | if (xs[0] != "binary") and (xs[3]=="merge"): |
if missing == 0: | if missing == 0: |
|
|
|---|
if curslot == myslot: | if curslot == myslot: |
return match | return match |
| |
def select_dep(self,myroot,depstring,myparent=None,arg=None,myuse=None,raise_on_missing=False): |
def select_dep(self,myroot,depstring,myparent=None,arg=None,myuse=None,raise_on_missing=False,soft_deps=False): |
""" Given a depstring, create the depgraph such that all dependencies are satisfied. | """ Given a depstring, create the depgraph such that all dependencies are satisfied. |
myroot = $ROOT from environment, where {R,P}DEPENDs are merged to. | myroot = $ROOT from environment, where {R,P}DEPENDs are merged to. |
myparent = the node whose depstring is being passed in | myparent = the node whose depstring is being passed in |
|
|
|---|
| |
portdb = self.trees[myroot]["porttree"].dbapi | portdb = self.trees[myroot]["porttree"].dbapi |
bindb = self.trees[myroot]["bintree"].dbapi | bindb = self.trees[myroot]["bintree"].dbapi |
|
vardb = self.trees[myroot]["vartree"].dbapi |
pkgsettings = self.pkgsettings[myroot] | pkgsettings = self.pkgsettings[myroot] |
| |
if "--debug" in self.myopts: | if "--debug" in self.myopts: |
|
|
|---|
mycheck = portage.dep_check(depstring, self.mydbapi[myroot], | mycheck = portage.dep_check(depstring, self.mydbapi[myroot], |
pkgsettings, myuse=myuse, | pkgsettings, myuse=myuse, |
use_binaries=("--usepkgonly" in self.myopts), | use_binaries=("--usepkgonly" in self.myopts), |
myroot=myroot, trees=self.trees) |
myroot=myroot, trees=self.trees, return_all_deps=True) |
| |
if not mycheck[0]: | if not mycheck[0]: |
mymerge=[] | mymerge=[] |
|
|
|---|
self.pkgsettings[p_root].setinst(p_key, | self.pkgsettings[p_root].setinst(p_key, |
self.trees[p_root][self.pkg_tree_map[p_type]].dbapi) | self.trees[p_root][self.pkg_tree_map[p_type]].dbapi) |
| |
if not mymerge: |
|
return 1 |
|
|
|
if "--debug" in self.myopts: | if "--debug" in self.myopts: |
print "Candidates:",mymerge | print "Candidates:",mymerge |
for x in mymerge: | for x in mymerge: |
|
|
|---|
selected_pkg = ["blocks", myroot, x[1:], None] | selected_pkg = ["blocks", myroot, x[1:], None] |
else: | else: |
#We are not processing a blocker but a normal dependency | #We are not processing a blocker but a normal dependency |
|
pkg_key = portage.dep_getkey(x) |
|
if pkg_key in pkgsettings.pprovideddict and \ |
|
portage.match_from_list( |
|
x, pkgsettings.pprovideddict[pkg_key]): |
|
continue |
|
|
# List of acceptable packages, ordered by type preference. | # List of acceptable packages, ordered by type preference. |
matched_packages = [] | matched_packages = [] |
myeb_matches = portdb.xmatch("match-visible", x) | myeb_matches = portdb.xmatch("match-visible", x) |
|
|
|---|
| |
if myparent: | if myparent: |
#we are a dependency, so we want to be unconditionally added | #we are a dependency, so we want to be unconditionally added |
|
soft_dep = soft_deps or vardb.match(x) |
if not self.create(selected_pkg[0:3], myparent, | if not self.create(selected_pkg[0:3], myparent, |
myuse=selected_pkg[-1]): |
myuse=selected_pkg[-1], soft_dep=soft_dep, arg=arg): |
return 0 | return 0 |
else: | else: |
#if mysource is not set, then we are a command-line dependency and should not be added | #if mysource is not set, then we are a command-line dependency and should not be added |
#if --onlydeps is specified. | #if --onlydeps is specified. |
if not self.create(selected_pkg[0:3], myparent, | if not self.create(selected_pkg[0:3], myparent, |
addme=("--onlydeps" not in self.myopts), | addme=("--onlydeps" not in self.myopts), |
myuse=selected_pkg[-1]): |
myuse=selected_pkg[-1], arg=arg): |
return 0 | return 0 |
| |
if "--debug" in self.myopts: | if "--debug" in self.myopts: |
|
|
|---|
while (not mygraph.empty()): | while (not mygraph.empty()): |
mycurkey=mygraph.firstzero() | mycurkey=mygraph.firstzero() |
if not mycurkey: | if not mycurkey: |
print "!!! Error: circular dependencies:" |
installables = mygraph.leaf_nodes(ignore_soft_deps=True) |
print |
if not installables: |
for x in mygraph.dict.keys(): |
print "!!! Error: circular dependencies:" |
for y in mygraph.dict[x][1]: |
print |
print y,"depends on",x |
for x in mygraph.allnodes(): |
print |
for y in mygraph.parent_nodes(x): |
sys.exit(1) |
print y,"depends on",x |
|
print |
|
sys.exit(1) |
|
mycurkey = installables[0] |
splitski=string.split(mycurkey) | splitski=string.split(mycurkey) |
#I'm not sure of the significance of the following lines (vestigal?) so I'm commenting 'em out. | #I'm not sure of the significance of the following lines (vestigal?) so I'm commenting 'em out. |
#These lines remove already-merged things from our alt-list | #These lines remove already-merged things from our alt-list |
