Attachment #43655 for bug #70663

Lines 287-291 Link Here

(-)catalyst/catalyst (-1 / +1 lines)
287	try:	287	try:
288	build_target(addlargs, targetmap)	288	build_target(addlargs, targetmap)
289	except:	289	except:
290	print "!!! catalyst: could not complete build"	290	raise CatalystError,"could not complete build"
291	sys.exit(2)	291	sys.exit(2)

Lines 43-48 Link Here

(-)catalyst/modules/catalyst_support.py (+3 lines)
43	if message:	43	if message:
44	print	44	print
45	print "!!! catalyst: "+message	45	print "!!! catalyst: "+message
		46
		47	#Uncomment the line below if you need more detailed debugging messages
		48	#raise
46		49
47	def die(msg=None):	50	def die(msg=None):
48	warn(msg)	51	warn(msg)

Lines 67-72 Link Here

(-)catalyst/modules/embedded_target.py (+9 lines)
67	self.unbind()	67	self.unbind()
68	raise CatalystError, "embedded runscript aborting due to error."	68	raise CatalystError, "embedded runscript aborting due to error."
69		69
		70	def set_action_sequence(self):
		71	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		72	"setup_environment","run_local","unbind","capture"]
		73
		74	def set_use(self):
		75	self.settings["use"]=self.settings["grp/use"]
		76	def set_stage_path(self):
		77	self.settings["stage_path"]=+self.settings["chroot_path"]+"/tmp/mergeroot"
		78	print "embedded stage path is "+self.settings["stage_path"]
70	def register(foo):	79	def register(foo):
71	foo.update({"embedded":embedded_target})	80	foo.update({"embedded":embedded_target})
72	return foo	81	return foo

Lines 104-110 Link Here

(-)catalyst/modules/generic_stage_target.py (-66 / +37 lines)
104	self.set_target_path()	104	self.set_target_path()
105	self.set_source_path()	105	self.set_source_path()
106	self.set_chroot_path()	106	self.set_chroot_path()
107		107	self.set_action_sequence()
		108	self.set_use()
		109	self.set_stage_path()
		110
108	# 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.
109	file_locate(self.settings,["source_path","snapshot_path","distdir"],expand=0)	112	file_locate(self.settings,["source_path","snapshot_path","distdir"],expand=0)
110		113
Lines 116-124 Link Here
116	self.mounts=[ "/proc","/dev","/dev/pts","/usr/portage/distfiles" ]	119	self.mounts=[ "/proc","/dev","/dev/pts","/usr/portage/distfiles" ]
117	self.mountmap={"/proc":"/proc", "/dev":"/dev", "/dev/pts":"/dev/pts",\	120	self.mountmap={"/proc":"/proc", "/dev":"/dev", "/dev/pts":"/dev/pts",\
118	"/usr/portage/distfiles":self.settings["distdir"]}	121	"/usr/portage/distfiles":self.settings["distdir"]}
119	if self.settings["target"]=="grp":	122	self.set_mounts()
120	self.mounts.append("/tmp/grp")
121	self.mountmap["/tmp/grp"]=self.settings["target_path"]
122		123
123	# 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)
124	if self.settings.has_key("PKGCACHE"):	125	if self.settings.has_key("PKGCACHE"):
Lines 158-163 Link Here
158		159
159	def set_chroot_path(self):	160	def set_chroot_path(self):
160	self.settings["chroot_path"]=self.settings["storedir"]+"/tmp/"+self.settings["target_subpath"]	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"]
161		173
162	def mount_safety_check(self):	174	def mount_safety_check(self):
163	mypath=self.settings["chroot_path"]	175	mypath=self.settings["chroot_path"]
Lines 193-199 Link Here
193	print "Setting up directories..."	205	print "Setting up directories..."
194	self.mount_safety_check()	206	self.mount_safety_check()
195		207
196	if not self.settings["target"] == "livecd-stage2":	208	if os.path.exists(self.settings["chroot_path"]):
197	cmd("rm -rf "+self.settings["chroot_path"],\	209	cmd("rm -rf "+self.settings["chroot_path"],\
198	"Could not remove existing directory: "+self.settings["chroot_path"])	210	"Could not remove existing directory: "+self.settings["chroot_path"])
199		211
Lines 295-330 Link Here
295	myf.write("# Please consult /etc/make.conf.example for a more detailed example\n")	307	myf.write("# Please consult /etc/make.conf.example for a more detailed example\n")
296	myf.write('CFLAGS="'+self.settings["CFLAGS"]+'"\n')	308	myf.write('CFLAGS="'+self.settings["CFLAGS"]+'"\n')
297	myf.write('CHOST="'+self.settings["CHOST"]+'"\n')	309	myf.write('CHOST="'+self.settings["CHOST"]+'"\n')
298
299	# figure out what our USE vars are for building	310	# figure out what our USE vars are for building
300	myusevars=[]	311	myusevars=[]
301	if self.settings.has_key("HOSTUSE"):	312	if self.settings.has_key("HOSTUSE"):
302	myusevars.extend(self.settings["HOSTUSE"])	313	myusevars.extend(self.settings["HOSTUSE"])
303		314
304	if self.settings["target"]=="grp":	315	if self.settings.has_key("use"):
305	myusevars.append("bindist")	316	myusevars.extend(self.settings["use"])
306	myusevars.extend(self.settings["grp/use"])
307	myf.write('USE="'+string.join(myusevars)+'"\n')
308
309	elif self.settings["target"]=="tinderbox":
310	myusevars.extend(self.settings["tinderbox/use"])
311	myf.write('USE="'+string.join(myusevars)+'"\n')
312
313	elif self.settings["target"]=="livecd-stage1":
314	myusevars.extend(self.settings["livecd/use"])
315	myf.write('USE="'+string.join(myusevars)+'"\n')
316
317	elif self.settings["target"]=="embedded":
318	myusevars.extend(self.settings["embedded/use"])
319	myf.write('USE="'+string.join(myusevars)+'"\n')	317	myf.write('USE="'+string.join(myusevars)+'"\n')
320		318
321	if self.settings.has_key("CXXFLAGS"):	319	if self.settings.has_key("CXXFLAGS"):
322	myf.write('CXXFLAGS="'+self.settings["CXXFLAGS"]+'"\n')	320	myf.write('CXXFLAGS="'+self.settings["CXXFLAGS"]+'"\n')
323		321
324	else:	322	else:
325	myf.write('CXXFLAGS="${CFLAGS}"\n')	323	myf.write('CXXFLAGS="${CFLAGS}"\n')
326	myf.close()	324	myf.close()
327		325
328	def clean(self):	326	def clean(self):
329	destpath=self.settings["chroot_path"]	327	destpath=self.settings["chroot_path"]
330		328
Lines 371-387 Link Here
371		369
372	print "Creating stage tarball..."	370	print "Creating stage tarball..."
373		371
374	if self.settings["target"]=="stage1":	372	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["stage_path"]+\
375	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\	373	" .","Couldn't create stage tarball")
376	"/tmp/stage1root .","Couldn't create stage tarball")
377
378	elif self.settings["target"]=="embedded":
379	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\
380	"/tmp/mergeroot .","Couldn't create stage tarball")
381
382	else:
383	cmd("tar cjf "+self.settings["target_path"]+" -C "+self.settings["chroot_path"]+\
384	" .","Couldn't create stage tarball")
385		374
386	def run_local(self):	375	def run_local(self):
387	try:	376	try:
Lines 391-407 Link Here
391	except CatalystError:	380	except CatalystError:
392	self.unbind()	381	self.unbind()
393	raise CatalystError,"Stage build aborting due to error."	382	raise CatalystError,"Stage build aborting due to error."
394		383
395	def run(self):	384	def setup_environment(self):
396	self.dir_setup()
397	self.unpack_and_bind()
398	try:
399	self.chroot_setup()
400
401	except:
402	self.unbind()
403	raise
404
405	# modify the current environment. This is an ugly hack that should be fixed. We need this	385	# modify the current environment. This is an ugly hack that should be fixed. We need this
406	# to use the os.system() call since we can't specify our own environ:	386	# to use the os.system() call since we can't specify our own environ:
407	for x in self.settings.keys():	387	for x in self.settings.keys():
Lines 413-436 Link Here
413	os.environ[varname]=self.settings[x]	393	os.environ[varname]=self.settings[x]
414	elif type(self.settings[x])==types.ListType:	394	elif type(self.settings[x])==types.ListType:
415	os.environ[varname]=string.join(self.settings[x])	395	os.environ[varname]=string.join(self.settings[x])
416		396
417	self.run_local()	397	def run(self):
418	if self.settings["target"] in ["stage1","stage2","stage3","livecd-stage1","livecd-stage2"]:
419	self.preclean()
420
421	if self.settings["target"] in ["livecd-stage2"]:
422	self.unmerge()
423
424	# unbind everything here so that we can clean()
425	self.unbind()
426
427	if self.settings["target"] in ["stage1","stage2","stage3","livecd-stage1","livecd-stage2"]:
428	# clean is for removing things after bind-mounts are
429	# unmounted (general file removal and cleanup)
430	self.clean()
431
432	if self.settings["target"] in ["stage1","stage2","stage3","embedded"]:
433	self.capture()
434		398
435	if self.settings["target"] in ["livecd-stage2"]:	399	for x in self.settings["action_sequence"]:
436	self.cdroot_setup()	400	print "Running action sequence: "+x
		401	if x == 'chroot_setup':
		402	try:
		403	self.chroot_setup()
		404	except:
		405	self.unbind()
		406	else:
		407	apply(getattr(self,x))




				self.unbind()
				raise CatalystError,"GRP build aborting due to error."

	def set_action_sequence(self):
	    self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
	    				    "setup_environment","run_local","unbind"]
	
	def set_use(self):
	    self.settings["use"]=self.settings["grp/use"]
	    self.settings["use"].append("bindlist")

	def set_mounts(self):
	    self.mounts.append("/tmp/grp")
            self.mountmap["/tmp/grp"]=self.settings["target_path"]

def register(foo):
	foo.update({"grp":grp_target})
	return foo

Lines 24-29 Link Here

(-)catalyst/modules/livecd_stage1_target.py (+7 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	self.settings["action_sequence"]=["chroot_setup"]
		31
		32	def set_use(self):
		33	self.settings["use"]=self.settings["livecd/use"]
27		34
28	def register(foo):	35	def register(foo):
29	foo.update({"livecd-stage1":livecd_stage1_target})	36	foo.update({"livecd-stage1":livecd_stage1_target})




	    #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 142-147 Link Here

(-)catalyst/modules/netboot.py (+4 lines)
142	print "netboot: build finished !"	142	print "netboot: build finished !"
143		143
144		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
145	def register(foo):	149	def register(foo):
146	foo.update({"netboot":netboot_target})	150	foo.update({"netboot":netboot_target})
147	return foo	151	return foo

Lines 14-19 Link Here

(-)catalyst/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 29-35 Link Here

(-)catalyst/modules/tinderbox_target.py (-1 / +2 lines)
29		29
30	def set_target_path(self):	30	def set_target_path(self):
31	self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]	31	self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
32		32	def set_use(self):
		33	self.settings["use"]=self.settings["tinderbox/use"]
33	def register(foo):	34	def register(foo):
34	foo.update({"tinderbox":tinderbox_target})	35	foo.update({"tinderbox":tinderbox_target})
35	return foo	36	return foo

Return to bug 70663

Lines 45-50 Link Here

(-)catalyst/modules/grp_target.py (+12 lines)
45	self.unbind()	45	self.unbind()
46	raise CatalystError,"GRP build aborting due to error."	46	raise CatalystError,"GRP build aborting due to error."
47		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
48	def register(foo):	60	def register(foo):
49	foo.update({"grp":grp_target})	61	foo.update({"grp":grp_target})
50	return foo	62	return foo

Lines 91-101 Link Here

(-)catalyst/modules/livecd_stage2_target.py (-1 / +19 lines)
91	#self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]	91	#self.settings["target_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
92		92
93	def set_source_path(self):	93	def set_source_path(self):
94	self.settings["source_path"]=self.settings["storedir"]+"/builds/"+self.settings["source_subpath"]	94	self.settings["source_path"]=self.settings["storedir"]+"/tmp/"+self.settings["source_subpath"]
95		95
96	def set_cdroot_path(self):	96	def set_cdroot_path(self):
97	self.settings["cdroot_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]	97	self.settings["cdroot_path"]=self.settings["storedir"]+"/builds/"+self.settings["target_subpath"]
98		98
		99	def dir_setup(self):
		100	print "Setting up directories..."
		101	self.mount_safety_check()
		102
		103	if not os.path.exists(self.settings["chroot_path"]+"/tmp"):
		104	os.makedirs(self.settings["chroot_path"]+"/tmp")
		105
		106	if not os.path.exists(self.settings["chroot_path"]):
		107	os.makedirs(self.settings["chroot_path"])
		108
		109	if self.settings.has_key("PKGCACHE"):
		110	if not os.path.exists(self.settings["pkgcache_path"]):
		111	os.makedirs(self.settings["pkgcache_path"])
		112
99	def unmerge(self):	113	def unmerge(self):
100	if self.settings.has_key("AUTORESUME") \	114	if self.settings.has_key("AUTORESUME") \
101	and os.path.exists(self.settings["chroot_path"]+"/tmp/.clst_unmerge"):	115	and os.path.exists(self.settings["chroot_path"]+"/tmp/.clst_unmerge"):
Lines 310-315 Link Here
310	if self.settings.has_key("livecd/root_overlay"):	324	if self.settings.has_key("livecd/root_overlay"):
311	cmd("rsync -a "+self.settings["livecd/root_overlay"]+"/* "+\	325	cmd("rsync -a "+self.settings["livecd/root_overlay"]+"/* "+\
312	self.settings["chroot_path"], "livecd/root_overlay copy failed.")	326	self.settings["chroot_path"], "livecd/root_overlay copy failed.")
		327	def set_action_sequence(self):
		328	self.settings["action_sequence"]=["dir_setup","unpack_and_bind","chroot_setup",\
		329	"setup_environment","run_local","preclean","unmerge",\
		330	"unbind","clean","cdroot_setup"]
313		331
314	def register(foo):	332	def register(foo):
315	foo.update({"livecd-stage2":livecd_stage2_target})	333	foo.update({"livecd-stage2":livecd_stage2_target})