2 # Copyright 1999-2006 Gentoo Foundation
3 # Distributed under the terms of the GNU General Public License v2
4 # $Id: emerge 5976 2007-02-17 09:14:53Z genone $
7 # This block ensures that ^C interrupts are handled quietly.
11 def exithandler(signum,frame):
12 signal.signal(signal.SIGINT, signal.SIG_IGN)
13 signal.signal(signal.SIGTERM, signal.SIG_IGN)
16 signal.signal(signal.SIGINT, exithandler)
17 signal.signal(signal.SIGTERM, exithandler)
18 signal.signal(signal.SIGPIPE, signal.SIG_DFL)
20 except KeyboardInterrupt:
25 os.environ["PORTAGE_LEGACY_GLOBALS"] = "false"
29 from os import path as osp
30 sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "pym"))
32 del os.environ["PORTAGE_LEGACY_GLOBALS"]
33 from portage import digraph, portdbapi
34 from portage.const import NEWS_LIB_PATH, CACHE_PATH
37 import portage.xpak, commands, errno, re, socket, time, types
38 from portage.output import blue, bold, colorize, darkblue, darkgreen, darkred, green, \
39 havecolor, nc_len, nocolor, red, teal, turquoise, white, xtermTitle, \
40 xtermTitleReset, yellow
41 from portage.output import create_color_func
42 good = create_color_func("GOOD")
43 bad = create_color_func("BAD")
46 portage.dep._dep_check_strict = True
49 import portage.exception
50 from portage.data import secpass
51 from portage.util import normalize_path as normpath
52 from portage.util import writemsg
54 if not hasattr(__builtins__, "set"):
55 from sets import Set as set
56 from itertools import chain, izip
57 from UserDict import DictMixin
62 import pickle as cPickle
64 class stdout_spinner(object):
66 "Gentoo Rocks ("+os.uname()[0]+")",
67 "Thank you for using Gentoo. :)",
68 "Are you actually trying to read this?",
69 "How many times have you stared at this?",
70 "We are generating the cache right now",
71 "You are paying too much attention.",
72 "A theory is better than its explanation.",
73 "Phasers locked on target, Captain.",
74 "Thrashing is just virtual crashing.",
75 "To be is to program.",
76 "Real Users hate Real Programmers.",
77 "When all else fails, read the instructions.",
78 "Functionality breeds Contempt.",
79 "The future lies ahead.",
80 "3.1415926535897932384626433832795028841971694",
81 "Sometimes insanity is the only alternative.",
82 "Inaccuracy saves a world of explanation.",
85 twirl_sequence = "/-\\|/-\\|/-\\|/-\\|\\-/|\\-/|\\-/|\\-/|"
89 self.update = self.update_twirl
90 self.scroll_sequence = self.scroll_msgs[
91 int(time.time() * 100) % len(self.scroll_msgs)]
93 def update_basic(self):
94 self.spinpos = (self.spinpos + 1) % 500
95 if (self.spinpos % 100) == 0:
97 sys.stdout.write(". ")
102 def update_scroll(self):
103 if(self.spinpos >= len(self.scroll_sequence)):
104 sys.stdout.write(darkgreen(" \b\b\b" + self.scroll_sequence[
105 len(self.scroll_sequence) - 1 - (self.spinpos % len(self.scroll_sequence))]))
107 sys.stdout.write(green("\b " + self.scroll_sequence[self.spinpos]))
109 self.spinpos = (self.spinpos + 1) % (2 * len(self.scroll_sequence))
111 def update_twirl(self):
112 self.spinpos = (self.spinpos + 1) % len(self.twirl_sequence)
113 sys.stdout.write("\b\b " + self.twirl_sequence[self.spinpos])
116 def update_quiet(self):
119 def userquery(prompt, responses=None, colours=None):
120 """Displays a prompt and a set of responses, then waits for a response
121 which is checked against the responses and the first to match is
122 returned. An empty response will match the first value in responses. The
123 input buffer is *not* cleared prior to the prompt!
126 responses: a List of Strings.
127 colours: a List of Functions taking and returning a String, used to
128 process the responses for display. Typically these will be functions
129 like red() but could be e.g. lambda x: "DisplayString".
130 If responses is omitted, defaults to ["Yes", "No"], [green, red].
131 If only colours is omitted, defaults to [bold, ...].
133 Returns a member of the List responses. (If called without optional
134 arguments, returns "Yes" or "No".)
135 KeyboardInterrupt is converted to SystemExit to avoid tracebacks being
137 if responses is None:
138 responses, colours = ["Yes", "No"], [green, red]
139 elif colours is None:
141 colours=(colours*len(responses))[:len(responses)]
145 response=raw_input("["+"/".join([colours[i](responses[i]) for i in range(len(responses))])+"] ")
146 for key in responses:
147 # An empty response will match the first value in responses.
148 if response.upper()==key[:len(response)].upper():
150 print "Sorry, response '%s' not understood." % response,
151 except (EOFError, KeyboardInterrupt):
156 "clean", "config", "depclean",
158 "prune", "regen", "search",
159 "sync", "system", "unmerge", "world",
162 "--ask", "--alphabetical",
163 "--buildpkg", "--buildpkgonly",
164 "--changelog", "--columns",
168 "--fetchonly", "--fetch-all-uri",
169 "--getbinpkg", "--getbinpkgonly",
170 "--help", "--ignore-default-opts",
172 "--newuse", "--nocolor",
173 "--nodeps", "--noreplace",
174 "--nospinner", "--oneshot",
175 "--onlydeps", "--pretend",
176 "--quiet", "--resume",
177 "--searchdesc", "--selective",
181 "--usepkg", "--usepkgonly",
182 "--verbose", "--version"
188 "b":"--buildpkg", "B":"--buildpkgonly",
189 "c":"--clean", "C":"--unmerge",
190 "d":"--debug", "D":"--deep",
192 "f":"--fetchonly", "F":"--fetch-all-uri",
193 "g":"--getbinpkg", "G":"--getbinpkgonly",
195 "k":"--usepkg", "K":"--usepkgonly",
197 "n":"--noreplace", "N":"--newuse",
198 "o":"--onlydeps", "O":"--nodeps",
199 "p":"--pretend", "P":"--prune",
201 "s":"--search", "S":"--searchdesc",
204 "v":"--verbose", "V":"--version"
207 def emergelog(xterm_titles, mystr, short_msg=None):
209 if short_msg == None:
211 if "HOSTNAME" in os.environ.keys():
212 short_msg = os.environ["HOSTNAME"]+": "+short_msg
213 xtermTitle(short_msg)
215 file_path = "/var/log/emerge.log"
216 mylogfile = open(file_path, "a")
217 portage.util.apply_secpass_permissions(file_path,
218 uid=portage.portage_uid, gid=portage.portage_gid,
222 mylock = portage.locks.lockfile(mylogfile)
223 # seek because we may have gotten held up by the lock.
224 # if so, we may not be positioned at the end of the file.
226 mylogfile.write(str(time.time())[:10]+": "+mystr+"\n")
230 portage.locks.unlockfile(mylock)
232 except (IOError,OSError,portage.exception.PortageException), e:
234 print >> sys.stderr, "emergelog():",e
236 def countdown(secs=5, doing="Starting"):
238 print ">>> Waiting",secs,"seconds before starting..."
239 print ">>> (Control-C to abort)...\n"+doing+" in: ",
243 sys.stdout.write(colorize("UNMERGE_WARN", str(sec+1)+" "))
248 # formats a size given in bytes nicely
249 def format_size(mysize):
250 if type(mysize) not in [types.IntType,types.LongType]:
252 if 0 != mysize % 1024:
253 # Always round up to the next kB so that it doesn't show 0 kB when
254 # some small file still needs to be fetched.
255 mysize += 1024 - mysize % 1024
256 mystr=str(mysize/1024)
260 mystr=mystr[:mycount]+","+mystr[mycount:]
264 def getgccversion(chost):
267 return: the current in-use gcc version
270 gcc_ver_command = 'gcc -dumpversion'
271 gcc_ver_prefix = 'gcc-'
273 gcc_not_found_error = red(
274 "!!! No gcc found. You probably need to 'source /etc/profile'\n" +
275 "!!! to update the environment of this terminal and possibly\n" +
276 "!!! other terminals also.\n"
279 mystatus, myoutput = commands.getstatusoutput("eselect compiler show")
280 if mystatus == os.EX_OK and len(myoutput.split("/")) == 2:
281 part1, part2 = myoutput.split("/")
282 if part1.startswith(chost + "-"):
283 return myoutput.replace(chost + "-", gcc_ver_prefix, 1)
285 mystatus, myoutput = commands.getstatusoutput("gcc-config -c")
286 if mystatus == os.EX_OK and myoutput.startswith(chost + "-"):
287 return myoutput.replace(chost + "-", gcc_ver_prefix, 1)
289 mystatus, myoutput = commands.getstatusoutput(
290 chost + "-" + gcc_ver_command)
291 if mystatus == os.EX_OK:
292 return gcc_ver_prefix + myoutput
294 mystatus, myoutput = commands.getstatusoutput(gcc_ver_command)
295 if mystatus == os.EX_OK:
296 return gcc_ver_prefix + myoutput
298 portage.writemsg(gcc_not_found_error, noiselevel=-1)
299 return "[unavailable]"
301 def getportageversion(portdir, target_root, profile, chost, vardb):
302 profilever = "unavailable"
304 realpath = os.path.realpath(profile)
305 basepath = os.path.realpath(os.path.join(portdir, "profiles"))
306 if realpath.startswith(basepath):
307 profilever = realpath[1 + len(basepath):]
310 profilever = "!" + os.readlink(profile)
313 del realpath, basepath
316 libclist = vardb.match("virtual/libc")
317 libclist += vardb.match("virtual/glibc")
318 libclist = portage.util.unique_array(libclist)
320 xs=portage.catpkgsplit(x)
322 libcver+=","+"-".join(xs[1:])
324 libcver="-".join(xs[1:])
326 libcver="unavailable"
328 gccver = getgccversion(chost)
329 unameout=os.uname()[2]+" "+os.uname()[4]
331 return "Portage " + portage.VERSION +" ("+profilever+", "+gccver+", "+libcver+", "+unameout+")"
333 def create_depgraph_params(myopts, myaction):
334 #configure emerge engine parameters
336 # self: include _this_ package regardless of if it is merged.
337 # selective: exclude the package if it is merged
338 # recurse: go into the dependencies
339 # deep: go into the dependencies of already merged packages
340 # empty: pretend nothing is merged
341 myparams = ["recurse"]
344 if "--update" in myopts or \
345 "--newuse" in myopts or \
346 "--noreplace" in myopts or \
347 myaction in ("system", "world"):
348 add.extend(["selective"])
349 if "--emptytree" in myopts:
350 add.extend(["empty"])
351 sub.extend(["selective"])
352 if "--nodeps" in myopts:
353 sub.extend(["recurse"])
354 if "--deep" in myopts:
357 if (x not in myparams) and (x not in sub):
364 # search functionality
376 def __init__(self, settings, portdb, vartree, spinner, searchdesc,
378 """Searches the available and installed packages for the supplied search key.
379 The list of available and installed packages is created at object instantiation.
380 This makes successive searches faster."""
381 self.settings = settings
383 self.vartree = vartree
384 self.spinner = spinner
385 self.verbose = verbose
386 self.searchdesc = searchdesc
388 def execute(self,searchkey):
389 """Performs the search for the supplied search key"""
391 self.searchkey=searchkey
392 self.packagematches = []
395 self.matches = {"pkg":[], "desc":[]}
398 self.matches = {"pkg":[]}
399 print "Searching... ",
402 if self.searchkey.startswith('%'):
404 self.searchkey = self.searchkey[1:]
405 if self.searchkey.startswith('@'):
407 self.searchkey = self.searchkey[1:]
409 self.searchre=re.compile(self.searchkey,re.I)
411 self.searchre=re.compile(re.escape(self.searchkey), re.I)
412 for package in self.portdb.cp_all():
413 self.spinner.update()
416 match_string = package[:]
418 match_string = package.split("/")[-1]
421 if self.searchre.search(match_string):
422 if not self.portdb.xmatch("match-visible", package):
424 self.matches["pkg"].append([package,masked])
425 elif self.searchdesc: # DESCRIPTION searching
426 full_package = self.portdb.xmatch("bestmatch-visible", package)
428 #no match found; we don't want to query description
429 full_package = portage.best(
430 self.portdb.xmatch("match-all", package))
436 full_desc = self.portdb.aux_get(
437 full_package, ["DESCRIPTION"])[0]
439 print "emerge: search: aux_get() failed, skipping"
441 if self.searchre.search(full_desc):
442 self.matches["desc"].append([full_package,masked])
444 for mtype in self.matches.keys():
445 self.matches[mtype].sort()
446 self.mlen += len(self.matches[mtype])
449 """Outputs the results of the search."""
450 print "\b\b \n[ Results for search key : "+white(self.searchkey)+" ]"
451 print "[ Applications found : "+white(str(self.mlen))+" ]"
453 for mtype in self.matches.keys():
454 for match,masked in self.matches[mtype]:
457 full_package = self.portdb.xmatch(
458 "bestmatch-visible", match)
460 #no match found; we don't want to query description
462 full_package = portage.best(
463 self.portdb.xmatch("match-all",match))
466 match = portage.pkgsplit(match)[0]
470 desc, homepage, license = self.portdb.aux_get(
471 full_package, ["DESCRIPTION","HOMEPAGE","LICENSE"])
473 print "emerge: search: aux_get() failed, skipping"
476 print green("*")+" "+white(match)+" "+red("[ Masked ]")
478 print green("*")+" "+white(match)
479 myversion = self.getVersion(full_package, search.VERSION_RELEASE)
482 mycat = match.split("/")[0]
483 mypkg = match.split("/")[1]
484 mycpv = match + "-" + myversion
485 myebuild = self.portdb.findname(mycpv)
486 pkgdir = os.path.dirname(myebuild)
487 from portage import manifest
488 mf = manifest.Manifest(
489 pkgdir, self.settings["DISTDIR"])
490 fetchlist = self.portdb.getfetchlist(mycpv,
491 mysettings=self.settings, all=True)[1]
493 mysum[0] = mf.getDistfilesSize(fetchlist)
494 mystr = str(mysum[0]/1024)
498 mystr=mystr[:mycount]+","+mystr[mycount:]
501 mysum[0] = "Unknown (missing digest for %s)" % str(e)
504 print " ", darkgreen("Latest version available:"),myversion
505 print " ", self.getInstallationStatus(mycat+'/'+mypkg)
506 print " ", darkgreen("Size of files:"),mysum[0]
507 print " ", darkgreen("Homepage:")+" ",homepage
508 print " ", darkgreen("Description:")+" ",desc
509 print " ", darkgreen("License:")+" ",license
515 def getInstallationStatus(self,package):
516 installed_package = self.vartree.dep_bestmatch(package)
518 version = self.getVersion(installed_package,search.VERSION_RELEASE)
520 result = darkgreen("Latest version installed:")+" "+version
522 result = darkgreen("Latest version installed:")+" [ Not Installed ]"
525 def getVersion(self,full_package,detail):
526 if len(full_package) > 1:
527 package_parts = portage.catpkgsplit(full_package)
528 if detail == search.VERSION_RELEASE and package_parts[3] != 'r0':
529 result = package_parts[2]+ "-" + package_parts[3]
531 result = package_parts[2]
537 #build our package digraph
538 def getlist(settings, mode):
540 mylines = settings.packages
543 file_path = os.path.join(settings["ROOT"], portage.WORLD_FILE)
544 myfile = open(file_path, "r")
545 mylines = myfile.readlines()
547 except (OSError, IOError), e:
548 if e.errno == errno.ENOENT:
549 portage.writemsg("\n!!! World file does not exist: '%s'\n" % file_path)
555 myline=" ".join(x.split())
564 mynewlines.append(myline.strip())
568 def clean_world(vardb, cpv):
569 """Remove a package from the world file when unmerged."""
570 world_filename = os.path.join(vardb.root, portage.WORLD_FILE)
571 worldlist = portage.util.grabfile(world_filename)
572 mykey = portage.cpv_getkey(cpv)
575 if portage.dep_getkey(x) == mykey:
576 matches = vardb.match(x, use_cache=0)
580 elif len(matches) == 1 and matches[0] == cpv:
584 #others are around; keep it.
585 newworldlist.append(x)
587 #this doesn't match the package we're unmerging; keep it.
588 newworldlist.append(x)
590 portage.util.ensure_dirs(os.path.join(vardb.root, portage.PRIVATE_PATH),
591 gid=portage.portage_gid, mode=02770)
592 portage.util.write_atomic(world_filename, "\n".join(newworldlist))
594 def genericdict(mylist):
597 mynewdict[portage.dep_getkey(x)]=x
600 def filter_iuse_defaults(iuse):
602 if flag.startswith("+") or flag.startswith("-"):
607 class DepPriority(object):
609 This class generates an integer priority level based of various
610 attributes of the dependency relationship. Attributes can be assigned
611 at any time and the new integer value will be generated on calls to the
612 __int__() method. Rich comparison operators are supported.
614 The boolean attributes that affect the integer value are "satisfied",
615 "buildtime", "runtime", and "system". Various combinations of
616 attributes lead to the following priority levels:
618 Combination of properties Priority level
620 not satisfied and buildtime 0
621 not satisfied and runtime -1
622 satisfied and buildtime -2
623 satisfied and runtime -3
624 (none of the above) -4
626 Several integer constants are defined for categorization of priority
629 MEDIUM The upper boundary for medium dependencies.
630 SOFT The upper boundary for soft dependencies.
631 MIN The lower boundary for soft dependencies.
633 __slots__ = ("__weakref__", "satisfied", "buildtime", "runtime")
637 def __init__(self, **kwargs):
638 for myattr in self.__slots__:
639 if myattr == "__weakref__":
641 myvalue = kwargs.get(myattr, False)
642 setattr(self, myattr, myvalue)
644 if not self.satisfied:
654 def __lt__(self, other):
655 return self.__int__() < other
656 def __le__(self, other):
657 return self.__int__() <= other
658 def __eq__(self, other):
659 return self.__int__() == other
660 def __ne__(self, other):
661 return self.__int__() != other
662 def __gt__(self, other):
663 return self.__int__() > other
664 def __ge__(self, other):
665 return self.__int__() >= other
668 return copy.copy(self)
670 myvalue = self.__int__()
671 if myvalue > self.MEDIUM:
673 if myvalue > self.SOFT:
677 class FakeVartree(portage.vartree):
678 """This is implements an in-memory copy of a vartree instance that provides
679 all the interfaces required for use by the depgraph. The vardb is locked
680 during the constructor call just long enough to read a copy of the
681 installed package information. This allows the depgraph to do it's
682 dependency calculations without holding a lock on the vardb. It also
683 allows things like vardb global updates to be done in memory so that the
684 user doesn't necessarily need write access to the vardb in cases where
685 global updates are necessary (updates are performed when necessary if there
686 is not a matching ebuild in the tree)."""
687 def __init__(self, real_vartree, portdb):
688 self.root = real_vartree.root
689 self.settings = real_vartree.settings
690 self.dbapi = portage.fakedbapi(settings=real_vartree.settings)
691 vdb_path = os.path.join(self.root, portage.VDB_PATH)
693 # At least the parent needs to exist for the lock file.
694 portage.util.ensure_dirs(vdb_path)
695 except portage.exception.PortageException:
699 if os.access(vdb_path, os.W_OK):
700 vdb_lock = portage.locks.lockdir(vdb_path)
701 mykeys = ["SLOT", "COUNTER", "PROVIDE", "USE", "IUSE",
702 "DEPEND", "RDEPEND", "PDEPEND"]
703 real_dbapi = real_vartree.dbapi
705 for cpv in real_dbapi.cpv_all():
706 metadata = dict(izip(mykeys, real_dbapi.aux_get(cpv, mykeys)))
707 myslot = metadata["SLOT"]
708 mycp = portage.dep_getkey(cpv)
709 myslot_atom = "%s:%s" % (mycp, myslot)
711 mycounter = long(metadata["COUNTER"])
714 metadata["COUNTER"] = str(mycounter)
715 other_counter = slot_counters.get(myslot_atom, None)
716 if other_counter is not None:
717 if other_counter > mycounter:
719 slot_counters[myslot_atom] = mycounter
720 self.dbapi.cpv_inject(cpv, metadata=metadata)
721 real_dbapi.flush_cache()
724 portage.locks.unlockdir(vdb_lock)
725 # Populate the old-style virtuals using the cached values.
726 if not self.settings.treeVirtuals:
727 self.settings.treeVirtuals = portage.util.map_dictlist_vals(
728 portage.getCPFromCPV, self.get_all_provides())
730 # Intialize variables needed for lazy cache pulls of the live ebuild
731 # metadata. This ensures that the vardb lock is released ASAP, without
732 # being delayed in case cache generation is triggered.
733 self._aux_get = self.dbapi.aux_get
734 self.dbapi.aux_get = self._aux_get_wrapper
735 self._aux_get_history = set()
736 self._portdb_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
737 self._portdb = portdb
738 self._global_updates = None
740 def _aux_get_wrapper(self, pkg, wants):
741 if pkg in self._aux_get_history:
742 return self._aux_get(pkg, wants)
743 self._aux_get_history.add(pkg)
745 # Use the live ebuild metadata if possible.
746 live_metadata = dict(izip(self._portdb_keys,
747 self._portdb.aux_get(pkg, self._portdb_keys)))
748 self.dbapi.aux_update(pkg, live_metadata)
749 except (KeyError, portage.exception.PortageException):
750 if self._global_updates is None:
751 self._global_updates = \
752 grab_global_updates(self._portdb.porttree_root)
753 perform_global_updates(
754 pkg, self.dbapi, self._global_updates)
755 return self._aux_get(pkg, wants)
757 def grab_global_updates(portdir):
758 from portage.update import grab_updates, parse_updates
759 updpath = os.path.join(portdir, "profiles", "updates")
761 rawupdates = grab_updates(updpath)
762 except portage.exception.DirectoryNotFound:
765 for mykey, mystat, mycontent in rawupdates:
766 commands, errors = parse_updates(mycontent)
767 upd_commands.extend(commands)
770 def perform_global_updates(mycpv, mydb, mycommands):
771 from portage.update import update_dbentries
772 aux_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
773 aux_dict = dict(izip(aux_keys, mydb.aux_get(mycpv, aux_keys)))
774 updates = update_dbentries(mycommands, aux_dict)
776 mydb.aux_update(mycpv, updates)
778 class BlockerCache(DictMixin):
779 """This caches blockers of installed packages so that dep_check does not
780 have to be done for every single installed package on every invocation of
781 emerge. The cache is invalidated whenever it is detected that something
782 has changed that might alter the results of dep_check() calls:
783 1) the set of installed packages (including COUNTER) has changed
784 2) the old-style virtuals have changed
786 class BlockerData(object):
787 def __init__(self, counter, atoms):
788 self.counter = counter
791 def __init__(self, myroot, vardb):
793 self._installed_pkgs = set(vardb.cpv_all())
794 self._virtuals = vardb.settings.getvirtuals()
795 self._cache_filename = os.path.join(myroot,
796 portage.CACHE_PATH.lstrip(os.path.sep), "vdb_blockers.pickle")
797 self._cache_version = "1"
798 self._cache_data = None
799 self._modified = False
804 f = open(self._cache_filename)
805 mypickle = cPickle.Unpickler(f)
806 mypickle.find_global = None
807 self._cache_data = mypickle.load()
810 except (IOError, OSError, EOFError, cPickle.UnpicklingError):
812 cache_valid = self._cache_data and \
813 isinstance(self._cache_data, dict) and \
814 self._cache_data.get("version") == self._cache_version and \
815 self._cache_data.get("virtuals") == self._virtuals and \
816 set(self._cache_data.get("blockers", [])) == self._installed_pkgs
818 for pkg in self._installed_pkgs:
819 if long(self._vardb.aux_get(pkg, ["COUNTER"])[0]) != \
824 self._cache_data = {"version":self._cache_version}
825 self._cache_data["blockers"] = {}
826 self._cache_data["virtuals"] = self._virtuals
827 self._modified = False
830 """If the current user has permission and the internal blocker cache
831 been updated, save it to disk and mark it unmodified. This is called
832 by emerge after it has proccessed blockers for all installed packages.
833 Currently, the cache is only written if the user has superuser
834 privileges (since that's required to obtain a lock), but all users
835 have read access and benefit from faster blocker lookups (as long as
836 the entire cache is still valid). The cache is stored as a pickled
837 dict object with the following format:
841 "blockers" : {cpv1:(counter,(atom1, atom2...)), cpv2...},
842 "virtuals" : vardb.settings.getvirtuals()
845 if self._modified and \
848 f = portage.util.atomic_ofstream(self._cache_filename)
849 cPickle.dump(self._cache_data, f, -1)
851 portage.util.apply_secpass_permissions(
852 self._cache_filename, gid=portage.portage_gid, mode=0644)
853 except (IOError, OSError), e:
855 self._modified = False
857 def __setitem__(self, cpv, blocker_data):
859 Update the cache and mark it as modified for a future call to
862 @param cpv: Package for which to cache blockers.
864 @param blocker_data: An object with counter and atoms attributes.
865 @type blocker_data: BlockerData
867 self._cache_data["blockers"][cpv] = \
868 (blocker_data.counter, blocker_data.atoms)
869 self._modified = True
871 def __getitem__(self, cpv):
874 @returns: An object with counter and atoms attributes.
876 return self.BlockerData(*self._cache_data["blockers"][cpv])
878 def show_invalid_depstring_notice(parent_node, depstring, error_msg):
880 from formatter import AbstractFormatter, DumbWriter
881 f = AbstractFormatter(DumbWriter(maxcol=72))
883 print "\n\n!!! Invalid or corrupt dependency specification: "
891 p_type, p_root, p_key, p_status = parent_node
893 if p_status == "nomerge":
894 category, pf = portage.catsplit(p_key)
895 pkg_location = os.path.join(p_root, portage.VDB_PATH, category, pf)
896 msg.append("Portage is unable to process the dependencies of the ")
897 msg.append("'%s' package. " % p_key)
898 msg.append("In order to correct this problem, the package ")
899 msg.append("should be uninstalled, reinstalled, or upgraded. ")
900 msg.append("As a temporary workaround, the --nodeps option can ")
901 msg.append("be used to ignore all dependencies. For reference, ")
902 msg.append("the problematic dependencies can be found in the ")
903 msg.append("*DEPEND files located in '%s/'." % pkg_location)
905 msg.append("This package can not be installed. ")
906 msg.append("Please notify the '%s' package maintainer " % p_key)
907 msg.append("about this problem.")
910 f.add_flowing_data(x)
918 "installed":"vartree"}
920 def __init__(self, settings, trees, myopts, myparams, spinner):
921 self.settings = settings
922 self.target_root = settings["ROOT"]
924 self.myparams = myparams
926 if settings.get("PORTAGE_DEBUG", "") == "1":
928 self.spinner = spinner
929 self.pkgsettings = {}
930 # Maps cpv to digraph node for all nodes added to the graph.
931 self.pkg_node_map = {}
932 # Maps slot atom to digraph node for all nodes added to the graph.
933 self._slot_node_map = {}
935 self._mydbapi_keys = ["SLOT", "DEPEND", "RDEPEND", "PDEPEND"]
939 self.trees[myroot] = {}
940 for tree in ("porttree", "bintree"):
941 self.trees[myroot][tree] = trees[myroot][tree]
942 self.trees[myroot]["vartree"] = \
943 FakeVartree(trees[myroot]["vartree"],
944 trees[myroot]["porttree"].dbapi)
945 self.pkgsettings[myroot] = portage.config(
946 clone=self.trees[myroot]["vartree"].settings)
947 self.pkg_node_map[myroot] = {}
948 self._slot_node_map[myroot] = {}
949 vardb = self.trees[myroot]["vartree"].dbapi
950 # This fakedbapi instance will model the state that the vdb will
951 # have after new packages have been installed.
952 fakedb = portage.fakedbapi(settings=self.pkgsettings[myroot])
953 self.mydbapi[myroot] = fakedb
954 if "--nodeps" not in self.myopts and \
955 "--buildpkgonly" not in self.myopts:
956 # --nodeps bypasses this, since it isn't needed in this case
957 # and the cache pulls might trigger (slow) cache generation.
958 for pkg in vardb.cpv_all():
959 self.spinner.update()
960 fakedb.cpv_inject(pkg,
961 metadata=dict(izip(self._mydbapi_keys,
962 vardb.aux_get(pkg, self._mydbapi_keys))))
964 self.useFlags[myroot] = {}
965 if "--usepkg" in self.myopts:
966 self.trees[myroot]["bintree"].populate(
967 "--getbinpkg" in self.myopts,
968 "--getbinpkgonly" in self.myopts)
972 self.digraph=portage.digraph()
973 # Tracks simple parent/child relationships (PDEPEND relationships are
975 self._parent_child_digraph = digraph()
977 self.outdatedpackages=[]
979 self.blocker_digraph = digraph()
980 self.blocker_parents = {}
981 self._unresolved_blocker_parents = {}
982 self._slot_collision_info = []
983 # Slot collision nodes are not allowed to block other packages since
984 # blocker validation is only able to account for one package per slot.
985 self._slot_collision_nodes = set()
986 self._altlist_cache = {}
987 self._pprovided_args = []
989 def _show_slot_collision_notice(self, packages):
990 """Show an informational message advising the user to mask one of the
991 the packages. In some cases it may be possible to resolve this
992 automatically, but support for backtracking (removal nodes that have
993 already been selected) will be required in order to handle all possible
997 msg.append("\n!!! Multiple versions within a single " + \
998 "package slot have been \n")
999 msg.append("!!! pulled into the dependency graph:\n\n")
1000 for node, parents in packages:
1001 msg.append(str(node))
1003 msg.append(" pulled in by\n")
1004 for parent in parents:
1006 msg.append(str(parent))
1009 msg.append(" (no parents)\n")
1011 sys.stderr.write("".join(msg))
1014 if "--quiet" in self.myopts:
1018 msg.append("It may be possible to solve this problem ")
1019 msg.append("by using package.mask to prevent one of ")
1020 msg.append("those packages from being selected. ")
1021 msg.append("However, it is also possible that conflicting ")
1022 msg.append("dependencies exist such that they are impossible to ")
1023 msg.append("satisfy simultaneously. If such a conflict exists in ")
1024 msg.append("the dependencies of two different packages, then those ")
1025 msg.append("packages can not be installed simultaneously.")
1027 from formatter import AbstractFormatter, DumbWriter
1028 f = AbstractFormatter(DumbWriter(sys.stderr, maxcol=72))
1030 f.add_flowing_data(x)
1034 msg.append("For more information, see MASKED PACKAGES ")
1035 msg.append("section in the emerge man page or refer ")
1036 msg.append("to the Gentoo Handbook.")
1038 f.add_flowing_data(x)
1042 def create(self, mybigkey, myparent=None, addme=1, myuse=None,
1043 priority=DepPriority(), rev_dep=False, arg=None):
1045 Fills the digraph with nodes comprised of packages to merge.
1046 mybigkey is the package spec of the package to merge.
1047 myparent is the package depending on mybigkey ( or None )
1048 addme = Should we add this package to the digraph or are we just looking at it's deps?
1049 Think --onlydeps, we need to ignore packages in that case.
1052 #IUSE-aware emerge -> USE DEP aware depgraph
1053 #"no downgrade" emerge
1055 mytype, myroot, mykey = mybigkey
1056 existing_node = None
1058 existing_node = self.pkg_node_map[myroot].get(mykey)
1060 self._parent_child_digraph.add(existing_node, myparent)
1061 if existing_node != myparent:
1062 # Refuse to make a node depend on itself so that the we don't
1063 # don't create a bogus circular dependency in self.altlist().
1064 if rev_dep and myparent:
1065 self.digraph.addnode(myparent, existing_node,
1068 self.digraph.addnode(existing_node, myparent,
1072 if "--nodeps" not in self.myopts:
1073 self.spinner.update()
1074 if mytype == "blocks":
1076 "--buildpkgonly" not in self.myopts and \
1077 "--nodeps" not in self.myopts and \
1078 myparent not in self._slot_collision_nodes:
1079 mybigkey[1] = myparent[1]
1080 self.blocker_parents.setdefault(
1081 tuple(mybigkey), set()).add(myparent)
1084 # select the correct /var database that we'll be checking against
1085 vardbapi = self.trees[myroot]["vartree"].dbapi
1086 portdb = self.trees[myroot]["porttree"].dbapi
1087 bindb = self.trees[myroot]["bintree"].dbapi
1088 pkgsettings = self.pkgsettings[myroot]
1090 # if the package is already on the system, we add a "nomerge"
1091 # directive, otherwise we add a "merge" directive.
1093 mydbapi = self.trees[myroot][self.pkg_tree_map[mytype]].dbapi
1095 if not arg and myroot == self.target_root:
1096 cpv_slot = "%s:%s" % (mykey, mydbapi.aux_get(mykey, ["SLOT"])[0])
1097 arg = portage.best_match_to_list(cpv_slot, self.args_keys)
1100 self.pkgsettings[myroot].setcpv(mykey, mydb=portdb)
1101 myuse = self.pkgsettings[myroot]["USE"].split()
1104 if mytype == "installed":
1106 if addme and mytype != "installed":
1107 # this is where we add the node to the list of packages to merge
1108 if "selective" in self.myparams or not arg:
1109 if "empty" not in self.myparams and vardbapi.cpv_exists(mykey):
1112 """ If we aren't merging, perform the --newuse check.
1113 If the package has new iuse flags or different use flags then if
1114 --newuse is specified, we need to merge the package. """
1115 if merging==0 and "--newuse" in self.myopts and \
1116 vardbapi.cpv_exists(mykey):
1117 pkgsettings.setcpv(mykey, mydb=mydbapi)
1118 forced_flags = set()
1119 forced_flags.update(pkgsettings.useforce)
1120 forced_flags.update(pkgsettings.usemask)
1121 old_use = vardbapi.aux_get(mykey, ["USE"])[0].split()
1122 iuses = set(filter_iuse_defaults(
1123 mydbapi.aux_get(mykey, ["IUSE"])[0].split()))
1124 old_iuse = set(filter_iuse_defaults(
1125 vardbapi.aux_get(mykey, ["IUSE"])[0].split()))
1126 if iuses.symmetric_difference(
1127 old_iuse).difference(forced_flags):
1129 elif old_iuse.intersection(old_use) != \
1130 iuses.intersection(myuse):
1133 if addme and merging == 1:
1134 mybigkey.append("merge")
1136 mybigkey.append("nomerge")
1137 jbigkey = tuple(mybigkey)
1140 metadata = dict(izip(self._mydbapi_keys,
1141 mydbapi.aux_get(mykey, self._mydbapi_keys)))
1142 if merging == 0 and vardbapi.cpv_exists(mykey) and \
1143 mytype != "installed":
1144 mybigkey[0] = "installed"
1146 jbigkey = tuple(mybigkey)
1147 metadata = dict(izip(self._mydbapi_keys,
1148 mydbapi.aux_get(mykey, self._mydbapi_keys)))
1149 myuse = mydbapi.aux_get(mykey, ["USE"])[0].split()
1150 slot_atom = "%s:%s" % (portage.dep_getkey(mykey), metadata["SLOT"])
1151 existing_node = self._slot_node_map[myroot].get(
1153 slot_collision = False
1155 e_type, myroot, e_cpv, e_status = existing_node
1157 # The existing node can be reused.
1158 self._parent_child_digraph.add(existing_node, myparent)
1159 if rev_dep and myparent:
1160 ptype, proot, pkey, pstatus = myparent
1161 self.digraph.addnode(myparent, existing_node,
1164 self.digraph.addnode(existing_node, myparent,
1168 # A slot collision has occurred. Sometimes this coincides
1169 # with unresolvable blockers, so the slot collision will be
1170 # shown later if there are no unresolvable blockers.
1171 e_parents = self._parent_child_digraph.parent_nodes(
1175 myparents.append(myparent)
1176 self._slot_collision_info.append(
1177 ((jbigkey, myparents), (existing_node, e_parents)))
1178 self._slot_collision_nodes.add(jbigkey)
1179 slot_collision = True
1182 # Now add this node to the graph so that self.display()
1183 # can show use flags and --tree portage.output. This node is
1184 # only being partially added to the graph. It must not be
1185 # allowed to interfere with the other nodes that have been
1186 # added. Do not overwrite data for existing nodes in
1187 # self.pkg_node_map and self.mydbapi since that data will
1188 # be used for blocker validation.
1189 self.pkg_node_map[myroot].setdefault(mykey, jbigkey)
1190 self.useFlags[myroot].setdefault(mykey, myuse)
1191 # Even though the graph is now invalid, continue to process
1192 # dependencies so that things like --fetchonly can still
1193 # function despite collisions.
1195 self.mydbapi[myroot].cpv_inject(mykey, metadata=metadata)
1196 self._slot_node_map[myroot][slot_atom] = jbigkey
1197 self.pkg_node_map[myroot][mykey] = jbigkey
1198 self.useFlags[myroot][mykey] = myuse
1200 if rev_dep and myparent:
1201 self.digraph.addnode(myparent, jbigkey,
1204 self.digraph.addnode(jbigkey, myparent,
1207 # Do this even when addme is False (--onlydeps) so that the
1208 # parent/child relationship is always known in case
1209 # self._show_slot_collision_notice() needs to be called later.
1210 self._parent_child_digraph.add(jbigkey, myparent)
1212 """ This section determines whether we go deeper into dependencies or not.
1213 We want to go deeper on a few occasions:
1214 Installing package A, we need to make sure package A's deps are met.
1215 emerge --deep <pkgspec>; we need to recursively check dependencies of pkgspec
1216 If we are in --nodeps (no recursion) mode, we obviously only check 1 level of dependencies.
1218 if "deep" not in self.myparams and not merging and \
1219 not ("--update" in self.myopts and arg and merging):
1221 elif "recurse" not in self.myparams:
1224 """ Check DEPEND/RDEPEND/PDEPEND/SLOT
1225 Pull from bintree if it's binary package, porttree if it's ebuild.
1226 Binpkg's can be either remote or local. """
1229 depkeys = ["DEPEND","RDEPEND","PDEPEND"]
1230 depvalues = mydbapi.aux_get(mykey, depkeys)
1231 for i in xrange(len(depkeys)):
1232 edepend[depkeys[i]] = depvalues[i]
1234 if mytype == "ebuild":
1235 if "--buildpkgonly" in self.myopts:
1236 edepend["RDEPEND"] = ""
1237 edepend["PDEPEND"] = ""
1238 if not (arg and "--onlydeps" in self.myopts and \
1239 mytype == "ebuild") and \
1240 self.myopts.get("--with-bdeps", "n") == "n" and \
1241 (mytype == "binary" or mybigkey[3] == "nomerge"):
1242 edepend["DEPEND"] = ""
1244 """ We have retrieve the dependency information, now we need to recursively
1245 process them. DEPEND gets processed for root = "/", {R,P}DEPEND in myroot. """
1247 mp = tuple(mybigkey)
1250 if not self.select_dep("/", edepend["DEPEND"], myparent=mp,
1251 myuse=myuse, priority=DepPriority(buildtime=True),
1254 """RDEPEND is soft by definition. However, in order to ensure
1255 correct merge order, we make it a hard dependency. Otherwise, a
1256 build time dependency might not be usable due to it's run time
1257 dependencies not being installed yet.
1259 if not self.select_dep(myroot,edepend["RDEPEND"], myparent=mp,
1260 myuse=myuse, priority=DepPriority(runtime=True),
1263 if edepend.has_key("PDEPEND") and edepend["PDEPEND"]:
1264 # Post Depend -- Add to the list without a parent, as it depends
1265 # on a package being present AND must be built after that package.
1266 if not self.select_dep(myroot, edepend["PDEPEND"], myparent=mp,
1267 myuse=myuse, priority=DepPriority(), rev_deps=True,
1270 except ValueError, e:
1272 portage.writemsg("\n\n!!! An atom in the dependencies " + \
1273 "is not fully-qualified. Multiple matches:\n\n", noiselevel=-1)
1275 portage.writemsg(" %s\n" % cpv, noiselevel=-1)
1276 portage.writemsg("\n", noiselevel=-1)
1277 if mytype == "binary":
1279 "!!! This binary package cannot be installed: '%s'\n" % \
1280 mykey, noiselevel=-1)
1281 elif mytype == "ebuild":
1282 myebuild, mylocation = portdb.findname2(mykey)
1283 portage.writemsg("!!! This ebuild cannot be installed: " + \
1284 "'%s'\n" % myebuild, noiselevel=-1)
1285 portage.writemsg("!!! Please notify the package maintainer " + \
1286 "that atoms must be fully-qualified.\n", noiselevel=-1)
1290 def select_files(self,myfiles):
1291 "given a list of .tbz2s, .ebuilds and deps, create the appropriate depgraph and return a favorite list"
1293 myroot = self.target_root
1294 portdb = self.trees[myroot]["porttree"].dbapi
1295 bindb = self.trees[myroot]["bintree"].dbapi
1296 pkgsettings = self.pkgsettings[myroot]
1298 def visible(mylist):
1299 matches = portdb.gvisible(portdb.visible(mylist))
1300 return [x for x in mylist \
1301 if x in matches or not portdb.cpv_exists(x)]
1303 ext = os.path.splitext(x)[1]
1305 if not os.path.exists(x):
1307 os.path.join(pkgsettings["PKGDIR"], "All", x)):
1308 x = os.path.join(pkgsettings["PKGDIR"], "All", x)
1309 elif os.path.exists(
1310 os.path.join(pkgsettings["PKGDIR"], x)):
1311 x = os.path.join(pkgsettings["PKGDIR"], x)
1313 print "\n\n!!! Binary package '"+str(x)+"' does not exist."
1314 print "!!! Please ensure the tbz2 exists as specified.\n"
1316 mytbz2=portage.xpak.tbz2(x)
1317 mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.splitext(os.path.basename(x))[0]
1318 if os.path.realpath(x) != \
1319 os.path.realpath(self.trees[myroot]["bintree"].getname(mykey)):
1320 print colorize("BAD", "\n*** You need to adjust PKGDIR to emerge this package.\n")
1322 if not self.create(["binary", myroot, mykey],
1323 None, "--onlydeps" not in self.myopts):
1324 return (0,myfavorites)
1325 elif not "--oneshot" in self.myopts:
1326 myfavorites.append(mykey)
1327 elif ext==".ebuild":
1328 x = os.path.realpath(x)
1329 mykey=os.path.basename(os.path.normpath(x+"/../.."))+"/"+os.path.splitext(os.path.basename(x))[0]
1330 ebuild_path = portdb.findname(mykey)
1332 if os.path.realpath(ebuild_path) != x:
1333 print colorize("BAD", "\n*** You need to adjust PORTDIR or PORTDIR_OVERLAY to emerge this package.\n")
1335 if mykey not in portdb.xmatch(
1336 "match-visible", portage.dep_getkey(mykey)):
1337 print colorize("BAD", "\n*** You are emerging a masked package. It is MUCH better to use")
1338 print colorize("BAD", "*** /etc/portage/package.* to accomplish this. See portage(5) man")
1339 print colorize("BAD", "*** page for details.")
1340 countdown(int(self.settings["EMERGE_WARNING_DELAY"]),
1343 raise portage.exception.PackageNotFound(
1344 "%s is not in a valid portage tree hierarchy or does not exist" % x)
1345 if not self.create(["ebuild", myroot, mykey],
1346 None, "--onlydeps" not in self.myopts):
1347 return (0,myfavorites)
1348 elif not "--oneshot" in self.myopts:
1349 myfavorites.append(mykey)
1351 if not is_valid_package_atom(x):
1352 portage.writemsg("\n\n!!! '%s' is not a valid package atom.\n" % x,
1354 portage.writemsg("!!! Please check ebuild(5) for full details.\n")
1355 portage.writemsg("!!! (Did you specify a version but forget to prefix with '='?)\n")
1359 if "--usepkg" in self.myopts:
1360 mykey = portage.dep_expand(x, mydb=bindb,
1361 settings=pkgsettings)
1362 if (mykey and not mykey.startswith("null/")) or \
1363 "--usepkgonly" in self.myopts:
1364 arg_atoms.append((x, mykey))
1367 mykey = portage.dep_expand(x,
1368 mydb=portdb, settings=pkgsettings)
1369 arg_atoms.append((x, mykey))
1370 except ValueError, errpkgs:
1371 print "\n\n!!! The short ebuild name \"" + x + "\" is ambiguous. Please specify"
1372 print "!!! one of the following fully-qualified ebuild names instead:\n"
1373 for i in errpkgs[0]:
1374 print " " + green(i)
1378 if "--update" in self.myopts:
1379 """Make sure all installed slots are updated when possible. Do this
1380 with --emptytree also, to ensure that all slots are remerged."""
1381 vardb = self.trees[self.target_root]["vartree"].dbapi
1383 for myarg, myatom in arg_atoms:
1384 greedy_atoms.append((myarg, myatom))
1386 for cpv in vardb.match(myatom):
1387 myslots.add(vardb.aux_get(cpv, ["SLOT"])[0])
1390 if "--usepkg" in self.myopts:
1391 mymatches = bindb.match(myatom)
1392 if "--usepkgonly" not in self.myopts:
1393 mymatches = visible(mymatches)
1394 best_pkg = portage.best(mymatches)
1396 best_slot = bindb.aux_get(best_pkg, ["SLOT"])[0]
1397 best_pkgs.append(("binary", best_pkg, best_slot))
1398 if "--usepkgonly" not in self.myopts:
1399 best_pkg = portage.best(portdb.match(myatom))
1401 best_slot = portdb.aux_get(best_pkg, ["SLOT"])[0]
1402 best_pkgs.append(("ebuild", best_pkg, best_slot))
1404 best_pkg = portage.best([x[1] for x in best_pkgs])
1405 best_pkgs = [x for x in best_pkgs if x[1] == best_pkg]
1406 best_slot = best_pkgs[0][2]
1407 myslots.add(best_slot)
1408 if len(myslots) > 1:
1409 for myslot in myslots:
1410 myslot_atom = "%s:%s" % \
1411 (portage.dep_getkey(myatom), myslot)
1413 if "--usepkgonly" not in self.myopts and \
1414 self.trees[self.target_root][
1415 "porttree"].dbapi.match(myslot_atom):
1417 elif "--usepkg" in self.myopts:
1418 mymatches = bindb.match(myslot_atom)
1419 if "--usepkgonly" not in self.myopts:
1420 mymatches = visible(mymatches)
1424 greedy_atoms.append((myarg, myslot_atom))
1425 arg_atoms = greedy_atoms
1427 """ These are used inside self.create() in order to ensure packages
1428 that happen to match arguments are not incorrectly marked as nomerge."""
1429 self.args_keys = [x[1] for x in arg_atoms]
1430 for myarg, myatom in arg_atoms:
1432 self.mysd = self.select_dep(myroot, myatom, arg=myarg)
1433 except portage.exception.MissingSignature, e:
1434 portage.writemsg("\n\n!!! A missing gpg signature is preventing portage from calculating the\n")
1435 portage.writemsg("!!! required dependencies. This is a security feature enabled by the admin\n")
1436 portage.writemsg("!!! to aid in the detection of malicious intent.\n\n")
1437 portage.writemsg("!!! THIS IS A POSSIBLE INDICATION OF TAMPERED FILES -- CHECK CAREFULLY.\n")
1438 portage.writemsg("!!! Affected file: %s\n" % (e), noiselevel=-1)
1440 except portage.exception.InvalidSignature, e:
1441 portage.writemsg("\n\n!!! An invalid gpg signature is preventing portage from calculating the\n")
1442 portage.writemsg("!!! required dependencies. This is a security feature enabled by the admin\n")
1443 portage.writemsg("!!! to aid in the detection of malicious intent.\n\n")
1444 portage.writemsg("!!! THIS IS A POSSIBLE INDICATION OF TAMPERED FILES -- CHECK CAREFULLY.\n")
1445 portage.writemsg("!!! Affected file: %s\n" % (e), noiselevel=-1)
1447 except SystemExit, e:
1448 raise # Needed else can't exit
1449 except Exception, e:
1450 print >> sys.stderr, "\n\n!!! Problem in '%s' dependencies." % mykey
1451 print >> sys.stderr, "!!!", str(e), getattr(e, "__module__", None)
1455 return (0,myfavorites)
1456 elif not "--oneshot" in self.myopts:
1457 mykey = portage.dep_getkey(myatom)
1458 if mykey not in myfavorites:
1459 myfavorites.append(mykey)
1462 if "--usepkgonly" in self.myopts:
1463 for xs in self.digraph.all_nodes():
1464 if len(xs) >= 4 and xs[0] != "binary" and xs[3] == "merge":
1468 print "Missing binary for:",xs[2]
1470 if not self.validate_blockers():
1471 return False, myfavorites
1473 # We're true here unless we are missing binaries.
1474 return (not missing,myfavorites)
1476 def select_dep(self, myroot, depstring, myparent=None, arg=None,
1477 myuse=None, raise_on_missing=False, priority=DepPriority(),
1478 rev_deps=False, parent_arg=None):
1479 """ Given a depstring, create the depgraph such that all dependencies are satisfied.
1480 myroot = $ROOT from environment, where {R,P}DEPENDs are merged to.
1481 myparent = the node whose depstring is being passed in
1482 arg = package was specified on the command line, merge even if it's already installed
1483 myuse = USE flags at present
1484 raise_on_missing = Given that the depgraph is not proper, raise an exception if true
1485 else continue trying.
1486 return 1 on success, 0 for failure
1489 portdb = self.trees[myroot]["porttree"].dbapi
1490 bindb = self.trees[myroot]["bintree"].dbapi
1491 vardb = self.trees[myroot]["vartree"].dbapi
1492 pkgsettings = self.pkgsettings[myroot]
1494 p_type, p_root, p_key, p_status = myparent
1496 if "--debug" in self.myopts:
1498 print "Parent: ",myparent
1499 print "Depstring:",depstring
1501 print "Reverse:", rev_deps
1502 print "Priority:", priority
1504 #processing dependencies
1505 """ Call portage.dep_check to evaluate the use? conditionals and make sure all
1506 dependencies are satisfiable. """
1508 mymerge = [depstring]
1509 pprovided = pkgsettings.pprovideddict.get(
1510 portage.dep_getkey(depstring))
1511 if pprovided and portage.match_from_list(depstring, pprovided):
1515 if myparent and p_status == "nomerge":
1516 portage.dep._dep_check_strict = False
1517 mycheck = portage.dep_check(depstring, None,
1518 pkgsettings, myuse=myuse,
1519 use_binaries=("--usepkgonly" in self.myopts),
1520 myroot=myroot, trees=self.trees)
1522 portage.dep._dep_check_strict = True
1526 show_invalid_depstring_notice(
1527 myparent, depstring, mycheck[1])
1529 sys.stderr.write("\n%s\n%s\n" % (depstring, mycheck[1]))
1531 mymerge = mycheck[1]
1533 if not mymerge and arg and \
1534 portage.best_match_to_list(depstring, self.args_keys):
1535 # A provided package has been specified on the command line. The
1536 # package will not be merged and a warning will be displayed.
1537 self._pprovided_args.append(arg)
1540 # The parent is added after it's own dep_check call so that it
1541 # isn't allowed to satisfy a direct bootstrap dependency on itself
1542 # via an old-style virtual. This isn't a problem with new-style
1543 # virtuals, which are preferenced in dep_zapdeps by looking only at
1544 # the depstring, vdb, and available packages.
1546 p_type, p_root, p_key, p_status = myparent
1547 if p_status == "merge":
1548 # Update old-style virtuals if this package provides any.
1549 # These are needed for dep_virtual calls inside dep_check.
1550 p_db = self.trees[p_root][self.pkg_tree_map[p_type]].dbapi
1552 self.pkgsettings[p_root].setinst(p_key, p_db)
1553 except portage.exception.InvalidDependString, e:
1554 provide = p_db.aux_get(p_key, ["PROVIDE"])[0]
1555 show_invalid_depstring_notice(myparent, provide, str(e))
1559 if "--debug" in self.myopts:
1560 print "Candidates:",mymerge
1564 selected_pkg = ["blocks", myroot, x[1:], None]
1566 #We are not processing a blocker but a normal dependency
1568 """In some cases, dep_check will return deps that shouldn't
1569 be proccessed any further, so they are identified and
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 \
1577 # List of acceptable packages, ordered by type preference.
1578 matched_packages = []
1579 myeb_matches = portdb.xmatch("match-visible", x)
1581 if "--usepkgonly" not in self.myopts:
1582 myeb = portage.best(myeb_matches)
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)
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()
1602 if "--usepkgonly" not in self.myopts and myeb:
1605 pkgsettings.setcpv(myeb, mydb=mydb)
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)
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):
1619 elif iuses.intersection(old_use) != \
1620 cur_iuse.intersection(now_use):
1624 self.trees[myroot]["bintree"].dbapi.aux_get(
1625 myeb_pkg, ["USE"])[0].split()
1626 matched_packages.append(
1627 ["binary", myroot, myeb_pkg, binpkguseflags])
1629 if "--usepkgonly" not in self.myopts and myeb_matches:
1630 matched_packages.append(
1631 ["ebuild", myroot, myeb, None])
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)]
1645 if myeb_inst_matches:
1646 myeb_inst = portage.best(myeb_inst_matches)
1648 binpkguseflags = vardb.aux_get(
1649 myeb_inst, ["USE"])[0].split()
1650 matched_packages.append(
1651 ["installed", myroot, myeb_inst, binpkguseflags])
1653 if not matched_packages:
1654 if raise_on_missing:
1661 xfrom = '(dependency required by '+ \
1662 green('"%s"' % myparent[2]) + \
1663 red(' [%s]' % myparent[0]) + ')'
1664 alleb = portdb.xmatch("match-all", x)
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:"
1672 mreasons = portage.getmaskingstatus(p,
1673 settings=pkgsettings, portdb=portdb)
1674 print "- "+p+" (masked by: "+", ".join(mreasons)+")"
1675 if "package.mask" in mreasons:
1676 comment, filename = \
1677 portage.getmaskingreason(p,
1678 settings=pkgsettings, portdb=portdb,
1679 return_location=True)
1680 if comment and comment != oldcomment:
1683 oldcomment = comment
1685 licenses = portdb.aux_get(p, ["LICENSE"])[0]
1687 # Corruption will have been reported above.
1691 pkgsettings.setcpv(p, mydb=portdb)
1692 uselist = pkgsettings.get("USE", "").split()
1693 missing_licenses = []
1695 missing_licenses = \
1696 pkgsettings.getMissingLicenses(
1697 licenses, p, uselist)
1698 except portage.exception.InvalidDependString:
1699 # This will have already been reported
1700 # above via mreasons.
1702 for l in missing_licenses:
1703 l_path = portdb.findLicensePath(l)
1704 if l in shown_licenses:
1706 msg = ("A copy of the '%s' license" + \
1707 " is located at '%s'.") % (l, l_path)
1710 shown_licenses.append(l)
1712 print "For more information, see MASKED PACKAGES section in the emerge man page or "
1713 print "refer to the Gentoo Handbook."
1715 print "\n!!! "+red("There are no packages available to satisfy: ")+green(xinfo)
1716 print "!!! Either add a suitable binary package or compile from an ebuild."
1718 print "\nemerge: there are no ebuilds to satisfy "+green(xinfo)+"."
1724 if "--debug" in self.myopts:
1725 for pkg in matched_packages:
1726 print (pkg[0] + ":").rjust(10), pkg[2]
1728 if len(matched_packages) > 1:
1729 bestmatch = portage.best(
1730 [pkg[2] for pkg in matched_packages])
1731 matched_packages = [pkg for pkg in matched_packages \
1732 if pkg[2] == bestmatch]
1734 # ordered by type preference ("ebuild" type is the last resort)
1735 selected_pkg = matched_packages[0]
1736 pkgtype, myroot, mycpv, myuse = selected_pkg
1737 mydbapi = self.trees[myroot][self.pkg_tree_map[pkgtype]].dbapi
1738 slot_atom = "%s:%s" % (portage.dep_getkey(mycpv),
1739 mydbapi.aux_get(mycpv, ["SLOT"])[0])
1740 existing_node = self._slot_node_map[myroot].get(
1743 e_type, myroot, e_cpv, e_status = existing_node
1744 if portage.match_from_list(x, [e_cpv]):
1745 # The existing node can be reused.
1746 selected_pkg = [e_type, myroot, e_cpv,
1747 self.useFlags[myroot][e_cpv]]
1750 #we are a dependency, so we want to be unconditionally added
1751 mypriority = priority.copy()
1753 mypriority.satisfied = True
1754 if not self.create(selected_pkg[0:3], myparent,
1755 myuse=selected_pkg[-1], priority=mypriority,
1756 rev_dep=rev_deps, arg=arg):
1759 #if mysource is not set, then we are a command-line dependency and should not be added
1760 #if --onlydeps is specified.
1761 if not self.create(selected_pkg[0:3], myparent,
1762 addme=("--onlydeps" not in self.myopts),
1763 myuse=selected_pkg[-1], rev_dep=rev_deps, arg=arg):
1766 if "--debug" in self.myopts:
1767 print "Exiting...",myparent
1770 def validate_blockers(self):
1771 """Remove any blockers from the digraph that do not match any of the
1772 packages within the graph. If necessary, create hard deps to ensure
1773 correct merge order such that mutually blocking packages are never
1774 installed simultaneously."""
1776 if "--buildpkgonly" in self.myopts or \
1777 "--nodeps" in self.myopts:
1781 for myroot in self.trees:
1783 modified_slots[myroot] = myslots
1784 final_db = self.mydbapi[myroot]
1785 slot_node_map = self._slot_node_map[myroot]
1786 for slot_atom, mynode in slot_node_map.iteritems():
1787 mytype, myroot, mycpv, mystatus = mynode
1788 if mystatus == "merge":
1789 myslots[slot_atom] = mycpv
1791 #if "deep" in self.myparams:
1793 # Pull in blockers from all installed packages that haven't already
1794 # been pulled into the depgraph. This is not enabled by default
1795 # due to the performance penalty that is incurred by all the
1796 # additional dep_check calls that are required.
1798 # Optimization hack for dep_check calls that minimizes the
1799 # available matches by replacing the portdb with a fakedbapi
1801 class FakePortageTree(object):
1802 def __init__(self, mydb):
1804 dep_check_trees = {}
1805 for myroot in self.trees:
1806 dep_check_trees[myroot] = self.trees[myroot].copy()
1807 dep_check_trees[myroot]["porttree"] = \
1808 FakePortageTree(self.mydbapi[myroot])
1810 dep_keys = ["DEPEND","RDEPEND","PDEPEND"]
1811 for myroot in self.trees:
1812 pkg_node_map = self.pkg_node_map[myroot]
1813 vardb = self.trees[myroot]["vartree"].dbapi
1814 portdb = self.trees[myroot]["porttree"].dbapi
1815 pkgsettings = self.pkgsettings[myroot]
1816 final_db = self.mydbapi[myroot]
1817 cpv_all_installed = self.trees[myroot]["vartree"].dbapi.cpv_all()
1818 blocker_cache = BlockerCache(myroot, vardb)
1819 for pkg in cpv_all_installed:
1820 blocker_atoms = None
1821 matching_node = pkg_node_map.get(pkg, None)
1822 if matching_node and \
1823 matching_node[3] == "nomerge":
1825 # If this node has any blockers, create a "nomerge"
1826 # node for it so that they can be enforced.
1827 self.spinner.update()
1828 blocker_data = blocker_cache.get(pkg)
1830 blocker_atoms = blocker_data.atoms
1832 dep_vals = vardb.aux_get(pkg, dep_keys)
1833 myuse = vardb.aux_get(pkg, ["USE"])[0].split()
1834 depstr = " ".join(dep_vals)
1835 # It is crucial to pass in final_db here in order to
1836 # optimize dep_check calls by eliminating atoms via
1837 # dep_wordreduce and dep_eval calls.
1839 portage.dep._dep_check_strict = False
1841 success, atoms = portage.dep_check(depstr,
1842 final_db, pkgsettings, myuse=myuse,
1843 trees=dep_check_trees, myroot=myroot)
1844 except Exception, e:
1845 if isinstance(e, SystemExit):
1847 # This is helpful, for example, if a ValueError
1848 # is thrown from cpv_expand due to multiple
1849 # matches (this can happen if an atom lacks a
1851 show_invalid_depstring_notice(
1852 ("installed", myroot, pkg, "nomerge"),
1857 portage.dep._dep_check_strict = True
1859 slot_atom = "%s:%s" % (portage.dep_getkey(pkg),
1860 vardb.aux_get(pkg, ["SLOT"])[0])
1861 if slot_atom in modified_slots[myroot]:
1862 # This package is being replaced anyway, so
1863 # ignore invalid dependencies so as not to
1864 # annoy the user too much (otherwise they'd be
1865 # forced to manually unmerge it first).
1867 show_invalid_depstring_notice(
1868 ("installed", myroot, pkg, "nomerge"),
1871 blocker_atoms = [myatom for myatom in atoms \
1872 if myatom.startswith("!")]
1873 counter = long(vardb.aux_get(pkg, ["COUNTER"])[0])
1874 blocker_cache[pkg] = \
1875 blocker_cache.BlockerData(counter, blocker_atoms)
1877 # Don't store this parent in pkg_node_map, because it's
1878 # not needed there and it might overwrite a "merge"
1879 # node with the same cpv.
1880 myparent = ("installed", myroot, pkg, "nomerge")
1881 for myatom in blocker_atoms:
1882 blocker = ("blocks", myroot, myatom[1:])
1884 self.blocker_parents.get(blocker, None)
1887 self.blocker_parents[blocker] = myparents
1888 myparents.add(myparent)
1889 blocker_cache.flush()
1892 for blocker in self.blocker_parents.keys():
1893 mytype, myroot, mydep = blocker
1894 initial_db = self.trees[myroot]["vartree"].dbapi
1895 final_db = self.mydbapi[myroot]
1896 blocked_initial = initial_db.match(mydep)
1897 blocked_final = final_db.match(mydep)
1898 if not blocked_initial and not blocked_final:
1899 del self.blocker_parents[blocker]
1901 blocked_slots_initial = {}
1902 blocked_slots_final = {}
1903 for cpv in blocked_initial:
1904 blocked_slots_initial[cpv] = \
1905 "%s:%s" % (portage.dep_getkey(cpv),
1906 initial_db.aux_get(cpv, ["SLOT"])[0])
1907 for cpv in blocked_final:
1908 blocked_slots_final[cpv] = \
1909 "%s:%s" % (portage.dep_getkey(cpv),
1910 final_db.aux_get(cpv, ["SLOT"])[0])
1911 for parent in list(self.blocker_parents[blocker]):
1912 ptype, proot, pcpv, pstatus = parent
1913 pdbapi = self.trees[proot][self.pkg_tree_map[ptype]].dbapi
1914 pslot = pdbapi.aux_get(pcpv, ["SLOT"])[0]
1915 pslot_atom = "%s:%s" % (portage.dep_getkey(pcpv), pslot)
1916 parent_static = pslot_atom not in modified_slots[proot]
1917 unresolved_blocks = False
1918 depends_on_order = set()
1919 for cpv in blocked_initial:
1920 slot_atom = blocked_slots_initial[cpv]
1921 if slot_atom == pslot_atom:
1922 # TODO: Support blocks within slots in cases where it
1923 # might make sense. For example, a new version might
1924 # require that the old version be uninstalled at build
1927 if parent_static and \
1928 slot_atom not in modified_slots[myroot]:
1929 # This blocker will be handled the next time that a
1930 # merge of either package is triggered.
1932 if pstatus == "merge" and \
1933 slot_atom in modified_slots[myroot]:
1934 replacement = final_db.match(slot_atom)
1936 if not portage.match_from_list(mydep, replacement):
1937 # Apparently a replacement may be able to
1938 # invalidate this block.
1939 replacement_node = \
1940 self.pkg_node_map[proot][replacement[0]]
1941 depends_on_order.add((replacement_node, parent))
1943 # None of the above blocker resolutions techniques apply,
1944 # so apparently this one is unresolvable.
1945 unresolved_blocks = True
1946 for cpv in blocked_final:
1947 slot_atom = blocked_slots_final[cpv]
1948 if slot_atom == pslot_atom:
1949 # TODO: Support blocks within slots.
1951 if parent_static and \
1952 slot_atom not in modified_slots[myroot]:
1953 # This blocker will be handled the next time that a
1954 # merge of either package is triggered.
1956 if not parent_static and pstatus == "nomerge" and \
1957 slot_atom in modified_slots[myroot]:
1958 replacement = final_db.match(pslot_atom)
1960 replacement_node = \
1961 self.pkg_node_map[proot][replacement[0]]
1962 if replacement_node not in \
1963 self.blocker_parents[blocker]:
1964 # Apparently a replacement may be able to
1965 # invalidate this block.
1966 blocked_node = self.pkg_node_map[proot][cpv]
1967 depends_on_order.add(
1968 (replacement_node, blocked_node))
1970 # None of the above blocker resolutions techniques apply,
1971 # so apparently this one is unresolvable.
1972 unresolved_blocks = True
1973 if not unresolved_blocks and depends_on_order:
1974 for node, pnode in depends_on_order:
1975 # Enforce correct merge order with a hard dep.
1976 self.digraph.addnode(node, pnode,
1977 priority=DepPriority(buildtime=True))
1978 # Count references to this blocker so that it can be
1979 # invalidated after nodes referencing it have been
1981 self.blocker_digraph.addnode(node, blocker)
1982 if not unresolved_blocks and not depends_on_order:
1983 self.blocker_parents[blocker].remove(parent)
1984 if unresolved_blocks:
1985 self._unresolved_blocker_parents.setdefault(
1986 blocker, set()).add(parent)
1987 if not self.blocker_parents[blocker]:
1988 del self.blocker_parents[blocker]
1989 # Validate blockers that depend on merge order.
1990 if not self.blocker_digraph.empty():
1992 if self._slot_collision_info:
1993 # The user is only notified of a slot collision if there are no
1994 # unresolvable blocks.
1995 for x in self.altlist():
1996 if x[0] == "blocks":
1998 self._show_slot_collision_notice(self._slot_collision_info[0])
1999 if not self._accept_collisions():
2003 def _accept_collisions(self):
2005 for x in ("--nodeps", "--pretend", "--fetchonly", "--fetch-all-uri"):
2006 if x in self.myopts:
2011 def _merge_order_bias(self, mygraph):
2012 """Order nodes from highest to lowest overall reference count for
2013 optimal leaf node selection."""
2015 for node in mygraph.order:
2016 node_info[node] = len(mygraph.parent_nodes(node))
2017 def cmp_merge_preference(node1, node2):
2018 return node_info[node2] - node_info[node1]
2019 mygraph.order.sort(cmp_merge_preference)
2021 def altlist(self, reversed=False):
2022 if reversed in self._altlist_cache:
2023 return self._altlist_cache[reversed][:]
2025 retlist = self.altlist()
2027 self._altlist_cache[reversed] = retlist[:]
2029 mygraph=self.digraph.copy()
2030 self._merge_order_bias(mygraph)
2031 myblockers = self.blocker_digraph.copy()
2033 circular_blocks = False
2037 get_nodes = mygraph.root_nodes
2039 get_nodes = mygraph.leaf_nodes
2040 for cpv, node in self.pkg_node_map["/"].iteritems():
2041 if "portage" == portage.catsplit(portage.dep_getkey(cpv))[-1]:
2042 asap_nodes.append(node)
2044 ignore_priority_range = [None]
2045 ignore_priority_range.extend(
2046 xrange(DepPriority.MIN, DepPriority.MEDIUM + 1))
2047 tree_mode = "--tree" in self.myopts
2048 while not mygraph.empty():
2049 ignore_priority = None
2052 """ASAP nodes are merged before their soft deps."""
2053 for node in asap_nodes:
2054 if not mygraph.contains(node):
2055 asap_nodes.remove(node)
2057 if not mygraph.child_nodes(node,
2058 ignore_priority=DepPriority.SOFT):
2060 asap_nodes.remove(node)
2063 for ignore_priority in ignore_priority_range:
2064 nodes = get_nodes(ignore_priority=ignore_priority)
2067 selected_nodes = None
2069 if ignore_priority <= DepPriority.SOFT:
2070 if ignore_priority is None and not tree_mode:
2071 # Greedily pop all of these nodes since no relationship
2072 # has been ignored. This optimization destroys --tree
2073 # output, so it's disabled in reversed mode.
2074 selected_nodes = nodes
2076 # For optimal merge order:
2077 # * Only pop one node.
2078 # * Removing a root node (node without a parent)
2079 # will not produce a leaf node, so avoid it.
2081 if mygraph.parent_nodes(node):
2082 # found a non-root node
2083 selected_nodes = [node]
2085 if not selected_nodes:
2086 # settle for a root node
2087 selected_nodes = [nodes[0]]
2089 """Recursively gather a group of nodes that RDEPEND on
2090 eachother. This ensures that they are merged as a group
2091 and get their RDEPENDs satisfied as soon as possible."""
2092 def gather_deps(mergeable_nodes, selected_nodes, node):
2093 if node in selected_nodes:
2095 if node not in mergeable_nodes:
2097 selected_nodes.add(node)
2098 for child in mygraph.child_nodes(node,
2099 ignore_priority=DepPriority.SOFT):
2101 mergeable_nodes, selected_nodes, child):
2104 mergeable_nodes = set(nodes)
2106 selected_nodes = set()
2108 mergeable_nodes, selected_nodes, node):
2111 selected_nodes = None
2113 if not selected_nodes:
2114 if not myblockers.is_empty():
2115 """A blocker couldn't be circumnavigated while keeping all
2116 dependencies satisfied. The user will have to resolve this
2117 manually. This is a panic condition and thus the order
2118 doesn't really matter, so just pop a random node in order
2119 to avoid a circular dependency panic if possible."""
2120 if not circular_blocks:
2121 circular_blocks = True
2122 blocker_deps = myblockers.leaf_nodes()
2124 selected_nodes = [blocker_deps.pop()]
2126 if not selected_nodes:
2127 # No leaf nodes are available, so we have a circular
2128 # dependency panic situation. Reduce the noise level to a
2129 # minimum via repeated elimination of root nodes since they
2130 # have no parents and thus can not be part of a cycle.
2132 root_nodes = mygraph.root_nodes(
2133 ignore_priority=DepPriority.SOFT)
2136 for node in root_nodes:
2137 mygraph.remove(node)
2138 # Display the USE flags that are enabled on nodes that are part
2139 # of dependency cycles in case that helps the user decide to
2140 # disable some of them.
2142 tempgraph = mygraph.copy()
2143 while not tempgraph.empty():
2144 nodes = tempgraph.leaf_nodes()
2146 node = tempgraph.order[0]
2149 display_order.append(list(node))
2150 tempgraph.remove(node)
2151 display_order.reverse()
2152 self.myopts.pop("--quiet", None)
2153 self.myopts.pop("--verbose", None)
2154 self.myopts["--tree"] = True
2155 self.display(display_order)
2156 print "!!! Error: circular dependencies:"
2158 mygraph.debug_print()
2160 print "!!! Note that circular dependencies can often be avoided by temporarily"
2161 print "!!! disabling USE flags that trigger optional dependencies."
2164 for node in selected_nodes:
2165 retlist.append(list(node))
2166 mygraph.remove(node)
2167 if not reversed and not circular_blocks and myblockers.contains(node):
2168 """This node may have invalidated one or more blockers."""
2169 myblockers.remove(node)
2170 for blocker in myblockers.root_nodes():
2171 if not myblockers.child_nodes(blocker):
2172 myblockers.remove(blocker)
2174 self._unresolved_blocker_parents.get(blocker)
2176 self.blocker_parents[blocker] = unresolved
2178 del self.blocker_parents[blocker]
2181 """Blocker validation does not work with reverse mode,
2182 so self.altlist() should first be called with reverse disabled
2183 so that blockers are properly validated."""
2184 self.blocker_digraph = myblockers
2186 """ Add any unresolved blocks so that they can be displayed."""
2187 for blocker in self.blocker_parents:
2188 retlist.append(list(blocker))
2189 self._altlist_cache[reversed] = retlist[:]
2192 def xcreate(self,mode="system"):
2193 vardb = self.trees[self.target_root]["vartree"].dbapi
2194 portdb = self.trees[self.target_root]["porttree"].dbapi
2195 bindb = self.trees[self.target_root]["bintree"].dbapi
2196 def visible(mylist):
2197 matches = portdb.gvisible(portdb.visible(mylist))
2198 return [x for x in mylist \
2199 if x in matches or not portdb.cpv_exists(x)]
2200 world_problems = False
2202 mylist = getlist(self.settings, "system")
2205 worldlist = getlist(self.settings, "world")
2206 mylist = getlist(self.settings, "system")
2207 worlddict=genericdict(worldlist)
2209 for x in worlddict.keys():
2210 if not portage.isvalidatom(x):
2211 world_problems = True
2212 elif not self.trees[self.target_root]["vartree"].dbapi.match(x):
2213 world_problems = True
2219 mykey = portage.dep_getkey(atom)
2221 newlist.append(atom)
2222 """Make sure all installed slots are updated when possible.
2223 Do this with --emptytree also, to ensure that all slots are
2226 for cpv in vardb.match(mykey):
2227 myslots.add(vardb.aux_get(cpv, ["SLOT"])[0])
2230 if "--usepkg" in self.myopts:
2231 mymatches = bindb.match(atom)
2232 if "--usepkgonly" not in self.myopts:
2233 mymatches = visible(mymatches)
2234 best_pkg = portage.best(mymatches)
2236 best_slot = bindb.aux_get(best_pkg, ["SLOT"])[0]
2237 best_pkgs.append(("binary", best_pkg, best_slot))
2238 if "--usepkgonly" not in self.myopts:
2239 best_pkg = portage.best(portdb.match(atom))
2241 best_slot = portdb.aux_get(best_pkg, ["SLOT"])[0]
2242 best_pkgs.append(("ebuild", best_pkg, best_slot))
2244 best_pkg = portage.best([x[1] for x in best_pkgs])
2245 best_pkgs = [x for x in best_pkgs if x[1] == best_pkg]
2246 best_slot = best_pkgs[0][2]
2247 myslots.add(best_slot)
2248 if len(myslots) > 1:
2249 for myslot in myslots:
2250 myslot_atom = "%s:%s" % (mykey, myslot)
2252 if "--usepkgonly" not in self.myopts and \
2253 self.trees[self.target_root][
2254 "porttree"].dbapi.match(myslot_atom):
2256 elif "--usepkg" in self.myopts:
2257 mymatches = bindb.match(myslot_atom)
2258 if "--usepkgonly" not in self.myopts:
2259 mymatches = visible(mymatches)
2263 newlist.append(myslot_atom)
2267 for mydep in mylist:
2269 if not self.select_dep(
2270 self.target_root, mydep, raise_on_missing=True, arg=mydep):
2271 print >> sys.stderr, "\n\n!!! Problem resolving dependencies for", mydep
2274 missing_atoms.append(mydep)
2276 if not self.validate_blockers():
2280 print >> sys.stderr, "\n!!! Problems have been detected with your world file"
2281 print >> sys.stderr, "!!! Please run "+green("emaint --check world")+"\n"
2284 print >> sys.stderr, "\n" + colorize("BAD", "!!!") + \
2285 " Ebuilds for the following packages are either all"
2286 print >> sys.stderr, colorize("BAD", "!!!") + " masked or don't exist:"
2287 print >> sys.stderr, " ".join(missing_atoms) + "\n"
2291 def display(self,mylist,verbosity=None):
2292 if verbosity is None:
2293 verbosity = ("--quiet" in self.myopts and 1 or \
2294 "--verbose" in self.myopts and 3 or 2)
2299 counters = PackageCounters()
2301 if verbosity == 1 and "--verbose" not in self.myopts:
2302 def create_use_string(*args):
2305 def create_use_string(name, cur_iuse, iuse_forced, cur_use,
2307 is_new, all_flags=(verbosity == 3 or "--quiet" in self.myopts),
2308 alphabetical=("--alphabetical" in self.myopts)):
2316 cur_iuse = set(cur_iuse)
2317 enabled_flags = cur_iuse.intersection(cur_use)
2318 removed_iuse = set(old_iuse).difference(cur_iuse)
2319 any_iuse = cur_iuse.union(old_iuse)
2320 any_iuse = list(any_iuse)
2322 for flag in any_iuse:
2325 if flag in enabled_flags:
2327 if is_new or flag in old_use and all_flags:
2328 flag_str = red(flag)
2329 elif flag not in old_iuse:
2330 flag_str = yellow(flag) + "%*"
2331 elif flag not in old_use:
2332 flag_str = green(flag) + "*"
2333 elif flag in removed_iuse:
2335 flag_str = yellow("-" + flag) + "%"
2338 flag_str = "(" + flag_str + ")"
2339 removed.append(flag_str)
2342 if is_new or flag in old_iuse and flag not in old_use and all_flags:
2343 flag_str = blue("-" + flag)
2344 elif flag not in old_iuse:
2345 flag_str = yellow("-" + flag)
2346 if flag not in iuse_forced:
2348 elif flag in old_use:
2349 flag_str = green("-" + flag) + "*"
2351 if flag in iuse_forced:
2352 flag_str = "(" + flag_str + ")"
2354 enabled.append(flag_str)
2356 disabled.append(flag_str)
2359 ret = " ".join(enabled)
2361 ret = " ".join(enabled + disabled + removed)
2363 ret = '%s="%s" ' % (name, ret)
2367 # FIXME: account for the possibility of different overlays in
2368 # /etc/make.conf vs. ${PORTAGE_CONFIGROOT}/etc/make.conf
2369 overlays = self.settings["PORTDIR_OVERLAY"].split()
2370 overlays_real = [os.path.realpath(t) \
2371 for t in self.settings["PORTDIR_OVERLAY"].split()]
2375 mygraph = self._parent_child_digraph
2380 if "blocks" == x[0]:
2381 display_list.append((x, 0, True))
2383 graph_key = tuple(x)
2384 if "--tree" in self.myopts:
2385 depth = len(tree_nodes)
2386 while depth and graph_key not in \
2387 mygraph.child_nodes(tree_nodes[depth-1]):
2390 tree_nodes = tree_nodes[:depth]
2391 tree_nodes.append(graph_key)
2392 display_list.append((x, depth, True))
2393 shown_edges.add((graph_key, tree_nodes[depth-1]))
2395 traversed_nodes = set() # prevent endless circles
2396 traversed_nodes.add(graph_key)
2397 def add_parents(current_node, ordered):
2398 parent_nodes = mygraph.parent_nodes(current_node)
2400 child_nodes = set(mygraph.child_nodes(current_node))
2401 selected_parent = None
2402 # First, try to avoid a direct cycle.
2403 for node in parent_nodes:
2404 if node not in traversed_nodes and \
2405 node not in child_nodes:
2406 edge = (current_node, node)
2407 if edge in shown_edges:
2409 selected_parent = node
2411 if not selected_parent:
2412 # A direct cycle is unavoidable.
2413 for node in parent_nodes:
2414 if node not in traversed_nodes:
2415 edge = (current_node, node)
2416 if edge in shown_edges:
2418 selected_parent = node
2421 shown_edges.add((current_node, selected_parent))
2422 traversed_nodes.add(selected_parent)
2423 add_parents(selected_parent, False)
2424 display_list.append((list(current_node),
2425 len(tree_nodes), ordered))
2426 tree_nodes.append(current_node)
2428 add_parents(graph_key, True)
2430 display_list.append((x, depth, True))
2431 mylist = display_list
2433 last_merge_depth = 0
2434 for i in xrange(len(mylist)-1,-1,-1):
2435 graph_key, depth, ordered = mylist[i]
2436 if not ordered and depth == 0 and i > 0 \
2437 and graph_key == mylist[i-1][0] and \
2438 mylist[i-1][1] == 0:
2439 # An ordered node got a consecutive duplicate when the tree was
2443 if "blocks" == graph_key[0]:
2445 if ordered and graph_key[-1] != "nomerge":
2446 last_merge_depth = depth
2448 if depth >= last_merge_depth or \
2449 i < len(mylist) - 1 and \
2450 depth >= mylist[i+1][1]:
2453 from portage import flatten
2454 from portage.dep import use_reduce, paren_reduce
2455 display_overlays=False
2456 # files to fetch list - avoids counting a same file twice
2457 # in size display (verbose mode)
2459 for mylist_index in xrange(len(mylist)):
2460 x, depth, ordered = mylist[mylist_index]
2464 portdb = self.trees[myroot]["porttree"].dbapi
2465 bindb = self.trees[myroot]["bintree"].dbapi
2466 vardb = self.trees[myroot]["vartree"].dbapi
2467 vartree = self.trees[myroot]["vartree"]
2468 pkgsettings = self.pkgsettings[myroot]
2473 addl=""+red("B")+" "+fetch+" "
2475 counters.blocks += 1
2476 resolved = portage.key_expand(
2477 pkg_key, mydb=vardb, settings=pkgsettings)
2478 if "--columns" in self.myopts and "--quiet" in self.myopts:
2479 addl = addl + " " + red(resolved)
2481 addl = "[blocks " + addl + "] " + red(resolved)
2482 block_parents = self.blocker_parents[tuple(x)]
2483 block_parents = set([pnode[2] for pnode in block_parents])
2484 block_parents = ", ".join(block_parents)
2486 addl += bad(" (\"%s\" is blocking %s)") % \
2487 (pkg_key, block_parents)
2489 addl += bad(" (is blocking %s)") % block_parents
2490 blockers.append(addl)
2492 mydbapi = self.trees[myroot][self.pkg_tree_map[pkg_type]].dbapi
2494 binary_package = True
2495 if "ebuild" == pkg_type:
2496 if "merge" == x[3] or \
2497 not vartree.dbapi.cpv_exists(pkg_key):
2498 """An ebuild "merge" node or a --onlydeps "nomerge"
2500 binary_package = False
2501 pkgsettings.setcpv(pkg_key, mydb=portdb)
2502 if pkg_key not in self.useFlags[myroot]:
2503 self.useFlags[myroot][pkg_key] = \
2504 pkgsettings["USE"].split()
2506 # An ebuild "nomerge" node, so USE come from the vardb.
2507 mydbapi = vartree.dbapi
2508 if pkg_key not in self.useFlags[myroot]:
2509 """If this is a --resume then the USE flags need to be
2510 fetched from the appropriate locations here."""
2511 self.useFlags[myroot][pkg_key] = mydbapi.aux_get(
2512 pkg_key, ["USE"])[0].split()
2515 restrict = flatten(use_reduce(paren_reduce(
2516 mydbapi.aux_get(pkg_key, ["RESTRICT"])[0]),
2517 uselist=self.useFlags[myroot][pkg_key]))
2518 except portage.exception.InvalidDependString, e:
2519 if pkg_status != "nomerge":
2520 restrict = mydbapi.aux_get(pkg_key, ["RESTRICT"])[0]
2521 show_invalid_depstring_notice(x, restrict, str(e))
2525 if "ebuild" == pkg_type and x[3] != "nomerge" and \
2526 "fetch" in restrict:
2529 counters.restrict_fetch += 1
2530 if portdb.fetch_check(
2531 pkg_key, self.useFlags[myroot][pkg_key]):
2534 counters.restrict_fetch_satisfied += 1
2536 #we need to use "--emptrytree" testing here rather than "empty" param testing because "empty"
2537 #param is used for -u, where you still *do* want to see when something is being upgraded.
2539 if vardb.cpv_exists(pkg_key):
2540 addl=" "+yellow("R")+fetch+" "
2541 if x[3] != "nomerge":
2543 counters.reinst += 1
2544 elif vardb.match(portage.dep_getkey(pkg_key)):
2545 mynewslot = mydbapi.aux_get(pkg_key, ["SLOT"])[0]
2546 myoldlist = self.trees[x[1]]["vartree"].dbapi.match(
2547 portage.pkgsplit(x[2])[0])
2548 myinslotlist = [inst_pkg for inst_pkg in myoldlist
2549 if mynewslot == vardb.aux_get(inst_pkg, ["SLOT"])[0]]
2551 myoldbest=portage.best(myinslotlist)
2553 if portage.pkgcmp(portage.pkgsplit(x[2]), portage.pkgsplit(myoldbest)) < 0:
2555 addl+=turquoise("U")+blue("D")
2557 counters.downgrades += 1
2560 addl+=turquoise("U")+" "
2562 counters.upgrades += 1
2564 # New slot, mark it new.
2565 addl=" "+green("NS")+fetch+" "
2567 counters.newslot += 1
2569 if "--changelog" in self.myopts:
2570 slot_atom = "%s:%s" % (portage.dep_getkey(pkg_key),
2571 mydbapi.aux_get(pkg_key, ["SLOT"])[0])
2572 inst_matches = vardb.match(slot_atom)
2574 changelogs.extend(self.calc_changelog(
2575 portdb.findname(pkg_key),
2576 inst_matches[0], pkg_key))
2578 addl=" "+green("N")+" "+fetch+" "
2584 if pkg_key in self.useFlags[myroot]:
2586 cur_iuse = list(filter_iuse_defaults(
2587 mydbapi.aux_get(pkg_key, ["IUSE"])[0].split()))
2589 forced_flags = set()
2590 if not binary_package:
2591 forced_flags.update(pkgsettings.useforce)
2592 forced_flags.update(pkgsettings.usemask)
2594 cur_iuse = portage.unique_array(cur_iuse)
2596 cur_use = self.useFlags[myroot][pkg_key]
2597 cur_use = [flag for flag in cur_use if flag in cur_iuse]
2603 if self.trees[x[1]]["vartree"].dbapi.cpv_exists(pkg):
2604 old_iuse, old_use = \
2605 self.trees[x[1]]["vartree"].dbapi.aux_get(
2606 pkg, ["IUSE", "USE"])
2607 old_iuse = list(set(
2608 filter_iuse_defaults(old_iuse.split())))
2610 old_use = old_use.split()
2617 old_use = [flag for flag in old_use if flag in old_iuse]
2619 use_expand = pkgsettings["USE_EXPAND"].lower().split()
2621 use_expand.reverse()
2622 use_expand_hidden = \
2623 pkgsettings["USE_EXPAND_HIDDEN"].lower().split()
2625 def map_to_use_expand(myvals, forcedFlags=False):
2628 for exp in use_expand:
2631 for val in myvals[:]:
2632 if val.startswith(exp.lower()+"_"):
2633 if val in forced_flags:
2634 forced[exp].add(val[len(exp)+1:])
2635 ret[exp].append(val[len(exp)+1:])
2638 forced["USE"] = [val for val in myvals \
2639 if val in forced_flags]
2640 for exp in use_expand_hidden:
2647 cur_iuse_map, iuse_forced = \
2648 map_to_use_expand(cur_iuse, forcedFlags=True)
2649 cur_use_map = map_to_use_expand(cur_use)
2650 old_iuse_map = map_to_use_expand(old_iuse)
2651 old_use_map = map_to_use_expand(old_use)
2654 use_expand.insert(0, "USE")
2656 for key in use_expand:
2657 if key in use_expand_hidden:
2659 verboseadd += create_use_string(key.upper(),
2660 cur_iuse_map[key], iuse_forced[key],
2661 cur_use_map[key], old_iuse_map[key],
2662 old_use_map[key], is_new)
2667 if x[0] == "ebuild" and ordered and x[-1] != "nomerge":
2669 myfilesdict = portdb.getfetchsizes(pkg_key,
2670 useflags=self.useFlags[myroot][pkg_key],
2672 except portage.exception.InvalidDependString, e:
2673 src_uri = portdb.aux_get(pkg_key, ["SRC_URI"])[0]
2674 show_invalid_depstring_notice(x, src_uri, str(e))
2677 if myfilesdict is None:
2678 myfilesdict="[empty/missing/bad digest]"
2680 for myfetchfile in myfilesdict.keys():
2681 if myfetchfile not in myfetchlist:
2682 mysize+=myfilesdict[myfetchfile]
2683 myfetchlist.append(myfetchfile)
2684 counters.totalsize += mysize
2685 verboseadd+=format_size(mysize)+" "
2688 # XXX: Invalid binaries have caused tracebacks here. 'if file_name'
2689 # x = ['binary', '/', 'sys-apps/pcmcia-cs-3.2.7.2.6', 'merge']
2690 file_name = portdb.findname(pkg_key)
2691 if file_name: # It might not exist in the tree
2692 dir_name=os.path.abspath(os.path.dirname(file_name)+"/../..")
2693 if (overlays_real.count(dir_name)>0):
2694 verboseadd+=teal("["+str(overlays_real.index(
2695 os.path.normpath(dir_name))+1)+"]")+" "
2696 display_overlays=True
2698 verboseadd += "[No ebuild?]"
2700 xs = list(portage.pkgsplit(x[2]))
2707 if "COLUMNWIDTH" in self.settings:
2709 mywidth = int(self.settings["COLUMNWIDTH"])
2710 except ValueError, e:
2711 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
2713 "!!! Unable to parse COLUMNWIDTH='%s'\n" % \
2714 self.settings["COLUMNWIDTH"], noiselevel=-1)
2719 indent = " " * depth
2722 myoldbest=portage.pkgsplit(myoldbest)[1]+"-"+portage.pkgsplit(myoldbest)[2]
2723 if myoldbest[-3:]=="-r0":
2724 myoldbest=myoldbest[:-3]
2725 myoldbest=blue("["+myoldbest+"]")
2730 if "--columns" in self.myopts:
2731 if "--quiet" in self.myopts:
2732 myprint=addl+" "+indent+darkgreen(xs[0])
2733 myprint=myprint+darkblue(" "+xs[1]+xs[2])+" "
2734 myprint=myprint+myoldbest
2735 myprint=myprint+darkgreen("to "+x[1])
2737 myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(xs[0])
2738 if (newlp-nc_len(myprint)) > 0:
2739 myprint=myprint+(" "*(newlp-nc_len(myprint)))
2740 myprint=myprint+"["+darkblue(xs[1]+xs[2])+"] "
2741 if (oldlp-nc_len(myprint)) > 0:
2742 myprint=myprint+" "*(oldlp-nc_len(myprint))
2743 myprint=myprint+myoldbest
2744 myprint=myprint+darkgreen("to "+x[1])+" "+verboseadd
2746 if x[-1] == "nomerge" or not ordered:
2747 myprint = darkblue("[nomerge ] ")
2749 myprint = "[" + pkg_type + " " + addl + "] "
2750 myprint += indent + darkgreen(pkg_key) + " " + \
2751 myoldbest + darkgreen("to " + myroot) + " " + \
2754 if "--columns" in self.myopts:
2755 if "--quiet" in self.myopts:
2756 myprint=addl+" "+indent+darkgreen(xs[0])
2757 myprint=myprint+" "+green(xs[1]+xs[2])+" "
2758 myprint=myprint+myoldbest
2760 myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(xs[0])
2761 if (newlp-nc_len(myprint)) > 0:
2762 myprint=myprint+(" "*(newlp-nc_len(myprint)))
2763 myprint=myprint+green(" ["+xs[1]+xs[2]+"] ")
2764 if (oldlp-nc_len(myprint)) > 0:
2765 myprint=myprint+(" "*(oldlp-nc_len(myprint)))
2766 myprint=myprint+myoldbest+" "+verboseadd
2768 if x[-1] == "nomerge" or not ordered:
2769 myprint=darkblue("[nomerge ] "+indent+x[2]+" "+myoldbest+" ")+verboseadd
2771 myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(x[2])+" "+myoldbest+" "+verboseadd
2774 mysplit = portage.pkgsplit(x[2])
2775 if "--tree" not in self.myopts and mysplit and \
2776 len(mysplit) == 3 and mysplit[0] == "sys-apps/portage" and \
2779 if mysplit[2] == "r0":
2780 myversion = mysplit[1]
2782 myversion = "%s-%s" % (mysplit[1], mysplit[2])
2784 if myversion != portage.VERSION and "--quiet" not in self.myopts:
2785 if mylist_index < len(mylist) - 1 and \
2786 "livecvsportage" not in self.settings.features:
2787 p.append(colorize("WARN", "*** Portage will stop merging at this point and reload itself,"))
2788 p.append(colorize("WARN", " then resume the merge."))
2800 if overlays and display_overlays:
2801 print "Portage overlays:"
2805 print " "+teal("["+str(y)+"]"),x
2807 if "--changelog" in self.myopts:
2809 for revision,text in changelogs:
2810 print bold('*'+revision)
2811 sys.stdout.write(text)
2813 if self._pprovided_args:
2815 msg.append(bad("\nWARNING: "))
2816 if len(self._pprovided_args) > 1:
2817 msg.append("Requested packages will not be " + \
2818 "merged because they are listed in\n")
2820 msg.append("A requested package will not be " + \
2821 "merged because it is listed in\n")
2822 msg.append(" package.provided:\n\n")
2823 for arg in self._pprovided_args:
2824 msg.append(" " + arg + "\n")
2826 sys.stderr.write("".join(msg))
2828 def calc_changelog(self,ebuildpath,current,next):
2829 if ebuildpath == None or not os.path.exists(ebuildpath):
2831 current = '-'.join(portage.catpkgsplit(current)[1:])
2832 if current.endswith('-r0'):
2833 current = current[:-3]
2834 next = '-'.join(portage.catpkgsplit(next)[1:])
2835 if next.endswith('-r0'):
2837 changelogpath = os.path.join(os.path.split(ebuildpath)[0],'ChangeLog')
2839 changelog = open(changelogpath).read()
2840 except SystemExit, e:
2841 raise # Needed else can't exit
2844 divisions = self.find_changelog_tags(changelog)
2845 #print 'XX from',current,'to',next
2846 #for div,text in divisions: print 'XX',div
2847 # skip entries for all revisions above the one we are about to emerge
2848 for i in range(len(divisions)):
2849 if divisions[i][0]==next:
2850 divisions = divisions[i:]
2852 # find out how many entries we are going to display
2853 for i in range(len(divisions)):
2854 if divisions[i][0]==current:
2855 divisions = divisions[:i]
2858 # couldnt find the current revision in the list. display nothing
2862 def find_changelog_tags(self,changelog):
2866 match = re.search(r'^\*\ ?([-a-zA-Z0-9_.+]*)(?:\ .*)?\n',changelog,re.M)
2868 if release is not None:
2869 divs.append((release,changelog))
2871 if release is not None:
2872 divs.append((release,changelog[:match.start()]))
2873 changelog = changelog[match.end():]
2874 release = match.group(1)
2875 if release.endswith('.ebuild'):
2876 release = release[:-7]
2877 if release.endswith('-r0'):
2878 release = release[:-3]
2881 return self.outdatedpackages
2883 class PackageCounters(object):
2893 self.restrict_fetch = 0
2894 self.restrict_fetch_satisfied = 0
2897 total_installs = self.upgrades + self.downgrades + self.newslot + self.new + self.reinst
2900 myoutput.append("Total: %s package" % total_installs)
2901 if total_installs != 1:
2902 myoutput.append("s")
2903 if total_installs != 0:
2904 myoutput.append(" (")
2905 if self.upgrades > 0:
2906 details.append("%s upgrade" % self.upgrades)
2907 if self.upgrades > 1:
2909 if self.downgrades > 0:
2910 details.append("%s downgrade" % self.downgrades)
2911 if self.downgrades > 1:
2914 details.append("%s new" % self.new)
2915 if self.newslot > 0:
2916 details.append("%s in new slot" % self.newslot)
2917 if self.newslot > 1:
2920 details.append("%s reinstall" % self.reinst)
2924 details.append("%s block" % self.blocks)
2927 myoutput.append(", ".join(details))
2928 if total_installs != 0:
2929 myoutput.append(")")
2930 myoutput.append(", Size of downloads: %s" % format_size(self.totalsize))
2931 if self.restrict_fetch:
2932 myoutput.append("\nFetch Restriction: %s package" % \
2933 self.restrict_fetch)
2934 if self.restrict_fetch > 1:
2935 myoutput.append("s")
2936 if self.restrict_fetch_satisfied < self.restrict_fetch:
2937 myoutput.append(bad(" (%s unsatisfied)") % \
2938 (self.restrict_fetch - self.restrict_fetch_satisfied))
2939 return "".join(myoutput)
2941 class MergeTask(object):
2943 def __init__(self, settings, trees, myopts):
2944 self.settings = settings
2945 self.target_root = settings["ROOT"]
2947 self.myopts = myopts
2949 if settings.get("PORTAGE_DEBUG", "") == "1":
2951 self.pkgsettings = {}
2952 self.pkgsettings[self.target_root] = portage.config(clone=settings)
2953 if self.target_root != "/":
2954 self.pkgsettings["/"] = \
2955 portage.config(clone=trees["/"]["vartree"].settings)
2957 def merge(self, mylist, favorites, mtimedb):
2959 fetchonly = "--fetchonly" in self.myopts or \
2960 "--fetch-all-uri" in self.myopts
2962 ldpath_mtimes = mtimedb["ldpath"]
2963 xterm_titles = "notitles" not in self.settings.features
2965 #check for blocking dependencies
2966 if "--fetchonly" not in self.myopts and \
2967 "--fetch-all-uri" not in self.myopts and \
2968 "--buildpkgonly" not in self.myopts:
2971 print "\n!!! Error: the "+x[2]+" package conflicts with another package;"
2972 print "!!! the two packages cannot be installed on the same system together."
2973 print "!!! Please use 'emerge --pretend' to determine blockers."
2974 if "--quiet" not in self.myopts:
2975 show_blocker_docs_link()
2978 if "--resume" in self.myopts:
2980 print colorize("GOOD", "*** Resuming merge...")
2981 emergelog(xterm_titles, " *** Resuming merge...")
2982 mylist = mtimedb["resume"]["mergelist"][:]
2983 if "--skipfirst" in self.myopts and mylist:
2984 del mtimedb["resume"]["mergelist"][0]
2987 validate_merge_list(self.trees, mylist)
2988 mymergelist = mylist
2990 # Verify all the manifests now so that the user is notified of failure
2991 # as soon as possible.
2992 if "--fetchonly" not in self.myopts and \
2993 "--fetch-all-uri" not in self.myopts and \
2994 "strict" in self.settings.features:
2995 shown_verifying_msg = False
2997 for myroot, pkgsettings in self.pkgsettings.iteritems():
2998 quiet_config = portage.config(clone=pkgsettings)
2999 quiet_config["PORTAGE_QUIET"] = "1"
3000 quiet_config.backup_changes("PORTAGE_QUIET")
3001 quiet_settings[myroot] = quiet_config
3004 if x[0] != "ebuild" or x[-1] == "nomerge":
3006 if not shown_verifying_msg:
3007 shown_verifying_msg = True
3008 print ">>> Verifying ebuild Manifests..."
3009 mytype, myroot, mycpv, mystatus = x
3010 portdb = self.trees[myroot]["porttree"].dbapi
3011 quiet_config = quiet_settings[myroot]
3012 quiet_config["O"] = os.path.dirname(portdb.findname(mycpv))
3013 if not portage.digestcheck([], quiet_config, strict=True):
3015 del x, mytype, myroot, mycpv, mystatus, quiet_config
3016 del shown_verifying_msg, quiet_settings
3018 #buildsyspkg: I need mysysdict also on resume (moved from the else block)
3019 mysysdict = genericdict(getlist(self.settings, "system"))
3020 if "--resume" not in self.myopts:
3021 myfavs = portage.grabfile(
3022 os.path.join(self.target_root, portage.WORLD_FILE))
3023 myfavdict=genericdict(myfavs)
3024 for x in range(len(mylist)):
3025 if mylist[x][3]!="nomerge":
3026 # Add to the mergelist
3027 mymergelist.append(mylist[x])
3029 myfavkey=portage.cpv_getkey(mylist[x][2])
3030 if "--onlydeps" in self.myopts:
3032 # Add to the world file. Since we won't be able to later.
3033 if "--fetchonly" not in self.myopts and \
3034 myfavkey in favorites:
3035 #don't record if already in system profile or already recorded
3036 if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
3037 #we don't have a favorites entry for this package yet; add one
3038 myfavdict[myfavkey]=myfavkey
3039 print ">>> Recording",myfavkey,"in \"world\" favorites file..."
3040 if not ("--fetchonly" in self.myopts or \
3041 "--fetch-all-uri" in self.myopts or \
3042 "--pretend" in self.myopts):
3043 portage.write_atomic(
3044 os.path.join(self.target_root, portage.WORLD_FILE),
3045 "\n".join(myfavdict.values()))
3047 mtimedb["resume"]["mergelist"]=mymergelist[:]
3050 myfeat = self.settings.features[:]
3051 bad_resume_opts = set(["--ask", "--tree", "--changelog", "--skipfirst",
3053 if "parallel-fetch" in myfeat and \
3054 not ("--pretend" in self.myopts or \
3055 "--fetch-all-uri" in self.myopts or \
3056 "--fetchonly" in self.myopts):
3057 if "distlocks" not in myfeat:
3059 print red("!!!")+" parallel-fetching requires the distlocks feature enabled"
3060 print red("!!!")+" you have it disabled, thus parallel-fetching is being disabled"
3062 elif len(mymergelist) > 1:
3063 print ">>> starting parallel fetching"
3064 fetch_log = "/var/log/emerge-fetch.log"
3065 logfile = open(fetch_log, "w")
3066 fd_pipes = {1:logfile.fileno(), 2:logfile.fileno()}
3067 portage.util.apply_secpass_permissions(fetch_log,
3068 uid=portage.portage_uid, gid=portage.portage_gid,
3070 fetch_env = os.environ.copy()
3071 fetch_env["FEATURES"] = fetch_env.get("FEATURES", "") + " -cvs"
3072 fetch_env["PORTAGE_NICENESS"] = "0"
3073 fetch_args = [sys.argv[0], "--resume", "--fetchonly"]
3074 resume_opts = self.myopts.copy()
3075 # For automatic resume, we need to prevent
3076 # any of bad_resume_opts from leaking in
3077 # via EMERGE_DEFAULT_OPTS.
3078 resume_opts["--ignore-default-opts"] = True
3079 for myopt, myarg in resume_opts.iteritems():
3080 if myopt not in bad_resume_opts:
3082 fetch_args.append(myopt)
3084 fetch_args.append(myopt +"="+ myarg)
3085 portage.process.spawn(fetch_args, env=fetch_env,
3086 fd_pipes=fd_pipes, returnpid=True)
3087 logfile.close() # belongs to the spawned process
3088 del fetch_log, logfile, fd_pipes, fetch_env, fetch_args, \
3092 for x in mymergelist:
3097 portdb = self.trees[myroot]["porttree"].dbapi
3098 bindb = self.trees[myroot]["bintree"].dbapi
3099 vartree = self.trees[myroot]["vartree"]
3100 pkgsettings = self.pkgsettings[myroot]
3103 y = portdb.findname(pkg_key)
3104 if "--pretend" not in self.myopts:
3105 print "\n>>> Emerging (" + \
3106 colorize("MERGE_LIST_PROGRESS", str(mergecount)) + " of " + \
3107 colorize("MERGE_LIST_PROGRESS", str(len(mymergelist))) + ") " + \
3108 colorize("GOOD", x[pkgindex]) + " to " + x[1]
3109 emergelog(xterm_titles, " >>> emerge ("+\
3110 str(mergecount)+" of "+str(len(mymergelist))+\
3111 ") "+x[pkgindex]+" to "+x[1])
3113 pkgsettings["EMERGE_FROM"] = x[0]
3114 pkgsettings.backup_changes("EMERGE_FROM")
3117 #buildsyspkg: Check if we need to _force_ binary package creation
3118 issyspkg = ("buildsyspkg" in myfeat) \
3119 and x[0] != "blocks" \
3120 and mysysdict.has_key(portage.cpv_getkey(x[2])) \
3121 and "--buildpkg" not in self.myopts
3122 if x[0] in ["ebuild","blocks"]:
3123 if x[0] == "blocks" and "--fetchonly" not in self.myopts:
3124 raise Exception, "Merging a blocker"
3125 elif "--fetchonly" in self.myopts or \
3126 "--fetch-all-uri" in self.myopts:
3127 if "--fetch-all-uri" in self.myopts:
3128 retval = portage.doebuild(y, "fetch", myroot,
3129 pkgsettings, self.edebug,
3130 "--pretend" in self.myopts, fetchonly=1,
3131 fetchall=1, mydbapi=portdb, tree="porttree")
3133 retval = portage.doebuild(y, "fetch", myroot,
3134 pkgsettings, self.edebug,
3135 "--pretend" in self.myopts, fetchonly=1,
3136 mydbapi=portdb, tree="porttree")
3137 if (retval is None) or retval:
3139 print "!!! Fetch for",y,"failed, continuing..."
3141 failed_fetches.append(pkg_key)
3144 portage.doebuild_environment(y, "setup", myroot,
3145 pkgsettings, self.edebug, 1, portdb)
3146 catdir = os.path.dirname(pkgsettings["PORTAGE_BUILDDIR"])
3147 portage.util.ensure_dirs(os.path.dirname(catdir),
3148 uid=portage.portage_uid, gid=portage.portage_gid,
3150 builddir_lock = None
3153 catdir_lock = portage.locks.lockdir(catdir)
3154 portage.util.ensure_dirs(catdir,
3155 uid=portage.portage_uid, gid=portage.portage_gid,
3157 builddir_lock = portage.locks.lockdir(
3158 pkgsettings["PORTAGE_BUILDDIR"])
3160 portage.locks.unlockdir(catdir_lock)
3163 msg = " === (%s of %s) Cleaning (%s::%s)" % \
3164 (mergecount, len(mymergelist), pkg_key, y)
3165 short_msg = "emerge: (%s of %s) %s Clean" % \
3166 (mergecount, len(mymergelist), pkg_key)
3167 emergelog(xterm_titles, msg, short_msg=short_msg)
3168 retval = portage.doebuild(y, "clean", myroot,
3169 pkgsettings, self.edebug, cleanup=1,
3170 mydbapi=portdb, tree="porttree")
3171 if retval != os.EX_OK:
3173 if "--buildpkg" in self.myopts or issyspkg:
3175 print ">>> This is a system package, " + \
3176 "let's pack a rescue tarball."
3177 msg = " === (%s of %s) Compiling/Packaging (%s::%s)" % \
3178 (mergecount, len(mymergelist), pkg_key, y)
3179 short_msg = "emerge: (%s of %s) %s Compile" % \
3180 (mergecount, len(mymergelist), pkg_key)
3181 emergelog(xterm_titles, msg, short_msg=short_msg)
3182 self.trees[myroot]["bintree"].prevent_collision(pkg_key)
3183 binpkg_tmpfile = os.path.join(pkgsettings["PKGDIR"],
3184 pkg_key + ".tbz2." + str(os.getpid()))
3185 pkgsettings["PORTAGE_BINPKG_TMPFILE"] = binpkg_tmpfile
3186 pkgsettings.backup_changes("PORTAGE_BINPKG_TMPFILE")
3187 retval = portage.doebuild(y, "package", myroot,
3188 pkgsettings, self.edebug, mydbapi=portdb,
3190 del pkgsettings["PORTAGE_BINPKG_TMPFILE"]
3191 if retval != os.EX_OK:
3193 bintree = self.trees[myroot]["bintree"]
3194 bintree.inject(pkg_key, filename=binpkg_tmpfile)
3195 if "--buildpkgonly" not in self.myopts:
3196 msg = " === (%s of %s) Merging (%s::%s)" % \
3197 (mergecount, len(mymergelist), pkg_key, y)
3198 short_msg = "emerge: (%s of %s) %s Merge" % \
3199 (mergecount, len(mymergelist), pkg_key)
3200 emergelog(xterm_titles, msg, short_msg=short_msg)
3201 retval = portage.merge(pkgsettings["CATEGORY"],
3202 pkgsettings["PF"], pkgsettings["D"],
3203 os.path.join(pkgsettings["PORTAGE_BUILDDIR"],
3204 "build-info"), myroot, pkgsettings,
3205 myebuild=pkgsettings["EBUILD"],
3206 mytree="porttree", mydbapi=portdb,
3207 vartree=vartree, prev_mtimes=ldpath_mtimes)
3208 if retval != os.EX_OK:
3210 elif "noclean" not in pkgsettings.features:
3211 portage.doebuild(y, "clean", myroot,
3212 pkgsettings, self.edebug, mydbapi=portdb,
3215 msg = " === (%s of %s) Compiling/Merging (%s::%s)" % \
3216 (mergecount, len(mymergelist), pkg_key, y)
3217 short_msg = "emerge: (%s of %s) %s Compile" % \
3218 (mergecount, len(mymergelist), pkg_key)
3219 emergelog(xterm_titles, msg, short_msg=short_msg)
3220 retval = portage.doebuild(y, "merge", myroot,
3221 pkgsettings, self.edebug, vartree=vartree,
3222 mydbapi=portdb, tree="porttree",
3223 prev_mtimes=ldpath_mtimes)
3224 if retval != os.EX_OK:
3228 portage.locks.unlockdir(builddir_lock)
3231 # Lock catdir for removal if empty.
3232 catdir_lock = portage.locks.lockdir(catdir)
3238 if e.errno not in (errno.ENOENT,
3239 errno.ENOTEMPTY, errno.EEXIST):
3242 portage.locks.unlockdir(catdir_lock)
3244 elif x[0]=="binary":
3246 mytbz2 = self.trees[myroot]["bintree"].getname(pkg_key)
3247 if "--getbinpkg" in self.myopts:
3250 if "distlocks" in pkgsettings.features and \
3251 os.access(pkgsettings["PKGDIR"], os.W_OK):
3252 portage.util.ensure_dirs(os.path.dirname(mytbz2))
3253 tbz2_lock = portage.locks.lockfile(mytbz2,
3255 if self.trees[myroot]["bintree"].isremote(pkg_key):
3256 msg = " --- (%s of %s) Fetching Binary (%s::%s)" %\
3257 (mergecount, len(mymergelist), pkg_key, mytbz2)
3258 short_msg = "emerge: (%s of %s) %s Fetch" % \
3259 (mergecount, len(mymergelist), pkg_key)
3260 emergelog(xterm_titles, msg, short_msg=short_msg)
3262 self.trees[myroot]["bintree"].gettbz2(pkg_key)
3263 except portage.exception.FileNotFound:
3264 writemsg("!!! Fetching Binary failed " + \
3265 "for '%s'\n" % pkg_key, noiselevel=-1)
3268 failed_fetches.append(pkg_key)
3269 except portage.exception.DigestException, e:
3270 writemsg("\n!!! Digest verification failed:\n",
3272 writemsg("!!! %s\n" % e.value[0],
3274 writemsg("!!! Reason: %s\n" % e.value[1],
3276 writemsg("!!! Got: %s\n" % e.value[2],
3278 writemsg("!!! Expected: %s\n" % e.value[3],
3283 failed_fetches.append(pkg_key)
3286 portage.locks.unlockfile(tbz2_lock)
3288 if "--fetchonly" in self.myopts or \
3289 "--fetch-all-uri" in self.myopts:
3292 short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Merge Binary"
3293 emergelog(xterm_titles, " === ("+str(mergecount)+\
3294 " of "+str(len(mymergelist))+") Merging Binary ("+\
3295 x[pkgindex]+"::"+mytbz2+")", short_msg=short_msg)
3296 retval = portage.pkgmerge(mytbz2, x[1], pkgsettings,
3298 vartree=self.trees[myroot]["vartree"],
3299 prev_mtimes=ldpath_mtimes)
3300 if retval != os.EX_OK:
3302 #need to check for errors
3303 if "--buildpkgonly" not in self.myopts:
3304 self.trees[x[1]]["vartree"].inject(x[2])
3305 myfavkey=portage.cpv_getkey(x[2])
3306 if "--fetchonly" not in self.myopts and \
3307 "--fetch-all-uri" not in self.myopts and \
3308 myfavkey in favorites:
3309 myfavs = portage.grabfile(os.path.join(myroot, portage.WORLD_FILE))
3310 myfavdict=genericdict(myfavs)
3311 #don't record if already in system profile or already recorded
3312 if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
3313 #we don't have a favorites entry for this package yet; add one
3314 myfavdict[myfavkey]=myfavkey
3315 print ">>> Recording",myfavkey,"in \"world\" favorites file..."
3316 emergelog(xterm_titles, " === ("+\
3317 str(mergecount)+" of "+\
3318 str(len(mymergelist))+\
3319 ") Updating world file ("+x[pkgindex]+")")
3320 portage.write_atomic(
3321 os.path.join(myroot, portage.WORLD_FILE),
3322 "\n".join(myfavdict.values()))
3324 if "--pretend" not in self.myopts and \
3325 "--fetchonly" not in self.myopts and \
3326 "--fetch-all-uri" not in self.myopts:
3327 # Clean the old package that we have merged over top of it.
3328 if pkgsettings.get("AUTOCLEAN", "yes") == "yes":
3329 xsplit=portage.pkgsplit(x[2])
3330 emergelog(xterm_titles, " >>> AUTOCLEAN: " + xsplit[0])
3331 retval = unmerge(pkgsettings, self.myopts, vartree,
3332 "clean", [xsplit[0]], ldpath_mtimes, autoclean=1)
3334 emergelog(xterm_titles,
3335 " --- AUTOCLEAN: Nothing unmerged.")
3337 portage.writemsg_stdout(colorize("WARN", "WARNING:")
3338 + " AUTOCLEAN is disabled. This can cause serious"
3339 + " problems due to overlapping packages.\n")
3341 # Figure out if we need a restart.
3342 mysplit=portage.pkgsplit(x[2])
3343 if mysplit[0] == "sys-apps/portage" and x[1] == "/":
3344 myver=mysplit[1]+"-"+mysplit[2]
3345 if myver[-3:]=='-r0':
3347 if (myver != portage.VERSION) and \
3348 "livecvsportage" not in self.settings.features:
3349 if len(mymergelist) > mergecount:
3350 emergelog(xterm_titles,
3351 " ::: completed emerge ("+ \
3352 str(mergecount)+" of "+ \
3353 str(len(mymergelist))+") "+ \
3355 emergelog(xterm_titles, " *** RESTARTING " + \
3356 "emerge via exec() after change of " + \
3358 del mtimedb["resume"]["mergelist"][0]
3360 portage.run_exitfuncs()
3361 mynewargv=[sys.argv[0],"--resume"]
3362 resume_opts = self.myopts.copy()
3363 # For automatic resume, we need to prevent
3364 # any of bad_resume_opts from leaking in
3365 # via EMERGE_DEFAULT_OPTS.
3366 resume_opts["--ignore-default-opts"] = True
3367 for myopt, myarg in resume_opts.iteritems():
3368 if myopt not in bad_resume_opts:
3370 mynewargv.append(myopt)
3372 mynewargv.append(myopt +"="+ myarg)
3373 # priority only needs to be adjusted on the first run
3374 os.environ["PORTAGE_NICENESS"] = "0"
3375 os.execv(mynewargv[0], mynewargv)
3377 if "--pretend" not in self.myopts and \
3378 "--fetchonly" not in self.myopts and \
3379 "--fetch-all-uri" not in self.myopts:
3380 if "noclean" not in self.settings.features:
3381 short_msg = "emerge: (%s of %s) %s Clean Post" % \
3382 (mergecount, len(mymergelist), x[pkgindex])
3383 emergelog(xterm_titles, (" === (%s of %s) " + \
3384 "Post-Build Cleaning (%s::%s)") % \
3385 (mergecount, len(mymergelist), x[pkgindex], y),
3386 short_msg=short_msg)
3387 emergelog(xterm_titles, " ::: completed emerge ("+\
3388 str(mergecount)+" of "+str(len(mymergelist))+") "+\
3391 # Unsafe for parallel merges
3392 del mtimedb["resume"]["mergelist"][0]
3393 # Commit after each merge so that --resume may still work in
3394 # in the event that portage is not allowed to exit normally
3395 # due to power failure, SIGKILL, etc...
3398 if "--pretend" not in self.myopts:
3399 emergelog(xterm_titles, " *** Finished. Cleaning up...")
3401 # We're out of the loop... We're done. Delete the resume data.
3402 if mtimedb.has_key("resume"):
3403 del mtimedb["resume"]
3406 #by doing an exit this way, --fetchonly can continue to try to
3407 #fetch everything even if a particular download fails.
3408 if "--fetchonly" in self.myopts or "--fetch-all-uri" in self.myopts:
3410 sys.stderr.write("\n\n!!! Some fetch errors were " + \
3411 "encountered. Please see above for details.\n\n")
3412 for cpv in failed_fetches:
3413 sys.stderr.write(" ")
3414 sys.stderr.write(cpv)
3415 sys.stderr.write("\n")
3416 sys.stderr.write("\n")
3422 def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
3423 ldpath_mtimes, autoclean=0):
3424 candidate_catpkgs=[]
3426 xterm_titles = "notitles" not in settings.features
3428 vdb_path = os.path.join(settings["ROOT"], portage.VDB_PATH)
3430 # At least the parent needs to exist for the lock file.
3431 portage.util.ensure_dirs(vdb_path)
3432 except portage.exception.PortageException:
3436 if os.access(vdb_path, os.W_OK):
3437 vdb_lock = portage.locks.lockdir(vdb_path)
3438 realsyslist = getlist(settings, "system")
3440 for x in realsyslist:
3441 mycp = portage.dep_getkey(x)
3442 if mycp in settings.getvirtuals():
3444 for provider in settings.getvirtuals()[mycp]:
3445 if vartree.dbapi.match(provider):
3446 providers.append(provider)
3447 if len(providers) == 1:
3448 syslist.extend(providers)
3450 syslist.append(mycp)
3452 mysettings = portage.config(clone=settings)
3454 if not unmerge_files or "world" in unmerge_files or \
3455 "system" in unmerge_files:
3456 if "unmerge"==unmerge_action:
3458 print bold("emerge unmerge") + " can only be used with " + \
3459 "specific package names, not with "+bold("world")+" or"
3460 print bold("system")+" targets."
3467 # process all arguments and add all
3468 # valid db entries to candidate_catpkgs
3470 if not unmerge_files or "world" in unmerge_files:
3471 candidate_catpkgs.extend(vartree.dbapi.cp_all())
3472 elif "system" in unmerge_files:
3473 candidate_catpkgs.extend(getlist(settings, "system"))
3475 #we've got command-line arguments
3476 if not unmerge_files:
3477 print "\nNo packages to unmerge have been provided.\n"
3479 for x in unmerge_files:
3480 arg_parts = x.split('/')
3481 if x[0] not in [".","/"] and \
3482 arg_parts[-1][-7:] != ".ebuild":
3483 #possible cat/pkg or dep; treat as such
3484 candidate_catpkgs.append(x)
3485 elif unmerge_action in ["prune","clean"]:
3486 print "\n!!! Prune and clean do not accept individual" + \
3487 " ebuilds as arguments;\n skipping.\n"
3490 # it appears that the user is specifying an installed
3491 # ebuild and we're in "unmerge" mode, so it's ok.
3492 if not os.path.exists(x):
3493 print "\n!!! The path '"+x+"' doesn't exist.\n"
3496 absx = os.path.abspath(x)
3497 sp_absx = absx.split("/")
3498 if sp_absx[-1][-7:] == ".ebuild":
3500 absx = "/".join(sp_absx)
3502 sp_absx_len = len(sp_absx)
3504 vdb_path = os.path.join(settings["ROOT"], portage.VDB_PATH)
3505 vdb_len = len(vdb_path)
3507 sp_vdb = vdb_path.split("/")
3508 sp_vdb_len = len(sp_vdb)
3510 if not os.path.exists(absx+"/CONTENTS"):
3511 print "!!! Not a valid db dir: "+str(absx)
3514 if sp_absx_len <= sp_vdb_len:
3515 # The Path is shorter... so it can't be inside the vdb.
3518 print "\n!!!",x,"cannot be inside "+ \
3519 vdb_path+"; aborting.\n"
3522 for idx in range(0,sp_vdb_len):
3523 if idx >= sp_absx_len or sp_vdb[idx] != sp_absx[idx]:
3526 print "\n!!!", x, "is not inside "+\
3527 vdb_path+"; aborting.\n"
3530 print "="+"/".join(sp_absx[sp_vdb_len:])
3531 candidate_catpkgs.append(
3532 "="+"/".join(sp_absx[sp_vdb_len:]))
3535 if (not "--quiet" in myopts):
3537 if settings["ROOT"] != "/":
3538 print darkgreen(newline+ \
3539 ">>> Using system located in ROOT tree "+settings["ROOT"])
3540 if (("--pretend" in myopts) or ("--ask" in myopts)) and \
3541 not ("--quiet" in myopts):
3542 print darkgreen(newline+\
3543 ">>> These are the packages that would be unmerged:")
3547 for x in candidate_catpkgs:
3548 # cycle through all our candidate deps and determine
3549 # what will and will not get unmerged
3551 mymatch=localtree.dep_match(x)
3554 except ValueError, errpkgs:
3555 print "\n\n!!! The short ebuild name \"" + \
3556 x + "\" is ambiguous. Please specify"
3557 print "!!! one of the following fully-qualified " + \
3558 "ebuild names instead:\n"
3559 for i in errpkgs[0]:
3560 print " " + green(i)
3564 if not mymatch and x[0] not in "<>=~":
3565 #add a "=" if missing
3566 mymatch=localtree.dep_match("="+x)
3568 portage.writemsg("\n--- Couldn't find '%s' to %s.\n" % \
3569 (x, unmerge_action), noiselevel=-1)
3571 mykey = portage.key_expand(
3573 mymatch[0]), mydb=vartree.dbapi, settings=settings)
3574 if not pkgmap.has_key(mykey):
3575 pkgmap[mykey]={"protected":[], "selected":[], "omitted":[] }
3576 if unmerge_action=="unmerge":
3578 if y not in pkgmap[mykey]["selected"]:
3579 pkgmap[mykey]["selected"].append(y)
3580 numselected=numselected+len(mymatch)
3583 #unmerge_action in ["prune", clean"]
3585 for mypkg in mymatch:
3586 if unmerge_action=="clean":
3587 myslot=localtree.getslot(mypkg)
3589 # since we're pruning, we don't care about slots
3590 # and put all the pkgs in together
3592 if not slotmap.has_key(myslot):
3594 slotmap[myslot][localtree.dbapi.cpv_counter(mypkg)]=mypkg
3595 for myslot in slotmap.keys():
3596 counterkeys=slotmap[myslot].keys()
3601 pkgmap[mykey]["protected"].append(
3602 slotmap[myslot][counterkeys[-1]])
3604 #be pretty and get them in order of merge:
3605 for ckey in counterkeys:
3606 pkgmap[mykey]["selected"].append(slotmap[myslot][ckey])
3607 numselected=numselected+1
3608 # ok, now the last-merged package
3609 # is protected, and the rest are selected
3610 if global_unmerge and not numselected:
3611 portage.writemsg_stdout("\n>>> No outdated packages were found on your system.\n")
3615 portage.writemsg_stdout(
3616 "\n>>> No packages selected for removal by " + \
3617 unmerge_action + "\n")
3621 portage.locks.unlockdir(vdb_lock)
3622 for x in pkgmap.keys():
3623 for y in localtree.dep_match(x):
3624 if y not in pkgmap[x]["omitted"] and \
3625 y not in pkgmap[x]["selected"] and \
3626 y not in pkgmap[x]["protected"]:
3627 pkgmap[x]["omitted"].append(y)
3628 if global_unmerge and not pkgmap[x]["selected"]:
3629 #avoid cluttering the preview printout with stuff that isn't getting unmerged
3631 if not (pkgmap[x]["protected"] or pkgmap[x]["omitted"]) and (x in syslist):
3632 print colorize("BAD","\a\n\n!!! '%s' is part of your system profile." % x)
3633 print colorize("WARN","\a!!! Unmerging it may be damaging to your system.\n")
3634 if "--pretend" not in myopts and "--ask" not in myopts:
3635 countdown(int(settings["EMERGE_WARNING_DELAY"]),
3636 colorize("UNMERGE_WARN", "Press Ctrl-C to Stop"))
3637 print "\n "+white(x)
3638 for mytype in ["selected","protected","omitted"]:
3639 portage.writemsg_stdout((mytype + ": ").rjust(14), noiselevel=-1)
3640 if pkgmap[x][mytype]:
3641 for mypkg in pkgmap[x][mytype]:
3642 mysplit=portage.catpkgsplit(mypkg)
3643 if mysplit[3]=="r0":
3644 myversion=mysplit[2]
3646 myversion=mysplit[2]+"-"+mysplit[3]
3647 if mytype=="selected":
3648 portage.writemsg_stdout(
3649 colorize("UNMERGE_WARN", myversion + " "), noiselevel=-1)
3651 portage.writemsg_stdout(
3652 colorize("GOOD", myversion + " "), noiselevel=-1)
3654 portage.writemsg_stdout("none", noiselevel=-1)
3655 portage.writemsg_stdout("\n", noiselevel=-1)
3657 portage.writemsg_stdout("\n>>> " + colorize("UNMERGE_WARN", "'Selected'") + \
3658 " packages are slated for removal.\n")
3659 portage.writemsg_stdout(">>> " + colorize("GOOD", "'Protected'") + \
3660 " and " + colorize("GOOD", "'omitted'") + \
3661 " packages will not be removed.\n\n")
3663 if "--pretend" in myopts:
3664 #we're done... return
3666 if "--ask" in myopts:
3667 if userquery("Would you like to unmerge these packages?")=="No":
3668 # enter pretend mode for correct formatting of results
3669 myopts["--pretend"] = True
3674 #the real unmerging begins, after a short delay....
3676 countdown(int(settings["CLEAN_DELAY"]), ">>> Unmerging")
3678 for x in pkgmap.keys():
3679 for y in pkgmap[x]["selected"]:
3680 print ">>> Unmerging "+y+"..."
3681 emergelog(xterm_titles, "=== Unmerging... ("+y+")")
3682 mysplit=y.split("/")
3684 retval = portage.unmerge(mysplit[0], mysplit[1], settings["ROOT"],
3685 mysettings, unmerge_action not in ["clean","prune"],
3686 vartree=vartree, ldpath_mtimes=ldpath_mtimes)
3687 if retval != os.EX_OK:
3688 emergelog(xterm_titles, " !!! unmerge FAILURE: "+y)
3689 ebuild = vartree.dbapi.findname(y)
3690 show_unmerge_failure_message(y, ebuild, retval)
3693 clean_world(vartree.dbapi, y)
3694 emergelog(xterm_titles, " >>> unmerge success: "+y)
3697 def show_unmerge_failure_message(pkg, ebuild, retval):
3699 from formatter import AbstractFormatter, DumbWriter
3700 f = AbstractFormatter(DumbWriter(sys.stderr, maxcol=72))
3703 msg.append("A removal phase of the '%s' package " % pkg)
3704 msg.append("has failed with exit value %s. " % retval)
3705 msg.append("The problem occurred while executing ")
3706 msg.append("the ebuild located at '%s'. " % ebuild)
3707 msg.append("If necessary, manually remove the ebuild " )
3708 msg.append("in order to skip the execution of removal phases.")
3712 f.add_flowing_data(x)
3716 def chk_updated_info_files(root, infodirs, prev_mtimes, retval):
3718 if os.path.exists("/usr/bin/install-info"):
3723 inforoot=normpath(root+z)
3724 if os.path.isdir(inforoot):
3725 infomtime = long(os.stat(inforoot).st_mtime)
3726 if inforoot not in prev_mtimes or \
3727 prev_mtimes[inforoot] != infomtime:
3728 regen_infodirs.append(inforoot)
3730 if not regen_infodirs:
3731 portage.writemsg_stdout(" "+green("*")+" GNU info directory index is up-to-date.\n")
3733 portage.writemsg_stdout(" "+green("*")+" Regenerating GNU info directory index...\n")
3737 for inforoot in regen_infodirs:
3740 for filename in ("dir", "dir.gz", "dir.bz2"):
3741 file_path = os.path.join(inforoot, filename)
3743 os.rename(file_path, file_path + ".old")
3745 if e.errno != errno.ENOENT:
3749 if not os.path.isdir(inforoot):
3752 file_list = os.listdir(inforoot)
3755 if (x[0] == ".") or (x in ["dir","dir.old"]) or (os.path.isdir(inforoot+"/"+x)):
3757 myso=commands.getstatusoutput("LANG=C LANGUAGE=C /usr/bin/install-info --dir-file="+inforoot+"/dir "+inforoot+"/"+x)[1]
3758 existsstr="already exists, for file `"
3760 if re.search(existsstr,myso):
3761 # Already exists... Don't increment the count for this.
3763 elif myso[:44]=="install-info: warning: no info dir entry in ":
3764 # This info file doesn't contain a DIR-header: install-info produces this
3765 # (harmless) warning (the --quiet switch doesn't seem to work).
3766 # Don't increment the count for this.
3770 errmsg += myso + "\n"
3773 #update mtime so we can potentially avoid regenerating.
3774 prev_mtimes[inforoot] = long(os.stat(inforoot).st_mtime)
3777 print " "+yellow("*")+" Processed",icount,"info files;",badcount,"errors."
3780 print " "+green("*")+" Processed",icount,"info files."
3783 def display_news_notification(settings):
3784 target_root = settings["ROOT"]
3785 NEWS_PATH = os.path.join("metadata", "news")
3786 UNREAD_PATH = os.path.join(target_root, NEWS_LIB_PATH, "news")
3787 porttree = portdbapi(porttree_root=settings["PORTDIR"], mysettings=settings)
3788 newsReaderDisplay = False
3790 for repo in porttree.getRepositories():
3791 unreadItems = checkUpdatedNewsItems(target_root, NEWS_PATH, UNREAD_PATH, repo)
3793 if not newsReaderDisplay:
3794 newsReaderDisplay = True
3796 print colorize("WARN", " * IMPORTANT:"),
3797 print "%s news items need reading for repository '%s'." % (unreadItems, repo)
3800 if newsReaderDisplay:
3801 print colorize("WARN", " *"),
3802 print "Use " + colorize("GOOD", "eselect news") + " to read news items."
3805 def post_emerge(settings, mtimedb, retval):
3807 Misc. things to run at the end of a merge session.
3813 Display preserved libs warnings
3816 @param settings: Configuration settings (typically portage.settings)
3817 @type settings: portage.config()
3818 @param mtimedb: The mtimeDB to store data needed across merge invocations
3819 @type mtimedb: MtimeDB class instance
3820 @param retval: Emerge's return value
3824 1. Calls sys.exit(retval)
3826 target_root = settings["ROOT"]
3827 info_mtimes = mtimedb["info"]
3829 # Load the most current variables from ${ROOT}/etc/profile.env
3831 settings.regenerate()
3834 config_protect = settings.get("CONFIG_PROTECT","").split()
3835 infodirs = settings.get("INFOPATH","").split(":") + \
3836 settings.get("INFODIR","").split(":")
3840 emergelog("notitles" not in settings.features,
3841 " *** exiting successfully.")
3843 if "noinfo" not in settings.features:
3844 chk_updated_info_files(target_root, infodirs, info_mtimes, retval)
3846 chk_updated_cfg_files(target_root, config_protect)
3848 display_news_notification(settings)
3850 from portage.dbapi.vartree import PreservedLibsRegistry
3851 plib_registry = PreservedLibsRegistry(os.path.join(target_root, CACHE_PATH, "preserved_libs_registry"))
3852 if plib_registry.hasEntries():
3853 print colorize("WARN", "!!!") + " existing preserved libs:"
3854 plibdata = plib_registry.getPreservedLibs()
3855 for cpv in plibdata.keys():
3856 print colorize("WARN", ">>>") + " package: %s" % cpv
3857 for f in plibdata[cpv]:
3858 print colorize("WARN", " * ") + " - %s" % f
3859 print "Use " + colorize("GOOD", "revdep-rebuild") + " to rebuild packages using these libraries"
3860 print "and then remerge the packages listed above."
3866 def chk_updated_cfg_files(target_root, config_protect):
3868 #number of directories with some protect files in them
3870 for x in config_protect:
3871 x = os.path.join(target_root, x.lstrip(os.path.sep))
3873 mymode = os.lstat(x).st_mode
3876 if stat.S_ISDIR(mymode):
3877 mycommand = "cd '%s'; find . -iname '._cfg????_*'" % x
3879 mycommand = "cd '%s'; find . -maxdepth 1 -iname '._cfg????_%s'" % \
3880 os.path.split(x.rstrip(os.path.sep))
3881 a = commands.getstatusoutput(mycommand + \
3882 " ! -iname '.*~' ! -iname '.*.bak'")
3884 print >> sys.stderr, " " + bad("*")+ " error scanning '%s'" % x
3886 files = a[1].split()
3889 print colorize("WARN", " * IMPORTANT:"),
3890 if stat.S_ISDIR(mymode):
3891 print "%d config files in '%s' need updating." % \
3894 print "config file '%s' needs updating." % x
3897 #print " "+yellow("*")+" Type "+green("emerge --help config")+" to learn how to update config files."
3898 print " "+yellow("*")+" Type "+green("emerge --help config")+" to learn how to update config files."
3900 def checkUpdatedNewsItems( root, NEWS_PATH, UNREAD_PATH, repo_id ):
3902 Examines news items in repodir + '/' + NEWS_PATH and attempts to find unread items
3903 Returns the number of unread (yet relevent) items.
3915 1. The number of unread but relevant news items.
3918 from portage.news import NewsManager
3919 manager = NewsManager( root, NEWS_PATH, UNREAD_PATH )
3920 return manager.getUnreadItems( repo_id, update=True )
3922 def is_valid_package_atom(x):
3924 testkey = portage.dep_getkey(x)
3925 except portage.exception.InvalidData:
3927 if testkey.startswith("null/"):
3928 testatom = x.replace(testkey[5:], "cat/"+testkey[5:])
3933 return portage.isvalidatom(testatom)
3935 def validate_merge_list(trees, mergelist):
3936 """Validate the list to make sure all the packages are still available.
3937 This is needed for --resume."""
3938 for (pkg_type, myroot, pkg_key, action) in mergelist:
3939 if pkg_type == "binary" and \
3940 not trees[myroot]["bintree"].dbapi.match("="+pkg_key) or \
3941 pkg_type == "ebuild" and \
3942 not trees[myroot]["porttree"].dbapi.xmatch(
3943 "match-all", "="+pkg_key):
3944 print red("!!! Error: The resume list contains packages that are no longer")
3945 print red("!!! available to be emerged. Please restart/continue")
3946 print red("!!! the merge operation manually.")
3949 def show_blocker_docs_link():
3951 print "For more information about " + bad("Blocked Packages") + ", please refer to the following"
3952 print "section of the Gentoo Linux x86 Handbook (architecture is irrelevant):"
3954 print "http://www.gentoo.org/doc/en/handbook/handbook-x86.xml?full=1#blocked"
3957 def action_sync(settings, trees, mtimedb, myopts, myaction):
3958 xterm_titles = "notitles" not in settings.features
3959 emergelog(xterm_titles, " === sync")
3960 myportdir = settings.get("PORTDIR", None)
3962 sys.stderr.write("!!! PORTDIR is undefined. Is /etc/make.globals missing?\n")
3964 if myportdir[-1]=="/":
3965 myportdir=myportdir[:-1]
3966 if not os.path.exists(myportdir):
3967 print ">>>",myportdir,"not found, creating it."
3968 os.makedirs(myportdir,0755)
3969 syncuri=settings["SYNC"].rstrip()
3971 updatecache_flg = False
3972 if myaction == "metadata":
3973 print "skipping sync"
3974 updatecache_flg = True
3975 tmpservertimestampfile = None
3976 elif syncuri[:8]=="rsync://":
3977 if not os.path.exists("/usr/bin/rsync"):
3978 print "!!! /usr/bin/rsync does not exist, so rsync support is disabled."
3979 print "!!! Type \"emerge net-misc/rsync\" to enable rsync support."
3984 import shlex, StringIO
3985 if settings["PORTAGE_RSYNC_OPTS"] == "":
3986 portage.writemsg("PORTAGE_RSYNC_OPTS empty or unset, using hardcoded defaults\n")
3988 "--recursive", # Recurse directories
3989 "--links", # Consider symlinks
3990 "--safe-links", # Ignore links outside of tree
3991 "--perms", # Preserve permissions
3992 "--times", # Preserive mod times
3993 "--compress", # Compress the data transmitted
3994 "--force", # Force deletion on non-empty dirs
3995 "--whole-file", # Don't do block transfers, only entire files
3996 "--delete", # Delete files that aren't in the master tree
3997 "--delete-after", # Delete only after everything else is done
3998 "--stats", # Show final statistics about what was transfered
3999 "--timeout="+str(mytimeout), # IO timeout if not done in X seconds
4000 "--exclude=/distfiles", # Exclude distfiles from consideration
4001 "--exclude=/local", # Exclude local from consideration
4002 "--exclude=/packages", # Exclude packages from consideration
4003 "--filter=H_**/files/digest-*", # Exclude manifest1 digests and delete on the receiving side
4007 # The below validation is not needed when using the above hardcoded
4010 portage.writemsg("Using PORTAGE_RSYNC_OPTS instead of hardcoded defaults\n", 1)
4011 lexer = shlex.shlex(StringIO.StringIO(
4012 settings.get("PORTAGE_RSYNC_OPTS","")), posix=True)
4013 lexer.whitespace_split = True
4014 rsync_opts.extend(lexer)
4017 for opt in ("--recursive", "--times"):
4018 if opt not in rsync_opts:
4019 portage.writemsg(yellow("WARNING:") + " adding required option " + \
4020 "%s not included in PORTAGE_RSYNC_OPTS\n" % opt)
4021 rsync_opts.append(opt)
4023 for exclude in ("distfiles", "local", "packages"):
4024 opt = "--exclude=/%s" % exclude
4025 if opt not in rsync_opts:
4026 portage.writemsg(yellow("WARNING:") + \
4027 " adding required option %s not included in " % opt + \
4028 "PORTAGE_RSYNC_OPTS (can be overridden with --exclude='!')\n")
4029 rsync_opts.append(opt)
4031 if settings["RSYNC_TIMEOUT"] != "":
4032 portage.writemsg("WARNING: usage of RSYNC_TIMEOUT is deprecated, " + \
4033 "use PORTAGE_RSYNC_EXTRA_OPTS instead\n")
4035 mytimeout = int(settings["RSYNC_TIMEOUT"])
4036 rsync_opts.append("--timeout=%d" % mytimeout)
4037 except ValueError, e:
4038 portage.writemsg("!!! %s\n" % str(e))
4040 # TODO: determine options required for official servers
4041 if syncuri.rstrip("/").endswith(".gentoo.org/gentoo-portage"):
4043 def rsync_opt_startswith(opt_prefix):
4044 for x in rsync_opts:
4045 if x.startswith(opt_prefix):
4049 if not rsync_opt_startswith("--timeout="):
4050 rsync_opts.append("--timeout=%d" % mytimeout)
4052 for opt in ("--compress", "--whole-file"):
4053 if opt not in rsync_opts:
4054 portage.writemsg(yellow("WARNING:") + " adding required option " + \
4055 "%s not included in PORTAGE_RSYNC_OPTS\n" % opt)
4056 rsync_opts.append(opt)
4058 if "--quiet" in myopts:
4059 rsync_opts.append("--quiet") # Shut up a lot
4061 rsync_opts.append("--verbose") # Print filelist
4063 if "--verbose" in myopts:
4064 rsync_opts.append("--progress") # Progress meter for each file
4066 if "--debug" in myopts:
4067 rsync_opts.append("--checksum") # Force checksum on all files
4069 if settings["RSYNC_EXCLUDEFROM"] != "":
4070 portage.writemsg(yellow("WARNING:") + \
4071 " usage of RSYNC_EXCLUDEFROM is deprecated, use " + \
4072 "PORTAGE_RSYNC_EXTRA_OPTS instead\n")
4073 if os.path.exists(settings["RSYNC_EXCLUDEFROM"]):
4074 rsync_opts.append("--exclude-from=%s" % \
4075 settings["RSYNC_EXCLUDEFROM"])
4077 portage.writemsg("!!! RSYNC_EXCLUDEFROM specified," + \
4078 " but file does not exist.\n")
4080 if settings["RSYNC_RATELIMIT"] != "":
4081 portage.writemsg(yellow("WARNING:") + \
4082 " usage of RSYNC_RATELIMIT is deprecated, use " + \
4083 "PORTAGE_RSYNC_EXTRA_OPTS instead")
4084 rsync_opts.append("--bwlimit=%s" % \
4085 settings["RSYNC_RATELIMIT"])
4087 # Real local timestamp file.
4088 servertimestampfile = os.path.join(
4089 myportdir, "metadata", "timestamp.chk")
4090 # Temporary file for remote server timestamp comparison.
4091 tmpservertimestampfile = os.path.join(
4092 settings["PORTAGE_TMPDIR"], "timestamp.chk")
4094 content = portage.util.grabfile(servertimestampfile)
4098 mytimestamp = time.mktime(time.strptime(content[0],
4099 "%a, %d %b %Y %H:%M:%S +0000"))
4100 except (OverflowError, ValueError):
4105 rsync_initial_timeout = \
4106 int(settings.get("PORTAGE_RSYNC_INITIAL_TIMEOUT", "15"))
4108 rsync_initial_timeout = 15
4111 if settings.has_key("RSYNC_RETRIES"):
4112 print yellow("WARNING:")+" usage of RSYNC_RETRIES is deprecated, use PORTAGE_RSYNC_RETRIES instead"
4113 maxretries=int(settings["RSYNC_RETRIES"])
4115 maxretries=int(settings["PORTAGE_RSYNC_RETRIES"])
4116 except SystemExit, e:
4117 raise # Needed else can't exit
4119 maxretries=3 #default number of retries
4122 user_name, hostname, port = re.split(
4123 "rsync://([^:/]+@)?([^:/]*)(:[0-9]+)?", syncuri, maxsplit=3)[1:4]
4126 if user_name is None:
4128 updatecache_flg=True
4129 all_rsync_opts = set(rsync_opts)
4130 lexer = shlex.shlex(StringIO.StringIO(
4131 settings.get("PORTAGE_RSYNC_EXTRA_OPTS","")), posix=True)
4132 lexer.whitespace_split = True
4133 extra_rsync_opts = list(lexer)
4135 all_rsync_opts.update(extra_rsync_opts)
4136 family = socket.AF_INET
4137 if "-4" in all_rsync_opts or "--ipv4" in all_rsync_opts:
4138 family = socket.AF_INET
4139 elif socket.has_ipv6 and \
4140 ("-6" in all_rsync_opts or "--ipv6" in all_rsync_opts):
4141 family = socket.AF_INET6
4148 for addrinfo in socket.getaddrinfo(
4149 hostname, None, family, socket.SOCK_STREAM):
4150 if addrinfo[0] == socket.AF_INET6:
4151 # IPv6 addresses need to be enclosed in square brackets
4152 ips.append("[%s]" % addrinfo[4][0])
4154 ips.append(addrinfo[4][0])
4155 from random import shuffle
4157 except SystemExit, e:
4158 raise # Needed else can't exit
4159 except Exception, e:
4160 print "Notice:",str(e)
4165 dosyncuri = syncuri.replace(
4166 "//" + user_name + hostname + port + "/",
4167 "//" + user_name + ips[0] + port + "/", 1)
4168 except SystemExit, e:
4169 raise # Needed else can't exit
4170 except Exception, e:
4171 print "Notice:",str(e)
4175 if "--ask" in myopts:
4176 if userquery("Do you want to sync your Portage tree with the mirror at\n" + blue(dosyncuri) + bold("?"))=="No":
4181 emergelog(xterm_titles, ">>> Starting rsync with " + dosyncuri)
4182 if "--quiet" not in myopts:
4183 print ">>> Starting rsync with "+dosyncuri+"..."
4185 emergelog(xterm_titles,
4186 ">>> Starting retry %d of %d with %s" % \
4187 (retries,maxretries,dosyncuri))
4188 print "\n\n>>> Starting retry %d of %d with %s" % (retries,maxretries,dosyncuri)
4190 if mytimestamp != 0 and "--quiet" not in myopts:
4191 print ">>> Checking server timestamp ..."
4193 rsynccommand = ["/usr/bin/rsync"] + rsync_opts + extra_rsync_opts
4195 if "--debug" in myopts:
4200 # Even if there's no timestamp available locally, fetch the
4201 # timestamp anyway as an initial probe to verify that the server is
4202 # responsive. This protects us from hanging indefinitely on a
4203 # connection attempt to an unresponsive server which rsync's
4204 # --timeout option does not prevent.
4206 mycommand = rsynccommand[:]
4207 mycommand.append(dosyncuri.rstrip("/") + \
4208 "/metadata/timestamp.chk")
4209 mycommand.append(tmpservertimestampfile)
4213 def timeout_handler(signum, frame):
4214 raise portage.exception.PortageException("timed out")
4215 signal.signal(signal.SIGALRM, timeout_handler)
4216 # Timeout here in case the server is unresponsive. The
4217 # --timeout rsync option doesn't apply to the initial
4218 # connection attempt.
4219 if rsync_initial_timeout:
4220 signal.alarm(rsync_initial_timeout)
4222 mypids.extend(portage.process.spawn(
4223 mycommand, env=settings.environ(), returnpid=True))
4224 exitcode = os.waitpid(mypids[0], 0)[1]
4225 content = portage.grabfile(tmpservertimestampfile)
4227 if rsync_initial_timeout:
4230 os.unlink(tmpservertimestampfile)
4233 except portage.exception.PortageException, e:
4237 if mypids and os.waitpid(mypids[0], os.WNOHANG) == (0,0):
4238 os.kill(mypids[0], signal.SIGTERM)
4239 os.waitpid(mypids[0], 0)
4240 # This is the same code rsync uses for timeout.
4243 if exitcode != os.EX_OK:
4245 exitcode = (exitcode & 0xff) << 8
4247 exitcode = exitcode >> 8
4249 portage.process.spawned_pids.remove(mypids[0])
4252 servertimestamp = time.mktime(time.strptime(
4253 content[0], "%a, %d %b %Y %H:%M:%S +0000"))
4254 except (OverflowError, ValueError):
4256 del mycommand, mypids, content
4257 if exitcode == os.EX_OK:
4258 if (servertimestamp != 0) and (servertimestamp == mytimestamp):
4259 emergelog(xterm_titles,
4260 ">>> Cancelling sync -- Already current.")
4263 print ">>> Timestamps on the server and in the local repository are the same."
4264 print ">>> Cancelling all further sync action. You are already up to date."
4266 print ">>> In order to force sync, remove '%s'." % servertimestampfile
4270 elif (servertimestamp != 0) and (servertimestamp < mytimestamp):
4271 emergelog(xterm_titles,
4272 ">>> Server out of date: %s" % dosyncuri)
4275 print ">>> SERVER OUT OF DATE: %s" % dosyncuri
4277 print ">>> In order to force sync, remove '%s'." % servertimestampfile
4280 elif (servertimestamp == 0) or (servertimestamp > mytimestamp):
4282 mycommand = rsynccommand + [dosyncuri+"/", myportdir]
4283 exitcode = portage.process.spawn(mycommand,
4284 env=settings.environ())
4285 if exitcode in [0,1,3,4,11,14,20,21]:
4287 elif exitcode in [1,3,4,11,14,20,21]:
4290 # Code 2 indicates protocol incompatibility, which is expected
4291 # for servers with protocol < 29 that don't support
4292 # --prune-empty-directories. Retry for a server that supports
4293 # at least rsync protocol version 29 (>=rsync-2.6.4).
4298 if retries<=maxretries:
4299 print ">>> Retrying..."
4304 updatecache_flg=False
4308 emergelog(xterm_titles, "=== Sync completed with %s" % dosyncuri)
4312 print darkred("!!!")+green(" Rsync has reported that there is a syntax error. Please ensure")
4313 print darkred("!!!")+green(" that your SYNC statement is proper.")
4314 print darkred("!!!")+green(" SYNC="+settings["SYNC"])
4316 print darkred("!!!")+green(" Rsync has reported that there is a File IO error. Normally")
4317 print darkred("!!!")+green(" this means your disk is full, but can be caused by corruption")
4318 print darkred("!!!")+green(" on the filesystem that contains PORTDIR. Please investigate")
4319 print darkred("!!!")+green(" and try again after the problem has been fixed.")
4320 print darkred("!!!")+green(" PORTDIR="+settings["PORTDIR"])
4322 print darkred("!!!")+green(" Rsync was killed before it finished.")
4324 print darkred("!!!")+green(" Rsync has not successfully finished. It is recommended that you keep")
4325 print darkred("!!!")+green(" trying or that you use the 'emerge-webrsync' option if you are unable")
4326 print darkred("!!!")+green(" to use rsync due to firewall or other restrictions. This should be a")
4327 print darkred("!!!")+green(" temporary problem unless complications exist with your network")
4328 print darkred("!!!")+green(" (and possibly your system's filesystem) configuration.")
4331 elif syncuri[:6]=="cvs://":
4332 if not os.path.exists("/usr/bin/cvs"):
4333 print "!!! /usr/bin/cvs does not exist, so CVS support is disabled."
4334 print "!!! Type \"emerge dev-util/cvs\" to enable CVS support."
4337 cvsdir=os.path.dirname(myportdir)
4338 if not os.path.exists(myportdir+"/CVS"):
4340 print ">>> Starting initial cvs checkout with "+syncuri+"..."
4341 if os.path.exists(cvsdir+"/gentoo-x86"):
4342 print "!!! existing",cvsdir+"/gentoo-x86 directory; exiting."
4347 if e.errno != errno.ENOENT:
4349 "!!! existing '%s' directory; exiting.\n" % myportdir)
4352 if portage.spawn("cd "+cvsdir+"; cvs -z0 -d "+cvsroot+" co -P gentoo-x86",settings,free=1):
4353 print "!!! cvs checkout error; exiting."
4355 os.rename(os.path.join(cvsdir, "gentoo-x86"), myportdir)
4358 print ">>> Starting cvs update with "+syncuri+"..."
4359 retval = portage.spawn("cd '%s'; cvs -z0 -q update -dP" % \
4360 myportdir, settings, free=1)
4361 if retval != os.EX_OK:
4365 print "!!! rsync setting: ",syncuri,"not recognized; exiting."
4368 if updatecache_flg and \
4369 myaction != "metadata" and \
4370 "metadata-transfer" not in settings.features:
4371 updatecache_flg = False
4373 # Reload the whole config from scratch.
4374 settings, trees, mtimedb = load_emerge_config(trees=trees)
4375 portdb = trees[settings["ROOT"]]["porttree"].dbapi
4377 if os.path.exists(myportdir+"/metadata/cache") and updatecache_flg:
4378 action_metadata(settings, portdb, myopts)
4380 if portage._global_updates(trees, mtimedb["updates"]):
4382 # Reload the whole config from scratch.
4383 settings, trees, mtimedb = load_emerge_config(trees=trees)
4384 portdb = trees[settings["ROOT"]]["porttree"].dbapi
4386 mybestpv = portdb.xmatch("bestmatch-visible", "sys-apps/portage")
4387 mypvs = portage.best(
4388 trees[settings["ROOT"]]["vartree"].dbapi.match("sys-apps/portage"))
4390 chk_updated_cfg_files("/", settings.get("CONFIG_PROTECT","").split())
4392 if myaction != "metadata":
4393 if os.access(portage.USER_CONFIG_PATH + "/bin/post_sync", os.X_OK):
4394 retval = portage.process.spawn(
4395 [os.path.join(portage.USER_CONFIG_PATH, "bin", "post_sync"),
4396 dosyncuri], env=settings.environ())
4397 if retval != os.EX_OK:
4398 print red(" * ")+bold("spawn failed of "+ portage.USER_CONFIG_PATH + "/bin/post_sync")
4400 if(mybestpv != mypvs) and not "--quiet" in myopts:
4402 print red(" * ")+bold("An update to portage is available.")+" It is _highly_ recommended"
4403 print red(" * ")+"that you update portage now, before any other packages are updated."
4404 print red(" * ")+"Please run 'emerge portage' and then update "+bold("ALL")+" of your"
4405 print red(" * ")+"configuration files."
4406 print red(" * ")+"To update portage, run 'emerge portage'."
4409 display_news_notification(settings)
4411 def action_metadata(settings, portdb, myopts):
4412 portage.writemsg_stdout("\n>>> Updating Portage cache: ")
4413 old_umask = os.umask(0002)
4414 cachedir = os.path.normpath(settings.depcachedir)
4415 if cachedir in ["/", "/bin", "/dev", "/etc", "/home",
4416 "/lib", "/opt", "/proc", "/root", "/sbin",
4417 "/sys", "/tmp", "/usr", "/var"]:
4418 print >> sys.stderr, "!!! PORTAGE_DEPCACHEDIR IS SET TO A PRIMARY " + \
4419 "ROOT DIRECTORY ON YOUR SYSTEM."
4420 print >> sys.stderr, \
4421 "!!! This is ALMOST CERTAINLY NOT what you want: '%s'" % cachedir
4423 if not os.path.exists(cachedir):
4426 ec = portage.eclass_cache.cache(portdb.porttree_root)
4427 myportdir = os.path.realpath(settings["PORTDIR"])
4428 cm = settings.load_best_module("portdbapi.metadbmodule")(
4429 myportdir, "metadata/cache", portage.auxdbkeys[:])
4431 from portage.cache import util
4433 class percentage_noise_maker(util.quiet_mirroring):
4434 def __init__(self, dbapi):
4436 self.cp_all = dbapi.cp_all()
4437 l = len(self.cp_all)
4438 self.call_update_min = 100000000
4439 self.min_cp_all = l/100.0
4444 for x in self.cp_all:
4446 if self.count > self.min_cp_all:
4447 self.call_update_min = 0
4449 for y in self.dbapi.cp_list(x):
4451 self.call_update_mine = 0
4453 def update(self, *arg):
4454 try: self.pstr = int(self.pstr) + 1
4455 except ValueError: self.pstr = 1
4456 sys.stdout.write("%s%i%%" % \
4457 ("\b" * (len(str(self.pstr))+1), self.pstr))
4459 self.call_update_min = 10000000
4461 def finish(self, *arg):
4462 sys.stdout.write("\b\b\b\b100%\n")
4465 if "--quiet" in myopts:
4466 def quicky_cpv_generator(cp_all_list):
4467 for x in cp_all_list:
4468 for y in portdb.cp_list(x):
4470 source = quicky_cpv_generator(portdb.cp_all())
4471 noise_maker = portage.cache.util.quiet_mirroring()
4473 noise_maker = source = percentage_noise_maker(portdb)
4474 portage.cache.util.mirror_cache(source, cm, portdb.auxdb[myportdir],
4475 eclass_cache=ec, verbose_instance=noise_maker)
4480 def action_regen(settings, portdb):
4481 xterm_titles = "notitles" not in settings.features
4482 emergelog(xterm_titles, " === regen")
4483 #regenerate cache entries
4484 print "Regenerating cache entries... "
4486 os.close(sys.stdin.fileno())
4487 except SystemExit, e:
4488 raise # Needed else can't exit
4492 mynodes = portdb.cp_all()
4493 from portage.cache.cache_errors import CacheError
4495 for mytree in portdb.porttrees:
4497 dead_nodes[mytree] = set(portdb.auxdb[mytree].iterkeys())
4498 except CacheError, e:
4499 print "\n error listing cache entries for " + \
4500 "'%s': %s, continuing..." % (mytree, e)
4505 mymatches = portdb.cp_list(x)
4506 portage.writemsg_stdout("processing %s\n" % x)
4509 foo = portdb.aux_get(y,["DEPEND"])
4510 except SystemExit, e:
4511 # sys.exit is an exception... And consequently, we can't catch it.
4513 except Exception, e:
4514 print "\n error processing %(cpv)s, continuing... (%(e)s)" % {"cpv":y,"e":str(e)}
4516 for mytree in portdb.porttrees:
4517 if portdb.findname2(y, mytree=mytree)[0]:
4518 dead_nodes[mytree].discard(y)
4520 for mytree, nodes in dead_nodes.iteritems():
4521 auxdb = portdb.auxdb[mytree]
4525 except (KeyError, CacheError):
4529 def action_config(settings, trees, myopts, myfiles):
4530 if len(myfiles) != 1 or "system" in myfiles or "world" in myfiles:
4531 print red("!!! config can only take a single package atom at this time\n")
4533 if not is_valid_package_atom(myfiles[0]):
4534 portage.writemsg("!!! '%s' is not a valid package atom.\n" % myfiles[0],
4536 portage.writemsg("!!! Please check ebuild(5) for full details.\n")
4537 portage.writemsg("!!! (Did you specify a version but forget to prefix with '='?)\n")
4541 pkgs = trees[settings["ROOT"]]["vartree"].dbapi.match(myfiles[0])
4542 except ValueError, e:
4543 # Multiple matches thrown from cpv_expand
4546 print "No packages found.\n"
4549 if "--ask" in myopts:
4551 print "Please select a package to configure:"
4555 options.append(str(idx))
4556 print options[-1]+") "+pkg
4559 idx = userquery("Selection?", options)
4562 pkg = pkgs[int(idx)-1]
4564 print "The following packages available:"
4567 print "\nPlease use a specific atom or the --ask option."
4573 if "--ask" in myopts:
4574 if userquery("Ready to configure "+pkg+"?") == "No":
4577 print "Configuring pkg..."
4579 ebuildpath = trees[settings["ROOT"]]["vartree"].dbapi.findname(pkg)
4580 mysettings = portage.config(clone=settings)
4581 portage.doebuild(ebuildpath, "config", settings["ROOT"], mysettings,
4582 debug=(settings.get("PORTAGE_DEBUG", "") == 1), cleanup=True,
4583 mydbapi=trees[settings["ROOT"]]["vartree"].dbapi, tree="vartree")
4586 def action_info(settings, trees, myopts, myfiles):
4587 unameout=commands.getstatusoutput("uname -mrp")[1]
4588 print getportageversion(settings["PORTDIR"], settings["ROOT"],
4589 settings.profile_path, settings["CHOST"],
4590 trees[settings["ROOT"]]["vartree"].dbapi)
4592 header_title = "System Settings"
4594 print header_width * "="
4595 print header_title.rjust(int(header_width/2 + len(header_title)/2))
4596 print header_width * "="
4597 print "System uname: "+unameout
4598 gentoo_release = portage.grabfile(os.path.join(
4599 settings["PORTAGE_CONFIGROOT"], "etc", "gentoo-release"))
4601 print gentoo_release[0]
4603 print "Unknown Host Operating System"
4604 lastSync = portage.grabfile(os.path.join(
4605 settings["PORTDIR"], "metadata", "timestamp.chk"))
4606 print "Timestamp of tree:",
4612 output=commands.getstatusoutput("distcc --version")
4614 print str(output[1].split("\n",1)[0]),
4615 if "distcc" in settings.features:
4620 output=commands.getstatusoutput("ccache -V")
4622 print str(output[1].split("\n",1)[0]),
4623 if "ccache" in settings.features:
4628 myvars = ["sys-devel/autoconf", "sys-devel/automake", "virtual/os-headers",
4629 "sys-devel/binutils", "sys-devel/libtool", "dev-lang/python"]
4630 myvars += portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_pkgs")
4631 myvars = portage.util.unique_array(myvars)
4635 if portage.isvalidatom(x):
4636 pkg_matches = trees["/"]["vartree"].dbapi.match(x)
4637 pkg_matches = [portage.catpkgsplit(cpv)[1:] for cpv in pkg_matches]
4638 pkg_matches.sort(portage.pkgcmp)
4640 for pn, ver, rev in pkg_matches:
4642 pkgs.append(ver + "-" + rev)
4646 pkgs = ", ".join(pkgs)
4647 print "%-20s %s" % (x+":", pkgs)
4649 print "%-20s %s" % (x+":", "[NOT VALID]")
4651 libtool_vers = ",".join(trees["/"]["vartree"].dbapi.match("sys-devel/libtool"))
4653 if "--verbose" in myopts:
4654 myvars=settings.keys()
4656 myvars = ['GENTOO_MIRRORS', 'CONFIG_PROTECT', 'CONFIG_PROTECT_MASK',
4657 'PORTDIR', 'DISTDIR', 'PKGDIR', 'PORTAGE_TMPDIR',
4658 'PORTDIR_OVERLAY', 'USE', 'CHOST', 'CFLAGS', 'CXXFLAGS',
4659 'ACCEPT_KEYWORDS', 'SYNC', 'FEATURES', 'EMERGE_DEFAULT_OPTS']
4661 myvars.extend(portage.util.grabfile(settings["PORTDIR"]+"/profiles/info_vars"))
4663 myvars = portage.util.unique_array(myvars)
4669 print '%s="%s"' % (x, settings[x])
4671 use = set(settings["USE"].split())
4672 use_expand = settings["USE_EXPAND"].split()
4674 for varname in use_expand:
4675 flag_prefix = varname.lower() + "_"
4677 if f.startswith(flag_prefix):
4681 print 'USE="%s"' % " ".join(use),
4682 for varname in use_expand:
4683 myval = settings.get(varname)
4685 print '%s="%s"' % (varname, myval),
4688 unset_vars.append(x)
4690 print "Unset: "+", ".join(unset_vars)
4693 if "--debug" in myopts:
4694 for x in dir(portage):
4695 module = getattr(portage, x)
4696 if "cvs_id_string" in dir(module):
4697 print "%s: %s" % (str(x), str(module.cvs_id_string))
4699 # See if we can find any packages installed matching the strings
4700 # passed on the command line
4702 vardb = trees[settings["ROOT"]]["vartree"].dbapi
4703 portdb = trees[settings["ROOT"]]["porttree"].dbapi
4705 mypkgs.extend(vardb.match(x))
4707 # If some packages were found...
4709 # Get our global settings (we only print stuff if it varies from
4710 # the current config)
4711 mydesiredvars = [ 'CHOST', 'CFLAGS', 'CXXFLAGS' ]
4712 auxkeys = mydesiredvars + [ "USE", "IUSE"]
4714 pkgsettings = portage.config(clone=settings)
4716 for myvar in mydesiredvars:
4717 global_vals[myvar] = set(settings.get(myvar, "").split())
4719 # Loop through each package
4720 # Only print settings if they differ from global settings
4721 header_printed = False
4723 # Get all package specific variables
4724 auxvalues = vardb.aux_get(pkg, auxkeys)
4726 for i in xrange(len(auxkeys)):
4727 valuesmap[auxkeys[i]] = set(auxvalues[i].split())
4729 for myvar in mydesiredvars:
4730 # If the package variable doesn't match the
4731 # current global variable, something has changed
4732 # so set diff_found so we know to print
4733 if valuesmap[myvar] != global_vals[myvar]:
4734 diff_values[myvar] = valuesmap[myvar]
4735 valuesmap["IUSE"] = set(filter_iuse_defaults(valuesmap["IUSE"]))
4736 valuesmap["USE"] = valuesmap["USE"].intersection(valuesmap["IUSE"])
4738 # If a matching ebuild is no longer available in the tree, maybe it
4739 # would make sense to compare against the flags for the best
4740 # available version with the same slot?
4742 if portdb.cpv_exists(pkg):
4744 pkgsettings.setcpv(pkg, mydb=mydb)
4745 if valuesmap["IUSE"].intersection(pkgsettings["USE"].split()) != \
4747 diff_values["USE"] = valuesmap["USE"]
4748 # If a difference was found, print the info for
4752 # If we have not yet printed the header,
4754 if not header_printed:
4755 header_title = "Package Settings"
4756 print header_width * "="
4757 print header_title.rjust(int(header_width/2 + len(header_title)/2))
4758 print header_width * "="
4759 header_printed = True
4761 # Print package info
4762 print "%s was built with the following:" % pkg
4763 for myvar in mydesiredvars + ["USE"]:
4764 if myvar in diff_values:
4765 mylist = list(diff_values[myvar])
4767 print "%s=\"%s\"" % (myvar, " ".join(mylist))
4770 def action_search(settings, portdb, vartree, myopts, myfiles, spinner):
4772 print "emerge: no search terms provided."
4774 searchinstance = search(settings, portdb,
4775 vartree, spinner, "--searchdesc" in myopts,
4776 "--quiet" not in myopts)
4777 for mysearch in myfiles:
4779 searchinstance.execute(mysearch)
4780 except re.error, comment:
4781 print "\n!!! Regular expression error in \"%s\": %s" % ( mysearch, comment )
4783 searchinstance.output()
4785 def action_depclean(settings, trees, ldpath_mtimes,
4787 # Kill packages that aren't explicitly merged or are required as a
4788 # dependency of another package. World file is explicit.
4790 warn_prefix = colorize("BAD", "*** WARNING *** ")
4792 print warn_prefix + "Depclean may break link level dependencies. Thus, it is"
4793 print warn_prefix + "recommended to use a tool such as " + good("`revdep-rebuild`") + " (from"
4794 print warn_prefix + "app-portage/gentoolkit) in order to detect such breakage."
4796 print warn_prefix + "Also study the list of packages to be cleaned for any obvious"
4797 print warn_prefix + "mistakes. Packages that are part of the world set will always"
4798 print warn_prefix + "be kept. They can be manually added to this set with"
4799 print warn_prefix + good("`emerge --noreplace <atom>`") + ". Packages that are listed in"
4800 print warn_prefix + "package.provided (see portage(5)) will be removed by"
4801 print warn_prefix + "depclean, even if they are part of the world set."
4803 print warn_prefix + "As a safety measure, depclean will not remove any packages"
4804 print warn_prefix + "unless *all* required dependencies have been resolved. As a"
4805 print warn_prefix + "consequence, it is often necessary to run "
4806 print warn_prefix + good("`emerge --update --newuse --deep world`") + " prior to depclean."
4808 xterm_titles = "notitles" not in settings.features
4809 myroot = settings["ROOT"]
4810 dep_check_trees = {}
4811 dep_check_trees[myroot] = {}
4812 dep_check_trees[myroot]["vartree"] = \
4813 FakeVartree(trees[myroot]["vartree"], trees[myroot]["porttree"].dbapi)
4814 vardb = dep_check_trees[myroot]["vartree"].dbapi
4815 # Constrain dependency selection to the installed packages.
4816 dep_check_trees[myroot]["porttree"] = dep_check_trees[myroot]["vartree"]
4817 syslist = getlist(settings, "system")
4818 worldlist = getlist(settings, "world")
4819 system_world_dict = genericdict(worldlist)
4820 system_world_dict.update(genericdict(syslist))
4821 fakedb = portage.fakedbapi(settings=settings)
4822 myvarlist = vardb.cpv_all()
4825 print "\n!!! You have no system list.",
4827 print "\n!!! You have no world file.",
4829 print "\n!!! You have no installed package database (%s)." % portage.VDB_PATH,
4831 if not (syslist and worldlist and myvarlist):
4832 print "\n!!! Proceeding "+(syslist and myvarlist and "may" or "will")
4833 print " break your installation.\n"
4834 if "--pretend" not in myopts:
4835 countdown(int(settings["EMERGE_WARNING_DELAY"]), ">>> Depclean")
4837 if not "--pretend" in myopts: #just check pretend, since --ask implies pretend
4838 emergelog(xterm_titles, " >>> depclean")
4840 if "--quiet" not in myopts:
4841 print "\nCalculating dependencies ",
4845 remaining_atoms = [(atom, 'world', hard) for atom in worldlist if vardb.match(atom)]
4846 remaining_atoms += [(atom, 'system', hard) for atom in syslist if vardb.match(atom)]
4848 aux_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
4850 while remaining_atoms:
4851 atom, parent, priority = remaining_atoms.pop()
4852 pkgs = vardb.match(atom)
4854 if not atom.startswith("!") and priority == hard:
4855 unresolveable.setdefault(atom, []).append(parent)
4857 if portage.dep_getkey(atom) not in system_world_dict:
4858 # Prune all but the best matching slot, since that's all that a
4859 # deep world update would pull in. Don't prune if the cpv is in
4860 # system or world though, since those sets trigger greedy update
4862 pkgs = [portage.best(pkgs)]
4864 if fakedb.cpv_exists(pkg):
4867 fakedb.cpv_inject(pkg)
4868 myaux = dict(izip(aux_keys, vardb.aux_get(pkg, aux_keys)))
4870 if myopts.get("--with-bdeps", "y") == "y":
4871 mydeps.append((myaux["DEPEND"], soft))
4873 mydeps.append((" ".join(myaux.values()), hard))
4874 usedef = vardb.aux_get(pkg, ["USE"])[0].split()
4875 for depstr, priority in mydeps:
4880 if "--debug" in myopts:
4882 print "Parent: ", pkg
4883 print "Depstring:", depstr
4885 if priority == soft:
4891 portage.dep._dep_check_strict = False
4892 success, atoms = portage.dep_check(depstr, None, settings,
4893 myuse=usedef, trees=dep_check_trees, myroot=myroot)
4895 portage.dep._dep_check_strict = True
4897 show_invalid_depstring_notice(
4898 ("installed", myroot, pkg, "nomerge"),
4902 if "--debug" in myopts:
4903 print "Candidates:", atoms
4906 remaining_atoms.append((atom, pkg, priority))
4908 if "--quiet" not in myopts:
4909 print "\b\b... done!\n"
4912 print "Dependencies could not be completely resolved due to"
4913 print "the following required packages not being installed:"
4915 for atom in unresolveable:
4916 print atom, "required by", " ".join(unresolveable[atom])
4918 print "Have you forgotten to run " + good("`emerge --update --newuse --deep world`") + " prior to"
4919 print "depclean? It may be necessary to manually uninstall packages that no longer"
4920 print "exist in the portage tree since it may not be possible to satisfy their"
4921 print "dependencies. Also, be aware of the --with-bdeps option that is documented"
4922 print "in " + good("`man emerge`") + "."
4926 cleanlist = [pkg for pkg in vardb.cpv_all() if not fakedb.cpv_exists(pkg)]
4929 unmerge(settings, myopts, trees[settings["ROOT"]]["vartree"],
4930 "unmerge", cleanlist, ldpath_mtimes)
4932 print "Packages installed: "+str(len(myvarlist))
4933 print "Packages in world: "+str(len(worldlist))
4934 print "Packages in system: "+str(len(syslist))
4935 print "Unique package names: "+str(len(myvarlist))
4936 print "Required packages: "+str(len(fakedb.cpv_all()))
4937 if "--pretend" in myopts:
4938 print "Number to remove: "+str(len(cleanlist))
4940 print "Number removed: "+str(len(cleanlist))
4942 def action_build(settings, trees, mtimedb,
4943 myopts, myaction, myfiles, spinner):
4944 ldpath_mtimes = mtimedb["ldpath"]
4946 if "--quiet" not in myopts and \
4947 ("--pretend" in myopts or "--ask" in myopts or \
4948 "--tree" in myopts or "--verbose" in myopts):
4950 if "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
4954 if "--tree" in myopts and action != "fetched": # Tree doesn't work with fetching
4956 print darkgreen("These are the packages that would be %s, in reverse order:") % action
4960 print darkgreen("These are the packages that would be %s, in order:") % action
4963 # validate the state of the resume data
4964 # so that we can make assumptions later.
4965 for k in ("resume", "resume_backup"):
4967 if "mergelist" in mtimedb[k]:
4968 if not mtimedb[k]["mergelist"]:
4973 if "--resume" in myopts and \
4974 ("resume" in mtimedb or
4975 "resume_backup" in mtimedb):
4976 if "resume" not in mtimedb:
4977 mtimedb["resume"] = mtimedb["resume_backup"]
4978 del mtimedb["resume_backup"]
4980 # XXX: "myopts" is a list for backward compatibility.
4981 myresumeopts = dict([(k,True) for k in mtimedb["resume"]["myopts"]])
4983 for opt in ("--skipfirst", "--ask", "--tree"):
4984 myresumeopts.pop(opt, None)
4986 for myopt, myarg in myopts.iteritems():
4987 if myopt not in myresumeopts:
4988 myresumeopts[myopt] = myarg
4991 # Adjust config according to options of the command being resumed.
4992 for myroot in trees:
4993 mysettings = trees[myroot]["vartree"].settings
4995 adjust_config(myopts, mysettings)
4997 del myroot, mysettings
4999 myparams = create_depgraph_params(myopts, myaction)
5000 if "--quiet" not in myopts and "--nodeps" not in myopts:
5001 print "Calculating dependencies ",
5002 mydepgraph = depgraph(settings, trees,
5003 myopts, myparams, spinner)
5004 if "--quiet" not in myopts and "--nodeps" not in myopts:
5005 print "\b\b... done!"
5007 if ("--resume" in myopts):
5008 print darkgreen("emerge: It seems we have nothing to resume...")
5011 myparams = create_depgraph_params(myopts, myaction)
5012 if myaction in ["system","world"]:
5013 if "--quiet" not in myopts and "--nodeps" not in myopts:
5014 print "Calculating",myaction,"dependencies ",
5016 mydepgraph = depgraph(settings, trees, myopts, myparams, spinner)
5017 if not mydepgraph.xcreate(myaction):
5018 print "!!! Depgraph creation failed."
5020 if "--quiet" not in myopts and "--nodeps" not in myopts:
5021 print "\b\b... done!"
5023 if "--quiet" not in myopts and "--nodeps" not in myopts:
5024 print "Calculating dependencies ",
5026 mydepgraph = depgraph(settings, trees, myopts, myparams, spinner)
5028 retval, favorites = mydepgraph.select_files(myfiles)
5029 except portage.exception.PackageNotFound, e:
5030 portage.writemsg("\n!!! %s\n" % str(e), noiselevel=-1)
5034 if "--quiet" not in myopts and "--nodeps" not in myopts:
5035 print "\b\b... done!"
5037 if ("--usepkgonly" in myopts) and mydepgraph.missingbins:
5038 sys.stderr.write(red("The following binaries are not available for merging...\n"))
5040 if mydepgraph.missingbins:
5041 for x in mydepgraph.missingbins:
5042 sys.stderr.write(" "+str(x)+"\n")
5043 sys.stderr.write("\nThese are required by '--usepkgonly' -- Terminating.\n\n")
5046 if "--pretend" not in myopts and \
5047 ("--ask" in myopts or "--tree" in myopts or \
5048 "--verbose" in myopts) and \
5049 not ("--quiet" in myopts and "--ask" not in myopts):
5050 if "--resume" in myopts:
5051 validate_merge_list(trees, mtimedb["resume"]["mergelist"])
5052 mymergelist = mtimedb["resume"]["mergelist"]
5053 if "--skipfirst" in myopts:
5054 mymergelist = mymergelist[1:]
5055 if len(mymergelist) == 0:
5056 print colorize("INFORM", "emerge: It seems we have nothing to resume...")
5058 mydepgraph.display(mymergelist)
5059 prompt="Would you like to resume merging these packages?"
5062 mydepgraph.altlist(reversed=("--tree" in myopts)))
5064 for x in mydepgraph.altlist():
5065 if x[0] != "blocks" and x[3] != "nomerge":
5067 #check for blocking dependencies
5068 if x[0]=="blocks" and "--fetchonly" not in myopts and "--fetch-all-uri" not in myopts:
5069 print "\n!!! Error: The above package list contains packages which cannot be installed"
5070 print "!!! at the same time on the same system."
5071 if "--quiet" not in myopts:
5072 show_blocker_docs_link()
5075 if "--noreplace" in myopts and favorites:
5078 print " %s %s" % (good("*"), x)
5079 prompt="Would you like to add these packages to your world favorites?"
5080 elif settings["AUTOCLEAN"] and "yes"==settings["AUTOCLEAN"]:
5081 prompt="Nothing to merge; would you like to auto-clean packages?"
5084 print "Nothing to merge; quitting."
5087 elif "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
5088 prompt="Would you like to fetch the source files for these packages?"
5090 prompt="Would you like to merge these packages?"
5092 if "--ask" in myopts and userquery(prompt) == "No":
5097 # Don't ask again (e.g. when auto-cleaning packages after merge)
5098 myopts.pop("--ask", None)
5100 if ("--pretend" in myopts) and not ("--fetchonly" in myopts or "--fetch-all-uri" in myopts):
5101 if ("--resume" in myopts):
5102 validate_merge_list(trees, mtimedb["resume"]["mergelist"])
5103 mymergelist = mtimedb["resume"]["mergelist"]
5104 if "--skipfirst" in myopts:
5105 mymergelist = mymergelist[1:]
5106 if len(mymergelist) == 0:
5107 print colorize("INFORM", "emerge: It seems we have nothing to resume...")
5109 mydepgraph.display(mymergelist)
5112 mydepgraph.altlist(reversed=("--tree" in myopts)))
5113 if ("--buildpkgonly" in myopts):
5114 if not mydepgraph.digraph.hasallzeros(ignore_priority=DepPriority.MEDIUM):
5115 print "\n!!! --buildpkgonly requires all dependencies to be merged."
5116 print "!!! You have to merge the dependencies before you can build this package.\n"
5119 if ("--buildpkgonly" in myopts):
5120 if not mydepgraph.digraph.hasallzeros(ignore_priority=DepPriority.MEDIUM):
5121 print "\n!!! --buildpkgonly requires all dependencies to be merged."
5122 print "!!! Cannot merge requested packages. Merge deps and try again.\n"
5125 if ("--resume" in myopts):
5126 favorites=mtimedb["resume"]["favorites"]
5127 mergetask = MergeTask(settings, trees, myopts)
5128 if "--fetchonly" in myopts:
5129 """ parallel-fetch uses --resume --fetchonly and we don't want
5130 it to write the mtimedb"""
5131 mtimedb.filename = None
5132 time.sleep(3) # allow the parent to have first fetch
5134 retval = mergetask.merge(
5135 mtimedb["resume"]["mergelist"], favorites, mtimedb)
5136 if retval != os.EX_OK:
5139 if "resume" in mtimedb and \
5140 "mergelist" in mtimedb["resume"] and \
5141 len(mtimedb["resume"]["mergelist"]) > 1:
5142 mtimedb["resume_backup"] = mtimedb["resume"]
5143 del mtimedb["resume"]
5145 mtimedb["resume"]={}
5146 # XXX: Stored as a list for backward compatibility.
5147 mtimedb["resume"]["myopts"] = \
5148 [k for k in myopts if myopts[k] is True]
5149 mtimedb["resume"]["favorites"]=favorites
5150 if ("--digest" in myopts) and not ("--fetchonly" in myopts or "--fetch-all-uri" in myopts):
5151 for pkgline in mydepgraph.altlist():
5152 if pkgline[0]=="ebuild" and pkgline[3]=="merge":
5153 y = trees[pkgline[1]]["porttree"].dbapi.findname(pkgline[2])
5154 tmpsettings = portage.config(clone=settings)
5156 if settings.get("PORTAGE_DEBUG", "") == "1":
5158 retval = portage.doebuild(
5159 y, "digest", settings["ROOT"], tmpsettings, edebug,
5160 ("--pretend" in myopts),
5161 mydbapi=trees[pkgline[1]]["porttree"].dbapi,
5163 if "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
5165 for pkg in mydepgraph.altlist():
5166 if pkg[0] != "blocks":
5169 pkglist = mydepgraph.altlist()
5171 mergetask = MergeTask(settings, trees, myopts)
5172 retval = mergetask.merge(pkglist, favorites, mtimedb)
5173 if retval != os.EX_OK:
5176 if mtimedb.has_key("resume"):
5177 del mtimedb["resume"]
5178 if settings["AUTOCLEAN"] and "yes"==settings["AUTOCLEAN"]:
5179 portage.writemsg_stdout(">>> Auto-cleaning packages...\n")
5180 vartree = trees[settings["ROOT"]]["vartree"]
5181 unmerge(settings, myopts, vartree, "clean", ["world"],
5182 ldpath_mtimes, autoclean=1)
5184 portage.writemsg_stdout(colorize("WARN", "WARNING:")
5185 + " AUTOCLEAN is disabled. This can cause serious"
5186 + " problems due to overlapping packages.\n")
5188 def multiple_actions(action1, action2):
5189 sys.stderr.write("\n!!! Multiple actions requested... Please choose one only.\n")
5190 sys.stderr.write("!!! '%s' or '%s'\n\n" % (action1, action2))
5193 def parse_opts(tmpcmdline, silent=False):
5198 global actions, options, shortmapping
5200 longopt_aliases = {"--cols":"--columns", "--skip-first":"--skipfirst"}
5201 argument_options = {
5203 "help":"specify the location for portage configuration files",
5207 "help":"enable or disable color output",
5209 "choices":("y", "n")
5212 "help":"include unnecessary build time dependencies",
5214 "choices":("y", "n")
5218 from optparse import OptionParser
5219 parser = OptionParser()
5220 if parser.has_option("--help"):
5221 parser.remove_option("--help")
5223 for action_opt in actions:
5224 parser.add_option("--" + action_opt, action="store_true",
5225 dest=action_opt.replace("-", "_"), default=False)
5226 for myopt in options:
5227 parser.add_option(myopt, action="store_true",
5228 dest=myopt.lstrip("--").replace("-", "_"), default=False)
5229 for shortopt, longopt in shortmapping.iteritems():
5230 parser.add_option("-" + shortopt, action="store_true",
5231 dest=longopt.lstrip("--").replace("-", "_"), default=False)
5232 for myalias, myopt in longopt_aliases.iteritems():
5233 parser.add_option(myalias, action="store_true",
5234 dest=myopt.lstrip("--").replace("-", "_"), default=False)
5236 for myopt, kwargs in argument_options.iteritems():
5237 parser.add_option(myopt,
5238 dest=myopt.lstrip("--").replace("-", "_"), **kwargs)
5240 myoptions, myargs = parser.parse_args(args=tmpcmdline)
5242 for myopt in options:
5243 v = getattr(myoptions, myopt.lstrip("--").replace("-", "_"))
5245 myopts[myopt] = True
5247 for myopt in argument_options:
5248 v = getattr(myoptions, myopt.lstrip("--").replace("-", "_"), None)
5252 for action_opt in actions:
5253 v = getattr(myoptions, action_opt.replace("-", "_"))
5256 multiple_actions(myaction, action_opt)
5258 myaction = action_opt
5261 if x in actions and myaction != "search":
5262 if not silent and x not in ["system", "world"]:
5263 print red("*** Deprecated use of action '%s', use '--%s' instead" % (x,x))
5264 # special case "search" so people can search for action terms, e.g. emerge -s sync
5266 multiple_actions(myaction, x)
5272 if "--nocolor" in myopts:
5274 sys.stderr.write("*** Deprecated use of '--nocolor', " + \
5275 "use '--color=n' instead.\n")
5276 del myopts["--nocolor"]
5277 myopts["--color"] = "n"
5279 return myaction, myopts, myfiles
5281 def validate_ebuild_environment(trees):
5282 for myroot in trees:
5283 mysettings = trees[myroot]["vartree"].settings
5284 for var in "ARCH", "USERLAND":
5285 if mysettings.get(var):
5287 print >> sys.stderr, bad(("\a!!! %s is not set... " % var) + \
5288 "Are you missing the '%setc/make.profile' symlink?" % \
5289 mysettings["PORTAGE_CONFIGROOT"])
5290 print >> sys.stderr, bad("\a!!! Is the symlink correct? " + \
5291 "Is your portage tree complete?\n")
5293 del myroot, mysettings
5295 def load_emerge_config(trees=None):
5297 for k, envvar in (("config_root", "PORTAGE_CONFIGROOT"), ("target_root", "ROOT")):
5298 kwargs[k] = os.environ.get(envvar, None)
5299 trees = portage.create_trees(trees=trees, **kwargs)
5301 settings = trees["/"]["vartree"].settings
5303 for myroot in trees:
5305 settings = trees[myroot]["vartree"].settings
5308 mtimedbfile = os.path.join("/", portage.CACHE_PATH.lstrip(os.path.sep), "mtimedb")
5309 mtimedb = portage.MtimeDB(mtimedbfile)
5310 return settings, trees, mtimedb
5312 def adjust_config(myopts, settings):
5313 """Make emerge specific adjustments to the config."""
5315 # To enhance usability, make some vars case insensitive by forcing them to
5317 for myvar in ("AUTOCLEAN", "NOCOLOR"):
5318 if myvar in settings:
5319 settings[myvar] = settings[myvar].lower()
5320 settings.backup_changes(myvar)
5323 # Kill noauto as it will break merges otherwise.
5324 if "noauto" in settings.features:
5325 while "noauto" in settings.features:
5326 settings.features.remove("noauto")
5327 settings["FEATURES"] = " ".join(settings.features)
5328 settings.backup_changes("FEATURES")
5332 CLEAN_DELAY = int(settings.get("CLEAN_DELAY", str(CLEAN_DELAY)))
5333 except ValueError, e:
5334 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
5335 portage.writemsg("!!! Unable to parse integer: CLEAN_DELAY='%s'\n" % \
5336 settings["CLEAN_DELAY"], noiselevel=-1)
5337 settings["CLEAN_DELAY"] = str(CLEAN_DELAY)
5338 settings.backup_changes("CLEAN_DELAY")
5340 EMERGE_WARNING_DELAY = 10
5342 EMERGE_WARNING_DELAY = int(settings.get(
5343 "EMERGE_WARNING_DELAY", str(EMERGE_WARNING_DELAY)))
5344 except ValueError, e:
5345 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
5346 portage.writemsg("!!! Unable to parse integer: EMERGE_WARNING_DELAY='%s'\n" % \
5347 settings["EMERGE_WARNING_DELAY"], noiselevel=-1)
5348 settings["EMERGE_WARNING_DELAY"] = str(EMERGE_WARNING_DELAY)
5349 settings.backup_changes("EMERGE_WARNING_DELAY")
5351 if "--quiet" in myopts:
5352 settings["PORTAGE_QUIET"]="1"
5353 settings.backup_changes("PORTAGE_QUIET")
5355 # Set so that configs will be merged regardless of remembered status
5356 if ("--noconfmem" in myopts):
5357 settings["NOCONFMEM"]="1"
5358 settings.backup_changes("NOCONFMEM")
5360 # Set various debug markers... They should be merged somehow.
5363 PORTAGE_DEBUG = int(settings.get("PORTAGE_DEBUG", str(PORTAGE_DEBUG)))
5364 if PORTAGE_DEBUG not in (0, 1):
5365 portage.writemsg("!!! Invalid value: PORTAGE_DEBUG='%i'\n" % \
5366 PORTAGE_DEBUG, noiselevel=-1)
5367 portage.writemsg("!!! PORTAGE_DEBUG must be either 0 or 1\n",
5370 except ValueError, e:
5371 portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
5372 portage.writemsg("!!! Unable to parse integer: PORTAGE_DEBUG='%s'\n" %\
5373 settings["PORTAGE_DEBUG"], noiselevel=-1)
5375 if "--debug" in myopts:
5377 settings["PORTAGE_DEBUG"] = str(PORTAGE_DEBUG)
5378 settings.backup_changes("PORTAGE_DEBUG")
5380 if settings.get("NOCOLOR") not in ("yes","true"):
5381 portage.output.havecolor = 1
5383 """The explicit --color < y | n > option overrides the NOCOLOR environment
5384 variable and stdout auto-detection."""
5385 if "--color" in myopts:
5386 if "y" == myopts["--color"]:
5387 portage.output.havecolor = 1
5388 settings["NOCOLOR"] = "false"
5390 portage.output.havecolor = 0
5391 settings["NOCOLOR"] = "true"
5392 settings.backup_changes("NOCOLOR")
5393 elif not sys.stdout.isatty() and settings.get("NOCOLOR") != "no":
5394 portage.output.havecolor = 0
5395 settings["NOCOLOR"] = "true"
5396 settings.backup_changes("NOCOLOR")
5399 global portage # NFC why this is necessary now - genone
5400 # Disable color until we're sure that it should be enabled (after
5401 # EMERGE_DEFAULT_OPTS has been parsed).
5402 portage.output.havecolor = 0
5403 # This first pass is just for options that need to be known as early as
5404 # possible, such as --config-root. They will be parsed again later,
5405 # together with EMERGE_DEFAULT_OPTS (which may vary depending on the
5406 # the value of --config-root).
5407 myaction, myopts, myfiles = parse_opts(sys.argv[1:], silent=True)
5408 if "--debug" in myopts:
5409 os.environ["PORTAGE_DEBUG"] = "1"
5410 if "--config-root" in myopts:
5411 os.environ["PORTAGE_CONFIGROOT"] = myopts["--config-root"]
5413 # Portage needs to ensure a sane umask for the files it creates.
5415 settings, trees, mtimedb = load_emerge_config()
5416 portdb = trees[settings["ROOT"]]["porttree"].dbapi
5419 os.nice(int(settings.get("PORTAGE_NICENESS", "0")))
5420 except (OSError, ValueError), e:
5421 portage.writemsg("!!! Failed to change nice value to '%s'\n" % \
5422 settings["PORTAGE_NICENESS"])
5423 portage.writemsg("!!! %s\n" % str(e))
5426 if portage._global_updates(trees, mtimedb["updates"]):
5428 # Reload the whole config from scratch.
5429 settings, trees, mtimedb = load_emerge_config(trees=trees)
5430 portdb = trees[settings["ROOT"]]["porttree"].dbapi
5432 xterm_titles = "notitles" not in settings.features
5435 if "--ignore-default-opts" not in sys.argv:
5436 tmpcmdline.extend(settings["EMERGE_DEFAULT_OPTS"].split())
5437 tmpcmdline.extend(sys.argv[1:])
5438 myaction, myopts, myfiles = parse_opts(tmpcmdline)
5440 if "--digest" in myopts:
5441 os.environ["FEATURES"] = os.environ.get("FEATURES","") + " digest"
5442 # Reload the whole config from scratch so that the portdbapi internal
5443 # config is updated with new FEATURES.
5444 settings, trees, mtimedb = load_emerge_config(trees=trees)
5445 portdb = trees[settings["ROOT"]]["porttree"].dbapi
5447 for myroot in trees:
5448 mysettings = trees[myroot]["vartree"].settings
5450 adjust_config(myopts, mysettings)
5452 del myroot, mysettings
5454 spinner = stdout_spinner()
5455 if "candy" in settings.features:
5456 spinner.update = spinner.update_scroll
5458 if "--quiet" not in myopts:
5459 portage.deprecated_profile_check()
5461 #Freeze the portdbapi for enhanced performance:
5462 for myroot in trees:
5463 trees[myroot]["porttree"].dbapi.freeze()
5466 if "moo" in myfiles:
5469 Larry loves Gentoo (""" + os.uname()[0] + """)
5471 _______________________
5472 < Have you mooed today? >
5473 -----------------------
5482 if (myaction in ["world", "system"]) and myfiles:
5483 print "emerge: please specify a package class (\"world\" or \"system\") or individual packages, but not both."
5487 ext = os.path.splitext(x)[1]
5488 if (ext == ".ebuild" or ext == ".tbz2") and os.path.exists(os.path.abspath(x)):
5489 print "emerging by path implies --oneshot... adding --oneshot to options."
5490 print colorize("BAD", "\n*** emerging by path is broken and may not always work!!!\n")
5493 if ("--tree" in myopts) and ("--columns" in myopts):
5494 print "emerge: can't specify both of \"--tree\" and \"--columns\"."
5497 if ("--quiet" in myopts):
5498 spinner.update = spinner.update_quiet
5499 portage.util.noiselimit = -1
5501 # Always create packages if FEATURES=buildpkg
5502 # Imply --buildpkg if --buildpkgonly
5503 if ("buildpkg" in settings.features) or ("--buildpkgonly" in myopts):
5504 if "--buildpkg" not in myopts:
5505 myopts["--buildpkg"] = True
5507 # Also allow -S to invoke search action (-sS)
5508 if ("--searchdesc" in myopts):
5509 if myaction and myaction != "search":
5510 myfiles.append(myaction)
5511 if "--search" not in myopts:
5512 myopts["--search"] = True
5515 # Always try and fetch binary packages if FEATURES=getbinpkg
5516 if ("getbinpkg" in settings.features):
5517 myopts["--getbinpkg"] = True
5519 if "--skipfirst" in myopts and "--resume" not in myopts:
5520 myopts["--resume"] = True
5522 if ("--getbinpkgonly" in myopts) and not ("--usepkgonly" in myopts):
5523 myopts["--usepkgonly"] = True
5525 if ("--getbinpkgonly" in myopts) and not ("--getbinpkg" in myopts):
5526 myopts["--getbinpkg"] = True
5528 if ("--getbinpkg" in myopts) and not ("--usepkg" in myopts):
5529 myopts["--usepkg"] = True
5531 # Also allow -K to apply --usepkg/-k
5532 if ("--usepkgonly" in myopts) and not ("--usepkg" in myopts):
5533 myopts["--usepkg"] = True
5535 # Allow -p to remove --ask
5536 if ("--pretend" in myopts) and ("--ask" in myopts):
5537 print ">>> --pretend disables --ask... removing --ask from options."
5540 # forbid --ask when not in a terminal
5541 # note: this breaks `emerge --ask | tee logfile`, but that doesn't work anyway.
5542 if ("--ask" in myopts) and (not sys.stdin.isatty()):
5543 portage.writemsg("!!! \"--ask\" should only be used in a terminal. Exiting.\n",
5547 if settings.get("PORTAGE_DEBUG", "") == "1":
5548 spinner.update = spinner.update_quiet
5550 if "python-trace" in settings.features:
5551 import portage.debug
5552 portage.debug.set_trace(True)
5554 if ("--resume" in myopts):
5555 if "--tree" in myopts:
5556 print "* --tree is currently broken with --resume. Disabling..."
5557 del myopts["--tree"]
5559 if not ("--quiet" in myopts):
5560 if not sys.stdout.isatty() or ("--nospinner" in myopts):
5561 spinner.update = spinner.update_basic
5563 if "--version" in myopts:
5564 print getportageversion(settings["PORTDIR"], settings["ROOT"],
5565 settings.profile_path, settings["CHOST"],
5566 trees[settings["ROOT"]]["vartree"].dbapi)
5568 elif "--help" in myopts:
5569 emerge.help.help(myaction, myopts, portage.output.havecolor)
5572 if portage.wheelgid == portage.portage_gid:
5573 print "emerge: wheel group use is being deprecated. Please update group and passwd to"
5574 print " include the portage user as noted above, and then use group portage."
5576 if "--debug" in myopts:
5577 print "myaction", myaction
5578 print "myopts", myopts
5580 if not myaction and not myfiles and "--resume" not in myopts:
5581 emerge.help.help(myaction, myopts, portage.output.havecolor)
5584 # check if root user is the current user for the actions where emerge needs this
5585 if portage.secpass < 2:
5586 # We've already allowed "--version" and "--help" above.
5587 if "--pretend" not in myopts and \
5588 myaction not in ("search","info"):
5589 need_superuser = not \
5590 ("--fetchonly" in myopts or \
5591 "--fetch-all-uri" in myopts or \
5592 myaction in ("metadata", "regen"))
5593 if portage.secpass < 1 or \
5596 access_desc = "superuser"
5598 access_desc = "portage group"
5599 # Always show portage_group_warning() when only portage group
5600 # access is required but the user is not in the portage group.
5601 from portage.data import portage_group_warning
5602 if "--ask" in myopts:
5603 myopts["--pretend"] = True
5605 print ("%s access would be required... " + \
5606 "adding --pretend to options.\n") % access_desc
5607 if portage.secpass < 1 and not need_superuser:
5608 portage_group_warning()
5610 sys.stderr.write(("emerge: %s access would be " + \
5611 "required.\n\n") % access_desc)
5612 if portage.secpass < 1 and not need_superuser:
5613 portage_group_warning()
5616 disable_emergelog = False
5617 for x in ("--pretend", "--fetchonly", "--fetch-all-uri"):
5619 disable_emergelog = True
5621 if myaction in ("search", "info"):
5622 disable_emergelog = True
5623 if disable_emergelog:
5624 """ Disable emergelog for everything except build or unmerge
5625 operations. This helps minimize parallel emerge.log entries that can
5626 confuse log parsers. We especially want it disabled during
5627 parallel-fetch, which uses --resume --fetchonly."""
5629 def emergelog(*pargs, **kargs):
5632 if not "--pretend" in myopts:
5633 emergelog(xterm_titles, "Started emerge on: "+\
5634 time.strftime("%b %d, %Y %H:%M:%S", time.localtime()))
5637 myelogstr=" ".join(myopts)
5639 myelogstr+=" "+myaction
5641 myelogstr+=" "+" ".join(myfiles)
5642 emergelog(xterm_titles, " *** emerge " + myelogstr)
5644 def emergeexitsig(signum, frame):
5645 signal.signal(signal.SIGINT, signal.SIG_IGN)
5646 signal.signal(signal.SIGTERM, signal.SIG_IGN)
5647 portage.util.writemsg("\n\nExiting on signal %(signal)s\n" % {"signal":signum})
5648 sys.exit(100+signum)
5649 signal.signal(signal.SIGINT, emergeexitsig)
5650 signal.signal(signal.SIGTERM, emergeexitsig)
5653 """This gets out final log message in before we quit."""
5654 if "--pretend" not in myopts:
5655 emergelog(xterm_titles, " *** terminating.")
5656 if "notitles" not in settings.features:
5658 portage.atexit_register(emergeexit)
5660 if myaction in ("config", "metadata", "regen", "sync"):
5661 if "--pretend" in myopts:
5662 sys.stderr.write(("emerge: The '%s' action does " + \
5663 "not support '--pretend'.\n") % myaction)
5665 if "sync" == myaction:
5666 action_sync(settings, trees, mtimedb, myopts, myaction)
5667 elif "metadata" == myaction:
5668 action_metadata(settings, portdb, myopts)
5669 elif myaction=="regen":
5670 validate_ebuild_environment(trees)
5671 action_regen(settings, portdb)
5673 elif "config"==myaction:
5674 validate_ebuild_environment(trees)
5675 action_config(settings, trees, myopts, myfiles)
5678 elif "info"==myaction:
5679 action_info(settings, trees, myopts, myfiles)
5682 elif "search"==myaction:
5683 validate_ebuild_environment(trees)
5684 action_search(settings, portdb, trees["/"]["vartree"],
5685 myopts, myfiles, spinner)
5686 elif "unmerge"==myaction or "prune"==myaction or "clean"==myaction:
5687 validate_ebuild_environment(trees)
5688 vartree = trees[settings["ROOT"]]["vartree"]
5689 if 1 == unmerge(settings, myopts, vartree, myaction, myfiles,
5691 if "--pretend" not in myopts:
5692 post_emerge(settings, mtimedb, 0)
5694 elif "depclean"==myaction:
5695 validate_ebuild_environment(trees)
5696 action_depclean(settings, trees, mtimedb["ldpath"],
5698 if "--pretend" not in myopts:
5699 post_emerge(settings, mtimedb, 0)
5700 # "update", "system", or just process files:
5702 validate_ebuild_environment(trees)
5703 if "--pretend" not in myopts:
5704 display_news_notification(settings)
5705 action_build(settings, trees, mtimedb,
5706 myopts, myaction, myfiles, spinner)
5707 if "--pretend" not in myopts:
5708 post_emerge(settings, mtimedb, 0)
5710 display_news_notification(settings)
5712 if __name__ == "__main__":
5713 retval = emerge_main()