Attachment #47624 for bug #70663

Lines 74-79 Link Here

(-)catalyst.orig/modules/embedded_target.py (+9 lines)
74	self.clean()	74	self.clean()
75	self.build_fs()	75	self.build_fs()
76		76
		77	def set_action_sequence(self):
		78	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		79	"setup_environment","run_local","unbind","capture"]
		80
		81	def set_use(self):
		82	self.settings["use"]=self.settings["embedded/use"]
		83	def set_stage_path(self):
		84	self.settings["stage_path"]=self.settings["chroot_path"]+"/tmp/mergeroot"
		85	print "embedded stage path is "+self.settings["stage_path"]
77	def register(foo):	86	def register(foo):
78	foo.update({"embedded":embedded_target})	87	foo.update({"embedded":embedded_target})
79	return foo	88	return foo




				self.settings[envvar] = os.environ[envvar]
		
		# define all of our core variables
		self.set_target_profile()
		self.set_target_subpath()
		self.set_snapshot_path()
		self.set_target_path()
		self.set_source_path()
		self.set_chroot_path()
		self.set_action_sequence()
		self.set_use()
		self.set_stage_path()

		
		elif self.settings["target"] == "livecd-stage2":
			self.settings["source_path"]=st+"/tmp/"+self.settings["source_subpath"]
			self.settings["cdroot_path"]=st+"/builds/"+self.settings["target_subpath"]
			
		elif self.settings["target"] == "netboot":
			self.settings["target_path"]=st+"/builds/"+self.settings["target_subpath"]
			self.settings["source_path"]=st+"/builds/"+self.settings["source_subpath"]+".tar.bz2"
		
		else:
			self.settings["target_path"]=st+"/builds/"+self.settings["target_subpath"]+".tar.bz2"
			self.settings["source_path"]=st+"/builds/"+self.settings["source_subpath"]+".tar.bz2"
		
		self.settings["chroot_path"]=st+"/tmp/"+self.settings["target_subpath"]
		
		# this next line checks to make sure that the specified variables exist on disk.
		file_locate(self.settings,["source_path","snapshot_path","distdir"],expand=0)
		

		self.mounts=[ "/proc","/dev","/dev/pts","/usr/portage/distfiles" ]
		self.mountmap={"/proc":"/proc", "/dev":"/dev", "/dev/pts":"/dev/pts",\
			"/usr/portage/distfiles":self.settings["distdir"]}
		self.set_mounts()
		if self.settings["target"]=="grp":
			self.mounts.append("/tmp/grp")
			self.mountmap["/tmp/grp"]=self.settings["target_path"]

		# configure any user specified options (either in catalyst.conf or on the cmdline)
		if self.settings.has_key("PKGCACHE"):
			self.settings["pkgcache_path"]=self.settings["storedir"]+"/packages/"+self.settings["target_subpath"]
			self.mounts.append("/usr/portage/packages")
			self.mountmap["/usr/portage/packages"]=self.settings["pkgcache_path"]


			self.mountmap["/var/tmp/ccache"]=ccdir
			# for the chroot:
			os.environ["CCACHE_DIR"]="/var/tmp/ccache"	
		
	def set_target_profile(self):
		self.settings["target_profile"]=self.settings["profile"]
	
	def set_target_subpath(self):
		self.settings["target_subpath"]=self.settings["rel_type"]+"/"+self.settings["target"]+\
			"-"+self.settings["subarch"]+"-"+self.settings["version_stamp"]

	def set_target_path(self):
		self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]+".tar.bz2"
	
	def set_source_path(self):
		self.settings["source_path"]=self.settings["storedir"]+"/builds/"+self.settings["source_subpath"]+".tar.bz2"
	
	def set_snapshot_path(self):
		self.settings["snapshot_path"]=self.settings["storedir"]+"/snapshots/portage-"+self.settings["snapshot"]+".tar.bz2"
	
	def set_chroot_path(self):
		self.settings["chroot_path"]=self.settings["storedir"]+"/tmp/"+self.settings["target_subpath"]

	def set_action_sequence(self):
		#Default action sequence for run method
		self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
				"setup_environment","run_local","preclean","unbind","clean","capture"]
	
	def set_use(self):
		pass

	def set_stage_path(self):
			self.settings["stage_path"]=self.settings["chroot_path"]
	def set_mounts(self):
		pass
	
	def mount_safety_check(self):
		mypath=self.settings["chroot_path"]
		

		print "Setting up directories..."
		self.mount_safety_check()
		
		if os.path.exists(self.settings["chroot_path"]):
			cmd("rm -rf "+self.settings["chroot_path"],\
				"Could not remove existing directory: "+self.settings["chroot_path"])
			

		myf.write("# Please consult /etc/make.conf.example for a more detailed example\n")
		myf.write('CFLAGS="'+self.settings["CFLAGS"]+'"\n')
		myf.write('CHOST="'+self.settings["CHOST"]+'"\n')
		
		# figure out what our USE vars are for building
		myusevars=[]
		if self.settings.has_key("HOSTUSE"):
			myusevars.extend(self.settings["HOSTUSE"])
		
		if self.settings.has_key("use"):
			myusevars.extend(self.settings["use"])
			myusevars.extend(self.settings["grp/use"])
			myf.write('USE="'+string.join(myusevars)+'"\n')
			
		elif self.settings["target"]=="tinderbox":
			myusevars.extend(self.settings["tinderbox/use"])
			myf.write('USE="'+string.join(myusevars)+'"\n')
			
		elif self.settings["target"]=="livecd-stage1":
			myusevars.extend(self.settings["livecd/use"])
			myf.write('USE="'+string.join(myusevars)+'"\n')
			
		elif self.settings["target"]=="embedded":
			myusevars.extend(self.settings["embedded/use"])
			myf.write('USE="'+string.join(myusevars)+'"\n')
		
		if self.settings.has_key("CXXFLAGS"):
			myf.write('CXXFLAGS="'+self.settings["CXXFLAGS"]+'"\n')
		
		else:
			myf.write('CXXFLAGS="${CFLAGS}"\n')
		myf.close()
	
	def clean(self):
		destpath=self.settings["chroot_path"]
		

			
		print "Creating stage tarball..."
		
		cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["stage_path"]+\
			" .","Couldn't create stage tarball")
				"/tmp/stage1root .","Couldn't create stage tarball")
		
		elif self.settings["target"]=="embedded":
			cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\
				"/tmp/mergeroot .","Couldn't create stage tarball")
		
		else:
			cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\
				" .","Couldn't create stage tarball")

	def run_local(self):
		try:

		except CatalystError:
			self.unbind()
			raise CatalystError,"Stage build aborting due to error."
	
	def setup_environment(self):
		self.dir_setup()
		self.unpack_and_bind()
		try:
			self.chroot_setup()
		
		except:
			self.unbind()
			raise
		
		# modify the current environment. This is an ugly hack that should be fixed. We need this
		# to use the os.system() call since we can't specify our own environ:
		for x in self.settings.keys():

				os.environ[varname]=self.settings[x]
			elif type(self.settings[x])==types.ListType:
				os.environ[varname]=string.join(self.settings[x])
	
	def run(self):
		if self.settings["target"] in ["stage1","stage2","stage3","livecd-stage1","livecd-stage2"]:
			self.preclean()
		
		if self.settings["target"] in ["livecd-stage2"]:
			self.unmerge()
		
		# unbind everything here so that we can clean()
		self.unbind()
		
		if self.settings["target"] in ["stage1","stage2","stage3","livecd-stage1","livecd-stage2"]:
			# clean is for removing things after bind-mounts are 
			# unmounted (general file removal and cleanup)
			self.clean()
		
		if self.settings["target"] in ["stage1","stage2","stage3","embedded"]:
			self.capture()
		
		for x in self.settings["action_sequence"]:
			print "Running action sequence: "+x
			if x == 'chroot_setup':
				try:
					self.chroot_setup()
				except:
					self.unbind()
					raise
			else:	
				apply(getattr(self,x))

Lines 28-34 Link Here

(-)catalyst.orig/modules/grp_target.py (-1 / +16 lines)
28	self.required_values.append("grp/"+x+"/type")	28	self.required_values.append("grp/"+x+"/type")
29		29
30	generic_stage_target.__init__(self,spec,addlargs)	30	generic_stage_target.__init__(self,spec,addlargs)
31		31
		32	def set_target_path(self):
		33	self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
		34
32	def run_local(self):	35	def run_local(self):
33	for pkgset in self.settings["grp"]:	36	for pkgset in self.settings["grp"]:
34	# example call: "grp.sh run pkgset cd1 xmms vim sys-apps/gleep"	37	# example call: "grp.sh run pkgset cd1 xmms vim sys-apps/gleep"
Lines 42-47 Link Here
42	self.unbind()	45	self.unbind()
43	raise CatalystError,"GRP build aborting due to error."	46	raise CatalystError,"GRP build aborting due to error."
44		47
		48	def set_action_sequence(self):
		49	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		50	"setup_environment","run_local","unbind"]
		51
		52	def set_use(self):
		53	self.settings["use"]=self.settings["grp/use"]
		54	self.settings["use"].append("bindlist")
		55
		56	def set_mounts(self):
		57	self.mounts.append("/tmp/grp")
		58	self.mountmap["/tmp/grp"]=self.settings["target_path"]
		59
45	def register(foo):	60	def register(foo):
46	foo.update({"grp":grp_target})	61	foo.update({"grp":grp_target})
47	return foo	62	return foo

Lines 24-29 Link Here

(-)catalyst.orig/modules/livecd_stage1_target.py (+6 lines)
24	except CatalystError:	24	except CatalystError:
25	self.unbind()	25	self.unbind()
26	raise CatalystError,"LiveCD stage1 build aborting due to error."	26	raise CatalystError,"LiveCD stage1 build aborting due to error."
		27	def set_action_sequence(self):
		28	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		29	"setup_environment","run_local","preclean","unbind","clean"]
		30
		31	def set_use(self):
		32	self.settings["use"]=self.settings["livecd/use"]
27		33
28	def register(foo):	34	def register(foo):
29	foo.update({"livecd-stage1":livecd_stage1_target})	35	foo.update({"livecd-stage1":livecd_stage1_target})




			"gamecd/conf"])
		
		generic_stage_target.__init__(self,spec,addlargs)
		self.set_cdroot_path()
		file_locate(self.settings, ["livecd/cdtar","livecd/archscript","livecd/runscript"])
		if self.settings.has_key("portage_confdir"):
			file_locate(self.settings,["portage_confdir"],expand=0)

			if retval!=0:
				self.unbind()
				raise CatalystError,"Couldn't bind mount "+src
        
	def set_target_path(self):
	    pass 
	    #self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
	    	
	def set_source_path(self):
	    self.settings["source_path"]=self.settings["storedir"]+"/tmp/"+self.settings["source_subpath"]
	
	def set_cdroot_path(self):
	    self.settings["cdroot_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]

        def dir_setup(self):
                print "Setting up directories..."
                self.mount_safety_check()

                if not os.path.exists(self.settings["chroot_path"]+"/tmp"):
                        os.makedirs(self.settings["chroot_path"]+"/tmp")

                if not os.path.exists(self.settings["chroot_path"]):
                        os.makedirs(self.settings["chroot_path"])

                if self.settings.has_key("PKGCACHE"):
                        if not os.path.exists(self.settings["pkgcache_path"]):
                                os.makedirs(self.settings["pkgcache_path"])

	def unmerge(self):
		if self.settings.has_key("AUTORESUME") \
			and os.path.exists(self.settings["chroot_path"]+"/tmp/.clst_unmerge"):

		if self.settings.has_key("livecd/root_overlay"):
			cmd("rsync -a "+self.settings["livecd/root_overlay"]+"/* "+\
				self.settings["chroot_path"], "livecd/root_overlay copy failed.")
	def set_action_sequence(self):
		self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
						"setup_environment","run_local","preclean","unmerge",\
						"unbind","clean","cdroot_setup"]

def register(foo):
	foo.update({"livecd-stage2":livecd_stage2_target})

Lines 53-58 Link Here

(-)catalyst.orig/modules/netboot.py (+7 lines)
53	if not os.environ.has_key(envvar) and not addlargs.has_key(envvar):	53	if not os.environ.has_key(envvar) and not addlargs.has_key(envvar):
54	self.settings[envvar] = "-Os -pipe"	54	self.settings[envvar] = "-Os -pipe"
55		55
		56	def set_target_path(self):
		57	self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
		58
56	def run_local(self):	59	def run_local(self):
57	# setup our chroot	60	# setup our chroot
58	try:	61	try:
Lines 139-144 Link Here
139	print "netboot: build finished !"	142	print "netboot: build finished !"
140		143
141		144
		145	def set_action_sequence(self):
		146	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		147	"setup_environment","run_local","unbind"]
		148
142	def register(foo):	149	def register(foo):
143	foo.update({"netboot":netboot_target})	150	foo.update({"netboot":netboot_target})
144	return foo	151	return foo

Lines 14-19 Link Here

(-)catalyst.orig/modules/stage1_target.py (+4 lines)
14	self.required_values=[]	14	self.required_values=[]
15	self.valid_values=[]	15	self.valid_values=[]
16	generic_stage_target.__init__(self,spec,addlargs)	16	generic_stage_target.__init__(self,spec,addlargs)
		17
		18	def set_stage_path(self):
		19	self.settings["stage_path"]=self.settings["chroot_path"]+"/tmp/stage1root"
		20	print "stage1 stage path is "+self.settings["stage_path"]
17		21
18	def register(foo):	22	def register(foo):
19	foo.update({"stage1":stage1_target})	23	foo.update({"stage1":stage1_target})

Lines 26-32 Link Here

(-)catalyst.orig/modules/tinderbox_target.py (-1 / +5 lines)
26	except CatalystError:	26	except CatalystError:
27	self.unbind()	27	self.unbind()
28	raise CatalystError,"Tinderbox aborting due to error."	28	raise CatalystError,"Tinderbox aborting due to error."
29		29
		30	def set_target_path(self):
		31	self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
		32	def set_use(self):
		33	self.settings["use"]=self.settings["tinderbox/use"]
30	def register(foo):	34	def register(foo):
31	foo.update({"tinderbox":tinderbox_target})	35	foo.update({"tinderbox":tinderbox_target})
32	return foo	36	return foo

Return to bug 70663

Lines 98-128 Link Here

(-)catalyst.orig/modules/generic_stage_target.py (-93 / +67 lines)
98	self.settings[envvar] = os.environ[envvar]	98	self.settings[envvar] = os.environ[envvar]
99		99
100	# define all of our core variables	100	# define all of our core variables
101	self.settings["target_profile"]=self.settings["profile"]	101	self.set_target_profile()
102	self.settings["target_subpath"]=self.settings["rel_type"]+"/"+self.settings["target"]+\	102	self.set_target_subpath()
103	"-"+self.settings["subarch"]+"-"+self.settings["version_stamp"]	103	self.set_snapshot_path()
104		104	self.set_target_path()
105	st=self.settings["storedir"]	105	self.set_source_path()
106	self.settings["snapshot_path"]=st+"/snapshots/portage-"+self.settings["snapshot"]+".tar.bz2"	106	self.set_chroot_path()
107	if self.settings["target"] in ["grp","tinderbox"]:	107	self.set_action_sequence()
108	# grp creates a directory of packages and sources rather than a compressed tarball	108	self.set_use()
109	self.settings["target_path"]=st+"/builds/"+self.settings["target_subpath"]	109	self.set_stage_path()
110	self.settings["source_path"]=st+"/builds/"+self.settings["source_subpath"]+".tar.bz2"	110
111
112	elif self.settings["target"] == "livecd-stage2":
113	self.settings["source_path"]=st+"/tmp/"+self.settings["source_subpath"]
114	self.settings["cdroot_path"]=st+"/builds/"+self.settings["target_subpath"]
115
116	elif self.settings["target"] == "netboot":
117	self.settings["target_path"]=st+"/builds/"+self.settings["target_subpath"]
118	self.settings["source_path"]=st+"/builds/"+self.settings["source_subpath"]+".tar.bz2"
119
120	else:
121	self.settings["target_path"]=st+"/builds/"+self.settings["target_subpath"]+".tar.bz2"
122	self.settings["source_path"]=st+"/builds/"+self.settings["source_subpath"]+".tar.bz2"
123
124	self.settings["chroot_path"]=st+"/tmp/"+self.settings["target_subpath"]
125
126	# this next line checks to make sure that the specified variables exist on disk.	111	# this next line checks to make sure that the specified variables exist on disk.
127	file_locate(self.settings,["source_path","snapshot_path","distdir"],expand=0)	112	file_locate(self.settings,["source_path","snapshot_path","distdir"],expand=0)
128		113
Lines 134-147 Link Here
134	self.mounts=[ "/proc","/dev","/dev/pts","/usr/portage/distfiles" ]	119	self.mounts=[ "/proc","/dev","/dev/pts","/usr/portage/distfiles" ]
135	self.mountmap={"/proc":"/proc", "/dev":"/dev", "/dev/pts":"/dev/pts",\	120	self.mountmap={"/proc":"/proc", "/dev":"/dev", "/dev/pts":"/dev/pts",\
136	"/usr/portage/distfiles":self.settings["distdir"]}	121	"/usr/portage/distfiles":self.settings["distdir"]}
137		122	self.set_mounts()
138	if self.settings["target"]=="grp":
139	self.mounts.append("/tmp/grp")
140	self.mountmap["/tmp/grp"]=self.settings["target_path"]
141		123
142	# configure any user specified options (either in catalyst.conf or on the cmdline)	124	# configure any user specified options (either in catalyst.conf or on the cmdline)
143	if self.settings.has_key("PKGCACHE"):	125	if self.settings.has_key("PKGCACHE"):
144	self.settings["pkgcache_path"]=st+"/packages/"+self.settings["target_subpath"]	126	self.settings["pkgcache_path"]=self.settings["storedir"]+"/packages/"+self.settings["target_subpath"]
145	self.mounts.append("/usr/portage/packages")	127	self.mounts.append("/usr/portage/packages")
146	self.mountmap["/usr/portage/packages"]=self.settings["pkgcache_path"]	128	self.mountmap["/usr/portage/packages"]=self.settings["pkgcache_path"]
147		129
Lines 158-164 Link Here
158	self.mountmap["/var/tmp/ccache"]=ccdir	140	self.mountmap["/var/tmp/ccache"]=ccdir
159	# for the chroot:	141	# for the chroot:
160	os.environ["CCACHE_DIR"]="/var/tmp/ccache"	142	os.environ["CCACHE_DIR"]="/var/tmp/ccache"
161		143
		144	def set_target_profile(self):
		145	self.settings["target_profile"]=self.settings["profile"]
		146
		147	def set_target_subpath(self):
		148	self.settings["target_subpath"]=self.settings["rel_type"]+"/"+self.settings["target"]+\
		149	"-"+self.settings["subarch"]+"-"+self.settings["version_stamp"]
		150
		151	def set_target_path(self):
		152	self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]+".tar.bz2"
		153
		154	def set_source_path(self):
		155	self.settings["source_path"]=self.settings["storedir"]+"/builds/"+self.settings["source_subpath"]+".tar.bz2"
		156
		157	def set_snapshot_path(self):
		158	self.settings["snapshot_path"]=self.settings["storedir"]+"/snapshots/portage-"+self.settings["snapshot"]+".tar.bz2"
		159
		160	def set_chroot_path(self):
		161	self.settings["chroot_path"]=self.settings["storedir"]+"/tmp/"+self.settings["target_subpath"]
		162
		163	def set_action_sequence(self):
		164	#Default action sequence for run method
		165	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		166	"setup_environment","run_local","preclean","unbind","clean","capture"]
		167
		168	def set_use(self):
		169	pass
		170
		171	def set_stage_path(self):
		172	self.settings["stage_path"]=self.settings["chroot_path"]
		173	def set_mounts(self):
		174	pass
		175
162	def mount_safety_check(self):	176	def mount_safety_check(self):
163	mypath=self.settings["chroot_path"]	177	mypath=self.settings["chroot_path"]
164		178
Lines 193-199 Link Here
193	print "Setting up directories..."	207	print "Setting up directories..."
194	self.mount_safety_check()	208	self.mount_safety_check()
195		209
196	if not self.settings["target"] == "livecd-stage2":	210	if os.path.exists(self.settings["chroot_path"]):
197	cmd("rm -rf "+self.settings["chroot_path"],\	211	cmd("rm -rf "+self.settings["chroot_path"],\
198	"Could not remove existing directory: "+self.settings["chroot_path"])	212	"Could not remove existing directory: "+self.settings["chroot_path"])
199		213
Lines 301-336 Link Here
301	myf.write("# Please consult /etc/make.conf.example for a more detailed example\n")	315	myf.write("# Please consult /etc/make.conf.example for a more detailed example\n")
302	myf.write('CFLAGS="'+self.settings["CFLAGS"]+'"\n')	316	myf.write('CFLAGS="'+self.settings["CFLAGS"]+'"\n')
303	myf.write('CHOST="'+self.settings["CHOST"]+'"\n')	317	myf.write('CHOST="'+self.settings["CHOST"]+'"\n')
304
305	# figure out what our USE vars are for building	318	# figure out what our USE vars are for building
306	myusevars=[]	319	myusevars=[]
307	if self.settings.has_key("HOSTUSE"):	320	if self.settings.has_key("HOSTUSE"):
308	myusevars.extend(self.settings["HOSTUSE"])	321	myusevars.extend(self.settings["HOSTUSE"])
309		322
310	if self.settings["target"]=="grp":	323	if self.settings.has_key("use"):
311	myusevars.append("bindist")	324	myusevars.extend(self.settings["use"])
312	myusevars.extend(self.settings["grp/use"])
313	myf.write('USE="'+string.join(myusevars)+'"\n')
314
315	elif self.settings["target"]=="tinderbox":
316	myusevars.extend(self.settings["tinderbox/use"])
317	myf.write('USE="'+string.join(myusevars)+'"\n')
318
319	elif self.settings["target"]=="livecd-stage1":
320	myusevars.extend(self.settings["livecd/use"])
321	myf.write('USE="'+string.join(myusevars)+'"\n')
322
323	elif self.settings["target"]=="embedded":
324	myusevars.extend(self.settings["embedded/use"])
325	myf.write('USE="'+string.join(myusevars)+'"\n')	325	myf.write('USE="'+string.join(myusevars)+'"\n')
326		326
327	if self.settings.has_key("CXXFLAGS"):	327	if self.settings.has_key("CXXFLAGS"):
328	myf.write('CXXFLAGS="'+self.settings["CXXFLAGS"]+'"\n')	328	myf.write('CXXFLAGS="'+self.settings["CXXFLAGS"]+'"\n')
329		329
330	else:	330	else:
331	myf.write('CXXFLAGS="${CFLAGS}"\n')	331	myf.write('CXXFLAGS="${CFLAGS}"\n')
332	myf.close()	332	myf.close()
333		333
334	def clean(self):	334	def clean(self):
335	destpath=self.settings["chroot_path"]	335	destpath=self.settings["chroot_path"]
336		336
Lines 381-397 Link Here
381		381
382	print "Creating stage tarball..."	382	print "Creating stage tarball..."
383		383
384	if self.settings["target"]=="stage1":	384	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["stage_path"]+\
385	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\	385	" .","Couldn't create stage tarball")
386	"/tmp/stage1root .","Couldn't create stage tarball")
387
388	elif self.settings["target"]=="embedded":
389	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\
390	"/tmp/mergeroot .","Couldn't create stage tarball")
391
392	else:
393	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\
394	" .","Couldn't create stage tarball")
395		386
396	def run_local(self):	387	def run_local(self):
397	try:	388	try:
Lines 401-417 Link Here
401	except CatalystError:	392	except CatalystError:
402	self.unbind()	393	self.unbind()
403	raise CatalystError,"Stage build aborting due to error."	394	raise CatalystError,"Stage build aborting due to error."
404		395
405	def run(self):	396	def setup_environment(self):
406	self.dir_setup()
407	self.unpack_and_bind()
408	try:
409	self.chroot_setup()
410
411	except:
412	self.unbind()
413	raise
414
415	# modify the current environment. This is an ugly hack that should be fixed. We need this	397	# modify the current environment. This is an ugly hack that should be fixed. We need this
416	# to use the os.system() call since we can't specify our own environ:	398	# to use the os.system() call since we can't specify our own environ:
417	for x in self.settings.keys():	399	for x in self.settings.keys():
Lines 423-446 Link Here
423	os.environ[varname]=self.settings[x]	405	os.environ[varname]=self.settings[x]
424	elif type(self.settings[x])==types.ListType:	406	elif type(self.settings[x])==types.ListType:
425	os.environ[varname]=string.join(self.settings[x])	407	os.environ[varname]=string.join(self.settings[x])
426		408
427	self.run_local()	409	def run(self):
428	if self.settings["target"] in ["stage1","stage2","stage3","livecd-stage1","livecd-stage2"]:
429	self.preclean()
430
431	if self.settings["target"] in ["livecd-stage2"]:
432	self.unmerge()
433
434	# unbind everything here so that we can clean()
435	self.unbind()
436
437	if self.settings["target"] in ["stage1","stage2","stage3","livecd-stage1","livecd-stage2"]:
438	# clean is for removing things after bind-mounts are
439	# unmounted (general file removal and cleanup)
440	self.clean()
441
442	if self.settings["target"] in ["stage1","stage2","stage3","embedded"]:
443	self.capture()
444		410
445	if self.settings["target"] in ["livecd-stage2"]:	411	for x in self.settings["action_sequence"]:
446	self.cdroot_setup()	412	print "Running action sequence: "+x
		413	if x == 'chroot_setup':
		414	try:
		415	self.chroot_setup()
		416	except:
		417	self.unbind()
		418	raise
		419	else:
		420	apply(getattr(self,x))

Lines 43-48 Link Here

(-)catalyst.orig/modules/livecd_stage2_target.py (-1 / +30 lines)
43	"gamecd/conf"])	43	"gamecd/conf"])
44		44
45	generic_stage_target.__init__(self,spec,addlargs)	45	generic_stage_target.__init__(self,spec,addlargs)
		46	self.set_cdroot_path()
46	file_locate(self.settings, ["livecd/cdtar","livecd/archscript","livecd/runscript"])	47	file_locate(self.settings, ["livecd/cdtar","livecd/archscript","livecd/runscript"])
47	if self.settings.has_key("portage_confdir"):	48	if self.settings.has_key("portage_confdir"):
48	file_locate(self.settings,["portage_confdir"],expand=0)	49	file_locate(self.settings,["portage_confdir"],expand=0)
Lines 85-91 Link Here
85	if retval!=0:	86	if retval!=0:
86	self.unbind()	87	self.unbind()
87	raise CatalystError,"Couldn't bind mount "+src	88	raise CatalystError,"Couldn't bind mount "+src
88		89
		90	def set_target_path(self):
		91	pass
		92	#self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
		93
		94	def set_source_path(self):
		95	self.settings["source_path"]=self.settings["storedir"]+"/tmp/"+self.settings["source_subpath"]
		96
		97	def set_cdroot_path(self):
		98	self.settings["cdroot_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
		99
		100	def dir_setup(self):
		101	print "Setting up directories..."
		102	self.mount_safety_check()
		103
		104	if not os.path.exists(self.settings["chroot_path"]+"/tmp"):
		105	os.makedirs(self.settings["chroot_path"]+"/tmp")
		106
		107	if not os.path.exists(self.settings["chroot_path"]):
		108	os.makedirs(self.settings["chroot_path"])
		109
		110	if self.settings.has_key("PKGCACHE"):
		111	if not os.path.exists(self.settings["pkgcache_path"]):
		112	os.makedirs(self.settings["pkgcache_path"])
		113
89	def unmerge(self):	114	def unmerge(self):
90	if self.settings.has_key("AUTORESUME") \	115	if self.settings.has_key("AUTORESUME") \
91	and os.path.exists(self.settings["chroot_path"]+"/tmp/.clst_unmerge"):	116	and os.path.exists(self.settings["chroot_path"]+"/tmp/.clst_unmerge"):
Lines 300-305 Link Here
300	if self.settings.has_key("livecd/root_overlay"):	325	if self.settings.has_key("livecd/root_overlay"):
301	cmd("rsync -a "+self.settings["livecd/root_overlay"]+"/* "+\	326	cmd("rsync -a "+self.settings["livecd/root_overlay"]+"/* "+\
302	self.settings["chroot_path"], "livecd/root_overlay copy failed.")	327	self.settings["chroot_path"], "livecd/root_overlay copy failed.")
		328	def set_action_sequence(self):
		329	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		330	"setup_environment","run_local","preclean","unmerge",\
		331	"unbind","clean","cdroot_setup"]
303		332
304	def register(foo):	333	def register(foo):
305	foo.update({"livecd-stage2":livecd_stage2_target})	334	foo.update({"livecd-stage2":livecd_stage2_target})