Attachment #16671 for bug #27264

View | Details | Raw Unified | Return to bug 27264 | Differences between
Collapse All | Expand All




"regen", "rsync",  "search",   "sync", "system", "unmerge", "world"
]
options=[
"--build-package",     "--build-package-only",
"--changelog",    "--columns",
"--debug",        "--deep",
"--digest",
"--empty-tree",    "--fetch-only",
"--get-binary-package",    "--get-binary-package-only",
"--help",         "--forget-configuration",
"--no-dependencies",       "--no-replace",
"--no-spinner",    "--once-only",
"--dependencies-only",     "--pretend",
"--quiet",        "--resume",
"--search-description",   "--selective",
"--skip-first",
"--update",       "--upgrade-only",
"--use-package",       "--use-package-only",
"--verbose",      "--version"
]

shortmapping={
"b":"--build-package",  "B":"--build-package-only",
"c":"--clean",     "C":"--unmerge",
"d":"--debug",     "D":"--deep",
"e":"--empty-tree",
"f":"--fetch-only",
"g":"--get-binary-package", "G":"--get-binary-package-only",
"h":"--help",
"i":"--inject",
"k":"--use-package",    "K":"--use-package-only",
"l":"--changelog",
"n":"--no-replace",
"o":"--dependencies-only",  "O":"--no-dependencies",
"p":"--pretend",   "P":"--prune",
"q":"--quiet",
"s":"--search",    "S":"--search-description",
"u":"--update",    "U":"--upgrade-only",
"v":"--verbose",   "V":"--version"
}


	sys.exit(1)

# Always create packages if FEATURES=buildpkg
# Imply --build-package if --build-package-only
if ("buildpkg" in portage.features) or ("--build-package-only" in myopts):
	if "--build-package" not in myopts:
		myopts.append("--build-package")

# Also allow -S to invoke search action (-sS)
if ("--search-description" in myopts) and (not myaction):
	myaction = "search"

if ("--get-binary-package-only" in myopts) and not ("--use-package-only" in myopts):
	myopts.append("--use-package-only")

if ("--get-binary-package-only" in myopts) and not ("--get-binary-package" in myopts):
	myopts.append("--get-binary-package")

if ("--get-binary-package" in myopts) and not ("--use-package" in myopts):
	myopts.append("--use-package")

# Also allow -K to apply --use-package/-k
if ("--use-package-only" in myopts) and not ("--use-package" in myopts):
	myopts.append("--use-package")

# Also allow -U to apply --update/-u
if ("--upgrade-only" in myopts) and not ("--update" in myopts):
	print ">>> --upgrade-only implies --update... adding --update to options."
	myopts.append("--update")

# Also allow -l to apply --pretend/-p

	myopts.append("--pretend")

# Set so that configs will be merged regardless of remembered status
if ("--forget-configuration" in myopts):
	portage.settings["NOCONFMEM"]="1"

# Set various debug markers... They should be merged somehow.

sub=[]
if "--update" in myopts:
	add.extend(["selective","empty"])
if "--empty-tree" in myopts:
	add.extend(["empty"])
	sub.extend(["selective"])
if "--no-dependencies" in myopts:
	sub.extend(["recurse"])
if "--no-replace" in myopts:
	add.extend(["selective"])
if "--deep" in myopts:
	add.extend(["deep"])


def update_spinner():
	global spinner, spinpos
	if sys.stdout.isatty() and not ("--no-spinner" in myopts):
		sys.stdout.write("\b"+spinner[spinpos])
		spinpos=(spinpos+1)%8
		sys.stdout.flush()

		global myopts
		self.searchkey=searchkey
		self.packagematches = []
		if "--search-description" in myopts:
			self.searchdesc=1
			self.matches = {"pkg":[], "desc":[]}
		else:

			else:
				self.mydbapi[portage.root]=portage.db[portage.root]["vartree"].dbapi
			
		if "--use-package" in myopts:
			try:
				portage.db["/"]["bintree"].populate(("--get-binary-package" in myopts), ("--get-binary-package-only" in myopts))
			except ValueError, e:
				sys.stderr.write(red("!!! Failed to get all metadata: "+str(e)+"\n"))
				sys.exit(1)

	def create(self,mybigkey,myparent=None,addme=1):
		"""creates the actual digraph of packages to merge.  return 1 on success, 0 on failure
		mybigkey = specification of package to merge; myparent = parent package (one depending on me);
		addme = should I be added to the tree? (for the --dependencies-only mode)"""
		#stuff to add:
		#SLOT-aware emerge
		#IUSE-aware emerge

						sys.exit(1)
				mytbz2=xpak.tbz2(x)
				mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.basename(x)[:-5]
				if not self.create(["binary",portage.root,mykey],None,"--dependencies-only" not in myopts):
					return (0,myfavorites)
				elif not "--once-only" in myopts:
					myfavorites.append(mykey)
			elif x[-7:]==".ebuild":
				mykey=os.path.basename(os.path.abspath(x+"/../.."))+"/"+os.path.basename(x)[:-7]
				if not self.create(["ebuild",portage.root,mykey],None,"--dependencies-only" not in myopts):
					return (0,myfavorites)
				elif not "--once-only" in myopts:
					myfavorites.append(mykey)
			else:
				mykey=portage.dep_expand(x,portage.portdb)


				if not self.mysd:
					return (0,myfavorites)
				elif not "--once-only" in myopts:
					myfavorites.append(mykey)

		self.missingbins=0
		if "--use-package-only" in myopts:
			for x in self.digraph.dict.keys():
				xs=string.split(x," ")
				if (xs[0] != "binary") and (xs[3]=="merge"):

			else:
				#We are not processing a blocker but a normal dependency
				myeb_pkg=None
				if ("--use-package" in myopts):
					myeb_pkg=portage.db[portage.root]["bintree"].dep_bestmatch(x)
				
				myeb=None
				if ("--use-package-only" not in myopts):
					myeb=portage.portdb.xmatch("bestmatch-visible",x)
				
				if (not myeb) and (not myeb_pkg):

						xfrom = '(dependency required by '+green('"'+myparent.split()[2]+'"')+red(' ['+myparent.split()[0]+"])")
					alleb=portage.portdb.xmatch("match-all",x)
					if alleb:
						if "--use-package-only" not in myopts:
							print "\n!!! "+red("all ebuilds that could satisfy ")+green(xinfo)+red(" have been masked.")
							if myparent:
								print     "!!!    "+red(xfrom)

					else:
						myeb = None

 				if "--upgrade-only" in myopts:
 					# Check that there isn't a newer version of this package already installed
 					cand=self.is_newer_ver_installed(myroot,x,myeb)
 					if cand:

					sys.stderr.write("!!! Confused... Don't know what I'm using for dependency info. :(\n")
					sys.exit(1)

				#if "--use-package" in myopts:
				#	#If we want to use packages, see if we have a pre-built one...
				#	mypk=portage.db["/"]["bintree"].dbapi.match(x)
				#	if myeb in mypk:

					return 0
			else:
				#if mysource is not set, then we are a command-line dependency and should not be added
				#if --dependencies-only is specified.
				if not self.create(myk,myparent,"--dependencies-only" not in myopts):
					return 0

		if "--debug" in myopts:

				#this is an unavailable world entry; just continue
				continue

			if "--upgrade-only" in myopts:
				cand=self.is_newer_ver_installed(portage.root,mydep,myeb)
				if cand:
					myeb=cand

			#THIS NEXT BUNCH OF CODE NEEDS TO BE REPLACED TO SUPPORT WORLD ANTI-DEPS
			#if mydep2[0]=="!":, etc.
			if "--use-package" in myopts:
				mypk=portage.db[portage.root]["bintree"].dep_bestmatch(mydep)
				if myeb==mypk:
					myk=["binary",portage.root,mypk]
				elif "--use-package-only" in myopts:
					self.missingbins += [myeb]
					myk=["binary",portage.root,myeb]
					#print "mypk:",mypk

				print
				sys.exit(1)

			if "--use-package" in myopts:
				mypk=portage.db[portage.root]["bintree"].dep_bestmatch(mydep)
				if myeb==mypk:
					myk="binary "+portage.root+" "+mypk

				#we need to use "--emptrytree" testing here rather than "empty" param testing because "empty"
				#param is used for -u, where you still *do* want to see when something is being upgraded.
				myoldbest=""
				if (not "--empty-tree" in myopts) and portage.db[x[1]]["vartree"].exists_specific(x[2]):
					addl="  "+yellow("R")+fetch+"  "
				elif (not "--empty-tree" in myopts) and portage.db[x[1]]["vartree"].exists_specific_cat(x[2]):
					myoldbest=portage.best(portage.db[x[1]]["vartree"].dbapi.match(portage.pkgsplit(x[2])[0]))

					try:

			mysplit=portage.pkgsplit(x[2])
			# XXX mysplit _can_ be None.... Why?
			if mysplit and (len(mysplit)==3):
				if "--empty-tree" not in myopts:
					if mysplit[0]=="sys-apps/portage":
						if mysplit[1]+mysplit[2]!=portage.VERSION:
							if mylist.index(x)<len(mylist)-1:

									print darkgreen("    You may avoid the remerging of packages by updating portage on its own.")
								print
				else:
					if mysplit[0]=="sys-apps/portage" and ("--empty-tree" in myopts):
						if mysplit[1]+mysplit[2]!=portage.VERSION:
							print red("***")+" Please update portage to the above version before proceeding."
							print "    Failure to do so may result in failed or improper merges."

		mymergelist=[]

		#check for blocking dependencies
		if ("--fetch-only" not in myopts) and ("--build-package-only" not in myopts):
			for x in mylist:
				if x[0]=="blocks":
					print "\n!!! Error: the "+x[2]+" package conflicts with another package."

			print green("*** Resuming merge...")
			emergelog(" *** Resuming merge...")
			mymergelist=portage.mtimedb["resume"]["mergelist"][:]
			if ("--skip-first" in myopts) and mymergelist:
				del mymergelist[0]
		else:
			myfavs=portage.grabfile(portage.root+"var/cache/edb/world")

				else:
					# Add to the world file. Since we won't be able to later.
					myfavkey=portage.cpv_getkey(mylist[x][2])
					if (not "--fetch-only" in myopts) and (myfavkey in favorites):
						#don't record if already in system profile or already recorded
						if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
							#we don't have a favorites entry for this package yet; add one
							myfavdict[myfavkey]=myfavkey
							print ">>> Recording",myfavkey,"in \"world\" favorites file..."
			if not "--fetch-only" in myopts:
				portage.writedict(myfavdict,portage.root+"var/cache/edb/world",writekey=0)

			portage.mtimedb["resume"]["mergelist"]=mymergelist[:]

				print ">>> emerge ("+str(mergecount)+" of "+str(len(mymergelist))+")",x[pkgindex],"to",x[1]
				emergelog(" >>> emerge ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" to "+x[1])
			if x[0] in ["ebuild","blocks"]:
				if ("--fetch-only" in myopts) or (x[0]=="blocks"):
					retval=portage.doebuild(y,"fetch",myroot,edebug,("--pretend" in myopts),fetchonly=1)
					if retval:
						print

						print	
						returnme=1
					continue
				elif "--build-package" in myopts:
					#create pkg, then merge pkg
					emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Cleaning ("+y+")")
					retval=portage.doebuild(y,"clean",myroot,edebug)

					if retval:
						sys.exit(1)
					#dynamically update our database
					if "--build-package-only" not in myopts:
						portage.db[portage.root]["bintree"].inject(x[2])
						mytbz2=portage.db[portage.root]["bintree"].getname(x[2])
						emergelog(" === ("+str(mergecount)+" of "+str(len(mymergelist))+") Merging ("+y+")")

				if retval==None:
					sys.exit(1)
				#need to check for errors
			if "--build-package-only" not in myopts:
				portage.db[x[1]]["vartree"].inject(x[2])
				myfavkey=portage.cpv_getkey(x[2])
				if (not "--fetch-only" in myopts) and (myfavkey in favorites):
					myfavs=portage.grabfile(myroot+"var/cache/edb/world")
					myfavdict=genericdict(myfavs)
					mysysdict=genericdict(syslist)

					if retval:
						sys.exit(1)
			
				if ("--pretend" not in myopts) and ("--fetch-only" not in myopts):
					# Clean the old package that we have merged over top of it.
					if portage.settings.has_key("AUTOCLEAN") and (portage.settings["AUTOCLEAN"]=="yes"):
						xsplit=portage.pkgsplit(x[2])

								portage.portageexit()
								os.execv("/usr/lib/portage/bin/emerge", myargv)

			if ("--pretend" not in myopts) and ("--fetch-only" not in myopts):
				emergelog(" ::: completed emerge ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[2]+" to "+x[1])
			
			# Unsafe for parallel merges

			del portage.mtimedb["resume"]

		if ("--pretend" not in myopts):
			if ("--fetch-only" not in myopts):
				if (mergecount>0):
					portage.env_update()

		#by doing an exit this way, --fetch-only can continue to try to
		#fetch everything even if a particular download fails.
		if "--fetch-only" in myopts:
			if returnme:
				print "\n\n!!! Some fetch errors were encountered.  Please see above for details.\n\n"
				sys.exit(returnme)

		sys.exit(1)
	print "\b\b ... done!"

	if ("--use-package-only" in myopts) and mydepgraph.missingbins:
		sys.stderr.write(red("The following binaries are not available for merging...\n"))
		for x in mydepgraph.missingbins:
			sys.stderr.write("   "+str(x)+"\n")
		sys.stderr.write("\nThese are required by '--use-package-only' -- Terminating.\n\n")
		sys.exit(1)

	alldeps=mydepgraph.digraph.allnodes()

else:
	favorites=[]
	syslist=getlist("system")
	if ("--pretend" in myopts) and not ("--fetch-only" in myopts):
		print
		print darkgreen("These are the packages that I would merge, in order:")
		print

				sys.exit(1)
			print "\b\b ...done!"

			if ("--use-package-only" in myopts) and mydepgraph.missingbins:
				sys.stderr.write(red("The following binaries are not available for merging...\n"))

		if mydepgraph.missingbins:
			for x in mydepgraph.missingbins:
				sys.stderr.write("   "+str(x)+"\n")
			sys.stderr.write("\nThese are required by '--use-package-only' -- Terminating.\n\n")
			sys.exit(1)

	if ("--pretend" in myopts) and ("--fetch-only" not in myopts):
		if ("--resume" in myopts):
			mydepgraph.display(portage.mtimedb["resume"]["mergelist"])
		else:
			mydepgraph.display(mydepgraph.altlist())
	else:
		if ("--build-package-only" in myopts):
			if not mydepgraph.digraph.hasallzeros():
				print "\n!!! --build-package-only requires all dependencies to be merged."
				print "!!! Cannot merge requested packages. Merge deps and try again.\n"
				sys.exit(1)


			portage.mtimedb["resume"]={}
			portage.mtimedb["resume"]["myopts"]=myopts
			portage.mtimedb["resume"]["favorites"]=favorites
			if ("--digest" in myopts) and not ("--fetch-only" in myopts):
				for pkgline in mydepgraph.altlist():
					if pkgline[0]=="ebuild" and pkgline[3]=="merge":
						y=portage.portdb.findname(pkgline[2])

Return to bug 27264