bin/emerge

   1 #!/usr/bin/python -O
   2 # Copyright 1999-2006 Gentoo Foundation
   3 # Distributed under the terms of the GNU General Public License v2
   4 # $Id$
   5
   6 import sys
   7 # This block ensures that ^C interrupts are handled quietly.
   8 try:
   9         import signal
  10
  11         def exithandler(signum,frame):
  12                 signal.signal(signal.SIGINT, signal.SIG_IGN)
  13                 signal.signal(signal.SIGTERM, signal.SIG_IGN)
  14                 sys.exit(1)
  15
  16         signal.signal(signal.SIGINT, exithandler)
  17         signal.signal(signal.SIGTERM, exithandler)
  18         signal.signal(signal.SIGPIPE, signal.SIG_DFL)
  19
  20 except KeyboardInterrupt:
  21         sys.exit(1)
  22
  23 import os, stat
  24
  25 os.environ["PORTAGE_LEGACY_GLOBALS"] = "false"
  26 try:
  27         import portage
  28 except ImportError:
  29         sys.path.insert(0, "/usr/lib/portage/pym")
  30         import portage
  31 del os.environ["PORTAGE_LEGACY_GLOBALS"]
  32 from portage import digraph, portdbapi
  33 from portage.const import NEWS_LIB_PATH
  34
  35 import portage.emergehelp, portage.xpak, commands, errno, re, socket, time, types
  36 import output
  37 from portage.output import blue, bold, colorize, darkblue, darkgreen, darkred, green, \
  38         havecolor, nc_len, nocolor, red, teal, turquoise, white, xtermTitle, \
  39         xtermTitleReset, yellow
  40 from portage.output import create_color_func
  41 good = create_color_func("GOOD")
  42 bad = create_color_func("BAD")
  43
  44 import portage.dep
  45 portage.dep._dep_check_strict = True
  46 import portage.util
  47 import portage.locks
  48 import portage.exception
  49 from portage.data import secpass
  50 from portage.util import normalize_path as normpath
  51
  52 if not hasattr(__builtins__, "set"):
  53         from sets import Set as set
  54 from itertools import chain, izip
  55 from UserDict import DictMixin
  56
  57 try:
  58         import cPickle
  59 except ImportError:
  60         import pickle as cPickle
  61
  62 class stdout_spinner(object):
  63         scroll_msgs = [
  64                 "Gentoo Rocks ("+os.uname()[0]+")",
  65                 "Thank you for using Gentoo. :)",
  66                 "Are you actually trying to read this?",
  67                 "How many times have you stared at this?",
  68                 "We are generating the cache right now",
  69                 "You are paying too much attention.",
  70                 "A theory is better than its explanation.",
  71                 "Phasers locked on target, Captain.",
  72                 "Thrashing is just virtual crashing.",
  73                 "To be is to program.",
  74                 "Real Users hate Real Programmers.",
  75                 "When all else fails, read the instructions.",
  76                 "Functionality breeds Contempt.",
  77                 "The future lies ahead.",
  78                 "3.1415926535897932384626433832795028841971694",
  79                 "Sometimes insanity is the only alternative.",
  80                 "Inaccuracy saves a world of explanation.",
  81         ]
  82
  83         twirl_sequence = "/-\\|/-\\|/-\\|/-\\|\\-/|\\-/|\\-/|\\-/|"
  84
  85         def __init__(self):
  86                 self.spinpos = 0
  87                 self.update = self.update_twirl
  88                 self.scroll_sequence = self.scroll_msgs[
  89                         int(time.time() * 100) % len(self.scroll_msgs)]
  90
  91         def update_basic(self):
  92                 self.spinpos = (self.spinpos + 1) % 500
  93                 if (self.spinpos % 100) == 0:
  94                         if self.spinpos == 0:
  95                                 sys.stdout.write(". ")
  96                         else:
  97                                 sys.stdout.write(".")
  98                 sys.stdout.flush()
  99
 100         def update_scroll(self):
 101                 if(self.spinpos >= len(self.scroll_sequence)):
 102                         sys.stdout.write(darkgreen(" \b\b\b" + self.scroll_sequence[
 103                                 len(self.scroll_sequence) - 1 - (self.spinpos % len(self.scroll_sequence))]))
 104                 else:
 105                         sys.stdout.write(green("\b " + self.scroll_sequence[self.spinpos]))
 106                 sys.stdout.flush()
 107                 self.spinpos = (self.spinpos + 1) % (2 * len(self.scroll_sequence))
 108
 109         def update_twirl(self):
 110                 self.spinpos = (self.spinpos + 1) % len(self.twirl_sequence)
 111                 sys.stdout.write("\b\b " + self.twirl_sequence[self.spinpos])
 112                 sys.stdout.flush()
 113
 114         def update_quiet(self):
 115                 return
 116
 117 def userquery(prompt, responses=None, colours=None):
 118         """Displays a prompt and a set of responses, then waits for a response
 119         which is checked against the responses and the first to match is
 120         returned.  An empty response will match the first value in responses.  The
 121         input buffer is *not* cleared prior to the prompt!
 122
 123         prompt: a String.
 124         responses: a List of Strings.
 125         colours: a List of Functions taking and returning a String, used to
 126         process the responses for display. Typically these will be functions
 127         like red() but could be e.g. lambda x: "DisplayString".
 128         If responses is omitted, defaults to ["Yes", "No"], [green, red].
 129         If only colours is omitted, defaults to [bold, ...].
 130
 131         Returns a member of the List responses. (If called without optional
 132         arguments, returns "Yes" or "No".)
 133         KeyboardInterrupt is converted to SystemExit to avoid tracebacks being
 134         printed."""
 135         if responses is None:
 136                 responses, colours = ["Yes", "No"], [green, red]
 137         elif colours is None:
 138                 colours=[bold]
 139         colours=(colours*len(responses))[:len(responses)]
 140         print bold(prompt),
 141         try:
 142                 while True:
 143                         response=raw_input("["+"/".join([colours[i](responses[i]) for i in range(len(responses))])+"] ")
 144                         for key in responses:
 145                                 # An empty response will match the first value in responses.
 146                                 if response.upper()==key[:len(response)].upper():
 147                                         return key
 148                         print "Sorry, response '%s' not understood." % response,
 149         except (EOFError, KeyboardInterrupt):
 150                 print "Interrupted."
 151                 sys.exit(1)
 152
 153 def sorted_versions(verlist):
 154         ret = []
 155         for ver in verlist:
 156                 verparts = ver.split("-")
 157                 if len(verparts) == 2:
 158                         verrev = int(verparts[1][1:])
 159                 else:
 160                         verrev = 0
 161                 x = 0
 162                 while x < len(ret):
 163                         retparts = ret[x].split("-")
 164                         verdiff = portage.vercmp(retparts[0], verparts[0])
 165                         if verdiff > 0:
 166                                 break
 167                         elif verdiff == 0:
 168                                 if len(retparts) == 2:
 169                                         retrev = int(retparts[1][1:])
 170                                 else:
 171                                         retrev = 0
 172                                 if retrev >= verrev:
 173                                         break
 174                         x += 1
 175                 ret.insert(x, ver)
 176         return ret
 177
 178
 179 actions=[
 180 "clean", "config", "depclean",
 181 "info", "metadata",
 182 "prune", "regen",  "search",
 183 "sync",  "system", "unmerge",  "world",
 184 ]
 185 options=[
 186 "--ask",          "--alphabetical",
 187 "--buildpkg",     "--buildpkgonly",
 188 "--changelog",    "--columns",
 189 "--debug",        "--deep",
 190 "--digest",
 191 "--emptytree",
 192 "--fetchonly",    "--fetch-all-uri",
 193 "--getbinpkg",    "--getbinpkgonly",
 194 "--help",         "--ignore-default-opts",
 195 "--noconfmem",
 196 "--newuse",       "--nocolor",
 197 "--nodeps",       "--noreplace",
 198 "--nospinner",    "--oneshot",
 199 "--onlydeps",     "--pretend",
 200 "--quiet",        "--resume",
 201 "--searchdesc",   "--selective",
 202 "--skipfirst",
 203 "--tree",
 204 "--update",
 205 "--usepkg",       "--usepkgonly",
 206 "--verbose",      "--version"
 207 ]
 208
 209 shortmapping={
 210 "1":"--oneshot",
 211 "a":"--ask",
 212 "b":"--buildpkg",  "B":"--buildpkgonly",
 213 "c":"--clean",     "C":"--unmerge",
 214 "d":"--debug",     "D":"--deep",
 215 "e":"--emptytree",
 216 "f":"--fetchonly", "F":"--fetch-all-uri",
 217 "g":"--getbinpkg", "G":"--getbinpkgonly",
 218 "h":"--help",
 219 "k":"--usepkg",    "K":"--usepkgonly",
 220 "l":"--changelog",
 221 "n":"--noreplace", "N":"--newuse",
 222 "o":"--onlydeps",  "O":"--nodeps",
 223 "p":"--pretend",   "P":"--prune",
 224 "q":"--quiet",
 225 "s":"--search",    "S":"--searchdesc",
 226 't':"--tree",
 227 "u":"--update",
 228 "v":"--verbose",   "V":"--version"
 229 }
 230
 231 def emergelog(xterm_titles, mystr, short_msg=None):
 232         if xterm_titles:
 233                 if short_msg:
 234                         xtermTitle(short_msg)
 235                 else:
 236                         xtermTitle(mystr)
 237         try:
 238                 file_path = "/var/log/emerge.log"
 239                 mylogfile = open(file_path, "a")
 240                 portage.util.apply_secpass_permissions(file_path,
 241                         uid=portage.portage_uid, gid=portage.portage_gid,
 242                         mode=0660)
 243                 mylock = None
 244                 try:
 245                         mylock = portage.locks.lockfile(mylogfile)
 246                         # seek because we may have gotten held up by the lock.
 247                         # if so, we may not be positioned at the end of the file.
 248                         mylogfile.seek(0, 2)
 249                         mylogfile.write(str(time.time())[:10]+": "+mystr+"\n")
 250                         mylogfile.flush()
 251                 finally:
 252                         if mylock:
 253                                 portage.locks.unlockfile(mylock)
 254                         mylogfile.close()
 255         except (IOError,OSError,portage.exception.PortageException), e:
 256                 if secpass >= 1:
 257                         print >> sys.stderr, "emergelog():",e
 258
 259 def countdown(secs=5, doing="Starting"):
 260         if secs:
 261                 print ">>> Waiting",secs,"seconds before starting..."
 262                 print ">>> (Control-C to abort)...\n"+doing+" in: ",
 263                 ticks=range(secs)
 264                 ticks.reverse()
 265                 for sec in ticks:
 266                         sys.stdout.write(colorize("UNMERGE_WARN", str(sec+1)+" "))
 267                         sys.stdout.flush()
 268                         time.sleep(1)
 269                 print
 270
 271 # formats a size given in bytes nicely
 272 def format_size(mysize):
 273         if type(mysize) not in [types.IntType,types.LongType]:
 274                 return str(mysize)
 275         if 0 != mysize % 1024:
 276                 # Always round up to the next kB so that it doesn't show 0 kB when
 277                 # some small file still needs to be fetched.
 278                 mysize += 1024 - mysize % 1024
 279         mystr=str(mysize/1024)
 280         mycount=len(mystr)
 281         while (mycount > 3):
 282                 mycount-=3
 283                 mystr=mystr[:mycount]+","+mystr[mycount:]
 284         return mystr+" kB"
 285
 286
 287 def getgccversion(chost):
 288         """
 289         rtype: C{str}
 290         return:  the current in-use gcc version
 291         """
 292
 293         gcc_ver_command = 'gcc -dumpversion'
 294         gcc_ver_prefix = 'gcc-'
 295
 296         gcc_not_found_error = red(
 297         "!!! No gcc found. You probably need to 'source /etc/profile'\n" +
 298         "!!! to update the environment of this terminal and possibly\n" +
 299         "!!! other terminals also.\n"
 300         )
 301
 302         mystatus, myoutput = commands.getstatusoutput("eselect compiler show")
 303         if mystatus == os.EX_OK and len(myoutput.split("/")) == 2:
 304                 part1, part2 = myoutput.split("/")
 305                 if part1.startswith(chost + "-"):
 306                         return myoutput.replace(chost + "-", gcc_ver_prefix, 1)
 307
 308         mystatus, myoutput = commands.getstatusoutput("gcc-config -c")
 309         if mystatus == os.EX_OK and myoutput.startswith(chost + "-"):
 310                 return myoutput.replace(chost + "-", gcc_ver_prefix, 1)
 311
 312         mystatus, myoutput = commands.getstatusoutput(
 313                 chost + "-" + gcc_ver_command)
 314         if mystatus == os.EX_OK:
 315                 return gcc_ver_prefix + myoutput
 316
 317         mystatus, myoutput = commands.getstatusoutput(gcc_ver_command)
 318         if mystatus == os.EX_OK:
 319                 return gcc_ver_prefix + myoutput
 320
 321         portage.writemsg(gcc_not_found_error, noiselevel=-1)
 322         return "[unavailable]"
 323
 324 def getportageversion(portdir, target_root, profile, chost, vardb):
 325         profilever = "unavailable"
 326         if profile:
 327                 realpath = os.path.realpath(profile)
 328                 basepath   = os.path.realpath(os.path.join(portdir, "profiles"))
 329                 if realpath.startswith(basepath):
 330                         profilever = realpath[1 + len(basepath):]
 331                 else:
 332                         try:
 333                                 profilever = "!" + os.readlink(profile)
 334                         except (OSError):
 335                                 pass
 336                 del realpath, basepath
 337
 338         libcver=[]
 339         libclist  = vardb.match("virtual/libc")
 340         libclist += vardb.match("virtual/glibc")
 341         libclist  = portage.util.unique_array(libclist)
 342         for x in libclist:
 343                 xs=portage.catpkgsplit(x)
 344                 if libcver:
 345                         libcver+=","+"-".join(xs[1:])
 346                 else:
 347                         libcver="-".join(xs[1:])
 348         if libcver==[]:
 349                 libcver="unavailable"
 350
 351         gccver = getgccversion(chost)
 352         unameout=os.uname()[2]+" "+os.uname()[4]
 353
 354         return "Portage " + portage.VERSION +" ("+profilever+", "+gccver+", "+libcver+", "+unameout+")"
 355
 356 def create_depgraph_params(myopts, myaction):
 357         #configure emerge engine parameters
 358         #
 359         # self:      include _this_ package regardless of if it is merged.
 360         # selective: exclude the package if it is merged
 361         # recurse:   go into the dependencies
 362         # deep:      go into the dependencies of already merged packages
 363         # empty:     pretend nothing is merged
 364         myparams = ["recurse"]
 365         add=[]
 366         sub=[]
 367         if "--update" in myopts or \
 368                 "--newuse" in myopts or \
 369                 "--noreplace" in myopts or \
 370                 myaction in ("system", "world"):
 371                 add.extend(["selective"])
 372         if "--emptytree" in myopts:
 373                 add.extend(["empty"])
 374                 sub.extend(["selective"])
 375         if "--nodeps" in myopts:
 376                 sub.extend(["recurse"])
 377         if "--deep" in myopts:
 378                 add.extend(["deep"])
 379         for x in add:
 380                 if (x not in myparams) and (x not in sub):
 381                         myparams.append(x)
 382         for x in sub:
 383                 if x in myparams:
 384                         myparams.remove(x)
 385         return myparams
 386
 387 # search functionality
 388 class search:
 389
 390         #
 391         # class constants
 392         #
 393         VERSION_SHORT=1
 394         VERSION_RELEASE=2
 395
 396         #
 397         # public interface
 398         #
 399         def __init__(self, settings, portdb, vartree, spinner, searchdesc,
 400                 verbose):
 401                 """Searches the available and installed packages for the supplied search key.
 402                 The list of available and installed packages is created at object instantiation.
 403                 This makes successive searches faster."""
 404                 self.settings = settings
 405                 self.portdb = portdb
 406                 self.vartree = vartree
 407                 self.spinner = spinner
 408                 self.verbose = verbose
 409                 self.searchdesc = searchdesc
 410
 411         def execute(self,searchkey):
 412                 """Performs the search for the supplied search key"""
 413                 match_category = 0
 414                 self.searchkey=searchkey
 415                 self.packagematches = []
 416                 if self.searchdesc:
 417                         self.searchdesc=1
 418                         self.matches = {"pkg":[], "desc":[]}
 419                 else:
 420                         self.searchdesc=0
 421                         self.matches = {"pkg":[]}
 422                 print "Searching...   ",
 423
 424                 regexsearch = False
 425                 if self.searchkey[0] == '%':
 426                         regexsearch = True
 427                         self.searchkey = self.searchkey[1:]
 428                 if self.searchkey[0] == '@':
 429                         match_category = 1
 430                         self.searchkey = self.searchkey[1:]
 431                 if regexsearch:
 432                         self.searchre=re.compile(self.searchkey,re.I)
 433                 else:
 434                         self.searchre=re.compile(re.escape(self.searchkey), re.I)
 435                 for package in self.portdb.cp_all():
 436                         self.spinner.update()
 437
 438                         if match_category:
 439                                 match_string  = package[:]
 440                         else:
 441                                 match_string  = package.split("/")[-1]
 442
 443                         masked=0
 444                         if self.searchre.search(match_string):
 445                                 if not self.portdb.xmatch("match-visible", package):
 446                                         masked=1
 447                                 self.matches["pkg"].append([package,masked])
 448                         elif self.searchdesc: # DESCRIPTION searching
 449                                 full_package = self.portdb.xmatch("bestmatch-visible", package)
 450                                 if not full_package:
 451                                         #no match found; we don't want to query description
 452                                         full_package = portage.best(
 453                                                 self.portdb.xmatch("match-all", package))
 454                                         if not full_package:
 455                                                 continue
 456                                         else:
 457                                                 masked=1
 458                                 try:
 459                                         full_desc = self.portdb.aux_get(
 460                                                 full_package, ["DESCRIPTION"])[0]
 461                                 except KeyError:
 462                                         print "emerge: search: aux_get() failed, skipping"
 463                                         continue
 464                                 if self.searchre.search(full_desc):
 465                                         self.matches["desc"].append([full_package,masked])
 466                 self.mlen=0
 467                 for mtype in self.matches.keys():
 468                         self.matches[mtype].sort()
 469                         self.mlen += len(self.matches[mtype])
 470
 471         def output(self):
 472                 """Outputs the results of the search."""
 473                 print "\b\b  \n[ Results for search key : "+white(self.searchkey)+" ]"
 474                 print "[ Applications found : "+white(str(self.mlen))+" ]"
 475                 print " "
 476                 for mtype in self.matches.keys():
 477                         for match,masked in self.matches[mtype]:
 478                                 if mtype=="pkg":
 479                                         catpack=match
 480                                         full_package = self.portdb.xmatch(
 481                                                 "bestmatch-visible", match)
 482                                         if not full_package:
 483                                                 #no match found; we don't want to query description
 484                                                 masked=1
 485                                                 full_package = portage.best(
 486                                                         self.portdb.xmatch("match-all",match))
 487                                 else:
 488                                         full_package = match
 489                                         match        = portage.pkgsplit(match)[0]
 490
 491                                 if full_package:
 492                                         try:
 493                                                 desc, homepage, license = self.portdb.aux_get(
 494                                                         full_package, ["DESCRIPTION","HOMEPAGE","LICENSE"])
 495                                         except KeyError:
 496                                                 print "emerge: search: aux_get() failed, skipping"
 497                                                 continue
 498                                         if masked:
 499                                                 print green("*")+"  "+white(match)+" "+red("[ Masked ]")
 500                                         else:
 501                                                 print green("*")+"  "+white(match)
 502                                         myversion = self.getVersion(full_package, search.VERSION_RELEASE)
 503
 504                                         mysum = [0,0]
 505                                         mycat = match.split("/")[0]
 506                                         mypkg = match.split("/")[1]
 507                                         mycpv = match + "-" + myversion
 508                                         myebuild = self.portdb.findname(mycpv)
 509                                         pkgdir = os.path.dirname(myebuild)
 510                                         from portage import manifest
 511                                         mf = manifest.Manifest(
 512                                                 pkgdir, self.settings["DISTDIR"])
 513                                         fetchlist = self.portdb.getfetchlist(mycpv,
 514                                                 mysettings=self.settings, all=True)[1]
 515                                         try:
 516                                                 mysum[0] = mf.getDistfilesSize(fetchlist)
 517                                                 mystr = str(mysum[0]/1024)
 518                                                 mycount=len(mystr)
 519                                                 while (mycount > 3):
 520                                                         mycount-=3
 521                                                         mystr=mystr[:mycount]+","+mystr[mycount:]
 522                                                 mysum[0]=mystr+" kB"
 523                                         except KeyError, e:
 524                                                 mysum[0] = "Unknown (missing digest for %s)" % str(e)
 525
 526                                         if self.verbose:
 527                                                 print "     ", darkgreen("Latest version available:"),myversion
 528                                                 print "     ", self.getInstallationStatus(mycat+'/'+mypkg)
 529                                                 print "     ", darkgreen("Size of files:"),mysum[0]
 530                                                 print "     ", darkgreen("Homepage:")+"     ",homepage
 531                                                 print "     ", darkgreen("Description:")+"  ",desc
 532                                                 print "     ", darkgreen("License:")+"      ",license
 533                                                 print
 534                 print
 535         #
 536         # private interface
 537         #
 538         def getInstallationStatus(self,package):
 539                 installed_package = self.vartree.dep_bestmatch(package)
 540                 result = ""
 541                 version = self.getVersion(installed_package,search.VERSION_RELEASE)
 542                 if len(version) > 0:
 543                         result = darkgreen("Latest version installed:")+" "+version
 544                 else:
 545                         result = darkgreen("Latest version installed:")+" [ Not Installed ]"
 546                 return result
 547
 548         def getVersion(self,full_package,detail):
 549                 if len(full_package) > 1:
 550                         package_parts = portage.catpkgsplit(full_package)
 551                         if detail == search.VERSION_RELEASE and package_parts[3] != 'r0':
 552                                 result = package_parts[2]+ "-" + package_parts[3]
 553                         else:
 554                                 result = package_parts[2]
 555                 else:
 556                         result = ""
 557                 return result
 558
 559
 560 #build our package digraph
 561 def getlist(settings, mode):
 562         if mode=="system":
 563                 mylines = settings.packages
 564         elif mode=="world":
 565                 try:
 566                         file_path = os.path.join(settings["ROOT"], portage.WORLD_FILE)
 567                         myfile = open(file_path, "r")
 568                         mylines = myfile.readlines()
 569                         myfile.close()
 570                 except (OSError, IOError), e:
 571                         if e.errno == errno.ENOENT:
 572                                 portage.writemsg("\n!!! World file does not exist: '%s'\n" % file_path)
 573                                 mylines=[]
 574                         else:
 575                                 raise
 576         mynewlines=[]
 577         for x in mylines:
 578                 myline=" ".join(x.split())
 579                 if not len(myline):
 580                         continue
 581                 elif myline[0]=="#":
 582                         continue
 583                 elif mode=="system":
 584                         if myline[0]!="*":
 585                                 continue
 586                         myline=myline[1:]
 587                 mynewlines.append(myline.strip())
 588
 589         return mynewlines
 590
 591 def clean_world(vardb, cpv):
 592         """Remove a package from the world file when unmerged."""
 593         world_filename = os.path.join(vardb.root, portage.WORLD_FILE)
 594         worldlist = portage.util.grabfile(world_filename)
 595         mykey = portage.cpv_getkey(cpv)
 596         newworldlist = []
 597         for x in worldlist:
 598                 if portage.dep_getkey(x) == mykey:
 599                         matches = vardb.match(x, use_cache=0)
 600                         if not matches:
 601                                 #zap our world entry
 602                                 pass
 603                         elif len(matches) == 1 and matches[0] == cpv:
 604                                 #zap our world entry
 605                                 pass
 606                         else:
 607                                 #others are around; keep it.
 608                                 newworldlist.append(x)
 609                 else:
 610                         #this doesn't match the package we're unmerging; keep it.
 611                         newworldlist.append(x)
 612
 613         portage.util.ensure_dirs(os.path.join(vardb.root, portage.PRIVATE_PATH),
 614                 gid=portage.portage_gid, mode=02770)
 615         portage.util.write_atomic(world_filename, "\n".join(newworldlist))
 616
 617 def genericdict(mylist):
 618         mynewdict={}
 619         for x in mylist:
 620                 mynewdict[portage.dep_getkey(x)]=x
 621         return mynewdict
 622
 623 def filter_iuse_defaults(iuse):
 624         for flag in iuse:
 625                 if flag.startswith("+"):
 626                         yield flag[1:]
 627                 else:
 628                         yield flag
 629
 630 class DepPriority(object):
 631         """
 632                 This class generates an integer priority level based of various
 633                 attributes of the dependency relationship.  Attributes can be assigned
 634                 at any time and the new integer value will be generated on calls to the
 635                 __int__() method.  Rich comparison operators are supported.
 636
 637                 The boolean attributes that affect the integer value are "satisfied",
 638                 "buildtime", "runtime", and "system".  Various combinations of
 639                 attributes lead to the following priority levels:
 640
 641                 Combination of properties    Priority level
 642
 643                 not satisfied and buildtime     0
 644                 not satisfied and runtime      -1
 645                 satisfied and buildtime        -2
 646                 satisfied and runtime          -3
 647                 (none of the above)            -4
 648
 649                 Several integer constants are defined for categorization of priority
 650                 levels:
 651
 652                 MEDIUM   The upper boundary for medium dependencies.
 653                 SOFT     The upper boundary for soft dependencies.
 654                 MIN      The lower boundary for soft dependencies.
 655         """
 656         __slots__ = ("__weakref__", "satisfied", "buildtime", "runtime")
 657         MEDIUM = -1
 658         SOFT   = -2
 659         MIN    = -4
 660         def __init__(self, **kwargs):
 661                 for myattr in self.__slots__:
 662                         if myattr == "__weakref__":
 663                                 continue
 664                         myvalue = kwargs.get(myattr, False)
 665                         setattr(self, myattr, myvalue)
 666         def __int__(self):
 667                 if not self.satisfied:
 668                         if self.buildtime:
 669                                 return 0
 670                         if self.runtime:
 671                                 return -1
 672                 if self.buildtime:
 673                         return -2
 674                 if self.runtime:
 675                         return -3
 676                 return -4
 677         def __lt__(self, other):
 678                 return self.__int__() < other
 679         def __le__(self, other):
 680                 return self.__int__() <= other
 681         def __eq__(self, other):
 682                 return self.__int__() == other
 683         def __ne__(self, other):
 684                 return self.__int__() != other
 685         def __gt__(self, other):
 686                 return self.__int__() > other
 687         def __ge__(self, other):
 688                 return self.__int__() >= other
 689         def copy(self):
 690                 import copy
 691                 return copy.copy(self)
 692         def __str__(self):
 693                 myvalue = self.__int__()
 694                 if myvalue > self.MEDIUM:
 695                         return "hard"
 696                 if myvalue > self.SOFT:
 697                         return "medium"
 698                 return "soft"
 699
 700 class FakeVartree(portage.vartree):
 701         """This is implements an in-memory copy of a vartree instance that provides
 702         all the interfaces required for use by the depgraph.  The vardb is locked
 703         during the constructor call just long enough to read a copy of the
 704         installed package information.  This allows the depgraph to do it's
 705         dependency calculations without holding a lock on the vardb.  It also
 706         allows things like vardb global updates to be done in memory so that the
 707         user doesn't necessarily need write access to the vardb in cases where
 708         global updates are necessary (updates are performed when necessary if there
 709         is not a matching ebuild in the tree)."""
 710         def __init__(self, real_vartree, portdb):
 711                 self.root = real_vartree.root
 712                 self.settings = real_vartree.settings
 713                 self.dbapi = portage.fakedbapi(settings=real_vartree.settings)
 714                 vdb_path = os.path.join(self.root, portage.VDB_PATH)
 715                 try:
 716                         # At least the parent needs to exist for the lock file.
 717                         portage.util.ensure_dirs(vdb_path)
 718                 except portage.exception.PortageException:
 719                         pass
 720                 vdb_lock = None
 721                 try:
 722                         if os.access(vdb_path, os.W_OK):
 723                                 vdb_lock = portage.locks.lockdir(vdb_path)
 724                         mykeys = ["SLOT", "COUNTER", "PROVIDE", "USE", "IUSE",
 725                                 "DEPEND", "RDEPEND", "PDEPEND"]
 726                         real_dbapi = real_vartree.dbapi
 727                         slot_counters = {}
 728                         for cpv in real_dbapi.cpv_all():
 729                                 metadata = dict(izip(mykeys, real_dbapi.aux_get(cpv, mykeys)))
 730                                 myslot = metadata["SLOT"]
 731                                 mycp = portage.dep_getkey(cpv)
 732                                 myslot_atom = "%s:%s" % (mycp, myslot)
 733                                 try:
 734                                         mycounter = long(metadata["COUNTER"])
 735                                 except ValueError:
 736                                         mycounter = 0
 737                                         metadata["COUNTER"] = str(mycounter)
 738                                 other_counter = slot_counters.get(myslot_atom, None)
 739                                 if other_counter is not None:
 740                                         if other_counter > mycounter:
 741                                                 continue
 742                                 slot_counters[myslot_atom] = mycounter
 743                                 self.dbapi.cpv_inject(cpv, metadata=metadata)
 744                         real_dbapi.flush_cache()
 745                 finally:
 746                         if vdb_lock:
 747                                 portage.locks.unlockdir(vdb_lock)
 748                 # Populate the old-style virtuals using the cached values.
 749                 if not self.settings.treeVirtuals:
 750                         self.settings.treeVirtuals = portage.util.map_dictlist_vals(
 751                                 portage.getCPFromCPV, self.get_all_provides())
 752
 753                 # Intialize variables needed for lazy cache pulls of the live ebuild
 754                 # metadata.  This ensures that the vardb lock is released ASAP, without
 755                 # being delayed in case cache generation is triggered.
 756                 self._aux_get = self.dbapi.aux_get
 757                 self.dbapi.aux_get = self._aux_get_wrapper
 758                 self._aux_get_history = set()
 759                 self._portdb_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
 760                 self._portdb = portdb
 761                 self._global_updates = None
 762
 763         def _aux_get_wrapper(self, pkg, wants):
 764                 if pkg in self._aux_get_history:
 765                         return self._aux_get(pkg, wants)
 766                 self._aux_get_history.add(pkg)
 767                 try:
 768                         # Use the live ebuild metadata if possible.
 769                         live_metadata = dict(izip(self._portdb_keys,
 770                                 self._portdb.aux_get(pkg, self._portdb_keys)))
 771                         self.dbapi.aux_update(pkg, live_metadata)
 772                 except (KeyError, portage.exception.PortageException):
 773                         if self._global_updates is None:
 774                                 self._global_updates = \
 775                                         grab_global_updates(self._portdb.porttree_root)
 776                         perform_global_updates(
 777                                 pkg, self.dbapi, self._global_updates)
 778                 return self._aux_get(pkg, wants)
 779
 780 def grab_global_updates(portdir):
 781         from portage.update import grab_updates, parse_updates
 782         updpath = os.path.join(portdir, "profiles", "updates")
 783         try:
 784                 rawupdates = grab_updates(updpath)
 785         except portage.exception.DirectoryNotFound:
 786                 rawupdates = []
 787         upd_commands = []
 788         for mykey, mystat, mycontent in rawupdates:
 789                 commands, errors = parse_updates(mycontent)
 790                 upd_commands.extend(commands)
 791         return upd_commands
 792
 793 def perform_global_updates(mycpv, mydb, mycommands):
 794         from portage.update import update_dbentries
 795         aux_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
 796         aux_dict = dict(izip(aux_keys, mydb.aux_get(mycpv, aux_keys)))
 797         updates = update_dbentries(mycommands, aux_dict)
 798         if updates:
 799                 mydb.aux_update(mycpv, updates)
 800
 801 class BlockerCache(DictMixin):
 802         """This caches blockers of installed packages so that dep_check does not
 803         have to be done for every single installed package on every invocation of
 804         emerge.  The cache is invalidated whenever it is detected that something
 805         has changed that might alter the results of dep_check() calls:
 806                 1) the set of installed packages (including COUNTER) has changed
 807                 2) the old-style virtuals have changed
 808         """
 809         class BlockerData(object):
 810                 def __init__(self, counter, atoms):
 811                         self.counter = counter
 812                         self.atoms = atoms
 813
 814         def __init__(self, myroot, vardb):
 815                 self._vardb = vardb
 816                 self._installed_pkgs = set(vardb.cpv_all())
 817                 self._virtuals = vardb.settings.getvirtuals()
 818                 self._cache_filename = os.path.join(myroot,
 819                         portage.CACHE_PATH.lstrip(os.path.sep), "vdb_blockers.pickle")
 820                 self._cache_version = "1"
 821                 self._cache_data = None
 822                 self._modified = False
 823                 self._load()
 824
 825         def _load(self):
 826                 try:
 827                         f = open(self._cache_filename)
 828                         mypickle = cPickle.Unpickler(f)
 829                         mypickle.find_global = None
 830                         self._cache_data = mypickle.load()
 831                         f.close()
 832                         del f
 833                 except (IOError, OSError, EOFError, cPickle.UnpicklingError):
 834                         pass
 835                 cache_valid = self._cache_data and \
 836                         isinstance(self._cache_data, dict) and \
 837                         self._cache_data.get("version") == self._cache_version and \
 838                         self._cache_data.get("virtuals") == self._virtuals and \
 839                         set(self._cache_data.get("blockers", [])) == self._installed_pkgs
 840                 if cache_valid:
 841                         for pkg in self._installed_pkgs:
 842                                 if long(self._vardb.aux_get(pkg, ["COUNTER"])[0]) != \
 843                                         self[pkg].counter:
 844                                         cache_valid = False
 845                                         break
 846                 if not cache_valid:
 847                         self._cache_data = {"version":self._cache_version}
 848                         self._cache_data["blockers"] = {}
 849                         self._cache_data["virtuals"] = self._virtuals
 850                 self._modified = False
 851
 852         def flush(self):
 853                 """If the current user has permission and the internal blocker cache
 854                 been updated, save it to disk and mark it unmodified.  This is called
 855                 by emerge after it has proccessed blockers for all installed packages.
 856                 Currently, the cache is only written if the user has superuser
 857                 privileges (since that's required to obtain a lock), but all users
 858                 have read access and benefit from faster blocker lookups (as long as
 859                 the entire cache is still valid).  The cache is stored as a pickled
 860                 dict object with the following format:
 861
 862                 {
 863                         version : "1",
 864                         "blockers" : {cpv1:(counter,(atom1, atom2...)), cpv2...},
 865                         "virtuals" : vardb.settings.getvirtuals()
 866                 }
 867                 """
 868                 if self._modified and \
 869                         secpass >= 2:
 870                         try:
 871                                 f = portage.util.atomic_ofstream(self._cache_filename)
 872                                 cPickle.dump(self._cache_data, f, -1)
 873                                 f.close()
 874                                 portage.util.apply_secpass_permissions(
 875                                         self._cache_filename, gid=portage.portage_gid, mode=0644)
 876                         except (IOError, OSError), e:
 877                                 pass
 878                         self._modified = False
 879
 880         def __setitem__(self, cpv, blocker_data):
 881                 """
 882                 Update the cache and mark it as modified for a future call to
 883                 self.flush().
 884
 885                 @param cpv: Package for which to cache blockers.
 886                 @type cpv: String
 887                 @param blocker_data: An object with counter and atoms attributes.
 888                 @type blocker_data: BlockerData
 889                 """
 890                 self._cache_data["blockers"][cpv] = \
 891                         (blocker_data.counter, blocker_data.atoms)
 892                 self._modified = True
 893
 894         def __getitem__(self, cpv):
 895                 """
 896                 @rtype: BlockerData
 897                 @returns: An object with counter and atoms attributes.
 898                 """
 899                 return self.BlockerData(*self._cache_data["blockers"][cpv])
 900
 901 def show_invalid_depstring_notice(parent_node, depstring, error_msg):
 902
 903         from formatter import AbstractFormatter, DumbWriter
 904         f = AbstractFormatter(DumbWriter(maxcol=72))
 905
 906         print "\n\n!!! Invalid or corrupt dependency specification: "
 907         print
 908         print error_msg
 909         print
 910         print parent_node
 911         print
 912         print depstring
 913         print
 914         p_type, p_root, p_key, p_status = parent_node
 915         msg = []
 916         if p_status == "nomerge":
 917                 category, pf = portage.catsplit(p_key)
 918                 pkg_location = os.path.join(p_root, portage.VDB_PATH, category, pf)
 919                 msg.append("Portage is unable to process the dependencies of the ")
 920                 msg.append("'%s' package. " % p_key)
 921                 msg.append("In order to correct this problem, the package ")
 922                 msg.append("should be uninstalled, reinstalled, or upgraded. ")
 923                 msg.append("As a temporary workaround, the --nodeps option can ")
 924                 msg.append("be used to ignore all dependencies.  For reference, ")
 925                 msg.append("the problematic dependencies can be found in the ")
 926                 msg.append("*DEPEND files located in '%s/'." % pkg_location)
 927         else:
 928                 msg.append("This package can not be installed.  ")
 929                 msg.append("Please notify the '%s' package maintainer " % p_key)
 930                 msg.append("about this problem.")
 931
 932         for x in msg:
 933                 f.add_flowing_data(x)
 934         f.end_paragraph(1)
 935
 936 class depgraph:
 937
 938         pkg_tree_map = {
 939                 "ebuild":"porttree",
 940                 "binary":"bintree",
 941                 "installed":"vartree"}
 942
 943         def __init__(self, settings, trees, myopts, myparams, spinner):
 944                 self.settings = settings
 945                 self.target_root = settings["ROOT"]
 946                 self.myopts = myopts
 947                 self.myparams = myparams
 948                 self.edebug = 0
 949                 if settings.get("PORTAGE_DEBUG", "") == "1":
 950                         self.edebug = 1
 951                 self.spinner = spinner
 952                 self.pkgsettings = {}
 953                 # Maps cpv to digraph node for all nodes added to the graph.
 954                 self.pkg_node_map = {}
 955                 # Maps slot atom to digraph node for all nodes added to the graph.
 956                 self._slot_node_map = {}
 957                 self.mydbapi = {}
 958                 self._mydbapi_keys = ["SLOT", "DEPEND", "RDEPEND", "PDEPEND"]
 959                 self.useFlags = {}
 960                 self.trees = {}
 961                 for myroot in trees:
 962                         self.trees[myroot] = {}
 963                         for tree in ("porttree", "bintree"):
 964                                 self.trees[myroot][tree] = trees[myroot][tree]
 965                         self.trees[myroot]["vartree"] = \
 966                                 FakeVartree(trees[myroot]["vartree"],
 967                                         trees[myroot]["porttree"].dbapi)
 968                         self.pkgsettings[myroot] = portage.config(
 969                                 clone=self.trees[myroot]["vartree"].settings)
 970                         self.pkg_node_map[myroot] = {}
 971                         self._slot_node_map[myroot] = {}
 972                         vardb = self.trees[myroot]["vartree"].dbapi
 973                         # This fakedbapi instance will model the state that the vdb will
 974                         # have after new packages have been installed.
 975                         fakedb = portage.fakedbapi(settings=self.pkgsettings[myroot])
 976                         self.mydbapi[myroot] = fakedb
 977                         if "--nodeps" not in self.myopts and \
 978                                 "--buildpkgonly" not in self.myopts:
 979                                 # --nodeps bypasses this, since it isn't needed in this case
 980                                 # and the cache pulls might trigger (slow) cache generation.
 981                                 for pkg in vardb.cpv_all():
 982                                         self.spinner.update()
 983                                         fakedb.cpv_inject(pkg,
 984                                                 metadata=dict(izip(self._mydbapi_keys,
 985                                                 vardb.aux_get(pkg, self._mydbapi_keys))))
 986                         del vardb, fakedb
 987                         self.useFlags[myroot] = {}
 988                         if "--usepkg" in self.myopts:
 989                                 self.trees[myroot]["bintree"].populate(
 990                                         "--getbinpkg" in self.myopts,
 991                                         "--getbinpkgonly" in self.myopts)
 992                 del trees
 993
 994                 self.missingbins=[]
 995                 self.digraph=portage.digraph()
 996                 # Tracks simple parent/child relationships (PDEPEND relationships are
 997                 # not reversed).
 998                 self._parent_child_digraph = digraph()
 999                 self.orderedkeys=[]
1000                 self.outdatedpackages=[]
1001                 self.args_keys = []
1002                 self.blocker_digraph = digraph()
1003                 self.blocker_parents = {}
1004                 self._slot_collision_info = []
1005                 # Slot collision nodes are not allowed to block other packages since
1006                 # blocker validation is only able to account for one package per slot.
1007                 self._slot_collision_nodes = set()
1008                 self._altlist_cache = {}
1009                 self._pprovided_args = []
1010
1011         def _show_slot_collision_notice(self, packages):
1012                 """Show an informational message advising the user to mask one of the
1013                 the packages. In some cases it may be possible to resolve this
1014                 automatically, but support for backtracking (removal nodes that have
1015                 already been selected) will be required in order to handle all possible
1016                 cases."""
1017
1018                 msg = []
1019                 msg.append("\n!!! Multiple versions within a single " + \
1020                         "package slot have been \n")
1021                 msg.append("!!! pulled into the dependency graph:\n\n")
1022                 for node, parents in packages:
1023                         msg.append(str(node))
1024                         if parents:
1025                                 msg.append(" pulled in by\n")
1026                                 for parent in parents:
1027                                         msg.append("  ")
1028                                         msg.append(str(parent))
1029                                         msg.append("\n")
1030                         else:
1031                                 msg.append(" (no parents)\n")
1032                         msg.append("\n")
1033                 sys.stderr.write("".join(msg))
1034                 sys.stderr.flush()
1035
1036                 if "--quiet" in self.myopts:
1037                         return
1038
1039                 msg = []
1040                 msg.append("It may be possible to solve this problem ")
1041                 msg.append("by using package.mask to prevent one of ")
1042                 msg.append("those packages from being selected. ")
1043                 msg.append("However, it is also possible that conflicting ")
1044                 msg.append("dependencies exist such that they are impossible to ")
1045                 msg.append("satisfy simultaneously.  If such a conflict exists in ")
1046                 msg.append("the dependencies of two different packages, then those ")
1047                 msg.append("packages can not be installed simultaneously.")
1048
1049                 from formatter import AbstractFormatter, DumbWriter
1050                 f = AbstractFormatter(DumbWriter(sys.stderr, maxcol=72))
1051                 for x in msg:
1052                         f.add_flowing_data(x)
1053                 f.end_paragraph(1)
1054
1055                 msg = []
1056                 msg.append("For more information, see MASKED PACKAGES ")
1057                 msg.append("section in the emerge man page or refer ")
1058                 msg.append("to the Gentoo Handbook.")
1059                 for x in msg:
1060                         f.add_flowing_data(x)
1061                 f.end_paragraph(1)
1062                 f.writer.flush()
1063
1064         def create(self, mybigkey, myparent=None, addme=1, myuse=None,
1065                 priority=DepPriority(), rev_dep=False, arg=None):
1066                 """
1067                 Fills the digraph with nodes comprised of packages to merge.
1068                 mybigkey is the package spec of the package to merge.
1069                 myparent is the package depending on mybigkey ( or None )
1070                 addme = Should we add this package to the digraph or are we just looking at it's deps?
1071                         Think --onlydeps, we need to ignore packages in that case.
1072                 #stuff to add:
1073                 #SLOT-aware emerge
1074                 #IUSE-aware emerge -> USE DEP aware depgraph
1075                 #"no downgrade" emerge
1076                 """
1077                 mytype, myroot, mykey = mybigkey
1078                 existing_node = None
1079                 if addme:
1080                         existing_node = self.pkg_node_map[myroot].get(mykey)
1081                 if existing_node:
1082                         self._parent_child_digraph.add(existing_node, myparent)
1083                         if existing_node != myparent:
1084                                 # Refuse to make a node depend on itself so that the we don't
1085                                 # don't create a bogus circular dependency in self.altlist().
1086                                 if rev_dep and myparent:
1087                                         self.digraph.addnode(myparent, existing_node,
1088                                                 priority=priority)
1089                                 else:
1090                                         self.digraph.addnode(existing_node, myparent,
1091                                                 priority=priority)
1092                         return 1
1093
1094                 self.spinner.update()
1095                 if mytype == "blocks":
1096                         if myparent and \
1097                                 "--buildpkgonly" not in self.myopts and \
1098                                 "--nodeps" not in self.myopts and \
1099                                 myparent not in self._slot_collision_nodes:
1100                                 mybigkey[1] = myparent[1]
1101                                 self.blocker_parents.setdefault(
1102                                         tuple(mybigkey), set()).add(myparent)
1103                         return 1
1104                 if not arg and myroot == self.target_root:
1105                         arg = portage.best_match_to_list(mykey, self.args_keys)
1106                 # select the correct /var database that we'll be checking against
1107                 vardbapi = self.trees[myroot]["vartree"].dbapi
1108                 portdb = self.trees[myroot]["porttree"].dbapi
1109                 bindb = self.trees[myroot]["bintree"].dbapi
1110                 pkgsettings = self.pkgsettings[myroot]
1111
1112                 # if the package is already on the system, we add a "nomerge"
1113                 # directive, otherwise we add a "merge" directive.
1114
1115                 mydbapi = self.trees[myroot][self.pkg_tree_map[mytype]].dbapi
1116
1117                 if myuse is None:
1118                         self.pkgsettings[myroot].setcpv(mykey, mydb=portdb)
1119                         myuse = self.pkgsettings[myroot]["USE"].split()
1120
1121                 merging=1
1122                 if mytype == "installed":
1123                         merging = 0
1124                 if addme and mytype != "installed":
1125                 # this is where we add the node to the list of packages to merge
1126                         if "selective" in self.myparams or not arg:
1127                                 if "empty" not in self.myparams and vardbapi.cpv_exists(mykey):
1128                                         merging=0
1129
1130                         """ If we aren't merging, perform the --newuse check.
1131                             If the package has new iuse flags or different use flags then if
1132                             --newuse is specified, we need to merge the package. """
1133                         if merging==0 and "--newuse" in self.myopts and \
1134                                 vardbapi.cpv_exists(mykey):
1135                                 pkgsettings.setcpv(mykey, mydb=mydbapi)
1136                                 forced_flags = set()
1137                                 forced_flags.update(pkgsettings.useforce)
1138                                 forced_flags.update(pkgsettings.usemask)
1139                                 old_use = vardbapi.aux_get(mykey, ["USE"])[0].split()
1140                                 iuses = set(filter_iuse_defaults(
1141                                         mydbapi.aux_get(mykey, ["IUSE"])[0].split()))
1142                                 old_iuse = set(filter_iuse_defaults(
1143                                         vardbapi.aux_get(mykey, ["IUSE"])[0].split()))
1144                                 if iuses.symmetric_difference(
1145                                         old_iuse).difference(forced_flags):
1146                                         merging = 1
1147                                 elif old_iuse.intersection(old_use) != \
1148                                         iuses.intersection(myuse):
1149                                         merging=1
1150
1151                 if addme and merging == 1:
1152                         mybigkey.append("merge")
1153                 else:
1154                         mybigkey.append("nomerge")
1155                 jbigkey = tuple(mybigkey)
1156
1157                 if addme:
1158                         metadata = dict(izip(self._mydbapi_keys,
1159                                 mydbapi.aux_get(mykey, self._mydbapi_keys)))
1160                         if merging == 0 and vardbapi.cpv_exists(mykey):
1161                                 metadata["USE"] = vardbapi.aux_get(mykey, ["USE"])[0]
1162                                 myuse = metadata["USE"].split()
1163                                 metadata["SLOT"] = vardbapi.aux_get(mykey, ["SLOT"])[0]
1164                         slot_atom = "%s:%s" % (portage.dep_getkey(mykey), metadata["SLOT"])
1165                         existing_node = self._slot_node_map[myroot].get(
1166                                 slot_atom, None)
1167                         slot_collision = False
1168                         if existing_node:
1169                                 e_type, myroot, e_cpv, e_status = existing_node
1170                                 if mykey == e_cpv:
1171                                         # The existing node can be reused.
1172                                         self._parent_child_digraph.add(existing_node, myparent)
1173                                         if rev_dep and myparent:
1174                                                 ptype, proot, pkey, pstatus = myparent
1175                                                 self.digraph.addnode(myparent, existing_node,
1176                                                         priority=priority)
1177                                         else:
1178                                                 self.digraph.addnode(existing_node, myparent,
1179                                                         priority=priority)
1180                                         return 1
1181                                 else:
1182                                         # A slot collision has occurred.  Sometimes this coincides
1183                                         # with unresolvable blockers, so the slot collision will be
1184                                         # shown later if there are no unresolvable blockers.
1185                                         e_parents = self._parent_child_digraph.parent_nodes(
1186                                                 existing_node)
1187                                         myparents = []
1188                                         if myparent:
1189                                                 myparents.append(myparent)
1190                                         self._slot_collision_info.append(
1191                                                 ((jbigkey, myparents), (existing_node, e_parents)))
1192                                         self._slot_collision_nodes.add(jbigkey)
1193                                         slot_collision = True
1194
1195                         if slot_collision:
1196                                 # Now add this node to the graph so that self.display()
1197                                 # can show use flags and --tree portage.output.  This node is
1198                                 # only being partially added to the graph.  It must not be
1199                                 # allowed to interfere with the other nodes that have been
1200                                 # added.  Do not overwrite data for existing nodes in
1201                                 # self.pkg_node_map and self.mydbapi since that data will
1202                                 # be used for blocker validation.
1203                                 self.pkg_node_map[myroot].setdefault(mykey, jbigkey)
1204                                 self.useFlags[myroot].setdefault(mykey, myuse)
1205                                 # Even though the graph is now invalid, continue to process
1206                                 # dependencies so that things like --fetchonly can still
1207                                 # function despite collisions.
1208                         else:
1209                                 self.mydbapi[myroot].cpv_inject(mykey, metadata=metadata)
1210                                 self._slot_node_map[myroot][slot_atom] = jbigkey
1211                                 self.pkg_node_map[myroot][mykey] = jbigkey
1212                                 self.useFlags[myroot][mykey] = myuse
1213
1214                         if rev_dep and myparent:
1215                                 self.digraph.addnode(myparent, jbigkey,
1216                                         priority=priority)
1217                         else:
1218                                 self.digraph.addnode(jbigkey, myparent,
1219                                         priority=priority)
1220
1221                 # Do this even when addme is False (--onlydeps) so that the
1222                 # parent/child relationship is always known in case
1223                 # self._show_slot_collision_notice() needs to be called later.
1224                 self._parent_child_digraph.add(jbigkey, myparent)
1225
1226                 """ This section determines whether we go deeper into dependencies or not.
1227                     We want to go deeper on a few occasions:
1228                     Installing package A, we need to make sure package A's deps are met.
1229                     emerge --deep <pkgspec>; we need to recursively check dependencies of pkgspec
1230                     If we are in --nodeps (no recursion) mode, we obviously only check 1 level of dependencies.
1231                 """
1232                 if "deep" not in self.myparams and not merging and \
1233                         not ("--update" in self.myopts and arg and merging):
1234                         return 1
1235                 elif "recurse" not in self.myparams:
1236                         return 1
1237
1238                 """ Check DEPEND/RDEPEND/PDEPEND/SLOT
1239                 Pull from bintree if it's binary package, porttree if it's ebuild.
1240                 Binpkg's can be either remote or local. """
1241
1242                 edepend={}
1243                 depkeys = ["DEPEND","RDEPEND","PDEPEND"]
1244                 depvalues = mydbapi.aux_get(mykey, depkeys)
1245                 for i in xrange(len(depkeys)):
1246                         edepend[depkeys[i]] = depvalues[i]
1247
1248                 if mytype == "ebuild":
1249                         if "--buildpkgonly" in self.myopts:
1250                                 edepend["RDEPEND"] = ""
1251                                 edepend["PDEPEND"] = ""
1252                 if not (arg and "--onlydeps" in self.myopts and \
1253                         mytype == "ebuild") and \
1254                         self.myopts.get("--with-bdeps", "n") == "n" and \
1255                         (mytype == "binary" or mybigkey[3] == "nomerge"):
1256                         edepend["DEPEND"] = ""
1257
1258                 """ We have retrieve the dependency information, now we need to recursively
1259                     process them.  DEPEND gets processed for root = "/", {R,P}DEPEND in myroot. """
1260
1261                 mp = tuple(mybigkey)
1262
1263                 try:
1264                         if not self.select_dep("/", edepend["DEPEND"], myparent=mp,
1265                                 myuse=myuse, priority=DepPriority(buildtime=True),
1266                                 parent_arg=arg):
1267                                 return 0
1268                         """RDEPEND is soft by definition.  However, in order to ensure
1269                         correct merge order, we make it a hard dependency.  Otherwise, a
1270                         build time dependency might not be usable due to it's run time
1271                         dependencies not being installed yet.
1272                         """
1273                         if not self.select_dep(myroot,edepend["RDEPEND"], myparent=mp,
1274                                 myuse=myuse, priority=DepPriority(runtime=True),
1275                                 parent_arg=arg):
1276                                 return 0
1277                         if edepend.has_key("PDEPEND") and edepend["PDEPEND"]:
1278                                 # Post Depend -- Add to the list without a parent, as it depends
1279                                 # on a package being present AND must be built after that package.
1280                                 if not self.select_dep(myroot, edepend["PDEPEND"], myparent=mp,
1281                                         myuse=myuse, priority=DepPriority(), rev_deps=True,
1282                                         parent_arg=arg):
1283                                         return 0
1284                 except ValueError, e:
1285                         pkgs = e.args[0]
1286                         portage.writemsg("\n\n!!! An atom in the dependencies " + \
1287                                 "is not fully-qualified. Multiple matches:\n\n", noiselevel=-1)
1288                         for cpv in pkgs:
1289                                 portage.writemsg("    %s\n" % cpv, noiselevel=-1)
1290                         portage.writemsg("\n", noiselevel=-1)
1291                         if mytype == "binary":
1292                                 portage.writemsg(
1293                                         "!!! This binary package cannot be installed: '%s'\n" % \
1294                                         mykey, noiselevel=-1)
1295                         elif mytype == "ebuild":
1296                                 myebuild, mylocation = portdb.findname2(mykey)
1297                                 portage.writemsg("!!! This ebuild cannot be installed: " + \
1298                                         "'%s'\n" % myebuild, noiselevel=-1)
1299                         portage.writemsg("!!! Please notify the package maintainer " + \
1300                                 "that atoms must be fully-qualified.\n", noiselevel=-1)
1301                         return 0
1302                 return 1
1303
1304         def select_files(self,myfiles):
1305                 "given a list of .tbz2s, .ebuilds and deps, create the appropriate depgraph and return a favorite list"
1306                 myfavorites=[]
1307                 myroot = self.target_root
1308                 portdb = self.trees[myroot]["porttree"].dbapi
1309                 bindb = self.trees[myroot]["bintree"].dbapi
1310                 pkgsettings = self.pkgsettings[myroot]
1311                 arg_atoms = []
1312                 def visible(mylist):
1313                         matches = portdb.gvisible(portdb.visible(mylist))
1314                         return [x for x in mylist \
1315                                 if x in matches or not portdb.cpv_exists(x)]
1316                 for x in myfiles:
1317                         ext = os.path.splitext(x)[1]
1318                         if ext==".tbz2":
1319                                 if not os.path.exists(x):
1320                                         if os.path.exists(
1321                                                 os.path.join(pkgsettings["PKGDIR"], "All", x)):
1322                                                 x = os.path.join(pkgsettings["PKGDIR"], "All", x)
1323                                         elif os.path.exists(
1324                                                 os.path.join(pkgsettings["PKGDIR"], x)):
1325                                                 x = os.path.join(pkgsettings["PKGDIR"], x)
1326                                         else:
1327                                                 print "\n\n!!! Binary package '"+str(x)+"' does not exist."
1328                                                 print "!!! Please ensure the tbz2 exists as specified.\n"
1329                                                 sys.exit(1)
1330                                 mytbz2=portage.xpak.tbz2(x)
1331                                 mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.splitext(os.path.basename(x))[0]
1332                                 if os.path.realpath(x) != \
1333                                         os.path.realpath(self.trees[myroot]["bintree"].getname(mykey)):
1334                                         print colorize("BAD", "\n*** You need to adjust PKGDIR to emerge this package.\n")
1335                                         sys.exit(1)
1336                                 if not self.create(["binary", myroot, mykey],
1337                                         None, "--onlydeps" not in self.myopts):
1338                                         return (0,myfavorites)
1339                                 elif not "--oneshot" in self.myopts:
1340                                         myfavorites.append(mykey)
1341                         elif ext==".ebuild":
1342                                 x = os.path.realpath(x)
1343                                 mykey=os.path.basename(os.path.normpath(x+"/../.."))+"/"+os.path.splitext(os.path.basename(x))[0]
1344                                 ebuild_path = portdb.findname(mykey)
1345                                 if ebuild_path:
1346                                         if os.path.realpath(ebuild_path) != x:
1347                                                 print colorize("BAD", "\n*** You need to adjust PORTDIR or PORTDIR_OVERLAY to emerge this package.\n")
1348                                                 sys.exit(1)
1349                                         if mykey not in portdb.xmatch(
1350                                                 "match-visible", portage.dep_getkey(mykey)):
1351                                                 print colorize("BAD", "\n*** You are emerging a masked package. It is MUCH better to use")
1352                                                 print colorize("BAD", "*** /etc/portage/package.* to accomplish this. See portage(5) man")
1353                                                 print colorize("BAD", "*** page for details.")
1354                                                 countdown(int(self.settings["EMERGE_WARNING_DELAY"]),
1355                                                         "Continuing...")
1356                                 else:
1357                                         raise portage.exception.PackageNotFound(
1358                                                 "%s is not in a valid portage tree hierarchy or does not exist" % x)
1359                                 if not self.create(["ebuild", myroot, mykey],
1360                                         None, "--onlydeps" not in self.myopts):
1361                                         return (0,myfavorites)
1362                                 elif not "--oneshot" in self.myopts:
1363                                         myfavorites.append(mykey)
1364                         else:
1365                                 if not is_valid_package_atom(x):
1366                                         portage.writemsg("\n\n!!! '%s' is not a valid package atom.\n" % x,
1367                                                 noiselevel=-1)
1368                                         portage.writemsg("!!! Please check ebuild(5) for full details.\n")
1369                                         portage.writemsg("!!! (Did you specify a version but forget to prefix with '='?)\n")
1370                                         return (0,[])
1371                                 try:
1372                                         mykey = None
1373                                         if "--usepkg" in self.myopts:
1374                                                 mykey = portage.dep_expand(x, mydb=bindb,
1375                                                         settings=pkgsettings)
1376                                         if (mykey and not mykey.startswith("null/")) or \
1377                                                 "--usepkgonly" in self.myopts:
1378                                                 arg_atoms.append((x, mykey))
1379                                                 continue
1380
1381                                         mykey = portage.dep_expand(x,
1382                                                 mydb=portdb, settings=pkgsettings)
1383                                         arg_atoms.append((x, mykey))
1384                                 except ValueError, errpkgs:
1385                                         print "\n\n!!! The short ebuild name \"" + x + "\" is ambiguous.  Please specify"
1386                                         print "!!! one of the following fully-qualified ebuild names instead:\n"
1387                                         for i in errpkgs[0]:
1388                                                 print "    " + green(i)
1389                                         print
1390                                         sys.exit(1)
1391
1392                 if "--update" in self.myopts:
1393                         """Make sure all installed slots are updated when possible. Do this
1394                         with --emptytree also, to ensure that all slots are remerged."""
1395                         vardb = self.trees[self.target_root]["vartree"].dbapi
1396                         greedy_atoms = []
1397                         for myarg, myatom in arg_atoms:
1398                                 greedy_atoms.append((myarg, myatom))
1399                                 myslots = set()
1400                                 for cpv in vardb.match(myatom):
1401                                         myslots.add(vardb.aux_get(cpv, ["SLOT"])[0])
1402                                 if myslots:
1403                                         best_pkgs = []
1404                                         if "--usepkg" in self.myopts:
1405                                                 mymatches = bindb.match(myatom)
1406                                                 if "--usepkgonly" not in self.myopts:
1407                                                         mymatches = visible(mymatches)
1408                                                 best_pkg = portage.best(mymatches)
1409                                                 if best_pkg:
1410                                                         best_slot = bindb.aux_get(best_pkg, ["SLOT"])[0]
1411                                                         best_pkgs.append(("binary", best_pkg, best_slot))
1412                                         if "--usepkgonly" not in self.myopts:
1413                                                 best_pkg = portage.best(portdb.match(myatom))
1414                                                 if best_pkg:
1415                                                         best_slot = portdb.aux_get(best_pkg, ["SLOT"])[0]
1416                                                         best_pkgs.append(("ebuild", best_pkg, best_slot))
1417                                         if best_pkgs:
1418                                                 best_pkg = portage.best([x[1] for x in best_pkgs])
1419                                                 best_pkgs = [x for x in best_pkgs if x[1] == best_pkg]
1420                                                 best_slot = best_pkgs[0][2]
1421                                                 myslots.add(best_slot)
1422                                 if len(myslots) > 1:
1423                                         for myslot in myslots:
1424                                                 myslot_atom = "%s:%s" % \
1425                                                         (portage.dep_getkey(myatom), myslot)
1426                                                 available = False
1427                                                 if "--usepkgonly" not in self.myopts and \
1428                                                         self.trees[self.target_root][
1429                                                         "porttree"].dbapi.match(myslot_atom):
1430                                                         available = True
1431                                                 elif "--usepkg" in self.myopts:
1432                                                         mymatches = bindb.match(myslot_atom)
1433                                                         if "--usepkgonly" not in self.myopts:
1434                                                                 mymatches = visible(mymatches)
1435                                                         if mymatches:
1436                                                                 available = True
1437                                                 if available:
1438                                                         greedy_atoms.append((myarg, myslot_atom))
1439                         arg_atoms = greedy_atoms
1440
1441                 """ These are used inside self.create() in order to ensure packages
1442                 that happen to match arguments are not incorrectly marked as nomerge."""
1443                 self.args_keys = [x[1] for x in arg_atoms]
1444                 for myarg, myatom in arg_atoms:
1445                                 try:
1446                                         self.mysd = self.select_dep(myroot, myatom, arg=myarg)
1447                                 except portage.exception.MissingSignature, e:
1448                                         portage.writemsg("\n\n!!! A missing gpg signature is preventing portage from calculating the\n")
1449                                         portage.writemsg("!!! required dependencies. This is a security feature enabled by the admin\n")
1450                                         portage.writemsg("!!! to aid in the detection of malicious intent.\n\n")
1451                                         portage.writemsg("!!! THIS IS A POSSIBLE INDICATION OF TAMPERED FILES -- CHECK CAREFULLY.\n")
1452                                         portage.writemsg("!!! Affected file: %s\n" % (e), noiselevel=-1)
1453                                         sys.exit(1)
1454                                 except portage.exception.InvalidSignature, e:
1455                                         portage.writemsg("\n\n!!! An invalid gpg signature is preventing portage from calculating the\n")
1456                                         portage.writemsg("!!! required dependencies. This is a security feature enabled by the admin\n")
1457                                         portage.writemsg("!!! to aid in the detection of malicious intent.\n\n")
1458                                         portage.writemsg("!!! THIS IS A POSSIBLE INDICATION OF TAMPERED FILES -- CHECK CAREFULLY.\n")
1459                                         portage.writemsg("!!! Affected file: %s\n" % (e), noiselevel=-1)
1460                                         sys.exit(1)
1461                                 except SystemExit, e:
1462                                         raise # Needed else can't exit
1463                                 except Exception, e:
1464                                         print >> sys.stderr, "\n\n!!! Problem in '%s' dependencies." % mykey
1465                                         print >> sys.stderr, "!!!", str(e), getattr(e, "__module__", None)
1466                                         raise
1467
1468                                 if not self.mysd:
1469                                         return (0,myfavorites)
1470                                 elif not "--oneshot" in self.myopts:
1471                                         mykey = portage.dep_getkey(myatom)
1472                                         if mykey not in myfavorites:
1473                                                 myfavorites.append(mykey)
1474
1475                 missing=0
1476                 if "--usepkgonly" in self.myopts:
1477                         for xs in self.digraph.all_nodes():
1478                                 if len(xs) >= 4 and xs[0] != "binary" and xs[3] == "merge":
1479                                         if missing == 0:
1480                                                 print
1481                                         missing += 1
1482                                         print "Missing binary for:",xs[2]
1483
1484                 if not self.validate_blockers():
1485                         return False, myfavorites
1486
1487                 # We're true here unless we are missing binaries.
1488                 return (not missing,myfavorites)
1489
1490         def select_dep(self, myroot, depstring, myparent=None, arg=None,
1491                 myuse=None, raise_on_missing=False, priority=DepPriority(),
1492                 rev_deps=False, parent_arg=None):
1493                 """ Given a depstring, create the depgraph such that all dependencies are satisfied.
1494                     myroot = $ROOT from environment, where {R,P}DEPENDs are merged to.
1495                     myparent = the node whose depstring is being passed in
1496                     arg = package was specified on the command line, merge even if it's already installed
1497                     myuse = USE flags at present
1498                     raise_on_missing = Given that the depgraph is not proper, raise an exception if true
1499                     else continue trying.
1500                     return 1 on success, 0 for failure
1501                 """
1502
1503                 portdb = self.trees[myroot]["porttree"].dbapi
1504                 bindb  = self.trees[myroot]["bintree"].dbapi
1505                 vardb  = self.trees[myroot]["vartree"].dbapi
1506                 pkgsettings = self.pkgsettings[myroot]
1507                 if myparent:
1508                         p_type, p_root, p_key, p_status = myparent
1509
1510                 if "--debug" in self.myopts:
1511                         print
1512                         print "Parent:   ",myparent
1513                         print "Depstring:",depstring
1514                         if rev_deps:
1515                                 print "Reverse:", rev_deps
1516                         print "Priority:", priority
1517
1518                 #processing dependencies
1519                 """ Call portage.dep_check to evaluate the use? conditionals and make sure all
1520                 dependencies are satisfiable. """
1521                 try:
1522                         if myparent and p_status == "nomerge":
1523                                 portage.dep._dep_check_strict = False
1524                         mycheck = portage.dep_check(depstring, None,
1525                                 pkgsettings, myuse=myuse,
1526                                 use_binaries=("--usepkgonly" in self.myopts),
1527                                 myroot=myroot, trees=self.trees)
1528                 finally:
1529                         portage.dep._dep_check_strict = True
1530
1531                 if not mycheck[0]:
1532                         if myparent:
1533                                 show_invalid_depstring_notice(myparent, depstring, mycheck[1])
1534                         else:
1535                                 sys.stderr.write("\n%s\n%s\n" % (depstring, mycheck[1]))
1536                         return 0
1537                 mymerge = mycheck[1]
1538
1539                 if not mymerge and arg and \
1540                         portage.best_match_to_list(depstring, self.args_keys):
1541                         # A provided package has been specified on the command line.  The
1542                         # package will not be merged and a warning will be displayed.
1543                         self._pprovided_args.append(arg)
1544
1545                 if myparent:
1546                         # The parent is added after it's own dep_check call so that it
1547                         # isn't allowed to satisfy a direct bootstrap dependency on itself
1548                         # via an old-style virtual.  This isn't a problem with new-style
1549                         # virtuals, which are preferenced in dep_zapdeps by looking only at
1550                         # the depstring, vdb, and available packages.
1551
1552                         p_type, p_root, p_key, p_status = myparent
1553                         if p_status == "merge":
1554                                 # Update old-style virtuals if this package provides any.
1555                                 # These are needed for dep_virtual calls inside dep_check.
1556                                 self.pkgsettings[p_root].setinst(p_key,
1557                                         self.trees[p_root][self.pkg_tree_map[p_type]].dbapi)
1558
1559                 if "--debug" in self.myopts:
1560                         print "Candidates:",mymerge
1561                 for x in mymerge:
1562                         selected_pkg = None
1563                         if x[0]=="!":
1564                                 selected_pkg = ["blocks", myroot, x[1:], None]
1565                         else:
1566                                 #We are not processing a blocker but a normal dependency
1567                                 if myparent:
1568                                         """In some cases, dep_check will return deps that shouldn't
1569                                         be proccessed any further, so they are identified and
1570                                         discarded here."""
1571                                         if "empty" not in self.myparams and \
1572                                                 "deep" not in self.myparams and \
1573                                                 not ("--update" in self.myopts and parent_arg) and \
1574                                                 vardb.match(x):
1575                                                 continue
1576
1577                                 # List of acceptable packages, ordered by type preference.
1578                                 matched_packages = []
1579                                 myeb_matches = portdb.xmatch("match-visible", x)
1580                                 myeb = None
1581                                 if "--usepkgonly" not in self.myopts:
1582                                         myeb = portage.best(myeb_matches)
1583
1584                                 myeb_pkg=None
1585                                 if "--usepkg" in self.myopts:
1586                                         # The next line assumes the binarytree has been populated.
1587                                         # XXX: Need to work out how we use the binary tree with roots.
1588                                         myeb_pkg_matches = bindb.match(x)
1589                                         if "--usepkgonly" not in self.myopts:
1590                                                 # Remove any binary package entries that are masked in the portage tree (#55871)
1591                                                 myeb_pkg_matches = [pkg for pkg in myeb_pkg_matches \
1592                                                         if pkg in myeb_matches or  \
1593                                                         not portdb.cpv_exists(pkg)]
1594                                         if myeb_pkg_matches:
1595                                                 myeb_pkg = portage.best(myeb_pkg_matches)
1596
1597                                 if myeb_pkg and "--newuse" in self.myopts:
1598                                         iuses = set(filter_iuse_defaults(
1599                                                 bindb.aux_get(myeb_pkg, ["IUSE"])[0].split()))
1600                                         old_use = bindb.aux_get(myeb_pkg, ["USE"])[0].split()
1601                                         mydb = None
1602                                         if "--usepkgonly" not in self.myopts and myeb:
1603                                                 mydb = portdb
1604                                         if myeb:
1605                                                 pkgsettings.setcpv(myeb, mydb=mydb)
1606                                         else:
1607                                                 pkgsettings.setcpv(myeb_pkg, mydb=mydb)
1608                                         now_use = pkgsettings["USE"].split()
1609                                         forced_flags = set()
1610                                         forced_flags.update(pkgsettings.useforce)
1611                                         forced_flags.update(pkgsettings.usemask)
1612                                         cur_iuse = iuses
1613                                         if "--usepkgonly" not in self.myopts and myeb:
1614                                                 cur_iuse = set(filter_iuse_defaults(
1615                                                         portdb.aux_get(myeb, ["IUSE"])[0].split()))
1616                                         if iuses.symmetric_difference(
1617                                                 cur_iuse).difference(forced_flags):
1618                                                 myeb_pkg = None
1619                                         elif iuses.intersection(old_use) != \
1620                                                 cur_iuse.intersection(now_use):
1621                                                 myeb_pkg = None
1622                                 if myeb_pkg:
1623                                         binpkguseflags = \
1624                                                 self.trees[myroot]["bintree"].dbapi.aux_get(
1625                                                         myeb_pkg, ["USE"])[0].split()
1626                                         matched_packages.append(
1627                                                 ["binary", myroot, myeb_pkg, binpkguseflags])
1628
1629                                 if "--usepkgonly" not in self.myopts and myeb_matches:
1630                                         matched_packages.append(
1631                                                 ["ebuild", myroot, myeb, None])
1632
1633                                 if not matched_packages and \
1634                                         not (arg and "selective" not in self.myparams):
1635                                         """Fall back to the installed package database.  This is a
1636                                         last resort because the metadata tends to diverge from that
1637                                         of the ebuild in the tree."""
1638                                         myeb_inst_matches = vardb.match(x)
1639                                         if "--usepkgonly" not in self.myopts:
1640                                                 """ TODO: Improve masking check for installed and
1641                                                 binary packages. bug #149816"""
1642                                                 myeb_inst_matches = [pkg for pkg in myeb_inst_matches \
1643                                                         if not portdb.cpv_exists(pkg)]
1644                                         myeb_inst = None
1645                                         if myeb_inst_matches:
1646                                                 myeb_inst = portage.best(myeb_inst_matches)
1647                                         if myeb_inst:
1648                                                 binpkguseflags = vardb.aux_get(
1649                                                         myeb_inst, ["USE"])[0].split()
1650                                                 matched_packages.append(
1651                                                         ["installed", myroot, myeb_inst, binpkguseflags])
1652
1653                                 if not matched_packages:
1654                                         if raise_on_missing:
1655                                                 raise ValueError
1656                                         if not arg:
1657                                                 xinfo='"'+x+'"'
1658                                         else:
1659                                                 xinfo='"'+arg+'"'
1660                                         if myparent:
1661                                                 xfrom = '(dependency required by '+ \
1662                                                         green('"%s"' % myparent[2]) + \
1663                                                         red(' [%s]' % myparent[0]) + ')'
1664                                         alleb = portdb.xmatch("match-all", x)
1665                                         if alleb:
1666                                                 if "--usepkgonly" not in self.myopts:
1667                                                         print "\n!!! "+red("All ebuilds that could satisfy ")+green(xinfo)+red(" have been masked.")
1668                                                         print "!!! One of the following masked packages is required to complete your request:"
1669                                                         oldcomment = ""
1670                                                         for p in alleb:
1671                                                                 mreasons = portage.getmaskingstatus(p,
1672                                                                         settings=pkgsettings, portdb=portdb)
1673                                                                 print "- "+p+" (masked by: "+", ".join(mreasons)+")"
1674                                                                 comment = portage.getmaskingreason(p,
1675                                                                         settings=pkgsettings, portdb=portdb)
1676                                                                 if comment and comment != oldcomment:
1677                                                                         print comment
1678                                                                         oldcomment = comment
1679                                                         print
1680                                                         print "For more information, see MASKED PACKAGES section in the emerge man page or "
1681                                                         print "refer to the Gentoo Handbook."
1682                                                 else:
1683                                                         print "\n!!! "+red("There are no packages available to satisfy: ")+green(xinfo)
1684                                                         print "!!! Either add a suitable binary package or compile from an ebuild."
1685                                         else:
1686                                                 print "\nemerge: there are no ebuilds to satisfy "+green(xinfo)+"."
1687                                         if myparent:
1688                                                 print xfrom
1689                                         print
1690                                         return 0
1691
1692                                 if "--debug" in self.myopts:
1693                                         for pkg in matched_packages:
1694                                                 print (pkg[0] + ":").rjust(10), pkg[2]
1695
1696                                 if len(matched_packages) > 1:
1697                                         bestmatch = portage.best(
1698                                                 [pkg[2] for pkg in matched_packages])
1699                                         matched_packages = [pkg for pkg in matched_packages \
1700                                                 if pkg[2] == bestmatch]
1701
1702                                 # ordered by type preference ("ebuild" type is the last resort)
1703                                 selected_pkg =  matched_packages[0]
1704                                 pkgtype, myroot, mycpv, myuse = selected_pkg
1705                                 mydbapi = self.trees[myroot][self.pkg_tree_map[pkgtype]].dbapi
1706                                 slot_atom = "%s:%s" % (portage.dep_getkey(mycpv),
1707                                         mydbapi.aux_get(mycpv, ["SLOT"])[0])
1708                                 existing_node = self._slot_node_map[myroot].get(
1709                                         slot_atom, None)
1710                                 if existing_node:
1711                                         e_type, myroot, e_cpv, e_status = existing_node
1712                                         if portage.match_from_list(x, [e_cpv]):
1713                                                 # The existing node can be reused.
1714                                                 selected_pkg = [e_type, myroot, e_cpv,
1715                                                         self.useFlags[myroot][e_cpv]]
1716
1717                         if myparent:
1718                                 #we are a dependency, so we want to be unconditionally added
1719                                 mypriority = priority.copy()
1720                                 if vardb.match(x):
1721                                         mypriority.satisfied = True
1722                                 if not self.create(selected_pkg[0:3], myparent,
1723                                         myuse=selected_pkg[-1], priority=mypriority,
1724                                         rev_dep=rev_deps, arg=arg):
1725                                         return 0
1726                         else:
1727                                 #if mysource is not set, then we are a command-line dependency and should not be added
1728                                 #if --onlydeps is specified.
1729                                 if not self.create(selected_pkg[0:3], myparent,
1730                                         addme=("--onlydeps" not in self.myopts),
1731                                         myuse=selected_pkg[-1], rev_dep=rev_deps, arg=arg):
1732                                         return 0
1733
1734                 if "--debug" in self.myopts:
1735                         print "Exiting...",myparent
1736                 return 1
1737
1738         def validate_blockers(self):
1739                 """Remove any blockers from the digraph that do not match any of the
1740                 packages within the graph.  If necessary, create hard deps to ensure
1741                 correct merge order such that mutually blocking packages are never
1742                 installed simultaneously."""
1743
1744                 if "--buildpkgonly" in self.myopts or \
1745                         "--nodeps" in self.myopts:
1746                         return True
1747
1748                 modified_slots = {}
1749                 for myroot in self.trees:
1750                         myslots = {}
1751                         modified_slots[myroot] = myslots
1752                         final_db = self.mydbapi[myroot]
1753                         slot_node_map = self._slot_node_map[myroot]
1754                         for slot_atom, mynode in slot_node_map.iteritems():
1755                                 mytype, myroot, mycpv, mystatus = mynode
1756                                 if mystatus == "merge":
1757                                         myslots[slot_atom] = mycpv
1758
1759                 #if "deep" in self.myparams:
1760                 if True:
1761                         # Pull in blockers from all installed packages that haven't already
1762                         # been pulled into the depgraph.  This is not enabled by default
1763                         # due to the performance penalty that is incurred by all the
1764                         # additional dep_check calls that are required.
1765
1766                         # Optimization hack for dep_check calls that minimizes the
1767                         # available matches by replacing the portdb with a fakedbapi
1768                         # instance.
1769                         class FakePortageTree(object):
1770                                 def __init__(self, mydb):
1771                                         self.dbapi = mydb
1772                         dep_check_trees = {}
1773                         for myroot in self.trees:
1774                                 dep_check_trees[myroot] = self.trees[myroot].copy()
1775                                 dep_check_trees[myroot]["porttree"] = \
1776                                         FakePortageTree(self.mydbapi[myroot])
1777
1778                         dep_keys = ["DEPEND","RDEPEND","PDEPEND"]
1779                         for myroot in self.trees:
1780                                 pkg_node_map = self.pkg_node_map[myroot]
1781                                 vardb = self.trees[myroot]["vartree"].dbapi
1782                                 portdb = self.trees[myroot]["porttree"].dbapi
1783                                 pkgsettings = self.pkgsettings[myroot]
1784                                 final_db = self.mydbapi[myroot]
1785                                 cpv_all_installed = self.trees[myroot]["vartree"].dbapi.cpv_all()
1786                                 blocker_cache = BlockerCache(myroot, vardb)
1787                                 for pkg in cpv_all_installed:
1788                                         blocker_atoms = None
1789                                         matching_node = pkg_node_map.get(pkg, None)
1790                                         if matching_node and \
1791                                                 matching_node[3] == "nomerge":
1792                                                 continue
1793                                         # If this node has any blockers, create a "nomerge"
1794                                         # node for it so that they can be enforced.
1795                                         self.spinner.update()
1796                                         blocker_data = blocker_cache.get(pkg)
1797                                         if blocker_data:
1798                                                 blocker_atoms = blocker_data.atoms
1799                                         else:
1800                                                 dep_vals = vardb.aux_get(pkg, dep_keys)
1801                                                 myuse = vardb.aux_get(pkg, ["USE"])[0].split()
1802                                                 depstr = " ".join(dep_vals)
1803                                                 # It is crucial to pass in final_db here in order to
1804                                                 # optimize dep_check calls by eliminating atoms via
1805                                                 # dep_wordreduce and dep_eval calls.
1806                                                 try:
1807                                                         portage.dep._dep_check_strict = False
1808                                                         try:
1809                                                                 success, atoms = portage.dep_check(depstr,
1810                                                                         final_db, pkgsettings, myuse=myuse,
1811                                                                         trees=dep_check_trees, myroot=myroot)
1812                                                         except Exception, e:
1813                                                                 if isinstance(e, SystemExit):
1814                                                                         raise
1815                                                                 # This is helpful, for example, if a ValueError
1816                                                                 # is thrown from cpv_expand due to multiple
1817                                                                 # matches (this can happen if an atom lacks a
1818                                                                 # category).
1819                                                                 show_invalid_depstring_notice(
1820                                                                         ("installed", myroot, pkg, "nomerge"),
1821                                                                         depstr, str(e))
1822                                                                 del e
1823                                                                 raise
1824                                                 finally:
1825                                                         portage.dep._dep_check_strict = True
1826                                                 if not success:
1827                                                         slot_atom = "%s:%s" % (portage.dep_getkey(pkg),
1828                                                                 vardb.aux_get(pkg, ["SLOT"])[0])
1829                                                         if slot_atom in modified_slots[myroot]:
1830                                                                 # This package is being replaced anyway, so
1831                                                                 # ignore invalid dependencies so as not to
1832                                                                 # annoy the user too much (otherwise they'd be
1833                                                                 # forced to manually unmerge it first).
1834                                                                 continue
1835                                                         show_invalid_depstring_notice(
1836                                                                 ("installed", myroot, pkg, "nomerge"),
1837                                                                 depstr, atoms)
1838                                                         return False
1839                                                 blocker_atoms = [myatom for myatom in atoms \
1840                                                         if myatom.startswith("!")]
1841                                                 counter = long(vardb.aux_get(pkg, ["COUNTER"])[0])
1842                                                 blocker_cache[pkg] = \
1843                                                         blocker_cache.BlockerData(counter, blocker_atoms)
1844                                         if blocker_atoms:
1845                                                 # Don't store this parent in pkg_node_map, because it's
1846                                                 # not needed there and it might overwrite a "merge"
1847                                                 # node with the same cpv.
1848                                                 myparent = ("installed", myroot, pkg, "nomerge")
1849                                                 for myatom in blocker_atoms:
1850                                                         blocker = ("blocks", myroot, myatom[1:])
1851                                                         myparents = \
1852                                                                 self.blocker_parents.get(blocker, None)
1853                                                         if not myparents:
1854                                                                 myparents = set()
1855                                                                 self.blocker_parents[blocker] = myparents
1856                                                         myparents.add(myparent)
1857                                 blocker_cache.flush()
1858                                 del blocker_cache
1859
1860                 for blocker in self.blocker_parents.keys():
1861                         mytype, myroot, mydep = blocker
1862                         initial_db = self.trees[myroot]["vartree"].dbapi
1863                         final_db = self.mydbapi[myroot]
1864                         blocked_initial = initial_db.match(mydep)
1865                         blocked_final = final_db.match(mydep)
1866                         if not blocked_initial and not blocked_final:
1867                                 del self.blocker_parents[blocker]
1868                                 continue
1869                         blocked_slots_initial = {}
1870                         blocked_slots_final = {}
1871                         for cpv in blocked_initial:
1872                                 blocked_slots_initial[cpv] = \
1873                                         "%s:%s" % (portage.dep_getkey(cpv),
1874                                                 initial_db.aux_get(cpv, ["SLOT"])[0])
1875                         for cpv in blocked_final:
1876                                 blocked_slots_final[cpv] = \
1877                                         "%s:%s" % (portage.dep_getkey(cpv),
1878                                                 final_db.aux_get(cpv, ["SLOT"])[0])
1879                         blocked_slots_final_values = set(blocked_slots_final.itervalues())
1880                         for parent in list(self.blocker_parents[blocker]):
1881                                 ptype, proot, pcpv, pstatus = parent
1882                                 pdbapi = self.trees[proot][self.pkg_tree_map[ptype]].dbapi
1883                                 pslot = pdbapi.aux_get(pcpv, ["SLOT"])[0]
1884                                 pslot_atom = "%s:%s" % (portage.dep_getkey(pcpv), pslot)
1885                                 parent_static = pslot_atom not in modified_slots[proot]
1886                                 unresolved_blocks = False
1887                                 depends_on_order = set()
1888                                 for cpv in blocked_initial:
1889                                         slot_atom = blocked_slots_initial[cpv]
1890                                         if slot_atom == pslot_atom:
1891                                                 # The parent blocks an initial package in the same
1892                                                 # slot as itself.  The merge/nomerge status of neither
1893                                                 # node matters.  In any case, this particular block is
1894                                                 # automatically resolved.
1895                                                 continue
1896                                         if parent_static and \
1897                                                 slot_atom not in modified_slots[myroot]:
1898                                                 # This blocker will be handled the next time that a
1899                                                 # merge of either package is triggered.
1900                                                 continue
1901                                         if pstatus == "merge" and \
1902                                                 slot_atom not in blocked_slots_final_values:
1903                                                 upgrade_matches = final_db.match(slot_atom)
1904                                                 if upgrade_matches:
1905                                                         # Apparently an upgrade may be able to invalidate
1906                                                         # this block.
1907                                                         upgrade_node = \
1908                                                                 self.pkg_node_map[proot][upgrade_matches[0]]
1909                                                         depends_on_order.add(upgrade_node)
1910                                                         continue
1911                                         # None of the above blocker resolutions techniques apply,
1912                                         # so apparently this one is unresolvable.
1913                                         unresolved_blocks = True
1914                                 for cpv in blocked_final:
1915                                         slot_atom = blocked_slots_final[cpv]
1916                                         if slot_atom == pslot_atom:
1917                                                 # The parent blocks itself, so the merge order does not
1918                                                 # need to be enforced.
1919                                                 continue
1920                                         if parent_static and \
1921                                                 slot_atom not in modified_slots[myroot]:
1922                                                 # This blocker will be handled the next time that a
1923                                                 # merge of either package is triggered.
1924                                                 continue
1925                                         # None of the above blocker resolutions techniques apply,
1926                                         # so apparently this one is unresolvable.
1927                                         unresolved_blocks = True
1928                                 if not unresolved_blocks and depends_on_order:
1929                                         for node in depends_on_order:
1930                                                 # Enforce correct merge order with a hard dep.
1931                                                 self.digraph.addnode(node, parent,
1932                                                         priority=DepPriority(buildtime=True))
1933                                                 # Count references to this blocker so that it can be
1934                                                 # invalidated after nodes referencing it have been
1935                                                 # merged.
1936                                                 self.blocker_digraph.addnode(node, blocker)
1937                                 if not unresolved_blocks and not depends_on_order:
1938                                         self.blocker_parents[blocker].remove(parent)
1939                         if not self.blocker_parents[blocker]:
1940                                 del self.blocker_parents[blocker]
1941                 # Validate blockers that depend on merge order.
1942                 if not self.blocker_digraph.empty():
1943                         self.altlist()
1944                 if self._slot_collision_info:
1945                         # The user is only notified of a slot collision if there are no
1946                         # unresolvable blocks.
1947                         for x in self.altlist():
1948                                 if x[0] == "blocks":
1949                                         return True
1950                         self._show_slot_collision_notice(self._slot_collision_info[0])
1951                         if not self._accept_collisions():
1952                                 return False
1953                 return True
1954
1955         def _accept_collisions(self):
1956                 acceptable = False
1957                 for x in ("--nodeps", "--pretend", "--fetchonly", "--fetch-all-uri"):
1958                         if x in self.myopts:
1959                                 acceptable = True
1960                                 break
1961                 return acceptable
1962
1963         def altlist(self, reversed=False):
1964                 if reversed in self._altlist_cache:
1965                         return self._altlist_cache[reversed][:]
1966                 mygraph=self.digraph.copy()
1967                 myblockers = self.blocker_digraph.copy()
1968                 retlist=[]
1969                 circular_blocks = False
1970                 blocker_deps = None
1971                 asap_nodes = []
1972                 if reversed:
1973                         get_nodes = mygraph.root_nodes
1974                 else:
1975                         get_nodes = mygraph.leaf_nodes
1976                         for cpv, node in self.pkg_node_map["/"].iteritems():
1977                                 if "portage" == portage.catsplit(portage.dep_getkey(cpv))[-1]:
1978                                         asap_nodes.append(node)
1979                                         break
1980                 ignore_priority_range = [None]
1981                 ignore_priority_range.extend(
1982                         xrange(DepPriority.MIN, DepPriority.MEDIUM + 1))
1983                 while not mygraph.empty():
1984                         ignore_priority = None
1985                         nodes = None
1986                         if asap_nodes:
1987                                 """ASAP nodes are merged before their soft deps."""
1988                                 for node in asap_nodes:
1989                                         if not mygraph.contains(node):
1990                                                 asap_nodes.remove(node)
1991                                                 continue
1992                                         if not mygraph.child_nodes(node,
1993                                                 ignore_priority=DepPriority.SOFT):
1994                                                 nodes = [node]
1995                                                 asap_nodes.remove(node)
1996                                                 break
1997                         if not nodes:
1998                                 for ignore_priority in ignore_priority_range:
1999                                         nodes = get_nodes(ignore_priority=ignore_priority)
2000                                         if nodes:
2001                                                 break
2002                         selected_nodes = None
2003                         if nodes:
2004                                 if ignore_priority <= DepPriority.SOFT:
2005                                         if ignore_priority is None and not reversed:
2006                                                 # Greedily pop all of these nodes since no relationship
2007                                                 # has been ignored.  This optimization destroys --tree
2008                                                 # output, so it's disabled in reversed mode.
2009                                                 selected_nodes = nodes
2010                                         else:
2011                                                 # Only pop one node for optimal merge order.
2012                                                 selected_nodes = [nodes[0]]
2013                                 else:
2014                                         """Recursively gather a group of nodes that RDEPEND on
2015                                         eachother.  This ensures that they are merged as a group
2016                                         and get their RDEPENDs satisfied as soon as possible."""
2017                                         def gather_deps(mergeable_nodes, selected_nodes, node):
2018                                                 if node in selected_nodes:
2019                                                         return True
2020                                                 if node not in mergeable_nodes:
2021                                                         return False
2022                                                 selected_nodes.add(node)
2023                                                 for child in mygraph.child_nodes(node,
2024                                                         ignore_priority=DepPriority.SOFT):
2025                                                         if not gather_deps(
2026                                                                 mergeable_nodes, selected_nodes, child):
2027                                                                 return False
2028                                                 return True
2029                                         mergeable_nodes = set(nodes)
2030                                         for node in nodes:
2031                                                 selected_nodes = set()
2032                                                 if gather_deps(
2033                                                         mergeable_nodes, selected_nodes, node):
2034                                                         break
2035                                                 else:
2036                                                         selected_nodes = None
2037
2038                         if not selected_nodes:
2039                                 if not myblockers.is_empty():
2040                                         """A blocker couldn't be circumnavigated while keeping all
2041                                         dependencies satisfied.  The user will have to resolve this
2042                                         manually.  This is a panic condition and thus the order
2043                                         doesn't really matter, so just pop a random node in order
2044                                         to avoid a circular dependency panic if possible."""
2045                                         if not circular_blocks:
2046                                                 circular_blocks = True
2047                                                 blocker_deps = myblockers.leaf_nodes()
2048                                         if blocker_deps:
2049                                                 selected_nodes = [blocker_deps.pop()]
2050
2051                         if not selected_nodes:
2052                                 if reversed:
2053                                         """The circular deps ouput should have less noise when
2054                                         altlist is not in reversed mode."""
2055                                         self.altlist()
2056                                 print "!!! Error: circular dependencies:"
2057                                 print
2058                                 mygraph.debug_print()
2059                                 sys.exit(1)
2060
2061                         for node in selected_nodes:
2062                                 retlist.append(list(node))
2063                                 mygraph.remove(node)
2064                                 if not reversed and not circular_blocks and myblockers.contains(node):
2065                                         """This node may have invalidated one or more blockers."""
2066                                         myblockers.remove(node)
2067                                         for blocker in myblockers.root_nodes():
2068                                                 if not myblockers.child_nodes(blocker):
2069                                                         myblockers.remove(blocker)
2070                                                         del self.blocker_parents[blocker]
2071
2072                 if not reversed:
2073                         """Blocker validation does not work with reverse mode,
2074                         so self.altlist() should first be called with reverse disabled
2075                         so that blockers are properly validated."""
2076                         self.blocker_digraph = myblockers
2077
2078                 """ Add any unresolved blocks so that they can be displayed."""
2079                 for blocker in self.blocker_parents:
2080                         retlist.append(list(blocker))
2081                 self._altlist_cache[reversed] = retlist[:]
2082                 return retlist
2083
2084         def xcreate(self,mode="system"):
2085                 vardb = self.trees[self.target_root]["vartree"].dbapi
2086                 portdb = self.trees[self.target_root]["porttree"].dbapi
2087                 bindb = self.trees[self.target_root]["bintree"].dbapi
2088                 def visible(mylist):
2089                         matches = portdb.gvisible(portdb.visible(mylist))
2090                         return [x for x in mylist \
2091                                 if x in matches or not portdb.cpv_exists(x)]
2092                 world_problems = False
2093                 if mode=="system":
2094                         mylist = getlist(self.settings, "system")
2095                 else:
2096                         #world mode
2097                         worldlist = getlist(self.settings, "world")
2098                         sysdict = genericdict(getlist(self.settings, "system"))
2099                         worlddict=genericdict(worldlist)
2100
2101                         for x in worlddict.keys():
2102                                 if not portage.isvalidatom(x):
2103                                         world_problems = True
2104                                 elif not self.trees[self.target_root]["vartree"].dbapi.match(x):
2105                                         world_problems = True
2106                                 else:
2107                                         sysdict[x]=worlddict[x]
2108
2109                         mylist = sysdict.keys()
2110
2111                 newlist = []
2112                 for atom in mylist:
2113                         mykey = portage.dep_getkey(atom)
2114                         if True:
2115                                 newlist.append(atom)
2116                                 """Make sure all installed slots are updated when possible.
2117                                 Do this with --emptytree also, to ensure that all slots are
2118                                 remerged."""
2119                                 myslots = set()
2120                                 for cpv in vardb.match(mykey):
2121                                         myslots.add(vardb.aux_get(cpv, ["SLOT"])[0])
2122                                 if myslots:
2123                                         best_pkgs = []
2124                                         if "--usepkg" in self.myopts:
2125                                                 mymatches = bindb.match(atom)
2126                                                 if "--usepkgonly" not in self.myopts:
2127                                                         mymatches = visible(mymatches)
2128                                                 best_pkg = portage.best(mymatches)
2129                                                 if best_pkg:
2130                                                         best_slot = bindb.aux_get(best_pkg, ["SLOT"])[0]
2131                                                         best_pkgs.append(("binary", best_pkg, best_slot))
2132                                         if "--usepkgonly" not in self.myopts:
2133                                                 best_pkg = portage.best(portdb.match(atom))
2134                                                 if best_pkg:
2135                                                         best_slot = portdb.aux_get(best_pkg, ["SLOT"])[0]
2136                                                         best_pkgs.append(("ebuild", best_pkg, best_slot))
2137                                         if best_pkgs:
2138                                                 best_pkg = portage.best([x[1] for x in best_pkgs])
2139                                                 best_pkgs = [x for x in best_pkgs if x[1] == best_pkg]
2140                                                 best_slot = best_pkgs[0][2]
2141                                                 myslots.add(best_slot)
2142                                 if len(myslots) > 1:
2143                                         for myslot in myslots:
2144                                                 myslot_atom = "%s:%s" % (mykey, myslot)
2145                                                 available = False
2146                                                 if "--usepkgonly" not in self.myopts and \
2147                                                         self.trees[self.target_root][
2148                                                         "porttree"].dbapi.match(myslot_atom):
2149                                                         available = True
2150                                                 elif "--usepkg" in self.myopts:
2151                                                         mymatches = bindb.match(myslot_atom)
2152                                                         if "--usepkgonly" not in self.myopts:
2153                                                                 mymatches = visible(mymatches)
2154                                                         if mymatches:
2155                                                                 available = True
2156                                                 if available:
2157                                                         newlist.append(myslot_atom)
2158                 mylist = newlist
2159
2160                 missing_atoms = []
2161                 for mydep in mylist:
2162                         try:
2163                                 if not self.select_dep(
2164                                         self.target_root, mydep, raise_on_missing=True, arg=mydep):
2165                                         print >> sys.stderr, "\n\n!!! Problem resolving dependencies for", mydep
2166                                         return 0
2167                         except ValueError:
2168                                 missing_atoms.append(mydep)
2169
2170                 if not self.validate_blockers():
2171                         return False
2172
2173                 if world_problems:
2174                         print >> sys.stderr, "\n!!! Problems have been detected with your world file"
2175                         print >> sys.stderr, "!!! Please run "+green("emaint --check world")+"\n"
2176
2177                 if missing_atoms:
2178                         print >> sys.stderr, "\n" + colorize("BAD", "!!!") + \
2179                                 " Ebuilds for the following packages are either all"
2180                         print >> sys.stderr, colorize("BAD", "!!!") + " masked or don't exist:"
2181                         print >> sys.stderr, " ".join(missing_atoms) + "\n"
2182
2183                 return 1
2184
2185         def display(self,mylist,verbosity=None):
2186                 if verbosity is None:
2187                         verbosity = ("--quiet" in self.myopts and 1 or \
2188                                 "--verbose" in self.myopts and 3 or 2)
2189                 changelogs=[]
2190                 p=[]
2191
2192                 counters = PackageCounters()
2193
2194                 if verbosity == 1 and "--verbose" not in self.myopts:
2195                         def create_use_string(*args):
2196                                 return ""
2197                 else:
2198                         def create_use_string(name, cur_iuse, iuse_forced, cur_use,
2199                                 old_iuse, old_use,
2200                                 is_new, all_flags=(verbosity == 3 or "--quiet" in self.myopts),
2201                                 alphabetical=("--alphabetical" in self.myopts)):
2202                                 enabled = []
2203                                 if alphabetical:
2204                                         disabled = enabled
2205                                         removed = enabled
2206                                 else:
2207                                         disabled = []
2208                                         removed = []
2209                                 cur_iuse = set(cur_iuse)
2210                                 enabled_flags = cur_iuse.intersection(cur_use)
2211                                 removed_iuse = set(old_iuse).difference(cur_iuse)
2212                                 any_iuse = cur_iuse.union(old_iuse)
2213                                 any_iuse = list(any_iuse)
2214                                 any_iuse.sort()
2215                                 for flag in any_iuse:
2216                                         flag_str = None
2217                                         isEnabled = False
2218                                         if flag in enabled_flags:
2219                                                 isEnabled = True
2220                                                 if is_new or flag in old_use and all_flags:
2221                                                         flag_str = red(flag)
2222                                                 elif flag not in old_iuse:
2223                                                         flag_str = yellow(flag) + "%*"
2224                                                 elif flag not in old_use:
2225                                                         flag_str = green(flag) + "*"
2226                                         elif flag in removed_iuse:
2227                                                 if all_flags:
2228                                                         flag_str = yellow("-" + flag) + "%"
2229                                                         if flag in old_use:
2230                                                                 flag_str += "*"
2231                                                         flag_str = "(" + flag_str + ")"
2232                                                         removed.append(flag_str)
2233                                                 continue
2234                                         else:
2235                                                 if is_new or flag in old_iuse and flag not in old_use and all_flags:
2236                                                         flag_str = blue("-" + flag)
2237                                                 elif flag not in old_iuse:
2238                                                         flag_str = yellow("-" + flag)
2239                                                         if flag not in iuse_forced:
2240                                                                 flag_str += "%"
2241                                                 elif flag in old_use:
2242                                                         flag_str = green("-" + flag) + "*"
2243                                         if flag_str:
2244                                                 if flag in iuse_forced:
2245                                                         flag_str = "(" + flag_str + ")"
2246                                                 if isEnabled:
2247                                                         enabled.append(flag_str)
2248                                                 else:
2249                                                         disabled.append(flag_str)
2250
2251                                 if alphabetical:
2252                                         ret = " ".join(enabled)
2253                                 else:
2254                                         ret = " ".join(enabled + disabled + removed)
2255                                 if ret:
2256                                         ret = '%s="%s" ' % (name, ret)
2257                                 return ret
2258
2259                 if verbosity == 3:
2260                         # FIXME: account for the possibility of different overlays in
2261                         # /etc/make.conf vs. ${PORTAGE_CONFIGROOT}/etc/make.conf
2262                         overlays = self.settings["PORTDIR_OVERLAY"].split()
2263                         overlays_real = [os.path.realpath(t) \
2264                                 for t in self.settings["PORTDIR_OVERLAY"].split()]
2265
2266                 tree_nodes = []
2267                 node_depth = {}
2268                 i = 0
2269                 depth = 0
2270                 for x in mylist:
2271                         if "blocks" == x[0]:
2272                                 continue
2273                         graph_key = tuple(x)
2274                         if "--tree" in self.myopts:
2275                                 depth = len(tree_nodes)
2276                                 while depth and graph_key not in \
2277                                         self.digraph.child_nodes(tree_nodes[depth-1]):
2278                                                 depth -= 1
2279                                 tree_nodes = tree_nodes[:depth]
2280                                 tree_nodes.append(graph_key)
2281                         node_depth[graph_key] = depth
2282
2283                 last_merge_depth = 0
2284                 for i in xrange(len(mylist)-1,-1,-1):
2285                         if "blocks" == mylist[i][0]:
2286                                 continue
2287                         graph_key = tuple(mylist[i])
2288                         if mylist[i][-1] != "nomerge":
2289                                 last_merge_depth = node_depth[graph_key]
2290                                 continue
2291                         if node_depth[graph_key] >= last_merge_depth or \
2292                                 i < len(mylist) - 1 and \
2293                                 node_depth[graph_key] >= node_depth[tuple(mylist[i+1])]:
2294                                         del mylist[i]
2295                                         del node_depth[graph_key]
2296                 del tree_nodes
2297
2298                 display_overlays=False
2299                 # files to fetch list - avoids counting a same file twice
2300                 # in size display (verbose mode)
2301                 myfetchlist=[]
2302                 for x in mylist:
2303                         pkg_type = x[0]
2304                         myroot = x[1]
2305                         pkg_key = x[2]
2306                         portdb = self.trees[myroot]["porttree"].dbapi
2307                         bindb  = self.trees[myroot]["bintree"].dbapi
2308                         vardb = self.trees[myroot]["vartree"].dbapi
2309                         vartree = self.trees[myroot]["vartree"]
2310                         pkgsettings = self.pkgsettings[myroot]
2311
2312                         fetch=" "
2313
2314                         if x[0]=="blocks":
2315                                 addl=""+red("B")+"  "+fetch+"  "
2316                                 counters.blocks += 1
2317                                 resolved = portage.key_expand(
2318                                         pkg_key, mydb=vardb, settings=pkgsettings)
2319                                 if "--columns" in self.myopts and "--quiet" in self.myopts:
2320                                         print addl,red(resolved),
2321                                 else:
2322                                         print "["+x[0]+" "+addl+"]",red(resolved),
2323                                 block_parents = self.blocker_parents[tuple(x)]
2324                                 block_parents = set([pnode[2] for pnode in block_parents])
2325                                 block_parents = ", ".join(block_parents)
2326                                 if resolved!=x[2]:
2327                                         print bad("(\"%s\" is blocking %s)") % \
2328                                                 (pkg_key, block_parents)
2329                                 else:
2330                                         print bad("(is blocking %s)") % block_parents
2331                         else:
2332                                 mydbapi = self.trees[myroot][self.pkg_tree_map[pkg_type]].dbapi
2333                                 binary_package = True
2334                                 if "ebuild" == pkg_type:
2335                                         if "merge" == x[3] or \
2336                                                 not vartree.dbapi.cpv_exists(pkg_key):
2337                                                 """An ebuild "merge" node or a --onlydeps "nomerge"
2338                                                 node."""
2339                                                 binary_package = False
2340                                                 pkgsettings.setcpv(pkg_key, mydb=portdb)
2341                                                 if pkg_key not in self.useFlags[myroot]:
2342                                                         self.useFlags[myroot][pkg_key] = \
2343                                                                 pkgsettings["USE"].split()
2344                                         else:
2345                                                 # An ebuild "nomerge" node, so USE come from the vardb.
2346                                                 mydbapi = vartree.dbapi
2347                                 if pkg_key not in self.useFlags[myroot]:
2348                                         """If this is a --resume then the USE flags need to be
2349                                         fetched from the appropriate locations here."""
2350                                         self.useFlags[myroot][pkg_key] = mydbapi.aux_get(
2351                                                 pkg_key, ["USE"])[0].split()
2352
2353                                 if "ebuild" == pkg_type and x[3] != "nomerge" and \
2354                                         "fetch" in portdb.aux_get(
2355                                         x[2], ["RESTRICT"])[0].split():
2356                                         fetch = red("F")
2357                                         counters.restrict_fetch += 1
2358                                         if portdb.fetch_check(
2359                                                 pkg_key, self.useFlags[myroot][pkg_key]):
2360                                                 fetch = green("f")
2361                                                 counters.restrict_fetch_satisfied += 1
2362
2363                                 #we need to use "--emptrytree" testing here rather than "empty" param testing because "empty"
2364                                 #param is used for -u, where you still *do* want to see when something is being upgraded.
2365                                 myoldbest=""
2366                                 if vardb.cpv_exists(pkg_key):
2367                                         addl="  "+yellow("R")+fetch+"  "
2368                                         if x[3] != "nomerge":
2369                                                 counters.reinst += 1
2370                                 elif vardb.match(portage.dep_getkey(pkg_key)):
2371                                         mynewslot = mydbapi.aux_get(pkg_key, ["SLOT"])[0]
2372                                         myoldlist = self.trees[x[1]]["vartree"].dbapi.match(
2373                                                 portage.pkgsplit(x[2])[0])
2374                                         myinslotlist = [inst_pkg for inst_pkg in myoldlist
2375                                                 if mynewslot == vardb.aux_get(inst_pkg, ["SLOT"])[0]]
2376                                         if myinslotlist:
2377                                                 myoldbest=portage.best(myinslotlist)
2378                                                 addl="   "+fetch
2379                                                 if portage.pkgcmp(portage.pkgsplit(x[2]), portage.pkgsplit(myoldbest)) < 0:
2380                                                         # Downgrade in slot
2381                                                         addl+=turquoise("U")+blue("D")
2382                                                         counters.downgrades += 1
2383                                                 else:
2384                                                         # Update in slot
2385                                                         addl+=turquoise("U")+" "
2386                                                         counters.upgrades += 1
2387                                         else:
2388                                                 # New slot, mark it new.
2389                                                 addl=" "+green("NS")+fetch+"  "
2390                                                 counters.newslot += 1
2391
2392                                         if "--changelog" in self.myopts:
2393                                                 slot_atom = "%s:%s" % (portage.dep_getkey(pkg_key),
2394                                                         mydbapi.aux_get(pkg_key, ["SLOT"])[0])
2395                                                 inst_matches = vardb.match(slot_atom)
2396                                                 if inst_matches:
2397                                                         changelogs.extend(self.calc_changelog(
2398                                                                 portdb.findname(pkg_key),
2399                                                                 inst_matches[0], pkg_key))
2400                                 else:
2401                                         addl=" "+green("N")+" "+fetch+"  "
2402                                         counters.new += 1
2403
2404                                 verboseadd=""
2405
2406                                 if pkg_key in self.useFlags[myroot]:
2407                                         # USE flag display
2408                                         cur_iuse = list(filter_iuse_defaults(
2409                                                 mydbapi.aux_get(pkg_key, ["IUSE"])[0].split()))
2410
2411                                         forced_flags = set()
2412                                         if not binary_package:
2413                                                 forced_flags.update(pkgsettings.useforce)
2414                                                 forced_flags.update(pkgsettings.usemask)
2415
2416                                         cur_iuse = portage.unique_array(cur_iuse)
2417                                         cur_iuse.sort()
2418                                         cur_use = self.useFlags[myroot][pkg_key]
2419                                         cur_use = [flag for flag in cur_use if flag in cur_iuse]
2420
2421                                         if myoldbest:
2422                                                 pkg = myoldbest
2423                                         else:
2424                                                 pkg = x[2]
2425                                         if self.trees[x[1]]["vartree"].dbapi.cpv_exists(pkg):
2426                                                 old_iuse, old_use = \
2427                                                         self.trees[x[1]]["vartree"].dbapi.aux_get(
2428                                                                 pkg, ["IUSE", "USE"])
2429                                                 old_iuse = list(set(
2430                                                         filter_iuse_defaults(old_iuse.split())))
2431                                                 old_iuse.sort()
2432                                                 old_use = old_use.split()
2433                                                 is_new = False
2434                                         else:
2435                                                 old_iuse = []
2436                                                 old_use = []
2437                                                 is_new = True
2438
2439                                         old_use = [flag for flag in old_use if flag in old_iuse]
2440
2441                                         use_expand = pkgsettings["USE_EXPAND"].lower().split()
2442                                         use_expand.sort()
2443                                         use_expand.reverse()
2444                                         use_expand_hidden = \
2445                                                 pkgsettings["USE_EXPAND_HIDDEN"].lower().split()
2446
2447                                         def map_to_use_expand(myvals, forcedFlags=False):
2448                                                 ret = {}
2449                                                 forced = {}
2450                                                 for exp in use_expand:
2451                                                         ret[exp] = []
2452                                                         forced[exp] = set()
2453                                                         for val in myvals[:]:
2454                                                                 if val.startswith(exp.lower()+"_"):
2455                                                                         if val in forced_flags:
2456                                                                                 forced[exp].add(val[len(exp)+1:])
2457                                                                         ret[exp].append(val[len(exp)+1:])
2458                                                                         myvals.remove(val)
2459                                                 ret["USE"] = myvals
2460                                                 forced["USE"] = [val for val in myvals \
2461                                                         if val in forced_flags]
2462                                                 for exp in use_expand_hidden:
2463                                                         if exp in ret:
2464                                                                 del ret[exp]
2465                                                 if forcedFlags:
2466                                                         return ret, forced
2467                                                 return ret
2468
2469                                         cur_iuse_map, iuse_forced = \
2470                                                 map_to_use_expand(cur_iuse, forcedFlags=True)
2471                                         cur_use_map = map_to_use_expand(cur_use)
2472                                         old_iuse_map = map_to_use_expand(old_iuse)
2473                                         old_use_map = map_to_use_expand(old_use)
2474
2475                                         use_expand.sort()
2476                                         use_expand.insert(0, "USE")
2477
2478                                         for key in use_expand:
2479                                                 if key in use_expand_hidden:
2480                                                         continue
2481                                                 verboseadd += create_use_string(key.upper(),
2482                                                         cur_iuse_map[key], iuse_forced[key],
2483                                                         cur_use_map[key], old_iuse_map[key],
2484                                                         old_use_map[key], is_new)
2485
2486                                 if verbosity == 3:
2487                                         # size verbose
2488                                         mysize=0
2489                                         if x[0] == "ebuild" and x[-1]!="nomerge":
2490                                                 try:
2491                                                         myfilesdict = portdb.getfetchsizes(pkg_key,
2492                                                                 useflags=self.useFlags[myroot][pkg_key],
2493                                                                 debug=self.edebug)
2494                                                 except portage.exception.InvalidDependString, e:
2495                                                         src_uri = portdb.aux_get(pkg_key, ["SRC_URI"])[0]
2496                                                         show_invalid_depstring_notice(x, src_uri, str(e))
2497                                                         del e
2498                                                         sys.exit(1)
2499                                                 if myfilesdict is None:
2500                                                         myfilesdict="[empty/missing/bad digest]"
2501                                                 else:
2502                                                         for myfetchfile in myfilesdict.keys():
2503                                                                 if myfetchfile not in myfetchlist:
2504                                                                         mysize+=myfilesdict[myfetchfile]
2505                                                                         myfetchlist.append(myfetchfile)
2506                                                         counters.totalsize += mysize
2507                                                 verboseadd+=format_size(mysize)+" "
2508
2509                                         # overlay verbose
2510                                         # XXX: Invalid binaries have caused tracebacks here. 'if file_name'
2511                                         # x = ['binary', '/', 'sys-apps/pcmcia-cs-3.2.7.2.6', 'merge']
2512                                         file_name = portdb.findname(pkg_key)
2513                                         if file_name: # It might not exist in the tree
2514                                                 dir_name=os.path.abspath(os.path.dirname(file_name)+"/../..")
2515                                                 if (overlays_real.count(dir_name)>0):
2516                                                         verboseadd+=teal("["+str(overlays_real.index(
2517                                                                 os.path.normpath(dir_name))+1)+"]")+" "
2518                                                         display_overlays=True
2519                                         else:
2520                                                 verboseadd += "[No ebuild?]"
2521
2522                                 xs=portage.pkgsplit(x[2])
2523                                 if xs[2]=="r0":
2524                                         xs[2]=""
2525                                 else:
2526                                         xs[2]="-"+xs[2]
2527
2528                                 mywidth = 130
2529                                 if "COLUMNWIDTH" in self.settings:
2530                                         try:
2531                                                 mywidth = int(self.settings["COLUMNWIDTH"])
2532                                         except ValueError, e:
2533                                                 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
2534                                                 portage.writemsg(
2535                                                         "!!! Unable to parse COLUMNWIDTH='%s'\n" % \
2536                                                         self.settings["COLUMNWIDTH"], noiselevel=-1)
2537                                                 del e
2538                                 oldlp=mywidth-30
2539                                 newlp=oldlp-30
2540
2541                                 indent = " " * node_depth[tuple(x)]
2542
2543                                 if myoldbest:
2544                                         myoldbest=portage.pkgsplit(myoldbest)[1]+"-"+portage.pkgsplit(myoldbest)[2]
2545                                         if myoldbest[-3:]=="-r0":
2546                                                 myoldbest=myoldbest[:-3]
2547                                         myoldbest=blue("["+myoldbest+"]")
2548
2549                                 if x[1]!="/":
2550                                         if myoldbest:
2551                                                 myoldbest +=" "
2552                                         if "--columns" in self.myopts:
2553                                                 if "--quiet" in self.myopts:
2554                                                         myprint=addl+" "+indent+darkgreen(xs[0])
2555                                                         myprint=myprint+darkblue(" "+xs[1]+xs[2])+" "
2556                                                         myprint=myprint+myoldbest
2557                                                         myprint=myprint+darkgreen("to "+x[1])
2558                                                 else:
2559                                                         myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(xs[0])
2560                                                         if (newlp-nc_len(myprint)) > 0:
2561                                                                 myprint=myprint+(" "*(newlp-nc_len(myprint)))
2562                                                         myprint=myprint+"["+darkblue(xs[1]+xs[2])+"] "
2563                                                         if (oldlp-nc_len(myprint)) > 0:
2564                                                                 myprint=myprint+" "*(oldlp-nc_len(myprint))
2565                                                         myprint=myprint+myoldbest
2566                                                         myprint=myprint+darkgreen("to "+x[1])+" "+verboseadd
2567                                         else:
2568                                                 if x[3] == "nomerge":
2569                                                         myprint = darkblue("[nomerge      ] ")
2570                                                 else:
2571                                                         myprint = "[" + pkg_type + " " + addl + "] "
2572                                                 myprint += indent + darkgreen(pkg_key) + " " + \
2573                                                         myoldbest + darkgreen("to " + myroot) + " " + \
2574                                                         verboseadd
2575                                 else:
2576                                         if "--columns" in self.myopts:
2577                                                 if "--quiet" in self.myopts:
2578                                                         myprint=addl+" "+indent+darkgreen(xs[0])
2579                                                         myprint=myprint+" "+green(xs[1]+xs[2])+" "
2580                                                         myprint=myprint+myoldbest
2581                                                 else:
2582                                                         myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(xs[0])
2583                                                         if (newlp-nc_len(myprint)) > 0:
2584                                                                 myprint=myprint+(" "*(newlp-nc_len(myprint)))
2585                                                         myprint=myprint+green(" ["+xs[1]+xs[2]+"] ")
2586                                                         if (oldlp-nc_len(myprint)) > 0:
2587                                                                 myprint=myprint+(" "*(oldlp-nc_len(myprint)))
2588                                                         myprint=myprint+myoldbest+"  "+verboseadd
2589                                         else:
2590                                                 if x[3]=="nomerge":
2591                                                         myprint=darkblue("[nomerge      ] "+indent+x[2]+" "+myoldbest+" ")+verboseadd
2592                                                 else:
2593                                                         myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(x[2])+" "+myoldbest+" "+verboseadd
2594                                 p.append(myprint)
2595
2596                         mysplit = portage.pkgsplit(x[2])
2597                         if "--tree" not in self.myopts and mysplit and \
2598                                 len(mysplit) == 3 and mysplit[0] == "sys-apps/portage" and \
2599                                 x[1] == "/":
2600
2601                                 if mysplit[2] == "r0":
2602                                         myversion = mysplit[1]
2603                                 else:
2604                                         myversion = "%s-%s" % (mysplit[1], mysplit[2])
2605
2606                                 if myversion != portage.VERSION and "--quiet" not in self.myopts:
2607                                         if mylist.index(x) < len(mylist) - 1 and \
2608                                                 "livecvsportage" not in self.settings.features:
2609                                                 p.append(colorize("WARN", "*** Portage will stop merging at this point and reload itself,"))
2610                                                 p.append(colorize("WARN", "    then resume the merge."))
2611                                                 print
2612                         del mysplit
2613
2614                 for x in p:
2615                         print x
2616
2617                 if verbosity == 3:
2618                         print
2619                         print counters
2620                         if overlays and display_overlays:
2621                                 print "Portage overlays:"
2622                                 y=0
2623                                 for x in overlays:
2624                                         y=y+1
2625                                         print " "+teal("["+str(y)+"]"),x
2626
2627                 if "--changelog" in self.myopts:
2628                         print
2629                         for revision,text in changelogs:
2630                                 print bold('*'+revision)
2631                                 sys.stdout.write(text)
2632
2633                 if self._pprovided_args:
2634                         msg = []
2635                         msg.append(bad("\nWARNING: "))
2636                         if len(self._pprovided_args) > 1:
2637                                 msg.append("Requested packages will not be " + \
2638                                         "merged because they are listed in\n")
2639                         else:
2640                                 msg.append("A requested package will not be " + \
2641                                         "merged because it is listed in\n")
2642                         msg.append("         package.provided:\n\n")
2643                         for arg in self._pprovided_args:
2644                                 msg.append("             " + arg + "\n")
2645                         msg.append("\n")
2646                         sys.stderr.write("".join(msg))
2647
2648         def calc_changelog(self,ebuildpath,current,next):
2649                 current = '-'.join(portage.catpkgsplit(current)[1:])
2650                 if current.endswith('-r0'): current = current[:-3]
2651                 next = '-'.join(portage.catpkgsplit(next)[1:])
2652                 if next.endswith('-r0'): next = next[:-3]
2653                 changelogpath = os.path.join(os.path.split(ebuildpath)[0],'ChangeLog')
2654                 try:
2655                         changelog = open(changelogpath).read()
2656                 except SystemExit, e:
2657                         raise # Needed else can't exit
2658                 except:
2659                         return []
2660                 divisions = self.find_changelog_tags(changelog)
2661                 #print 'XX from',current,'to',next
2662                 #for div,text in divisions: print 'XX',div
2663                 # skip entries for all revisions above the one we are about to emerge
2664                 for i in range(len(divisions)):
2665                         if divisions[i][0]==next:
2666                                 divisions = divisions[i:]
2667                                 break
2668                 # find out how many entries we are going to display
2669                 for i in range(len(divisions)):
2670                         if divisions[i][0]==current:
2671                                 divisions = divisions[:i]
2672                                 break
2673                 else:
2674                     # couldnt find the current revision in the list. display nothing
2675                         return []
2676                 return divisions
2677
2678         def find_changelog_tags(self,changelog):
2679                 divs = []
2680                 release = None
2681                 while 1:
2682                         match = re.search(r'^\*\ ?([-a-zA-Z0-9_.+]*)(?:\ .*)?\n',changelog,re.M)
2683                         if match is None:
2684                                 if release is not None:
2685                                         divs.append((release,changelog))
2686                                 return divs
2687                         if release is not None:
2688                                 divs.append((release,changelog[:match.start()]))
2689                         changelog = changelog[match.end():]
2690                         release = match.group(1)
2691                         if release.endswith('.ebuild'):
2692                                 release = release[:-7]
2693                         if release.endswith('-r0'):
2694                                 release = release[:-3]
2695
2696         def outdated(self):
2697                 return self.outdatedpackages
2698
2699 class PackageCounters(object):
2700
2701         def __init__(self):
2702                 self.upgrades   = 0
2703                 self.downgrades = 0
2704                 self.new        = 0
2705                 self.newslot    = 0
2706                 self.reinst     = 0
2707                 self.blocks     = 0
2708                 self.totalsize  = 0
2709                 self.restrict_fetch           = 0
2710                 self.restrict_fetch_satisfied = 0
2711
2712         def __str__(self):
2713                 total_installs = self.upgrades + self.downgrades + self.newslot + self.new + self.reinst
2714                 myoutput = []
2715                 details = []
2716                 myoutput.append("Total: %s package" % total_installs)
2717                 if total_installs != 1:
2718                         myoutput.append("s")
2719                 if total_installs != 0:
2720                         myoutput.append(" (")
2721                 if self.upgrades > 0:
2722                         details.append("%s upgrade" % self.upgrades)
2723                         if self.upgrades > 1:
2724                                 details[-1] += "s"
2725                 if self.downgrades > 0:
2726                         details.append("%s downgrade" % self.downgrades)
2727                         if self.downgrades > 1:
2728                                 details[-1] += "s"
2729                 if self.new > 0:
2730                         details.append("%s new" % self.new)
2731                 if self.newslot > 0:
2732                         details.append("%s in new slot" % self.newslot)
2733                         if self.newslot > 1:
2734                                 details[-1] += "s"
2735                 if self.reinst > 0:
2736                         details.append("%s reinstall" % self.reinst)
2737                         if self.reinst > 1:
2738                                 details[-1] += "s"
2739                 if self.blocks > 0:
2740                         details.append("%s block" % self.blocks)
2741                         if self.blocks > 1:
2742                                 details[-1] += "s"
2743                 myoutput.append(", ".join(details))
2744                 if total_installs != 0:
2745                         myoutput.append(")")
2746                 myoutput.append(", Size of downloads: %s" % format_size(self.totalsize))
2747                 if self.restrict_fetch:
2748                         myoutput.append("\nFetch Restriction: %s package" % \
2749                                 self.restrict_fetch)
2750                         if self.restrict_fetch > 1:
2751                                 myoutput.append("s")
2752                 if self.restrict_fetch_satisfied < self.restrict_fetch:
2753                         myoutput.append(bad(" (%s unsatisfied)") % \
2754                                 (self.restrict_fetch - self.restrict_fetch_satisfied))
2755                 return "".join(myoutput)
2756
2757 class MergeTask(object):
2758
2759         def __init__(self, settings, trees, myopts):
2760                 self.settings = settings
2761                 self.target_root = settings["ROOT"]
2762                 self.trees = trees
2763                 self.myopts = myopts
2764                 self.edebug = 0
2765                 if settings.get("PORTAGE_DEBUG", "") == "1":
2766                         self.edebug = 1
2767                 self.pkgsettings = {}
2768                 self.pkgsettings[self.target_root] = portage.config(clone=settings)
2769                 if self.target_root != "/":
2770                         self.pkgsettings["/"] = \
2771                                 portage.config(clone=trees["/"]["vartree"].settings)
2772
2773         def merge(self, mylist, favorites, mtimedb):
2774                 failed_fetches = []
2775                 mymergelist=[]
2776                 ldpath_mtimes = mtimedb["ldpath"]
2777                 xterm_titles = "notitles" not in self.settings.features
2778
2779                 #check for blocking dependencies
2780                 if "--fetchonly" not in self.myopts and \
2781                         "--buildpkgonly" not in self.myopts:
2782                         for x in mylist:
2783                                 if x[0]=="blocks":
2784                                         print "\n!!! Error: the "+x[2]+" package conflicts with another package;"
2785                                         print   "!!!        the two packages cannot be installed on the same system together."
2786                                         print   "!!!        Please use 'emerge --pretend' to determine blockers."
2787                                         if "--quiet" not in self.myopts:
2788                                                 show_blocker_docs_link()
2789                                         if "--pretend" not in self.myopts:
2790                                                 try:
2791                                                         del mtimedb["resume"]
2792                                                 except KeyError:
2793                                                         pass
2794                                                 sys.exit(1)
2795
2796                 #buildsyspkg: I need mysysdict also on resume (moved from the else block)
2797                 mysysdict = genericdict(getlist(self.settings, "system"))
2798                 if "--resume" in self.myopts:
2799                         # We're resuming.
2800                         print colorize("GOOD", "*** Resuming merge...")
2801                         emergelog(xterm_titles, " *** Resuming merge...")
2802                         mymergelist=mtimedb["resume"]["mergelist"][:]
2803                         if "--skipfirst" in self.myopts and mymergelist:
2804                                 del mtimedb["resume"]["mergelist"][0]
2805                                 del mymergelist[0]
2806                                 mtimedb.commit()
2807                         validate_merge_list(self.trees, mymergelist)
2808                 else:
2809                         myfavs = portage.grabfile(
2810                                 os.path.join(self.target_root, portage.WORLD_FILE))
2811                         myfavdict=genericdict(myfavs)
2812                         for x in range(len(mylist)):
2813                                 if mylist[x][3]!="nomerge":
2814                                         # Add to the mergelist
2815                                         mymergelist.append(mylist[x])
2816                                 else:
2817                                         myfavkey=portage.cpv_getkey(mylist[x][2])
2818                                         if "--onlydeps" in self.myopts:
2819                                                 continue
2820                                         # Add to the world file. Since we won't be able to later.
2821                                         if "--fetchonly" not in self.myopts and \
2822                                                 myfavkey in favorites:
2823                                                 #don't record if already in system profile or already recorded
2824                                                 if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
2825                                                         #we don't have a favorites entry for this package yet; add one
2826                                                         myfavdict[myfavkey]=myfavkey
2827                                                         print ">>> Recording",myfavkey,"in \"world\" favorites file..."
2828                         if not ("--fetchonly" in self.myopts or \
2829                                 "--fetch-all-uri" in self.myopts or \
2830                                 "--pretend" in self.myopts):
2831                                 portage.write_atomic(
2832                                         os.path.join(self.target_root, portage.WORLD_FILE),
2833                                         "\n".join(myfavdict.values()))
2834
2835                         mtimedb["resume"]["mergelist"]=mymergelist[:]
2836                         mtimedb.commit()
2837
2838                 myfeat = self.settings.features[:]
2839                 bad_resume_opts = set(["--ask", "--tree", "--changelog", "--skipfirst",
2840                         "--resume"])
2841                 if "parallel-fetch" in myfeat and \
2842                         not ("--pretend" in self.myopts or \
2843                         "--fetch-all-uri" in self.myopts or \
2844                         "--fetchonly" in self.myopts):
2845                         if "distlocks" not in myfeat:
2846                                 print red("!!!")
2847                                 print red("!!!")+" parallel-fetching requires the distlocks feature enabled"
2848                                 print red("!!!")+" you have it disabled, thus parallel-fetching is being disabled"
2849                                 print red("!!!")
2850                         elif len(mymergelist) > 1:
2851                                 print ">>> starting parallel fetching"
2852                                 fetch_log = "/var/log/emerge-fetch.log"
2853                                 logfile = open(fetch_log, "w")
2854                                 fd_pipes = {1:logfile.fileno(), 2:logfile.fileno()}
2855                                 portage.util.apply_secpass_permissions(fetch_log,
2856                                         uid=portage.portage_uid, gid=portage.portage_gid,
2857                                         mode=0660)
2858                                 fetch_env = os.environ.copy()
2859                                 fetch_env["FEATURES"] = fetch_env.get("FEATURES", "") + " -cvs"
2860                                 fetch_env["PORTAGE_NICENESS"] = "0"
2861                                 fetch_args = [sys.argv[0], "--resume", "--fetchonly"]
2862                                 for myopt, myarg in self.myopts.iteritems():
2863                                         if myopt not in bad_resume_opts:
2864                                                 if myarg is True:
2865                                                         fetch_args.append(myopt)
2866                                                 else:
2867                                                         fetch_args.append(myopt +"="+ myarg)
2868                                 portage.process.spawn(fetch_args, env=fetch_env,
2869                                         fd_pipes=fd_pipes, returnpid=True)
2870                                 logfile.close() # belongs to the spawned process
2871
2872                 mergecount=0
2873                 for x in mymergelist:
2874                         mergecount+=1
2875                         myroot=x[1]
2876                         pkg_key = x[2]
2877                         pkgindex=2
2878                         portdb = self.trees[myroot]["porttree"].dbapi
2879                         bindb  = self.trees[myroot]["bintree"].dbapi
2880                         vartree = self.trees[myroot]["vartree"]
2881                         pkgsettings = self.pkgsettings[myroot]
2882                         if x[0]=="blocks":
2883                                 pkgindex=3
2884                         y = portdb.findname(pkg_key)
2885                         if "--pretend" not in self.myopts:
2886                                 print "\n>>> Emerging (" + \
2887                                         colorize("MERGE_LIST_PROGRESS", str(mergecount)) + " of " + \
2888                                         colorize("MERGE_LIST_PROGRESS", str(len(mymergelist))) + ") " + \
2889                                         colorize("GOOD", x[pkgindex]) + " to " + x[1]
2890                                 emergelog(xterm_titles, " >>> emerge ("+\
2891                                         str(mergecount)+" of "+str(len(mymergelist))+\
2892                                         ") "+x[pkgindex]+" to "+x[1])
2893
2894                         pkgsettings["EMERGE_FROM"] = x[0]
2895                         pkgsettings.backup_changes("EMERGE_FROM")
2896                         pkgsettings.reset()
2897
2898                         #buildsyspkg: Check if we need to _force_ binary package creation
2899                         issyspkg = ("buildsyspkg" in myfeat) \
2900                                         and x[0] != "blocks" \
2901                                         and mysysdict.has_key(portage.cpv_getkey(x[2])) \
2902                                         and "--buildpkg" not in self.myopts
2903                         if x[0] in ["ebuild","blocks"]:
2904                                 if x[0] == "blocks" and "--fetchonly" not in self.myopts:
2905                                         raise Exception, "Merging a blocker"
2906                                 elif "--fetchonly" in self.myopts or \
2907                                         "--fetch-all-uri" in self.myopts:
2908                                         if "--fetch-all-uri" in self.myopts:
2909                                                 retval = portage.doebuild(y, "fetch", myroot,
2910                                                         pkgsettings, self.edebug,
2911                                                         "--pretend" in self.myopts, fetchonly=1,
2912                                                         fetchall=1, mydbapi=portdb, tree="porttree")
2913                                         else:
2914                                                 retval = portage.doebuild(y, "fetch", myroot,
2915                                                         pkgsettings, self.edebug,
2916                                                         "--pretend" in self.myopts, fetchonly=1,
2917                                                         mydbapi=portdb, tree="porttree")
2918                                         if (retval is None) or retval:
2919                                                 print
2920                                                 print "!!! Fetch for",y,"failed, continuing..."
2921                                                 print
2922                                                 failed_fetches.append(pkg_key)
2923                                         continue
2924
2925                                 portage.doebuild_environment(y, "setup", myroot,
2926                                         pkgsettings, self.edebug, 1, portdb)
2927                                 catdir = os.path.dirname(pkgsettings["PORTAGE_BUILDDIR"])
2928                                 portage.util.ensure_dirs(os.path.dirname(catdir),
2929                                         uid=portage.portage_uid, gid=portage.portage_gid,
2930                                         mode=070, mask=0)
2931                                 builddir_lock = None
2932                                 catdir_lock = None
2933                                 try:
2934                                         catdir_lock = portage.locks.lockdir(catdir)
2935                                         portage.util.ensure_dirs(catdir,
2936                                                 uid=portage.portage_uid, gid=portage.portage_gid,
2937                                                 mode=070, mask=0)
2938                                         builddir_lock = portage.locks.lockdir(
2939                                                 pkgsettings["PORTAGE_BUILDDIR"])
2940                                         try:
2941                                                 portage.locks.unlockdir(catdir_lock)
2942                                         finally:
2943                                                 catdir_lock = None
2944                                         msg = " === (%s of %s) Cleaning (%s::%s)" % \
2945                                                 (mergecount, len(mymergelist), pkg_key, y)
2946                                         short_msg = "emerge: (%s of %s) %s Clean" % \
2947                                                 (mergecount, len(mymergelist), pkg_key)
2948                                         emergelog(xterm_titles, msg, short_msg=short_msg)
2949                                         retval = portage.doebuild(y, "clean", myroot,
2950                                                 pkgsettings, self.edebug, cleanup=1,
2951                                                 mydbapi=portdb, tree="porttree")
2952                                         if retval != os.EX_OK:
2953                                                 return retval
2954                                         if "--buildpkg" in self.myopts or issyspkg:
2955                                                 if issyspkg:
2956                                                         print ">>> This is a system package, " + \
2957                                                                 "let's pack a rescue tarball."
2958                                                 msg = " === (%s of %s) Compiling/Packaging (%s::%s)" % \
2959                                                         (mergecount, len(mymergelist), pkg_key, y)
2960                                                 short_msg = "emerge: (%s of %s) %s Compile" % \
2961                                                         (mergecount, len(mymergelist), pkg_key)
2962                                                 emergelog(xterm_titles, msg, short_msg=short_msg)
2963                                                 self.trees[myroot]["bintree"].prevent_collision(pkg_key)
2964                                                 retval = portage.doebuild(y, "package", myroot,
2965                                                         pkgsettings, self.edebug, mydbapi=portdb,
2966                                                         tree="porttree")
2967                                                 if retval != os.EX_OK:
2968                                                         return retval
2969                                                 if "--buildpkgonly" not in self.myopts:
2970                                                         bintree = self.trees[myroot]["bintree"]
2971                                                         bintree.inject(pkg_key)
2972                                                         mytbz2 = bintree.getname(pkg_key)
2973                                                         msg = " === (%s of %s) Merging (%s::%s)" % \
2974                                                                 (mergecount, len(mymergelist), pkg_key, y)
2975                                                         short_msg = "emerge: (%s of %s) %s Merge" % \
2976                                                                 (mergecount, len(mymergelist), pkg_key)
2977                                                         emergelog(xterm_titles, msg, short_msg=short_msg)
2978                                                         retval = portage.merge(pkgsettings["CATEGORY"],
2979                                                                 pkgsettings["PF"], pkgsettings["D"],
2980                                                                 os.path.join(pkgsettings["PORTAGE_BUILDDIR"],
2981                                                                 "build-info"), myroot, pkgsettings,
2982                                                                 myebuild=pkgsettings["EBUILD"],
2983                                                                 mytree="porttree", mydbapi=portdb,
2984                                                                 vartree=vartree, prev_mtimes=ldpath_mtimes)
2985                                                         if retval != os.EX_OK:
2986                                                                 return retval
2987                                                 elif "noclean" not in pkgsettings.features:
2988                                                         portage.doebuild(y, "clean", myroot,
2989                                                                 pkgsettings, self.edebug, mydbapi=portdb,
2990                                                                 tree="porttree")
2991                                         else:
2992                                                 msg = " === (%s of %s) Compiling/Merging (%s::%s)" % \
2993                                                         (mergecount, len(mymergelist), pkg_key, y)
2994                                                 short_msg = "emerge: (%s of %s) %s Compile" % \
2995                                                         (mergecount, len(mymergelist), pkg_key)
2996                                                 emergelog(xterm_titles, msg, short_msg=short_msg)
2997                                                 retval = portage.doebuild(y, "merge", myroot,
2998                                                         pkgsettings, self.edebug, vartree=vartree,
2999                                                         mydbapi=portdb, tree="porttree",
3000                                                         prev_mtimes=ldpath_mtimes)
3001                                                 if retval != os.EX_OK:
3002                                                         return retval
3003                                 finally:
3004                                         if builddir_lock:
3005                                                 portage.locks.unlockdir(builddir_lock)
3006                                         try:
3007                                                 if not catdir_lock:
3008                                                         # Lock catdir for removal if empty.
3009                                                         catdir_lock = portage.locks.lockdir(catdir)
3010                                         finally:
3011                                                 if catdir_lock:
3012                                                         try:
3013                                                                 os.rmdir(catdir)
3014                                                         except OSError, e:
3015                                                                 if e.errno not in (errno.ENOENT,
3016                                                                         errno.ENOTEMPTY, errno.EEXIST):
3017                                                                         raise
3018                                                                 del e
3019                                                         portage.locks.unlockdir(catdir_lock)
3020
3021                         elif x[0]=="binary":
3022                                 #merge the tbz2
3023                                 mytbz2 = self.trees[myroot]["bintree"].getname(pkg_key)
3024                                 if "--getbinpkg" in self.myopts:
3025                                         tbz2_lock = None
3026                                         try:
3027                                                 if "distlocks" in pkgsettings.features and \
3028                                                         os.access(pkgsettings["PKGDIR"], os.W_OK):
3029                                                         portage.util.ensure_dirs(os.path.dirname(mytbz2))
3030                                                         tbz2_lock = portage.locks.lockfile(mytbz2,
3031                                                                 wantnewlockfile=1)
3032                                                 if self.trees[myroot]["bintree"].isremote(pkg_key):
3033                                                         msg = " --- (%s of %s) Fetching Binary (%s::%s)" %\
3034                                                                 (mergecount, len(mymergelist), pkg_key, mytbz2)
3035                                                         short_msg = "emerge: (%s of %s) %s Fetch" % \
3036                                                                 (mergecount, len(mymergelist), pkg_key)
3037                                                         emergelog(xterm_titles, msg, short_msg=short_msg)
3038                                                         if not self.trees[myroot]["bintree"].gettbz2(
3039                                                                 pkg_key):
3040                                                                 return 1
3041                                         finally:
3042                                                 if tbz2_lock:
3043                                                         portage.locks.unlockfile(tbz2_lock)
3044
3045                                 if "--fetchonly" in self.myopts or \
3046                                         "--fetch-all-uri" in self.myopts:
3047                                         continue
3048
3049                                 short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Merge Binary"
3050                                 emergelog(xterm_titles, " === ("+str(mergecount)+\
3051                                         " of "+str(len(mymergelist))+") Merging Binary ("+\
3052                                         x[pkgindex]+"::"+mytbz2+")", short_msg=short_msg)
3053                                 retval = portage.pkgmerge(mytbz2, x[1], pkgsettings,
3054                                         mydbapi=bindb,
3055                                         vartree=self.trees[myroot]["vartree"],
3056                                         prev_mtimes=ldpath_mtimes)
3057                                 if retval != os.EX_OK:
3058                                         return retval
3059                                 #need to check for errors
3060                         if "--buildpkgonly" not in self.myopts:
3061                                 self.trees[x[1]]["vartree"].inject(x[2])
3062                                 myfavkey=portage.cpv_getkey(x[2])
3063                                 if "--fetchonly" not in self.myopts and \
3064                                         "--fetch-all-uri" not in self.myopts and \
3065                                         myfavkey in favorites:
3066                                         myfavs = portage.grabfile(os.path.join(myroot, portage.WORLD_FILE))
3067                                         myfavdict=genericdict(myfavs)
3068                                         #don't record if already in system profile or already recorded
3069                                         if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
3070                                                 #we don't have a favorites entry for this package yet; add one
3071                                                 myfavdict[myfavkey]=myfavkey
3072                                                 print ">>> Recording",myfavkey,"in \"world\" favorites file..."
3073                                                 emergelog(xterm_titles, " === ("+\
3074                                                         str(mergecount)+" of "+\
3075                                                         str(len(mymergelist))+\
3076                                                         ") Updating world file ("+x[pkgindex]+")")
3077                                                 portage.write_atomic(
3078                                                 os.path.join(myroot, portage.WORLD_FILE),
3079                                                 "\n".join(myfavdict.values()))
3080
3081                                 if "--pretend" not in self.myopts and \
3082                                         "--fetchonly" not in self.myopts and \
3083                                         "--fetch-all-uri" not in self.myopts:
3084                                         # Clean the old package that we have merged over top of it.
3085                                         if pkgsettings.get("AUTOCLEAN", "yes") == "yes":
3086                                                 xsplit=portage.pkgsplit(x[2])
3087                                                 emergelog(xterm_titles, " >>> AUTOCLEAN: " + xsplit[0])
3088                                                 retval = unmerge(pkgsettings, self.myopts, vartree,
3089                                                         "clean", [xsplit[0]], ldpath_mtimes, autoclean=1)
3090                                                 if not retval:
3091                                                         emergelog(xterm_titles,
3092                                                                 " --- AUTOCLEAN: Nothing unmerged.")
3093                                         else:
3094                                                 portage.writemsg_stdout(colorize("WARN", "WARNING:")
3095                                                         + " AUTOCLEAN is disabled.  This can cause serious"
3096                                                         + " problems due to overlapping packages.\n")
3097
3098                                         # Figure out if we need a restart.
3099                                         mysplit=portage.pkgsplit(x[2])
3100                                         if mysplit[0] == "sys-apps/portage" and x[1] == "/":
3101                                                 myver=mysplit[1]+"-"+mysplit[2]
3102                                                 if myver[-3:]=='-r0':
3103                                                         myver=myver[:-3]
3104                                                 if (myver != portage.VERSION) and \
3105                                                    "livecvsportage" not in self.settings.features:
3106                                                         if len(mymergelist) > mergecount:
3107                                                                 emergelog(xterm_titles,
3108                                                                         " ::: completed emerge ("+ \
3109                                                                         str(mergecount)+" of "+ \
3110                                                                         str(len(mymergelist))+") "+ \
3111                                                                         x[2]+" to "+x[1])
3112                                                                 emergelog(xterm_titles, " *** RESTARTING " + \
3113                                                                         "emerge via exec() after change of " + \
3114                                                                         "portage version.")
3115                                                                 del mtimedb["resume"]["mergelist"][0]
3116                                                                 mtimedb.commit()
3117                                                                 portage.run_exitfuncs()
3118                                                                 mynewargv=[sys.argv[0],"--resume"]
3119                                                                 for myopt, myarg in self.myopts.iteritems():
3120                                                                         if myopt not in bad_resume_opts:
3121                                                                                 if myarg is True:
3122                                                                                         mynewargv.append(myopt)
3123                                                                                 else:
3124                                                                                         mynewargv.append(myopt +"="+ myarg)
3125                                                                 # priority only needs to be adjusted on the first run
3126                                                                 os.environ["PORTAGE_NICENESS"] = "0"
3127                                                                 os.execv(mynewargv[0], mynewargv)
3128
3129                         if "--pretend" not in self.myopts and \
3130                                 "--fetchonly" not in self.myopts and \
3131                                 "--fetch-all-uri" not in self.myopts:
3132                                 if "noclean" not in self.settings.features:
3133                                         short_msg = "emerge: (%s of %s) %s Clean Post" % \
3134                                                 (mergecount, len(mymergelist), x[pkgindex])
3135                                         emergelog(xterm_titles, (" === (%s of %s) " + \
3136                                                 "Post-Build Cleaning (%s::%s)") % \
3137                                                 (mergecount, len(mymergelist), x[pkgindex], y),
3138                                                 short_msg=short_msg)
3139                                 emergelog(xterm_titles, " ::: completed emerge ("+\
3140                                         str(mergecount)+" of "+str(len(mymergelist))+") "+\
3141                                         x[2]+" to "+x[1])
3142
3143                         # Unsafe for parallel merges
3144                         del mtimedb["resume"]["mergelist"][0]
3145                         # Commit after each merge so that --resume may still work in
3146                         # in the event that portage is not allowed to exit normally
3147                         # due to power failure, SIGKILL, etc...
3148                         mtimedb.commit()
3149
3150                 if "--pretend" not in self.myopts:
3151                         emergelog(xterm_titles, " *** Finished. Cleaning up...")
3152
3153                 # We're out of the loop... We're done. Delete the resume data.
3154                 if mtimedb.has_key("resume"):
3155                         del mtimedb["resume"]
3156                 mtimedb.commit()
3157
3158                 #by doing an exit this way, --fetchonly can continue to try to
3159                 #fetch everything even if a particular download fails.
3160                 if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:
3161                         if failed_fetches:
3162                                 sys.stderr.write("\n\n!!! Some fetch errors were " + \
3163                                         "encountered.  Please see above for details.\n\n")
3164                                 for cpv in failed_fetches:
3165                                         sys.stderr.write("   ")
3166                                         sys.stderr.write(cpv)
3167                                         sys.stderr.write("\n")
3168                                 sys.stderr.write("\n")
3169                                 sys.exit(1)
3170                         else:
3171                                 sys.exit(0)
3172                 return os.EX_OK
3173
3174 def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
3175         ldpath_mtimes, autoclean=0):
3176         candidate_catpkgs=[]
3177         global_unmerge=0
3178         xterm_titles = "notitles" not in settings.features
3179
3180         vdb_path = os.path.join(settings["ROOT"], portage.VDB_PATH)
3181         try:
3182                 # At least the parent needs to exist for the lock file.
3183                 portage.util.ensure_dirs(vdb_path)
3184         except portage.exception.PortageException:
3185                 pass
3186         vdb_lock = None
3187         try:
3188                 if os.access(vdb_path, os.W_OK):
3189                         vdb_lock = portage.locks.lockdir(vdb_path)
3190                 realsyslist = getlist(settings, "system")
3191                 syslist = []
3192                 for x in realsyslist:
3193                         mycp = portage.dep_getkey(x)
3194                         if mycp in settings.getvirtuals():
3195                                 providers = []
3196                                 for provider in settings.getvirtuals()[mycp]:
3197                                         if vartree.dbapi.match(provider):
3198                                                 providers.append(provider)
3199                                 if len(providers) == 1:
3200                                         syslist.extend(providers)
3201                         else:
3202                                 syslist.append(mycp)
3203
3204                 mysettings = portage.config(clone=settings)
3205
3206                 if not unmerge_files or "world" in unmerge_files or \
3207                         "system" in unmerge_files:
3208                         if "unmerge"==unmerge_action:
3209                                 print
3210                                 print bold("emerge unmerge") + " can only be used with " + \
3211                                         "specific package names, not with "+bold("world")+" or"
3212                                 print bold("system")+" targets."
3213                                 print
3214                                 return 0
3215                         else:
3216                                 global_unmerge = 1
3217
3218                 localtree = vartree
3219                 # process all arguments and add all
3220                 # valid db entries to candidate_catpkgs
3221                 if global_unmerge:
3222                         if not unmerge_files or "world" in unmerge_files:
3223                                 candidate_catpkgs.extend(vartree.dbapi.cp_all())
3224                         elif "system" in unmerge_files:
3225                                 candidate_catpkgs.extend(getlist(settings, "system"))
3226                 else:
3227                         #we've got command-line arguments
3228                         if not unmerge_files:
3229                                 print "\nNo packages to unmerge have been provided.\n"
3230                                 return 0
3231                         for x in unmerge_files:
3232                                 arg_parts = x.split('/')
3233                                 if x[0] not in [".","/"] and \
3234                                         arg_parts[-1][-7:] != ".ebuild":
3235                                         #possible cat/pkg or dep; treat as such
3236                                         candidate_catpkgs.append(x)
3237                                 elif unmerge_action in ["prune","clean"]:
3238                                         print "\n!!! Prune and clean do not accept individual" + \
3239                                                 " ebuilds as arguments;\n    skipping.\n"
3240                                         continue
3241                                 else:
3242                                         # it appears that the user is specifying an installed
3243                                         # ebuild and we're in "unmerge" mode, so it's ok.
3244                                         if not os.path.exists(x):
3245                                                 print "\n!!! The path '"+x+"' doesn't exist.\n"
3246                                                 return 0
3247
3248                                         absx   = os.path.abspath(x)
3249                                         sp_absx = absx.split("/")
3250                                         if sp_absx[-1][-7:] == ".ebuild":
3251                                                 del sp_absx[-1]
3252                                                 absx = "/".join(sp_absx)
3253
3254                                         sp_absx_len = len(sp_absx)
3255
3256                                         vdb_path = os.path.join(settings["ROOT"], portage.VDB_PATH)
3257                                         vdb_len  = len(vdb_path)
3258
3259                                         sp_vdb     = vdb_path.split("/")
3260                                         sp_vdb_len = len(sp_vdb)
3261
3262                                         if not os.path.exists(absx+"/CONTENTS"):
3263                                                 print "!!! Not a valid db dir: "+str(absx)
3264                                                 return 0
3265
3266                                         if sp_absx_len <= sp_vdb_len:
3267                                                 # The Path is shorter... so it can't be inside the vdb.
3268                                                 print sp_absx
3269                                                 print absx
3270                                                 print "\n!!!",x,"cannot be inside "+ \
3271                                                         vdb_path+"; aborting.\n"
3272                                                 return 0
3273
3274                                         for idx in range(0,sp_vdb_len):
3275                                                 if idx >= sp_absx_len or sp_vdb[idx] != sp_absx[idx]:
3276                                                         print sp_absx
3277                                                         print absx
3278                                                         print "\n!!!", x, "is not inside "+\
3279                                                                 vdb_path+"; aborting.\n"
3280                                                         return 0
3281
3282                                         print "="+"/".join(sp_absx[sp_vdb_len:])
3283                                         candidate_catpkgs.append(
3284                                                 "="+"/".join(sp_absx[sp_vdb_len:]))
3285
3286                 newline=""
3287                 if (not "--quiet" in myopts):
3288                         newline="\n"
3289                 if settings["ROOT"] != "/":
3290                         print darkgreen(newline+ \
3291                                 ">>> Using system located in ROOT tree "+settings["ROOT"])
3292                 if (("--pretend" in myopts) or ("--ask" in myopts)) and \
3293                         not ("--quiet" in myopts):
3294                         print darkgreen(newline+\
3295                                 ">>> These are the packages that would be unmerged:")
3296
3297                 pkgmap={}
3298                 numselected=0
3299                 for x in candidate_catpkgs:
3300                         # cycle through all our candidate deps and determine
3301                         # what will and will not get unmerged
3302                         try:
3303                                 mymatch=localtree.dep_match(x)
3304                         except KeyError:
3305                                 mymatch=None
3306                         except ValueError, errpkgs:
3307                                 print "\n\n!!! The short ebuild name \"" + \
3308                                         x + "\" is ambiguous.  Please specify"
3309                                 print "!!! one of the following fully-qualified " + \
3310                                         "ebuild names instead:\n"
3311                                 for i in errpkgs[0]:
3312                                         print "    " + green(i)
3313                                 print
3314                                 sys.exit(1)
3315
3316                         if not mymatch and x[0] not in "<>=~":
3317                                 #add a "=" if missing
3318                                 mymatch=localtree.dep_match("="+x)
3319                         if not mymatch:
3320                                 portage.writemsg("\n--- Couldn't find '%s' to %s.\n" % \
3321                                         (x, unmerge_action), noiselevel=-1)
3322                                 continue
3323                         mykey = portage.key_expand(
3324                                 portage.dep_getkey(
3325                                         mymatch[0]), mydb=vartree.dbapi, settings=settings)
3326                         if not pkgmap.has_key(mykey):
3327                                 pkgmap[mykey]={"protected":[], "selected":[], "omitted":[] }
3328                         if unmerge_action=="unmerge":
3329                                         for y in mymatch:
3330                                                 if y not in pkgmap[mykey]["selected"]:
3331                                                         pkgmap[mykey]["selected"].append(y)
3332                                                         numselected=numselected+len(mymatch)
3333
3334                         else:
3335                                 #unmerge_action in ["prune", clean"]
3336                                 slotmap={}
3337                                 for mypkg in mymatch:
3338                                         if unmerge_action=="clean":
3339                                                 myslot=localtree.getslot(mypkg)
3340                                         else:
3341                                                 # since we're pruning, we don't care about slots
3342                                                 # and put all the pkgs in together
3343                                                 myslot=0
3344                                         if not slotmap.has_key(myslot):
3345                                                 slotmap[myslot]={}
3346                                         slotmap[myslot][localtree.dbapi.cpv_counter(mypkg)]=mypkg
3347                                 for myslot in slotmap.keys():
3348                                         counterkeys=slotmap[myslot].keys()
3349                                         counterkeys.sort()
3350                                         if not counterkeys:
3351                                                 continue
3352                                         counterkeys.sort()
3353                                         pkgmap[mykey]["protected"].append(
3354                                                 slotmap[myslot][counterkeys[-1]])
3355                                         del counterkeys[-1]
3356                                         #be pretty and get them in order of merge:
3357                                         for ckey in counterkeys:
3358                                                 pkgmap[mykey]["selected"].append(slotmap[myslot][ckey])
3359                                                 numselected=numselected+1
3360                                         # ok, now the last-merged package
3361                                         # is protected, and the rest are selected
3362                 if global_unmerge and not numselected:
3363                         print "\n>>> No outdated packages were found on your system.\n"
3364                         return 0
3365
3366                 if not numselected:
3367                         portage.writemsg_stdout(
3368                                 "\n>>> No packages selected for removal by " + \
3369                                 unmerge_action + "\n")
3370                         return 0
3371         finally:
3372                 if vdb_lock:
3373                         portage.locks.unlockdir(vdb_lock)
3374         for x in pkgmap.keys():
3375                 for y in localtree.dep_match(x):
3376                         if y not in pkgmap[x]["omitted"] and \
3377                            y not in pkgmap[x]["selected"] and \
3378                            y not in pkgmap[x]["protected"]:
3379                                 pkgmap[x]["omitted"].append(y)
3380                 if global_unmerge and not pkgmap[x]["selected"]:
3381                         #avoid cluttering the preview printout with stuff that isn't getting unmerged
3382                         continue
3383                 if not (pkgmap[x]["protected"] or pkgmap[x]["omitted"]) and (x in syslist):
3384                         print colorize("BAD","\a\n\n!!! '%s' is part of your system profile." % x)
3385                         print colorize("WARN","\a!!! Unmerging it may be damaging to your system.\n")
3386                         if "--pretend" not in myopts and "--ask" not in myopts:
3387                                 countdown(int(settings["EMERGE_WARNING_DELAY"]),
3388                                         colorize("UNMERGE_WARN", "Press Ctrl-C to Stop"))
3389                 print "\n "+white(x)
3390                 for mytype in ["selected","protected","omitted"]:
3391                         portage.writemsg_stdout((mytype + ": ").rjust(14), noiselevel=-1)
3392                         if pkgmap[x][mytype]:
3393                                 for mypkg in pkgmap[x][mytype]:
3394                                         mysplit=portage.catpkgsplit(mypkg)
3395                                         if mysplit[3]=="r0":
3396                                                 myversion=mysplit[2]
3397                                         else:
3398                                                 myversion=mysplit[2]+"-"+mysplit[3]
3399                                         if mytype=="selected":
3400                                                 portage.writemsg_stdout(
3401                                                         colorize("UNMERGE_WARN", myversion + " "), noiselevel=-1)
3402                                         else:
3403                                                 portage.writemsg_stdout(
3404                                                         colorize("GOOD", myversion + " "), noiselevel=-1)
3405                         else:
3406                                 portage.writemsg_stdout("none", noiselevel=-1)
3407                         portage.writemsg_stdout("\n", noiselevel=-1)
3408
3409         portage.writemsg_stdout("\n>>> " + colorize("UNMERGE_WARN", "'Selected'") + \
3410                 " packages are slated for removal.\n")
3411         portage.writemsg_stdout(">>> " + colorize("GOOD", "'Protected'") + \
3412                         " and " + colorize("GOOD", "'omitted'") + \
3413                         " packages will not be removed.\n\n")
3414
3415         if "--pretend" in myopts:
3416                 #we're done... return
3417                 return 0
3418         if "--ask" in myopts:
3419                 if userquery("Would you like to unmerge these packages?")=="No":
3420                         # enter pretend mode for correct formatting of results
3421                         myopts["--pretend"] = True
3422                         print
3423                         print "Quitting."
3424                         print
3425                         return 0
3426         #the real unmerging begins, after a short delay....
3427         if not autoclean:
3428                 countdown(int(settings["CLEAN_DELAY"]), ">>> Unmerging")
3429
3430         for x in pkgmap.keys():
3431                 for y in pkgmap[x]["selected"]:
3432                         print ">>> Unmerging "+y+"..."
3433                         emergelog(xterm_titles, "=== Unmerging... ("+y+")")
3434                         mysplit=y.split("/")
3435                         #unmerge...
3436                         retval = portage.unmerge(mysplit[0], mysplit[1], settings["ROOT"],
3437                                 mysettings, unmerge_action not in ["clean","prune"],
3438                                 vartree=vartree, ldpath_mtimes=ldpath_mtimes)
3439                         if retval != os.EX_OK:
3440                                 emergelog(xterm_titles, " !!! unmerge FAILURE: "+y)
3441                                 ebuild = vartree.dbapi.findname(y)
3442                                 show_unmerge_failure_message(y, ebuild, retval)
3443                                 sys.exit(retval)
3444                         else:
3445                                 clean_world(vartree.dbapi, y)
3446                                 emergelog(xterm_titles, " >>> unmerge success: "+y)
3447         return 1
3448
3449 def show_unmerge_failure_message(pkg, ebuild, retval):
3450
3451         from formatter import AbstractFormatter, DumbWriter
3452         f = AbstractFormatter(DumbWriter(sys.stderr, maxcol=72))
3453
3454         msg = []
3455         msg.append("A removal phase of the '%s' package " % pkg)
3456         msg.append("has failed with exit value %s.  " % retval)
3457         msg.append("The problem occurred while executing ")
3458         msg.append("the ebuild located at '%s'.  " % ebuild)
3459         msg.append("If necessary, manually remove the ebuild " )
3460         msg.append("in order to skip the execution of removal phases.")
3461
3462         f.end_paragraph(1)
3463         for x in msg:
3464                 f.add_flowing_data(x)
3465         f.end_paragraph(1)
3466         f.writer.flush()
3467
3468 def chk_updated_info_files(root, infodirs, prev_mtimes, retval):
3469
3470         print
3471         if os.path.exists("/usr/bin/install-info"):
3472                 regen_infodirs=[]
3473                 for z in infodirs:
3474                         if z=='':
3475                                 continue
3476                         inforoot=normpath(root+z)
3477                         if os.path.isdir(inforoot):
3478                                 infomtime = long(os.stat(inforoot).st_mtime)
3479                                 if inforoot not in prev_mtimes or \
3480                                         prev_mtimes[inforoot] != infomtime:
3481                                                 regen_infodirs.append(inforoot)
3482
3483                 if not regen_infodirs:
3484                         print " "+green("*")+" GNU info directory index is up-to-date."
3485                 else:
3486                         print " "+green("*")+" Regenerating GNU info directory index..."
3487
3488                         icount=0
3489                         badcount=0
3490                         for inforoot in regen_infodirs:
3491                                 if inforoot=='':
3492                                         continue
3493                                 for filename in ("dir", "dir.gz", "dir.bz2"):
3494                                         file_path = os.path.join(inforoot, filename)
3495                                         try:
3496                                                 os.rename(file_path, file_path + ".old")
3497                                         except OSError, e:
3498                                                 if e.errno != errno.ENOENT:
3499                                                         raise
3500                                                 del e
3501
3502                                 if not os.path.isdir(inforoot):
3503                                         continue
3504                                 errmsg = ""
3505                                 file_list = os.listdir(inforoot)
3506                                 file_list.sort()
3507                                 for x in file_list:
3508                                         if (x[0] == ".") or (x in ["dir","dir.old"]) or (os.path.isdir(inforoot+"/"+x)):
3509                                                 continue
3510                                         myso=commands.getstatusoutput("LANG=C LANGUAGE=C /usr/bin/install-info --dir-file="+inforoot+"/dir "+inforoot+"/"+x)[1]
3511                                         existsstr="already exists, for file `"
3512                                         if myso!="":
3513                                                 if re.search(existsstr,myso):
3514                                                         # Already exists... Don't increment the count for this.
3515                                                         pass
3516                                                 elif myso[:44]=="install-info: warning: no info dir entry in ":
3517                                                         # This info file doesn't contain a DIR-header: install-info produces this
3518                                                         # (harmless) warning (the --quiet switch doesn't seem to work).
3519                                                         # Don't increment the count for this.
3520                                                         pass
3521                                                 else:
3522                                                         badcount=badcount+1
3523                                                         errmsg += myso + "\n"
3524                                         icount=icount+1
3525
3526                                 #update mtime so we can potentially avoid regenerating.
3527                                 prev_mtimes[inforoot] = long(os.stat(inforoot).st_mtime)
3528
3529                         if badcount:
3530                                 print " "+yellow("*")+" Processed",icount,"info files;",badcount,"errors."
3531                                 print errmsg
3532                         else:
3533                                 print " "+green("*")+" Processed",icount,"info files."
3534
3535
3536 def post_emerge(settings, mtimedb, retval):
3537         """
3538         Misc. things to run at the end of a merge session.
3539
3540         Update Info Files
3541         Update Config Files
3542         Update News Items
3543         Commit mtimeDB
3544         Exit Emerge
3545
3546         @param settings: Configuration settings (typically portage.settings)
3547         @type settings: portage.config()
3548         @param mtimedb: The mtimeDB to store data needed across merge invocations
3549         @type mtimedb: MtimeDB class instance
3550         @param retval: Emerge's return value
3551         @type retval: Int
3552         @rype: None
3553         @returns:
3554         1.  Calls sys.exit(retval)
3555         """
3556         target_root = settings["ROOT"]
3557         info_mtimes = mtimedb["info"]
3558
3559         # Load the most current variables from ${ROOT}/etc/profile.env
3560         settings.unlock()
3561         settings.regenerate()
3562         settings.lock()
3563
3564         config_protect = settings.get("CONFIG_PROTECT","").split()
3565         infodirs = settings.get("INFOPATH","").split(":") + \
3566                 settings.get("INFODIR","").split(":")
3567
3568         os.chdir("/")
3569
3570         emergelog("notitles" not in settings.features,
3571                 " *** exiting successfully.")
3572
3573         if "noinfo" not in settings.features:
3574                 chk_updated_info_files(target_root, infodirs, info_mtimes, retval)
3575
3576         chk_updated_cfg_files(target_root, config_protect)
3577
3578         NEWS_PATH = os.path.join( "metadata", "news" )
3579         UNREAD_PATH = os.path.join( target_root, NEWS_LIB_PATH, 'news')
3580         porttree = portdbapi( porttree_root = settings["PORTDIR"], mysettings = settings )
3581         newsReaderDisplay = False
3582
3583         for repo in porttree.getRepositories():
3584                 unreadItems = checkUpdatedNewsItems(target_root, NEWS_PATH, UNREAD_PATH, repo)
3585                 if unreadItems:
3586                         print colorize("WARN", " * IMPORTANT:"),
3587                         print "%s news items need reading for repository '%s'." % (unreadItems, repo)
3588                         newsReaderDisplay = True
3589
3590         if newsReaderDisplay:
3591                 print colorize("WARN", " *"),
3592                 print "Use " + colorize("GOOD", "eselect news") + " to read news items."
3593
3594         mtimedb.commit()
3595         sys.exit(retval)
3596
3597
3598 def chk_updated_cfg_files(target_root, config_protect):
3599         if config_protect:
3600                 #number of directories with some protect files in them
3601                 procount=0
3602                 for x in config_protect:
3603                         x = os.path.join(target_root, x.lstrip(os.path.sep))
3604                         try:
3605                                 mymode = os.lstat(x).st_mode
3606                         except OSError:
3607                                 continue
3608                         if stat.S_ISDIR(mymode):
3609                                 mycommand = "cd '%s'; find . -iname '._cfg????_*'" % x
3610                         else:
3611                                 mycommand = "cd '%s'; find . -maxdepth 1 -iname '._cfg????_%s'" % \
3612                                         os.path.split(x.rstrip(os.path.sep))
3613                         a = commands.getstatusoutput(mycommand + \
3614                                 " ! -iname '.*~' ! -iname '.*.bak'")
3615                         if a[0] != 0:
3616                                 print >> sys.stderr, " " + bad("*")+ " error scanning '%s'" % x
3617                         else:
3618                                 files = a[1].split()
3619                                 if files:
3620                                         procount += 1
3621                                         print colorize("WARN", " * IMPORTANT:"),
3622                                         if stat.S_ISDIR(mymode):
3623                                                  print "%d config files in '%s' need updating." % \
3624                                                         (len(files), x)
3625                                         else:
3626                                                  print "config file '%s' needs updating." % x
3627
3628                 if procount:
3629                         #print " "+yellow("*")+" Type "+green("emerge --help config")+" to learn how to update config files."
3630                         print " "+yellow("*")+" Type "+green("emerge --help config")+" to learn how to update config files."
3631
3632 def checkUpdatedNewsItems( root, NEWS_PATH, UNREAD_PATH, repo_id ):
3633         """
3634         Examines news items in repodir + '/' + NEWS_PATH and attempts to find unread items
3635         Returns the number of unread (yet relevent) items.
3636
3637         @param root:
3638         @type root:
3639         @param NEWS_PATH:
3640         @type NEWS_PATH:
3641         @param UNREAD_PATH:
3642         @type UNREAD_PATH:
3643         @param repo_id:
3644         @type repo_id:
3645         @rtype: Integer
3646         @returns:
3647         1.  The number of unread but relevant news items.
3648
3649         """
3650         from portage.news import NewsManager
3651         manager = NewsManager( root, NEWS_PATH, UNREAD_PATH )
3652         return manager.getUnreadItems( repo_id, update=True )
3653
3654 def is_valid_package_atom(x):
3655         try:
3656                 testkey = portage.dep_getkey(x)
3657         except portage.exception.InvalidData:
3658                 return False
3659         if testkey.startswith("null/"):
3660                 testatom = x.replace(testkey[5:], "cat/"+testkey[5:])
3661         elif "/" not in x:
3662                 testatom = "cat/"+x
3663         else:
3664                 testatom = x
3665         return portage.isvalidatom(testatom)
3666
3667 def validate_merge_list(trees, mergelist):
3668         """Validate the list to make sure all the packages are still available.
3669         This is needed for --resume."""
3670         for (pkg_type, myroot, pkg_key, action) in mergelist:
3671                 if pkg_type == "binary" and \
3672                         not trees[myroot]["bintree"].dbapi.match("="+pkg_key) or \
3673                         pkg_type == "ebuild" and \
3674                         not trees[myroot]["porttree"].dbapi.xmatch(
3675                         "match-all", "="+pkg_key):
3676                         print red("!!! Error: The resume list contains packages that are no longer")
3677                         print red("!!!        available to be emerged. Please restart/continue")
3678                         print red("!!!        the merge operation manually.")
3679                         sys.exit(1)
3680
3681 def show_blocker_docs_link():
3682         print
3683         print "For more information about " + bad("Blocked Packages") + ", please refer to the following"
3684         print "section of the Gentoo Linux x86 Handbook (architecture is irrelevant):"
3685         print
3686         print "http://www.gentoo.org/doc/en/handbook/handbook-x86.xml?full=1#blocked"
3687         print
3688
3689 def action_sync(settings, trees, mtimedb, myopts, myaction):
3690         xterm_titles = "notitles" not in settings.features
3691         emergelog(xterm_titles, " === sync")
3692         myportdir = settings.get("PORTDIR", None)
3693         if not myportdir:
3694                 sys.stderr.write("!!! PORTDIR is undefined.  Is /etc/make.globals missing?\n")
3695                 sys.exit(1)
3696         if myportdir[-1]=="/":
3697                 myportdir=myportdir[:-1]
3698         if not os.path.exists(myportdir):
3699                 print ">>>",myportdir,"not found, creating it."
3700                 os.makedirs(myportdir,0755)
3701         syncuri=settings["SYNC"].rstrip()
3702         os.umask(0022)
3703         updatecache_flg = False
3704         if myaction == "metadata":
3705                 print "skipping sync"
3706                 updatecache_flg = True
3707                 tmpservertimestampfile = None
3708         elif syncuri[:8]=="rsync://":
3709                 if not os.path.exists("/usr/bin/rsync"):
3710                         print "!!! /usr/bin/rsync does not exist, so rsync support is disabled."
3711                         print "!!! Type \"emerge net-misc/rsync\" to enable rsync support."
3712                         sys.exit(1)
3713                 mytimeout=180
3714
3715                 rsync_opts = []
3716
3717                 if settings["PORTAGE_RSYNC_OPTS"] == "":
3718                         portage.writemsg("PORTAGE_RSYNC_OPTS empty or unset, using hardcoded defaults\n")
3719                         rsync_opts.extend([
3720                                 "--recursive",    # Recurse directories
3721                                 "--links",        # Consider symlinks
3722                                 "--safe-links",   # Ignore links outside of tree
3723                                 "--perms",        # Preserve permissions
3724                                 "--times",        # Preserive mod times
3725                                 "--compress",     # Compress the data transmitted
3726                                 "--force",        # Force deletion on non-empty dirs
3727                                 "--whole-file",   # Don't do block transfers, only entire files
3728                                 "--delete",       # Delete files that aren't in the master tree
3729                                 "--delete-after", # Delete only after everything else is done
3730                                 "--stats",        # Show final statistics about what was transfered
3731                                 "--timeout="+str(mytimeout), # IO timeout if not done in X seconds
3732                                 "--exclude='/distfiles'",   # Exclude distfiles from consideration
3733                                 "--exclude='/local'",       # Exclude local     from consideration
3734                                 "--exclude='/packages'",    # Exclude packages  from consideration
3735                         ])
3736
3737                 else:
3738                         # The below validation is not needed when using the above hardcoded
3739                         # defaults.
3740
3741                         portage.writemsg("Using PORTAGE_RSYNC_OPTS instead of hardcoded defaults\n", 1)
3742                         rsync_opts.extend(settings["PORTAGE_RSYNC_OPTS"].split())
3743
3744                         for opt in ("--recursive", "--times"):
3745                                 if opt not in rsync_opts:
3746                                         portage.writemsg(yellow("WARNING:") + " adding required option " + \
3747                                         "%s not included in PORTAGE_RSYNC_OPTS\n" % opt)
3748                                         rsync_opts.append(opt)
3749
3750                         for exclude in ("distfiles", "local", "packages"):
3751                                 opt = "--exclude=/%s" % exclude
3752                                 if opt not in rsync_opts:
3753                                         portage.writemsg(yellow("WARNING:") + \
3754                                         " adding required option %s not included in "  % opt + \
3755                                         "PORTAGE_RSYNC_OPTS (can be overridden with --exclude='!')\n")
3756                                         rsync_opts.append(opt)
3757
3758                         if settings["RSYNC_TIMEOUT"] != "":
3759                                 portage.writemsg("WARNING: usage of RSYNC_TIMEOUT is deprecated, " + \
3760                                 "use PORTAGE_RSYNC_EXTRA_OPTS instead\n")
3761                                 try:
3762                                         mytimeout = int(settings["RSYNC_TIMEOUT"])
3763                                         rsync_opts.append("--timeout=%d" % mytimeout)
3764                                 except ValueError, e:
3765                                         portage.writemsg("!!! %s\n" % str(e))
3766
3767                         # TODO: determine options required for official servers
3768                         if syncuri.rstrip("/").endswith(".gentoo.org/gentoo-portage"):
3769
3770                                 def rsync_opt_startswith(opt_prefix):
3771                                         for x in rsync_opts:
3772                                                 if x.startswith(opt_prefix):
3773                                                         return True
3774                                         return False
3775
3776                                 if not rsync_opt_startswith("--timeout="):
3777                                         rsync_opts.append("--timeout=%d" % mytimeout)
3778
3779                                 for opt in ("--compress", "--whole-file"):
3780                                         if opt not in rsync_opts:
3781                                                 portage.writemsg(yellow("WARNING:") + " adding required option " + \
3782                                                 "%s not included in PORTAGE_RSYNC_OPTS\n" % opt)
3783                                                 rsync_opts.append(opt)
3784
3785                 if "--quiet" in myopts:
3786                         rsync_opts.append("--quiet")    # Shut up a lot
3787                 else:
3788                         rsync_opts.append("--verbose")  # Print filelist
3789
3790                 if "--verbose" in myopts:
3791                         rsync_opts.append("--progress")  # Progress meter for each file
3792
3793                 if "--debug" in myopts:
3794                         rsync_opts.append("--checksum") # Force checksum on all files
3795
3796                 if settings["RSYNC_EXCLUDEFROM"] != "":
3797                         portage.writemsg(yellow("WARNING:") + \
3798                         " usage of RSYNC_EXCLUDEFROM is deprecated, use " + \
3799                         "PORTAGE_RSYNC_EXTRA_OPTS instead\n")
3800                         if os.path.exists(settings["RSYNC_EXCLUDEFROM"]):
3801                                 rsync_opts.append("--exclude-from=%s" % \
3802                                 settings["RSYNC_EXCLUDEFROM"])
3803                         else:
3804                                 portage.writemsg("!!! RSYNC_EXCLUDEFROM specified," + \
3805                                 " but file does not exist.\n")
3806
3807                 if settings["RSYNC_RATELIMIT"] != "":
3808                         portage.writemsg(yellow("WARNING:") + \
3809                         " usage of RSYNC_RATELIMIT is deprecated, use " + \
3810                         "PORTAGE_RSYNC_EXTRA_OPTS instead")
3811                         rsync_opts.append("--bwlimit=%s" % \
3812                         settings["RSYNC_RATELIMIT"])
3813
3814                 # Real local timestamp file.
3815                 servertimestampfile = os.path.join(
3816                         myportdir, "metadata", "timestamp.chk")
3817                 # Temporary file for remote server timestamp comparison.
3818                 tmpservertimestampfile = os.path.join(
3819                         settings["PORTAGE_TMPDIR"], "timestamp.chk")
3820
3821                 content = portage.util.grabfile(servertimestampfile)
3822                 mytimestamp = 0
3823                 if content:
3824                         try:
3825                                 mytimestamp = time.mktime(time.strptime(content[0],
3826                                         "%a, %d %b %Y %H:%M:%S +0000"))
3827                         except OverflowError, ValueError:
3828                                 pass
3829                 del content
3830
3831                 try:
3832                         if settings.has_key("RSYNC_RETRIES"):
3833                                 print yellow("WARNING:")+" usage of RSYNC_RETRIES is deprecated, use PORTAGE_RSYNC_RETRIES instead"
3834                                 maxretries=int(settings["RSYNC_RETRIES"])
3835                         else:
3836                                 maxretries=int(settings["PORTAGE_RSYNC_RETRIES"])
3837                 except SystemExit, e:
3838                         raise # Needed else can't exit
3839                 except:
3840                         maxretries=3 #default number of retries
3841
3842                 retries=0
3843                 user_name, hostname, port = re.split(
3844                         "rsync://([^:/]+@)?([^:/]*)(:[0-9]+)?", syncuri, maxsplit=3)[1:4]
3845                 if port is None:
3846                         port=""
3847                 if user_name is None:
3848                         user_name=""
3849                 updatecache_flg=True
3850                 all_rsync_opts = set(rsync_opts)
3851                 all_rsync_opts.update(
3852                         settings.get("PORTAGE_RSYNC_EXTRA_OPTS","").split())
3853                 family = socket.AF_UNSPEC
3854                 if "-4" in all_rsync_opts or "--ipv4" in all_rsync_opts:
3855                         family = socket.AF_INET
3856                 elif socket.has_ipv6 and \
3857                         ("-6" in all_rsync_opts or "--ipv6" in all_rsync_opts):
3858                         family = socket.AF_INET6
3859                 ips=[]
3860                 while (1):
3861                         if ips:
3862                                 del ips[0]
3863                         if ips==[]:
3864                                 try:
3865                                         for addrinfo in socket.getaddrinfo(
3866                                                 hostname, None, family, socket.SOCK_STREAM):
3867                                                 if addrinfo[0] == socket.AF_INET6:
3868                                                         # IPv6 addresses need to be enclosed in square brackets
3869                                                         ips.append("[%s]" % addrinfo[4][0])
3870                                                 else:
3871                                                         ips.append(addrinfo[4][0])
3872                                         from random import shuffle
3873                                         shuffle(ips)
3874                                 except SystemExit, e:
3875                                         raise # Needed else can't exit
3876                                 except Exception, e:
3877                                         print "Notice:",str(e)
3878                                         dosyncuri=syncuri
3879
3880                         if ips:
3881                                 try:
3882                                         dosyncuri = syncuri.replace(
3883                                                 "//" + user_name + hostname + port + "/",
3884                                                 "//" + user_name + ips[0] + port + "/", 1)
3885                                 except SystemExit, e:
3886                                         raise # Needed else can't exit
3887                                 except Exception, e:
3888                                         print "Notice:",str(e)
3889                                         dosyncuri=syncuri
3890
3891                         if (retries==0):
3892                                 if "--ask" in myopts:
3893                                         if userquery("Do you want to sync your Portage tree with the mirror at\n" + blue(dosyncuri) + bold("?"))=="No":
3894                                                 print
3895                                                 print "Quitting."
3896                                                 print
3897                                                 sys.exit(0)
3898                                 emergelog(xterm_titles, ">>> Starting rsync with " + dosyncuri)
3899                                 if "--quiet" not in myopts:
3900                                         print ">>> Starting rsync with "+dosyncuri+"..."
3901                         else:
3902                                 emergelog(xterm_titles,
3903                                         ">>> Starting retry %d of %d with %s" % \
3904                                                 (retries,maxretries,dosyncuri))
3905                                 print "\n\n>>> Starting retry %d of %d with %s" % (retries,maxretries,dosyncuri)
3906
3907                         if mytimestamp != 0 and "--quiet" not in myopts:
3908                                 print ">>> Checking server timestamp ..."
3909
3910                         rsynccommand = " ".join(["/usr/bin/rsync", " ".join(rsync_opts),
3911                                 settings.get("PORTAGE_RSYNC_EXTRA_OPTS","")])
3912
3913                         if "--debug" in myopts:
3914                                 print rsynccommand
3915
3916                         exitcode = os.EX_OK
3917                         servertimestamp = 0
3918                         if mytimestamp != 0:
3919                                 mycommand = rsynccommand.split()
3920                                 mycommand.append(dosyncuri.rstrip("/") + \
3921                                         "/metadata/timestamp.chk")
3922                                 mycommand.append(tmpservertimestampfile)
3923                                 try:
3924                                         exitcode = portage.process.spawn(
3925                                                 mycommand, env=settings.environ())
3926                                         content = portage.grabfile(tmpservertimestampfile)
3927                                         if content:
3928                                                 try:
3929                                                         servertimestamp = time.mktime(time.strptime(
3930                                                                 content[0], "%a, %d %b %Y %H:%M:%S +0000"))
3931                                                 except OverflowError, ValueError:
3932                                                         pass
3933                                         del content
3934                                 finally:
3935                                         try:
3936                                                 os.unlink(tmpservertimestampfile)
3937                                         except OSError:
3938                                                 pass
3939                                 del mycommand
3940                         if exitcode == os.EX_OK:
3941                                 if (servertimestamp != 0) and (servertimestamp == mytimestamp):
3942                                         emergelog(xterm_titles,
3943                                                 ">>> Cancelling sync -- Already current.")
3944                                         print
3945                                         print ">>>"
3946                                         print ">>> Timestamps on the server and in the local repository are the same."
3947                                         print ">>> Cancelling all further sync action. You are already up to date."
3948                                         print ">>>"
3949                                         print ">>> In order to force sync, remove '%s'." % servertimestampfile
3950                                         print ">>>"
3951                                         print
3952                                         sys.exit(0)
3953                                 elif (servertimestamp != 0) and (servertimestamp < mytimestamp):
3954                                         emergelog(xterm_titles,
3955                                                 ">>> Server out of date: %s" % dosyncuri)
3956                                         print
3957                                         print ">>>"
3958                                         print ">>> SERVER OUT OF DATE: %s" % dosyncuri
3959                                         print ">>>"
3960                                         print ">>> In order to force sync, remove '%s'." % servertimestampfile
3961                                         print ">>>"
3962                                         print
3963                                 elif (servertimestamp == 0) or (servertimestamp > mytimestamp):
3964                                         # actual sync
3965                                         mycommand=rsynccommand+" "+dosyncuri+"/ "+myportdir
3966                                         exitcode=portage.spawn(mycommand,settings,free=1)
3967                                         if exitcode in [0,1,2,3,4,11,14,20,21]:
3968                                                 break
3969                         elif exitcode in [0,1,2,3,4,11,14,20,21]:
3970                                 break
3971
3972                         retries=retries+1
3973
3974                         if retries<=maxretries:
3975                                 print ">>> Retrying..."
3976                                 time.sleep(11)
3977                         else:
3978                                 # over retries
3979                                 # exit loop
3980                                 updatecache_flg=False
3981                                 break
3982
3983                 if (exitcode==0):
3984                         emergelog(xterm_titles, "=== Sync completed with %s" % dosyncuri)
3985                 elif (exitcode>0):
3986                         print
3987                         if exitcode==1:
3988                                 print darkred("!!!")+green(" Rsync has reported that there is a syntax error. Please ensure")
3989                                 print darkred("!!!")+green(" that your SYNC statement is proper.")
3990                                 print darkred("!!!")+green(" SYNC="+settings["SYNC"])
3991                         elif exitcode==11:
3992                                 print darkred("!!!")+green(" Rsync has reported that there is a File IO error. Normally")
3993                                 print darkred("!!!")+green(" this means your disk is full, but can be caused by corruption")
3994                                 print darkred("!!!")+green(" on the filesystem that contains PORTDIR. Please investigate")
3995                                 print darkred("!!!")+green(" and try again after the problem has been fixed.")
3996                                 print darkred("!!!")+green(" PORTDIR="+settings["PORTDIR"])
3997                         elif exitcode==20:
3998                                 print darkred("!!!")+green(" Rsync was killed before it finished.")
3999                         else:
4000                                 print darkred("!!!")+green(" Rsync has not successfully finished. It is recommended that you keep")
4001                                 print darkred("!!!")+green(" trying or that you use the 'emerge-webrsync' option if you are unable")
4002                                 print darkred("!!!")+green(" to use rsync due to firewall or other restrictions. This should be a")
4003                                 print darkred("!!!")+green(" temporary problem unless complications exist with your network")
4004                                 print darkred("!!!")+green(" (and possibly your system's filesystem) configuration.")
4005                         print
4006                         sys.exit(exitcode)
4007         elif syncuri[:6]=="cvs://":
4008                 if not os.path.exists("/usr/bin/cvs"):
4009                         print "!!! /usr/bin/cvs does not exist, so CVS support is disabled."
4010                         print "!!! Type \"emerge dev-util/cvs\" to enable CVS support."
4011                         sys.exit(1)
4012                 cvsroot=syncuri[6:]
4013                 cvsdir=os.path.dirname(myportdir)
4014                 if not os.path.exists(myportdir+"/CVS"):
4015                         #initial checkout
4016                         print ">>> Starting initial cvs checkout with "+syncuri+"..."
4017                         if os.path.exists(cvsdir+"/gentoo-x86"):
4018                                 print "!!! existing",cvsdir+"/gentoo-x86 directory; exiting."
4019                                 sys.exit(1)
4020                         try:
4021                                 os.rmdir(myportdir)
4022                         except OSError, e:
4023                                 if e.errno != errno.ENOENT:
4024                                         sys.stderr.write(
4025                                                 "!!! existing '%s' directory; exiting.\n" % myportdir)
4026                                         sys.exit(1)
4027                                 del e
4028                         if portage.spawn("cd "+cvsdir+"; cvs -z0 -d "+cvsroot+" co -P gentoo-x86",settings,free=1):
4029                                 print "!!! cvs checkout error; exiting."
4030                                 sys.exit(1)
4031                         os.rename(os.path.join(cvsdir, "gentoo-x86"), myportdir)
4032                 else:
4033                         #cvs update
4034                         print ">>> Starting cvs update with "+syncuri+"..."
4035                         retval = portage.spawn("cd '%s'; cvs -z0 -q update -dP" % \
4036                                 myportdir, settings, free=1)
4037                         if retval != os.EX_OK:
4038                                 sys.exit(retval)
4039                 dosyncuri = syncuri
4040         else:
4041                 print "!!! rsync setting: ",syncuri,"not recognized; exiting."
4042                 sys.exit(1)
4043
4044         if updatecache_flg and  \
4045                 myaction != "metadata" and \
4046                 "metadata-transfer" not in settings.features:
4047                 updatecache_flg = False
4048
4049         # Reload the whole config from scratch.
4050         settings, trees, mtimedb = load_emerge_config(trees=trees)
4051         portdb = trees[settings["ROOT"]]["porttree"].dbapi
4052
4053         if os.path.exists(myportdir+"/metadata/cache") and updatecache_flg:
4054                 action_metadata(settings, portdb, myopts)
4055
4056         if portage.global_updates(settings, trees, mtimedb["updates"]):
4057                 mtimedb.commit()
4058                 # Reload the whole config from scratch.
4059                 settings, trees, mtimedb = load_emerge_config(trees=trees)
4060                 portdb = trees[settings["ROOT"]]["porttree"].dbapi
4061
4062         mybestpv = portdb.xmatch("bestmatch-visible", "sys-apps/portage")
4063         mypvs = portage.best(
4064                 trees[settings["ROOT"]]["vartree"].dbapi.match("sys-apps/portage"))
4065
4066         chk_updated_cfg_files("/", settings.get("CONFIG_PROTECT","").split())
4067
4068         if myaction != "metadata":
4069                 if os.access(portage.USER_CONFIG_PATH + "/bin/post_sync", os.X_OK):
4070                         retval = portage.process.spawn(
4071                                 [os.path.join(portage.USER_CONFIG_PATH, "bin", "post_sync"),
4072                                 dosyncuri], env=settings.environ())
4073                         if retval != os.EX_OK:
4074                                 print red(" * ")+bold("spawn failed of "+ portage.USER_CONFIG_PATH + "/bin/post_sync")
4075
4076         if(mybestpv != mypvs) and not "--quiet" in myopts:
4077                 print
4078                 print red(" * ")+bold("An update to portage is available.")+" It is _highly_ recommended"
4079                 print red(" * ")+"that you update portage now, before any other packages are updated."
4080                 print red(" * ")+"Please run 'emerge portage' and then update "+bold("ALL")+" of your"
4081                 print red(" * ")+"configuration files."
4082                 print red(" * ")+"To update portage, run 'emerge portage'."
4083                 print
4084
4085 def action_metadata(settings, portdb, myopts):
4086         portage.writemsg_stdout("\n>>> Updating Portage cache:      ")
4087         old_umask = os.umask(0002)
4088         cachedir = os.path.normpath(settings.depcachedir)
4089         if cachedir in ["/",    "/bin", "/dev",  "/etc",  "/home",
4090                                         "/lib", "/opt", "/proc", "/root", "/sbin",
4091                                         "/sys", "/tmp", "/usr",  "/var"]:
4092                 print >> sys.stderr, "!!! PORTAGE_DEPCACHEDIR IS SET TO A PRIMARY " + \
4093                         "ROOT DIRECTORY ON YOUR SYSTEM."
4094                 print >> sys.stderr, \
4095                         "!!! This is ALMOST CERTAINLY NOT what you want: '%s'" % cachedir
4096                 sys.exit(73)
4097         if not os.path.exists(cachedir):
4098                 os.mkdir(cachedir)
4099
4100         ec = portage.eclass_cache.cache(portdb.porttree_root)
4101         myportdir = os.path.realpath(settings["PORTDIR"])
4102         cm = settings.load_best_module("portdbapi.metadbmodule")(
4103                 myportdir, "metadata/cache", portage.auxdbkeys[:])
4104
4105         from portage.cache import util
4106
4107         class percentage_noise_maker(util.quiet_mirroring):
4108                 def __init__(self, dbapi):
4109                         self.dbapi = dbapi
4110                         self.cp_all = dbapi.cp_all()
4111                         l = len(self.cp_all)
4112                         self.call_update_min = 100000000
4113                         self.min_cp_all = l/100.0
4114                         self.count = 1
4115                         self.pstr = ''
4116
4117                 def __iter__(self):
4118                         for x in self.cp_all:
4119                                 self.count += 1
4120                                 if self.count > self.min_cp_all:
4121                                         self.call_update_min = 0
4122                                         self.count = 0
4123                                 for y in self.dbapi.cp_list(x):
4124                                         yield y
4125                         self.call_update_mine = 0
4126
4127                 def update(self, *arg):
4128                         try:                            self.pstr = int(self.pstr) + 1
4129                         except ValueError:      self.pstr = 1
4130                         sys.stdout.write("%s%i%%" % \
4131                                 ("\b" * (len(str(self.pstr))+1), self.pstr))
4132                         sys.stdout.flush()
4133                         self.call_update_min = 10000000
4134
4135                 def finish(self, *arg):
4136                         sys.stdout.write("\b\b\b\b100%\n")
4137                         sys.stdout.flush()
4138
4139         if "--quiet" in myopts:
4140                 def quicky_cpv_generator(cp_all_list):
4141                         for x in cp_all_list:
4142                                 for y in portdb.cp_list(x):
4143                                         yield y
4144                 source = quicky_cpv_generator(portdb.cp_all())
4145                 noise_maker = portage.cache.util.quiet_mirroring()
4146         else:
4147                 noise_maker = source = percentage_noise_maker(portdb)
4148         portage.cache.util.mirror_cache(source, cm, portdb.auxdb[myportdir],
4149                 eclass_cache=ec, verbose_instance=noise_maker)
4150
4151         sys.stdout.flush()
4152         os.umask(old_umask)
4153
4154 def action_regen(settings, portdb):
4155         xterm_titles = "notitles" not in settings.features
4156         emergelog(xterm_titles, " === regen")
4157         #regenerate cache entries
4158         print "Regenerating cache entries... "
4159         try:
4160                 os.close(sys.stdin.fileno())
4161         except SystemExit, e:
4162                 raise # Needed else can't exit
4163         except:
4164                 pass
4165         sys.stdout.flush()
4166         mynodes = portdb.cp_all()
4167         from portage.cache.cache_errors import CacheError
4168         dead_nodes = {}
4169         for mytree in portdb.porttrees:
4170                 try:
4171                         dead_nodes[mytree] = set(portdb.auxdb[mytree].iterkeys())
4172                 except CacheError, e:
4173                         print "\n  error listing cache entries for " + \
4174                                 "'%s': %s, continuing..." % (mytree, e)
4175                         del e
4176                         dead_nodes = None
4177                         break
4178         for x in mynodes:
4179                 mymatches = portdb.xmatch("match-all",x)
4180                 portage.writemsg_stdout("processing %s\n" % x)
4181                 for y in mymatches:
4182                         try:
4183                                 foo = portdb.aux_get(y,["DEPEND"])
4184                         except SystemExit, e:
4185                                 # sys.exit is an exception... And consequently, we can't catch it.
4186                                 raise
4187                         except Exception, e:
4188                                 print "\n  error processing %(cpv)s, continuing... (%(e)s)" % {"cpv":y,"e":str(e)}
4189                         if dead_nodes:
4190                                 for mytree in portdb.porttrees:
4191                                         if portdb.findname2(y, mytree=mytree)[0]:
4192                                                 dead_nodes[mytree].discard(y)
4193         if dead_nodes:
4194                 for mytree, nodes in dead_nodes.iteritems():
4195                         auxdb = portdb.auxdb[mytree]
4196                         for y in nodes:
4197                                 try:
4198                                         del auxdb[y]
4199                                 except KeyError, CacheError:
4200                                         pass
4201         print "done!"
4202
4203 def action_config(settings, trees, myopts, myfiles):
4204         if len(myfiles) != 1 or "system" in myfiles or "world" in myfiles:
4205                 print red("!!! config can only take a single package atom at this time\n")
4206                 sys.exit(1)
4207         if not is_valid_package_atom(myfiles[0]):
4208                 portage.writemsg("!!! '%s' is not a valid package atom.\n" % myfiles[0],
4209                         noiselevel=-1)
4210                 portage.writemsg("!!! Please check ebuild(5) for full details.\n")
4211                 portage.writemsg("!!! (Did you specify a version but forget to prefix with '='?)\n")
4212                 sys.exit(1)
4213         print
4214         try:
4215                 pkgs = trees[settings["ROOT"]]["vartree"].dbapi.match(myfiles[0])
4216         except ValueError, e:
4217                 # Multiple matches thrown from cpv_expand
4218                 pkgs = e.args[0]
4219         if len(pkgs) == 0:
4220                 print "No packages found.\n"
4221                 sys.exit(0)
4222         elif len(pkgs) > 1:
4223                 if "--ask" in myopts:
4224                         options = []
4225                         print "Please select a package to configure:"
4226                         idx = 0
4227                         for pkg in pkgs:
4228                                 idx += 1
4229                                 options.append(str(idx))
4230                                 print options[-1]+") "+pkg
4231                         print "X) Cancel"
4232                         options.append("X")
4233                         idx = userquery("Selection?", options)
4234                         if idx == "X":
4235                                 sys.exit(0)
4236                         pkg = pkgs[int(idx)-1]
4237                 else:
4238                         print "The following packages available:"
4239                         for pkg in pkgs:
4240                                 print "* "+pkg
4241                         print "\nPlease use a specific atom or the --ask option."
4242                         sys.exit(1)
4243         else:
4244                 pkg = pkgs[0]
4245
4246         print
4247         if "--ask" in myopts:
4248                 if userquery("Ready to configure "+pkg+"?") == "No":
4249                         sys.exit(0)
4250         else:
4251                 print "Configuring pkg..."
4252         print
4253         ebuildpath = trees[settings["ROOT"]]["vartree"].dbapi.findname(pkg)
4254         mysettings = portage.config(clone=settings)
4255         portage.doebuild(ebuildpath, "config", settings["ROOT"], mysettings,
4256                 debug=(settings.get("PORTAGE_DEBUG", "") == 1), cleanup=True,
4257                 mydbapi=trees[settings["ROOT"]]["vartree"].dbapi, tree="vartree")
4258         print
4259
4260 def action_info(settings, trees, myopts, myfiles):
4261         unameout=commands.getstatusoutput("uname -mrp")[1]
4262         print getportageversion(settings["PORTDIR"], settings["ROOT"],
4263                 settings.profile_path, settings["CHOST"],
4264                 trees[settings["ROOT"]]["vartree"].dbapi)
4265         header_width = 65
4266         header_title = "System Settings"
4267         if myfiles:
4268                 print header_width * "="
4269                 print header_title.rjust(int(header_width/2 + len(header_title)/2))
4270         print header_width * "="
4271         print "System uname: "+unameout
4272         gentoo_release = portage.grabfile(os.path.join(
4273                 settings["PORTAGE_CONFIGROOT"], "etc", "gentoo-release"))
4274         if gentoo_release:
4275                 print gentoo_release[0]
4276         else:
4277                 print "Unknown Host Operating System"
4278         lastSync = portage.grabfile(os.path.join(
4279                 settings["PORTDIR"], "metadata", "timestamp.chk"))
4280         print "Timestamp of tree:",
4281         if lastSync:
4282                 print lastSync[0]
4283         else:
4284                 print "Unknown"
4285
4286         output=commands.getstatusoutput("distcc --version")
4287         if not output[0]:
4288                 print str(output[1].split("\n",1)[0]),
4289                 if "distcc" in settings.features:
4290                         print "[enabled]"
4291                 else:
4292                         print "[disabled]"
4293
4294         output=commands.getstatusoutput("ccache -V")
4295         if not output[0]:
4296                 print str(output[1].split("\n",1)[0]),
4297                 if "ccache" in settings.features:
4298                         print "[enabled]"
4299                 else:
4300                         print "[disabled]"
4301
4302         myvars  = ["sys-devel/autoconf", "sys-devel/automake", "virtual/os-headers",
4303                    "sys-devel/binutils", "sys-devel/libtool",  "dev-lang/python"]
4304         myvars += portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_pkgs")
4305         myvars  = portage.util.unique_array(myvars)
4306         myvars.sort()
4307
4308         for x in myvars:
4309                 if portage.isvalidatom(x):
4310                         pkg_matches = trees["/"]["vartree"].dbapi.match(x)
4311                         pkgs = []
4312                         for y in pkg_matches:
4313                                 mycpv   = portage.catpkgsplit(y)
4314                                 if(mycpv[3] != "r0"):
4315                                         pkgs += [mycpv[2] + "-" + mycpv[3]]
4316                                 else:
4317                                         pkgs += [mycpv[2]]
4318                         if pkgs:
4319                                 pkgs = ", ".join(sorted_versions(pkgs))
4320                                 print "%-20s %s" % (x+":", pkgs)
4321                 else:
4322                         print "%-20s %s" % (x+":", "[NOT VALID]")
4323
4324         libtool_vers = ",".join(trees["/"]["vartree"].dbapi.match("sys-devel/libtool"))
4325
4326         if "--verbose" in myopts:
4327                 myvars=settings.keys()
4328         else:
4329                 myvars = ['GENTOO_MIRRORS', 'CONFIG_PROTECT', 'CONFIG_PROTECT_MASK',
4330                           'PORTDIR', 'DISTDIR', 'PKGDIR', 'PORTAGE_TMPDIR',
4331                           'PORTDIR_OVERLAY', 'USE', 'CHOST', 'CFLAGS', 'CXXFLAGS',
4332                           'ACCEPT_KEYWORDS', 'SYNC', 'FEATURES', 'EMERGE_DEFAULT_OPTS']
4333
4334                 myvars.extend(portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_vars"))
4335
4336         myvars = portage.util.unique_array(myvars)
4337         unset_vars = []
4338         myvars.sort()
4339         for x in myvars:
4340                 if x in settings:
4341                         if x != "USE":
4342                                 print '%s="%s"' % (x, settings[x])
4343                         else:
4344                                 use = set(settings["USE"].split())
4345                                 use_expand = settings["USE_EXPAND"].split()
4346                                 use_expand.sort()
4347                                 for varname in use_expand:
4348                                         flag_prefix = varname.lower() + "_"
4349                                         for f in list(use):
4350                                                 if f.startswith(flag_prefix):
4351                                                         use.remove(f)
4352                                 use = list(use)
4353                                 use.sort()
4354                                 print 'USE="%s"' % " ".join(use),
4355                                 for varname in use_expand:
4356                                         myval = settings.get(varname)
4357                                         if myval:
4358                                                 print '%s="%s"' % (varname, myval),
4359                                 print
4360                 else:
4361                         unset_vars.append(x)
4362         if unset_vars:
4363                 print "Unset:  "+", ".join(unset_vars)
4364         print
4365
4366         if "--debug" in myopts:
4367                 for x in dir(portage):
4368                         module = getattr(portage, x)
4369                         if "cvs_id_string" in dir(module):
4370                                 print "%s: %s" % (str(x), str(module.cvs_id_string))
4371
4372         # See if we can find any packages installed matching the strings
4373         # passed on the command line
4374         mypkgs = []
4375         vardb = trees[settings["ROOT"]]["vartree"].dbapi
4376         portdb = trees[settings["ROOT"]]["porttree"].dbapi
4377         for x in myfiles:
4378                 mypkgs.extend(vardb.match(x))
4379
4380         # If some packages were found...
4381         if mypkgs:
4382                 # Get our global settings (we only print stuff if it varies from
4383                 # the current config)
4384                 mydesiredvars = [ 'CHOST', 'CFLAGS', 'CXXFLAGS' ]
4385                 auxkeys = mydesiredvars + [ "USE", "IUSE"]
4386                 global_vals = {}
4387                 pkgsettings = portage.config(clone=settings)
4388
4389                 for myvar in mydesiredvars:
4390                         global_vals[myvar] = set(settings.get(myvar, "").split())
4391
4392                 # Loop through each package
4393                 # Only print settings if they differ from global settings
4394                 header_printed = False
4395                 for pkg in mypkgs:
4396                         # Get all package specific variables
4397                         auxvalues = vardb.aux_get(pkg, auxkeys)
4398                         valuesmap = {}
4399                         for i in xrange(len(auxkeys)):
4400                                 valuesmap[auxkeys[i]] = set(auxvalues[i].split())
4401                         diff_values = {}
4402                         for myvar in mydesiredvars:
4403                                 # If the package variable doesn't match the
4404                                 # current global variable, something has changed
4405                                 # so set diff_found so we know to print
4406                                 if valuesmap[myvar] != global_vals[myvar]:
4407                                         diff_values[myvar] = valuesmap[myvar]
4408                         valuesmap["IUSE"] = set(filter_iuse_defaults(valuesmap["IUSE"]))
4409                         valuesmap["USE"] = valuesmap["USE"].intersection(valuesmap["IUSE"])
4410                         pkgsettings.reset()
4411                         # If a matching ebuild is no longer available in the tree, maybe it
4412                         # would make sense to compare against the flags for the best
4413                         # available version with the same slot?
4414                         mydb = None
4415                         if portdb.cpv_exists(pkg):
4416                                 mydb = portdb
4417                         pkgsettings.setcpv(pkg, mydb=mydb)
4418                         if valuesmap["IUSE"].intersection(pkgsettings["USE"].split()) != \
4419                                 valuesmap["USE"]:
4420                                 diff_values["USE"] = valuesmap["USE"]
4421                         # If a difference was found, print the info for
4422                         # this package.
4423                         if diff_values:
4424
4425                                 # If we have not yet printed the header,
4426                                 # print it now
4427                                 if not header_printed:
4428                                         header_title = "Package Settings"
4429                                         print header_width * "="
4430                                         print header_title.rjust(int(header_width/2 + len(header_title)/2))
4431                                         print header_width * "="
4432                                         header_printed = True
4433
4434                                 # Print package info
4435                                 print "%s was built with the following:" % pkg
4436                                 for myvar in mydesiredvars + ["USE"]:
4437                                         if myvar in diff_values:
4438                                                 mylist = list(diff_values[myvar])
4439                                                 mylist.sort()
4440                                                 print "%s=\"%s\"" % (myvar, " ".join(mylist))
4441                                 print
4442
4443 def action_search(settings, portdb, vartree, myopts, myfiles, spinner):
4444         if not myfiles:
4445                 print "emerge: no search terms provided."
4446         else:
4447                 searchinstance = search(settings, portdb,
4448                         vartree, spinner, "--searchdesc" in myopts,
4449                         "--quiet" not in myopts)
4450                 for mysearch in myfiles:
4451                         try:
4452                                 searchinstance.execute(mysearch)
4453                         except re.error, comment:
4454                                 print "\n!!! Regular expression error in \"%s\": %s" % ( mysearch, comment )
4455                                 sys.exit(1)
4456                         searchinstance.output()
4457
4458 def action_depclean(settings, trees, ldpath_mtimes,
4459         myopts, spinner):
4460         # Kill packages that aren't explicitly merged or are required as a
4461         # dependency of another package. World file is explicit.
4462
4463         warn_prefix = colorize("BAD", "*** WARNING ***  ")
4464         print
4465         print warn_prefix + "Depclean may break link level dependencies.  Thus, it is"
4466         print warn_prefix + "recommended to use a tool such as " + good("`revdep-rebuild`") + " (from"
4467         print warn_prefix + "app-portage/gentoolkit) in order to detect such breakage."
4468         print warn_prefix
4469         print warn_prefix + "Also study the list of packages to be cleaned for any obvious"
4470         print warn_prefix + "mistakes. Packages that are part of the world set will always"
4471         print warn_prefix + "be kept.  They can be manually added to this set with"
4472         print warn_prefix + good("`emerge --noreplace <atom>`") + ".  Packages that are listed in"
4473         print warn_prefix + "package.provided (see portage(5)) will be removed by"
4474         print warn_prefix + "depclean, even if they are part of the world set."
4475         print warn_prefix
4476         print warn_prefix + "As a safety measure, depclean will not remove any packages"
4477         print warn_prefix + "unless *all* required dependencies have been resolved.  As a"
4478         print warn_prefix + "consequence, it is often necessary to run "
4479         print warn_prefix + good("`emerge --update --newuse --deep world`") + " prior to depclean."
4480
4481         xterm_titles = "notitles" not in settings.features
4482         myroot = settings["ROOT"]
4483         dep_check_trees = {}
4484         dep_check_trees[myroot] = {}
4485         dep_check_trees[myroot]["vartree"] = \
4486                 FakeVartree(trees[myroot]["vartree"], trees[myroot]["porttree"].dbapi)
4487         vardb = dep_check_trees[myroot]["vartree"].dbapi
4488         # Constrain dependency selection to the installed packages.
4489         dep_check_trees[myroot]["porttree"] = dep_check_trees[myroot]["vartree"]
4490         syslist = getlist(settings, "system")
4491         worldlist = getlist(settings, "world")
4492         fakedb = portage.fakedbapi(settings=settings)
4493         myvarlist = vardb.cpv_all()
4494
4495         if not syslist:
4496                 print "\n!!! You have no system list.",
4497         if not worldlist:
4498                 print "\n!!! You have no world file.",
4499         if not myvarlist:
4500                 print "\n!!! You have no installed package database (%s)." % portage.VDB_PATH,
4501
4502         if not (syslist and worldlist and myvarlist):
4503                 print "\n!!! Proceeding "+(syslist and myvarlist and "may" or "will")
4504                 print " break your installation.\n"
4505                 if "--pretend" not in myopts:
4506                         countdown(int(settings["EMERGE_WARNING_DELAY"]), ">>> Depclean")
4507
4508         if not "--pretend" in myopts: #just check pretend, since --ask implies pretend
4509                 emergelog(xterm_titles, " >>> depclean")
4510
4511         if "--quiet" not in myopts:
4512                 print "\nCalculating dependencies  ",
4513
4514         soft = 0
4515         hard = 1
4516         remaining_atoms = [(atom, 'world', hard) for atom in worldlist if vardb.match(atom)]
4517         remaining_atoms += [(atom, 'system', hard) for atom in syslist if vardb.match(atom)]
4518         unresolveable = {}
4519         aux_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
4520
4521         while remaining_atoms:
4522                 atom, parent, priority = remaining_atoms.pop()
4523                 pkgs = vardb.match(atom)
4524                 if not pkgs:
4525                         if not atom.startswith("!") and priority == hard:
4526                                 unresolveable.setdefault(atom, []).append(parent)
4527                         continue
4528                 # Could put slot checking here to ensure that there aren't two
4529                 # packages with the same slot...
4530                 for pkg in pkgs:
4531                         if fakedb.cpv_exists(pkg):
4532                                 continue
4533                         spinner.update()
4534                         fakedb.cpv_inject(pkg)
4535                         myaux = dict(izip(aux_keys, vardb.aux_get(pkg, aux_keys)))
4536                         mydeps = []
4537                         if myopts.get("--with-bdeps", "y") == "y":
4538                                 mydeps.append((myaux["DEPEND"], soft))
4539                         del myaux["DEPEND"]
4540                         mydeps.append((" ".join(myaux.values()), hard))
4541                         usedef = vardb.aux_get(pkg, ["USE"])[0].split()
4542                         for depstr, priority in mydeps:
4543
4544                                 if not depstr:
4545                                         continue
4546
4547                                 if "--debug" in myopts:
4548                                         print
4549                                         print "Parent:   ", pkg
4550                                         print "Depstring:", depstr
4551                                         print "Priority:",
4552                                         if priority == soft:
4553                                                 print "soft"
4554                                         else:
4555                                                 print "hard"
4556
4557                                 try:
4558                                         portage.dep._dep_check_strict = False
4559                                         success, atoms = portage.dep_check(depstr, None, settings,
4560                                                 myuse=usedef, trees=dep_check_trees, myroot=myroot)
4561                                 finally:
4562                                         portage.dep._dep_check_strict = True
4563                                 if not success:
4564                                         show_invalid_depstring_notice(
4565                                                 ("installed", myroot, pkg, "nomerge"),
4566                                                 depstr, atoms)
4567                                         return
4568
4569                                 if "--debug" in myopts:
4570                                         print "Candidates:", atoms
4571
4572                                 for atom in atoms:
4573                                         remaining_atoms.append((atom, pkg, priority))
4574
4575         if "--quiet" not in myopts:
4576                 print "\b\b... done!\n"
4577
4578         if unresolveable:
4579                 print "Dependencies could not be completely resolved due to"
4580                 print "the following required packages not being installed:"
4581                 print
4582                 for atom in unresolveable:
4583                         print atom, "required by", " ".join(unresolveable[atom])
4584                 print
4585                 print "Have you forgotten to run " + good("`emerge --update --newuse --deep world`") + " prior to"
4586                 print "depclean?  It may also be necessary to manually uninstalled packages that no"
4587                 print "longer exist in the portage tree since it may not be possible to satisfy their"
4588                 print "dependencies."
4589                 print
4590                 return
4591
4592         cleanlist = [pkg for pkg in vardb.cpv_all() if not fakedb.cpv_exists(pkg)]
4593
4594         if len(cleanlist):
4595                 unmerge(settings, myopts, trees[settings["ROOT"]]["vartree"],
4596                         "unmerge", cleanlist, ldpath_mtimes)
4597
4598         print "Packages installed:   "+str(len(myvarlist))
4599         print "Packages in world:    "+str(len(worldlist))
4600         print "Packages in system:   "+str(len(syslist))
4601         print "Unique package names: "+str(len(myvarlist))
4602         print "Required packages:    "+str(len(fakedb.cpv_all()))
4603         if "--pretend" in myopts:
4604                 print "Number to remove:     "+str(len(cleanlist))
4605         else:
4606                 print "Number removed:       "+str(len(cleanlist))
4607
4608 def action_build(settings, trees, mtimedb,
4609         myopts, myaction, myfiles, spinner):
4610         ldpath_mtimes = mtimedb["ldpath"]
4611         favorites=[]
4612         if ("--ask" in myopts or "--pretend" in myopts) and not "--quiet" in myopts:
4613                 action = ""
4614                 if "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
4615                         action = "fetched"
4616                 else:
4617                         action = "merged"
4618                 if "--tree" in myopts and action != "fetched": # Tree doesn't work with fetching
4619                         print
4620                         print darkgreen("These are the packages that would be %s, in reverse order:") % action
4621                         print
4622                 else:
4623                         print
4624                         print darkgreen("These are the packages that would be %s, in order:") % action
4625                         print
4626
4627         # validate the state of the resume data
4628         # so that we can make assumptions later.
4629         for k in ("resume", "resume_backup"):
4630                 if k in mtimedb:
4631                         if "mergelist" in mtimedb[k]:
4632                                 if not mtimedb[k]["mergelist"]:
4633                                         del mtimedb[k]
4634                         else:
4635                                 del mtimedb[k]
4636
4637         if "--resume" in myopts and \
4638                 ("resume" in mtimedb or
4639                 "resume_backup" in mtimedb):
4640                 if "resume" not in mtimedb:
4641                         mtimedb["resume"] = mtimedb["resume_backup"]
4642                         del mtimedb["resume_backup"]
4643                         mtimedb.commit()
4644                 # XXX: "myopts" is a list for backward compatibility.
4645                 myresumeopts = dict([(k,True) for k in mtimedb["resume"]["myopts"]])
4646
4647                 for opt in ("--skipfirst", "--ask", "--tree"):
4648                         myresumeopts.pop(opt, None)
4649
4650                 for myopt, myarg in myopts.iteritems():
4651                         if myopt not in myresumeopts:
4652                                 myresumeopts[myopt] = myarg
4653                 myopts=myresumeopts
4654                 myparams = create_depgraph_params(myopts, myaction)
4655                 if not "--quiet" in myopts:
4656                         print "Calculating dependencies  ",
4657                 mydepgraph = depgraph(settings, trees,
4658                         myopts, myparams, spinner)
4659                 if not "--quiet" in myopts:
4660                         print "\b\b... done!"
4661         else:
4662                 if ("--resume" in myopts):
4663                         print darkgreen("emerge: It seems we have nothing to resume...")
4664                         sys.exit(0)
4665
4666                 myparams = create_depgraph_params(myopts, myaction)
4667                 if myaction in ["system","world"]:
4668                         if not ("--quiet" in myopts):
4669                                 print "Calculating",myaction,"dependencies  ",
4670                                 sys.stdout.flush()
4671                         mydepgraph = depgraph(settings, trees, myopts, myparams, spinner)
4672                         if not mydepgraph.xcreate(myaction):
4673                                 print "!!! Depgraph creation failed."
4674                                 sys.exit(1)
4675                         if not ("--quiet" in myopts):
4676                                 print "\b\b... done!"
4677                 else:
4678                         if not ("--quiet" in myopts):
4679                                 print "Calculating dependencies  ",
4680                                 sys.stdout.flush()
4681                         mydepgraph = depgraph(settings, trees, myopts, myparams, spinner)
4682                         try:
4683                                 retval, favorites = mydepgraph.select_files(myfiles)
4684                         except portage.exception.PackageNotFound, e:
4685                                 portage.writemsg("\n!!! %s\n" % str(e), noiselevel=-1)
4686                                 sys.exit(1)
4687                         if not retval:
4688                                 sys.exit(1)
4689                         if not ("--quiet" in myopts):
4690                                 print "\b\b... done!"
4691
4692                         if ("--usepkgonly" in myopts) and mydepgraph.missingbins:
4693                                 sys.stderr.write(red("The following binaries are not available for merging...\n"))
4694
4695                 if mydepgraph.missingbins:
4696                         for x in mydepgraph.missingbins:
4697                                 sys.stderr.write("   "+str(x)+"\n")
4698                         sys.stderr.write("\nThese are required by '--usepkgonly' -- Terminating.\n\n")
4699                         sys.exit(1)
4700
4701         if "--ask" in myopts:
4702                 if "--resume" in myopts:
4703                         validate_merge_list(trees, mtimedb["resume"]["mergelist"])
4704                         mymergelist = mtimedb["resume"]["mergelist"]
4705                         if "--skipfirst" in myopts:
4706                                 mymergelist = mymergelist[1:]
4707                         if len(mymergelist) == 0:
4708                                 print colorize("INFORM", "emerge: It seems we have nothing to resume...")
4709                                 sys.exit(0)
4710                         mydepgraph.display(mymergelist)
4711                         prompt="Would you like to resume merging these packages?"
4712                 else:
4713                         mydepgraph.display(
4714                                 mydepgraph.altlist(reversed=("--tree" in myopts)))
4715                         mergecount=0
4716                         for x in mydepgraph.altlist():
4717                                 if x[0] != "blocks" and x[3] != "nomerge":
4718                                         mergecount+=1
4719                                 #check for blocking dependencies
4720                                 if x[0]=="blocks" and "--fetchonly" not in myopts and "--fetch-all-uri" not in myopts:
4721                                         print "\n!!! Error: The above package list contains packages which cannot be installed"
4722                                         print   "!!!        at the same time on the same system."
4723                                         if "--quiet" not in myopts:
4724                                                 show_blocker_docs_link()
4725                                         sys.exit(1)
4726                         if mergecount==0:
4727                                 if "--noreplace" in myopts and favorites:
4728                                         print
4729                                         for x in favorites:
4730                                                 print " %s %s" % (good("*"), x)
4731                                         prompt="Would you like to add these packages to your world favorites?"
4732                                 elif settings["AUTOCLEAN"] and "yes"==settings["AUTOCLEAN"]:
4733                                         prompt="Nothing to merge; would you like to auto-clean packages?"
4734                                 else:
4735                                         print
4736                                         print "Nothing to merge; quitting."
4737                                         print
4738                                         sys.exit(0)
4739                         elif "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
4740                                 prompt="Would you like to fetch the source files for these packages?"
4741                         else:
4742                                 prompt="Would you like to merge these packages?"
4743                 print
4744                 if userquery(prompt)=="No":
4745                         print
4746                         print "Quitting."
4747                         print
4748                         sys.exit(0)
4749                 # Don't ask again (e.g. when auto-cleaning packages after merge)
4750                 del myopts["--ask"]
4751
4752         if ("--pretend" in myopts) and not ("--fetchonly" in myopts or "--fetch-all-uri" in myopts):
4753                 if ("--resume" in myopts):
4754                         validate_merge_list(trees, mtimedb["resume"]["mergelist"])
4755                         mymergelist = mtimedb["resume"]["mergelist"]
4756                         if "--skipfirst" in myopts:
4757                                 mymergelist = mymergelist[1:]
4758                         if len(mymergelist) == 0:
4759                                 print colorize("INFORM", "emerge: It seems we have nothing to resume...")
4760                                 sys.exit(0)
4761                         mydepgraph.display(mymergelist)
4762                 else:
4763                         mydepgraph.display(
4764                                 mydepgraph.altlist(reversed=("--tree" in myopts)))
4765         else:
4766                 if ("--buildpkgonly" in myopts):
4767                         if not mydepgraph.digraph.hasallzeros(ignore_priority=DepPriority.MEDIUM):
4768                                 print "\n!!! --buildpkgonly requires all dependencies to be merged."
4769                                 print "!!! Cannot merge requested packages. Merge deps and try again.\n"
4770                                 sys.exit(1)
4771
4772                 if ("--resume" in myopts):
4773                         favorites=mtimedb["resume"]["favorites"]
4774                         mergetask = MergeTask(settings, trees, myopts)
4775                         if "--fetchonly" in myopts:
4776                                 """ parallel-fetch uses --resume --fetchonly and we don't want
4777                                 it to write the mtimedb"""
4778                                 mtimedb.filename = None
4779                                 time.sleep(3) # allow the parent to have first fetch
4780                         del mydepgraph
4781                         retval = mergetask.merge(
4782                                 mtimedb["resume"]["mergelist"], favorites, mtimedb)
4783                         if retval != os.EX_OK:
4784                                 sys.exit(retval)
4785                 else:
4786                         if "resume" in mtimedb and \
4787                         "mergelist" in mtimedb["resume"] and \
4788                         len(mtimedb["resume"]["mergelist"]) > 1:
4789                                 mtimedb["resume_backup"] = mtimedb["resume"]
4790                                 del mtimedb["resume"]
4791                                 mtimedb.commit()
4792                         mtimedb["resume"]={}
4793                         # XXX: Stored as a list for backward compatibility.
4794                         mtimedb["resume"]["myopts"] = \
4795                                 [k for k in myopts if myopts[k] is True]
4796                         mtimedb["resume"]["favorites"]=favorites
4797                         if ("--digest" in myopts) and not ("--fetchonly" in myopts or "--fetch-all-uri" in myopts):
4798                                 for pkgline in mydepgraph.altlist():
4799                                         if pkgline[0]=="ebuild" and pkgline[3]=="merge":
4800                                                 y = trees[pkgline[1]]["porttree"].dbapi.findname(pkgline[2])
4801                                                 tmpsettings = portage.config(clone=settings)
4802                                                 edebug = 0
4803                                                 if settings.get("PORTAGE_DEBUG", "") == "1":
4804                                                         edebug = 1
4805                                                 retval = portage.doebuild(
4806                                                         y, "digest", settings["ROOT"], tmpsettings, edebug,
4807                                                         ("--pretend" in myopts),
4808                                                         mydbapi=trees[pkgline[1]]["porttree"].dbapi,
4809                                                         tree="porttree")
4810                         if "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
4811                                 pkglist = []
4812                                 for pkg in mydepgraph.altlist():
4813                                         if pkg[0] != "blocks":
4814                                                 pkglist.append(pkg)
4815                         else:
4816                                 pkglist = mydepgraph.altlist()
4817                         del mydepgraph
4818                         mergetask = MergeTask(settings, trees, myopts)
4819                         retval = mergetask.merge(pkglist, favorites, mtimedb)
4820                         if retval != os.EX_OK:
4821                                 sys.exit(retval)
4822
4823                 if mtimedb.has_key("resume"):
4824                         del mtimedb["resume"]
4825                 if settings["AUTOCLEAN"] and "yes"==settings["AUTOCLEAN"]:
4826                         print ">>> Auto-cleaning packages..."
4827                         vartree = trees[settings["ROOT"]]["vartree"]
4828                         unmerge(settings, myopts, vartree, "clean", ["world"],
4829                                 ldpath_mtimes, autoclean=1)
4830                 else:
4831                         portage.writemsg_stdout(colorize("WARN", "WARNING:")
4832                                 + " AUTOCLEAN is disabled.  This can cause serious"
4833                                 + " problems due to overlapping packages.\n")
4834
4835 def multiple_actions(action1, action2):
4836         sys.stderr.write("\n!!! Multiple actions requested... Please choose one only.\n")
4837         sys.stderr.write("!!! '%s' or '%s'\n\n" % (action1, action2))
4838         sys.exit(1)
4839
4840 def parse_opts(tmpcmdline, silent=False):
4841         myaction=None
4842         myopts = {}
4843         myfiles=[]
4844
4845         global actions, options, shortmapping
4846
4847         longopt_aliases = {"--cols":"--columns", "--skip-first":"--skipfirst"}
4848         argument_options = {
4849                 "--config-root": {
4850                         "help":"specify the location for portage configuration files",
4851                         "action":"store"
4852                 },
4853                 "--color": {
4854                         "help":"enable or disable color output",
4855                         "type":"choice",
4856                         "choices":("y", "n")
4857                 },
4858                 "--with-bdeps": {
4859                         "help":"include unnecessary build time dependencies",
4860                         "type":"choice",
4861                         "choices":("y", "n")
4862                 }
4863         }
4864
4865         from optparse import OptionParser
4866         parser = OptionParser()
4867         if parser.has_option("--help"):
4868                 parser.remove_option("--help")
4869
4870         for action_opt in actions:
4871                 parser.add_option("--" + action_opt, action="store_true",
4872                         dest=action_opt.replace("-", "_"), default=False)
4873         for myopt in options:
4874                 parser.add_option(myopt, action="store_true",
4875                         dest=myopt.lstrip("--").replace("-", "_"), default=False)
4876         for shortopt, longopt in shortmapping.iteritems():
4877                 parser.add_option("-" + shortopt, action="store_true",
4878                         dest=longopt.lstrip("--").replace("-", "_"), default=False)
4879         for myalias, myopt in longopt_aliases.iteritems():
4880                 parser.add_option(myalias, action="store_true",
4881                         dest=myopt.lstrip("--").replace("-", "_"), default=False)
4882
4883         for myopt, kwargs in argument_options.iteritems():
4884                 parser.add_option(myopt,
4885                         dest=myopt.lstrip("--").replace("-", "_"), **kwargs)
4886
4887         myoptions, myargs = parser.parse_args(args=tmpcmdline)
4888
4889         for myopt in options:
4890                 v = getattr(myoptions, myopt.lstrip("--").replace("-", "_"))
4891                 if v:
4892                         myopts[myopt] = True
4893
4894         for myopt in argument_options:
4895                 v = getattr(myoptions, myopt.lstrip("--").replace("-", "_"), None)
4896                 if v is not None:
4897                         myopts[myopt] = v
4898
4899         for action_opt in actions:
4900                 v = getattr(myoptions, action_opt.replace("-", "_"))
4901                 if v:
4902                         if myaction:
4903                                 multiple_actions(myaction, action_opt)
4904                                 sys.exit(1)
4905                         myaction = action_opt
4906
4907         for x in myargs:
4908                 if x in actions and myaction != "search":
4909                         if not silent and x not in ["system", "world"]:
4910                                 print red("*** Deprecated use of action '%s', use '--%s' instead" % (x,x))
4911                         # special case "search" so people can search for action terms, e.g. emerge -s sync
4912                         if myaction:
4913                                 multiple_actions(myaction, x)
4914                                 sys.exit(1)
4915                         myaction = x
4916                 else:
4917                         myfiles.append(x)
4918
4919         if "--nocolor" in myopts:
4920                 if not silent:
4921                         sys.stderr.write("*** Deprecated use of '--nocolor', " + \
4922                                 "use '--color=n' instead.\n")
4923                 del myopts["--nocolor"]
4924                 myopts["--color"] = "n"
4925
4926         return myaction, myopts, myfiles
4927
4928 def validate_ebuild_environment(trees):
4929         for myroot in trees:
4930                 mysettings = trees[myroot]["vartree"].settings
4931                 if not mysettings.get("ARCH", None):
4932                         print >> sys.stderr, bad("\a!!! ARCH is not set... " + \
4933                                 "Are you missing the '%setc/make.profile' symlink?" % \
4934                                 mysettings["PORTAGE_CONFIGROOT"])
4935                         print >> sys.stderr, bad("\a!!! Is the symlink correct? " + \
4936                                 "Is your portage tree complete?\n")
4937                         sys.exit(9)
4938                 del myroot, mysettings
4939
4940 def load_emerge_config(trees=None):
4941         kwargs = {}
4942         for k, envvar in (("config_root", "PORTAGE_CONFIGROOT"), ("target_root", "ROOT")):
4943                 kwargs[k] = os.environ.get(envvar, None)
4944         trees = portage.create_trees(trees=trees, **kwargs)
4945
4946         settings = trees["/"]["vartree"].settings
4947
4948         for myroot in trees:
4949                 if myroot != "/":
4950                         settings = trees[myroot]["vartree"].settings
4951                         break
4952
4953         mtimedbfile = os.path.join("/", portage.CACHE_PATH.lstrip(os.path.sep), "mtimedb")
4954         mtimedb = portage.MtimeDB(mtimedbfile)
4955         return settings, trees, mtimedb
4956
4957 def adjust_config(myopts, settings):
4958         """Make emerge specific adjustments to the config."""
4959
4960         # To enhance usability, make some vars case insensitive by forcing them to
4961         # lower case.
4962         for myvar in ("AUTOCLEAN", "NOCOLOR"):
4963                 if myvar in settings:
4964                         settings[myvar] = settings[myvar].lower()
4965                         settings.backup_changes(myvar)
4966         del myvar
4967
4968         # Kill noauto as it will break merges otherwise.
4969         if "noauto" in settings.features:
4970                 while "noauto" in settings.features:
4971                         settings.features.remove("noauto")
4972                 settings["FEATURES"] = " ".join(settings.features)
4973                 settings.backup_changes("FEATURES")
4974
4975         CLEAN_DELAY = 5
4976         try:
4977                 CLEAN_DELAY = int(settings.get("CLEAN_DELAY", str(CLEAN_DELAY)))
4978         except ValueError, e:
4979                 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
4980                 portage.writemsg("!!! Unable to parse integer: CLEAN_DELAY='%s'\n" % \
4981                         settings["CLEAN_DELAY"], noiselevel=-1)
4982         settings["CLEAN_DELAY"] = str(CLEAN_DELAY)
4983         settings.backup_changes("CLEAN_DELAY")
4984
4985         EMERGE_WARNING_DELAY = 10
4986         try:
4987                 EMERGE_WARNING_DELAY = int(settings.get(
4988                         "EMERGE_WARNING_DELAY", str(EMERGE_WARNING_DELAY)))
4989         except ValueError, e:
4990                 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
4991                 portage.writemsg("!!! Unable to parse integer: EMERGE_WARNING_DELAY='%s'\n" % \
4992                         settings["EMERGE_WARNING_DELAY"], noiselevel=-1)
4993         settings["EMERGE_WARNING_DELAY"] = str(EMERGE_WARNING_DELAY)
4994         settings.backup_changes("EMERGE_WARNING_DELAY")
4995
4996         if "--quiet" in myopts:
4997                 settings["PORTAGE_QUIET"]="1"
4998                 settings.backup_changes("PORTAGE_QUIET")
4999
5000         # Set so that configs will be merged regardless of remembered status
5001         if ("--noconfmem" in myopts):
5002                 settings["NOCONFMEM"]="1"
5003                 settings.backup_changes("NOCONFMEM")
5004
5005         # Set various debug markers... They should be merged somehow.
5006         PORTAGE_DEBUG = 0
5007         try:
5008                 PORTAGE_DEBUG = int(settings.get("PORTAGE_DEBUG", str(PORTAGE_DEBUG)))
5009                 if PORTAGE_DEBUG not in (0, 1):
5010                         portage.writemsg("!!! Invalid value: PORTAGE_DEBUG='%i'\n" % \
5011                                 PORTAGE_DEBUG, noiselevel=-1)
5012                         portage.writemsg("!!! PORTAGE_DEBUG must be either 0 or 1\n",
5013                                 noiselevel=-1)
5014                         PORTAGE_DEBUG = 0
5015         except ValueError, e:
5016                 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
5017                 portage.writemsg("!!! Unable to parse integer: PORTAGE_DEBUG='%s'\n" %\
5018                         settings["PORTAGE_DEBUG"], noiselevel=-1)
5019                 del e
5020         if "--debug" in myopts:
5021                 PORTAGE_DEBUG = 1
5022         settings["PORTAGE_DEBUG"] = str(PORTAGE_DEBUG)
5023         settings.backup_changes("PORTAGE_DEBUG")
5024
5025         if settings.get("NOCOLOR") not in ("yes","true"):
5026                 portage.output.havecolor = 1
5027
5028         """The explicit --color < y | n > option overrides the NOCOLOR environment
5029         variable and stdout auto-detection."""
5030         if "--color" in myopts:
5031                 if "y" == myopts["--color"]:
5032                         portage.output.havecolor = 1
5033                         settings["NOCOLOR"] = "false"
5034                 else:
5035                         portage.output.havecolor = 0
5036                         settings["NOCOLOR"] = "true"
5037                 settings.backup_changes("NOCOLOR")
5038         elif not sys.stdout.isatty() and settings.get("NOCOLOR") != "no":
5039                 portage.output.havecolor = 0
5040                 settings["NOCOLOR"] = "true"
5041                 settings.backup_changes("NOCOLOR")
5042
5043 def emerge_main():
5044         global portage  # NFC why this is necessary now - genone
5045         # Disable color until we're sure that it should be enabled (after
5046         # EMERGE_DEFAULT_OPTS has been parsed).
5047         portage.output.havecolor = 0
5048         # This first pass is just for options that need to be known as early as
5049         # possible, such as --config-root.  They will be parsed again later,
5050         # together with EMERGE_DEFAULT_OPTS (which may vary depending on the
5051         # the value of --config-root).
5052         myaction, myopts, myfiles = parse_opts(sys.argv[1:], silent=True)
5053         if "--debug" in myopts:
5054                 os.environ["PORTAGE_DEBUG"] = "1"
5055         if "--config-root" in myopts:
5056                 os.environ["PORTAGE_CONFIGROOT"] = myopts["--config-root"]
5057
5058         # Portage needs to ensure a sane umask for the files it creates.
5059         os.umask(022)
5060         settings, trees, mtimedb = load_emerge_config()
5061         portdb = trees[settings["ROOT"]]["porttree"].dbapi
5062
5063         try:
5064                 os.nice(int(settings.get("PORTAGE_NICENESS", "0")))
5065         except (OSError, ValueError), e:
5066                 portage.writemsg("!!! Failed to change nice value to '%s'\n" % \
5067                         settings["PORTAGE_NICENESS"])
5068                 portage.writemsg("!!! %s\n" % str(e))
5069                 del e
5070
5071         if portage.global_updates(settings, trees, mtimedb["updates"]):
5072                 mtimedb.commit()
5073                 # Reload the whole config from scratch.
5074                 settings, trees, mtimedb = load_emerge_config(trees=trees)
5075                 portdb = trees[settings["ROOT"]]["porttree"].dbapi
5076
5077         xterm_titles = "notitles" not in settings.features
5078
5079         tmpcmdline = []
5080         if "--ignore-default-opts" not in sys.argv:
5081                 tmpcmdline.extend(settings["EMERGE_DEFAULT_OPTS"].split())
5082         tmpcmdline.extend(sys.argv[1:])
5083         myaction, myopts, myfiles = parse_opts(tmpcmdline)
5084
5085         if "--digest" in myopts:
5086                 os.environ["FEATURES"] = os.environ.get("FEATURES","") + " digest"
5087                 # Reload the whole config from scratch so that the portdbapi internal
5088                 # config is updated with new FEATURES.
5089                 settings, trees, mtimedb = load_emerge_config(trees=trees)
5090                 portdb = trees[settings["ROOT"]]["porttree"].dbapi
5091
5092         for myroot in trees:
5093                 mysettings =  trees[myroot]["vartree"].settings
5094                 mysettings.unlock()
5095                 adjust_config(myopts, mysettings)
5096                 mysettings.lock()
5097                 del myroot, mysettings
5098
5099         spinner = stdout_spinner()
5100         if "candy" in settings.features:
5101                 spinner.update = spinner.update_scroll
5102
5103         portage.deprecated_profile_check()
5104
5105         #Freeze the portdbapi for enhanced performance:
5106         for myroot in trees:
5107                 trees[myroot]["porttree"].dbapi.freeze()
5108                 del myroot
5109
5110         if "moo" in myfiles:
5111                 print """
5112
5113   Larry loves Gentoo (""" + os.uname()[0] + """)
5114
5115  _______________________
5116 < Have you mooed today? >
5117  -----------------------
5118         \   ^__^
5119          \  (oo)\_______
5120             (__)\       )\/\
5121                 ||----w |
5122                 ||     ||
5123
5124 """
5125
5126         if (myaction in ["world", "system"]) and myfiles:
5127                 print "emerge: please specify a package class (\"world\" or \"system\") or individual packages, but not both."
5128                 sys.exit(1)
5129
5130         for x in myfiles:
5131                 ext = os.path.splitext(x)[1]
5132                 if (ext == ".ebuild" or ext == ".tbz2") and os.path.exists(os.path.abspath(x)):
5133                         print "emerging by path implies --oneshot... adding --oneshot to options."
5134                         print colorize("BAD", "\n*** emerging by path is broken and may not always work!!!\n")
5135                         break
5136
5137         if ("--tree" in myopts) and ("--columns" in myopts):
5138                 print "emerge: can't specify both of \"--tree\" and \"--columns\"."
5139                 sys.exit(1)
5140
5141         if ("--quiet" in myopts):
5142                 spinner.update = spinner.update_quiet
5143                 portage.util.noiselimit = -1
5144
5145         # Always create packages if FEATURES=buildpkg
5146         # Imply --buildpkg if --buildpkgonly
5147         if ("buildpkg" in settings.features) or ("--buildpkgonly" in myopts):
5148                 if "--buildpkg" not in myopts:
5149                         myopts["--buildpkg"] = True
5150
5151         # Also allow -S to invoke search action (-sS)
5152         if ("--searchdesc" in myopts):
5153                 if myaction and myaction != "search":
5154                         myfiles.append(myaction)
5155                 if "--search" not in myopts:
5156                         myopts["--search"] = True
5157                 myaction = "search"
5158
5159         # Always try and fetch binary packages if FEATURES=getbinpkg
5160         if ("getbinpkg" in settings.features):
5161                 myopts["--getbinpkg"] = True
5162
5163         if "--skipfirst" in myopts and "--resume" not in myopts:
5164                 myopts["--resume"] = True
5165
5166         if ("--getbinpkgonly" in myopts) and not ("--usepkgonly" in myopts):
5167                 myopts["--usepkgonly"] = True
5168
5169         if ("--getbinpkgonly" in myopts) and not ("--getbinpkg" in myopts):
5170                 myopts["--getbinpkg"] = True
5171
5172         if ("--getbinpkg" in myopts) and not ("--usepkg" in myopts):
5173                 myopts["--usepkg"] = True
5174
5175         # Also allow -K to apply --usepkg/-k
5176         if ("--usepkgonly" in myopts) and not ("--usepkg" in myopts):
5177                 myopts["--usepkg"] = True
5178
5179         # Allow -p to remove --ask
5180         if ("--pretend" in myopts) and ("--ask" in myopts):
5181                 print ">>> --pretend disables --ask... removing --ask from options."
5182                 del myopts["--ask"]
5183
5184         # forbid --ask when not in a terminal
5185         # note: this breaks `emerge --ask | tee logfile`, but that doesn't work anyway.
5186         if ("--ask" in myopts) and (not sys.stdin.isatty()):
5187                 portage.writemsg("!!! \"--ask\" should only be used in a terminal. Exiting.\n",
5188                         noiselevel=-1)
5189                 sys.exit(1)
5190
5191         if settings.get("PORTAGE_DEBUG", "") == "1":
5192                 spinner.update = spinner.update_quiet
5193                 portage.debug=1
5194                 if "python-trace" in settings.features:
5195                         import portage.debug
5196                         portage.debug.set_trace(True)
5197
5198         if ("--resume" in myopts):
5199                 if "--tree" in myopts:
5200                         print "* --tree is currently broken with --resume. Disabling..."
5201                         del myopts["--tree"]
5202
5203         if not ("--quiet" in myopts):
5204                 if not sys.stdout.isatty() or ("--nospinner" in myopts):
5205                         spinner.update = spinner.update_basic
5206
5207         if "--version" in myopts:
5208                 print getportageversion(settings["PORTDIR"], settings["ROOT"],
5209                         settings.profile_path, settings["CHOST"],
5210                         trees[settings["ROOT"]]["vartree"].dbapi)
5211                 sys.exit(0)
5212         elif "--help" in myopts:
5213                 portage.emergehelp.help(myaction, myopts, portage.output.havecolor)
5214                 sys.exit(0)
5215
5216         if portage.wheelgid == portage.portage_gid:
5217                 print "emerge: wheel group use is being deprecated. Please update group and passwd to"
5218                 print "        include the portage user as noted above, and then use group portage."
5219
5220         if "--debug" in myopts:
5221                 print "myaction", myaction
5222                 print "myopts", myopts
5223
5224         if not myaction and not myfiles and "--resume" not in myopts:
5225                 portage.emergehelp.help(myaction, myopts, portage.output.havecolor)
5226                 sys.exit(1)
5227
5228         # check if root user is the current user for the actions where emerge needs this
5229         if portage.secpass < 2:
5230                 # We've already allowed "--version" and "--help" above.
5231                 if "--pretend" not in myopts and \
5232                 myaction not in ("search","info"):
5233                         need_superuser = not \
5234                                 ("--fetchonly" in myopts or \
5235                                 "--fetch-all-uri" in myopts or \
5236                                 myaction in ("metadata", "regen"))
5237                         if portage.secpass < 1 or \
5238                                 need_superuser:
5239                                 if need_superuser:
5240                                         access_desc = "superuser"
5241                                 else:
5242                                         access_desc = "portage group"
5243                                 # Always show portage_group_warning() when only portage group
5244                                 # access is required but the user is not in the portage group.
5245                                 from portage.data import portage_group_warning
5246                                 if "--ask" in myopts:
5247                                         myopts["--pretend"] = True
5248                                         del myopts["--ask"]
5249                                         print ("%s access would be required... " + \
5250                                                 "adding --pretend to options.\n") % access_desc
5251                                         if portage.secpass < 1 and not need_superuser:
5252                                                 portage_group_warning()
5253                                 else:
5254                                         sys.stderr.write(("emerge: %s access would be " + \
5255                                                 "required.\n\n") % access_desc)
5256                                         if portage.secpass < 1 and not need_superuser:
5257                                                 portage_group_warning()
5258                                         return 1
5259
5260         disable_emergelog = False
5261         for x in ("--pretend", "--fetchonly", "--fetch-all-uri"):
5262                 if x in myopts:
5263                         disable_emergelog = True
5264                         break
5265         if myaction in ("search", "info"):
5266                 disable_emergelog = True
5267         if disable_emergelog:
5268                 """ Disable emergelog for everything except build or unmerge
5269                 operations.  This helps minimize parallel emerge.log entries that can
5270                 confuse log parsers.  We especially want it disabled during
5271                 parallel-fetch, which uses --resume --fetchonly."""
5272                 global emergelog
5273                 def emergelog(*pargs, **kargs):
5274                         pass
5275
5276         if not "--pretend" in myopts:
5277                 emergelog(xterm_titles, "Started emerge on: "+\
5278                         time.strftime("%b %d, %Y %H:%M:%S", time.localtime()))
5279                 myelogstr=""
5280                 if myopts:
5281                         myelogstr=" ".join(myopts)
5282                 if myaction:
5283                         myelogstr+=" "+myaction
5284                 if myfiles:
5285                         myelogstr+=" "+" ".join(myfiles)
5286                 emergelog(xterm_titles, " *** emerge " + myelogstr)
5287
5288         def emergeexitsig(signum, frame):
5289                 signal.signal(signal.SIGINT, signal.SIG_IGN)
5290                 signal.signal(signal.SIGTERM, signal.SIG_IGN)
5291                 portage.util.writemsg("\n\nExiting on signal %(signal)s\n" % {"signal":signum})
5292                 sys.exit(100+signum)
5293         signal.signal(signal.SIGINT, emergeexitsig)
5294         signal.signal(signal.SIGTERM, emergeexitsig)
5295
5296         def emergeexit():
5297                 """This gets out final log message in before we quit."""
5298                 if "--pretend" not in myopts:
5299                         emergelog(xterm_titles, " *** terminating.")
5300                 if "notitles" not in settings.features:
5301                         xtermTitleReset()
5302         portage.atexit_register(emergeexit)
5303
5304         if myaction in ("config", "metadata", "regen", "sync"):
5305                 if "--pretend" in myopts:
5306                         sys.stderr.write(("emerge: The '%s' action does " + \
5307                                 "not support '--pretend'.\n") % myaction)
5308                         return 1
5309         if "sync" == myaction:
5310                 action_sync(settings, trees, mtimedb, myopts, myaction)
5311         elif "metadata" == myaction:
5312                 action_metadata(settings, portdb, myopts)
5313         elif myaction=="regen":
5314                 validate_ebuild_environment(trees)
5315                 action_regen(settings, portdb)
5316         # HELP action
5317         elif "config"==myaction:
5318                 validate_ebuild_environment(trees)
5319                 action_config(settings, trees, myopts, myfiles)
5320
5321         # INFO action
5322         elif "info"==myaction:
5323                 action_info(settings, trees, myopts, myfiles)
5324
5325         # SEARCH action
5326         elif "search"==myaction:
5327                 validate_ebuild_environment(trees)
5328                 action_search(settings, portdb, trees["/"]["vartree"],
5329                         myopts, myfiles, spinner)
5330         elif "unmerge"==myaction or "prune"==myaction or "clean"==myaction:
5331                 validate_ebuild_environment(trees)
5332                 vartree = trees[settings["ROOT"]]["vartree"]
5333                 if 1 == unmerge(settings, myopts, vartree, myaction, myfiles,
5334                         mtimedb["ldpath"]):
5335                         if "--pretend" not in myopts:
5336                                 post_emerge(settings, mtimedb, 0)
5337
5338         elif "depclean"==myaction:
5339                 validate_ebuild_environment(trees)
5340                 action_depclean(settings, trees, mtimedb["ldpath"],
5341                         myopts, spinner)
5342                 if "--pretend" not in myopts:
5343                         post_emerge(settings, mtimedb, 0)
5344         # "update", "system", or just process files:
5345         else:
5346                 validate_ebuild_environment(trees)
5347                 action_build(settings, trees, mtimedb,
5348                         myopts, myaction, myfiles, spinner)
5349                 if "--pretend" not in myopts:
5350                         post_emerge(settings, mtimedb, 0)
5351
5352 if __name__ == "__main__":
5353         retval = emerge_main()
5354         sys.exit(retval)