Attachment #57383 for bug #89683




                                 (self.set_timezone, "Setting timezone"),
                                 (self.emerge_kernel_sources, "Emerge kernel sources"),
                                 (self.build_kernel, "Building kernel"),
                                 (self.install_kernel, "Installing a kernel"),
                                 (self.install_logging_daemon, "Logger"),
                                 (self.install_cron_daemon, "Cron daemon"),
                                 (self.install_filesystem_tools, "Installing filesystem tools"),

				return GLIUtility.spawn("emerge " + package, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)

	##
	# Private Function.  Will edit a config file and insert a value or two
	# overridding the previous value (comments out the old values).
	#
	# @param filename                  File to be edited.
	# @param newvalues                 A dictionary of VARIABLE:VALUE pairs.
	# @param delimeter='='             What is between the key and the value.
	# @param quotes_around_value=True  Whether there are quotes around the
	#                                  value or not (ex. "local" vs. localhost).
	# @param only_value=False          Ignore the keys and output only a value.
	# @param create=True               Create the file if it doesn't exist.
	def _edit_config(self, filename, newvalues, delimeter='=', quotes_around_value=True, only_value=False, create=True):
		if GLIUtility.is_file(filename):
			f = open(filename)
			file = f.readlines()
			f.close()
		else:
			# File does not exist, check if creation is not allowed.
			if not create:
				raise GLIException("NoSuchFileError", 'notice','_edit_config',filename + ' does not exist!')
			else:
				file = []

		for key in newvalues.keys():
			regexpr = '^\s*#?\s*' + key + '\s*' + delimeter + '.*$'
			regexpr = re.compile(regexpr)

				if regexpr.match(file[i]):
					if not file[i][0] == '#':
						file[i] = '#' + file[i]

			if key == "SPACER":
				file.append('\n')
			elif key == "COMMENT" or key == "##comment##":
				file.append('# ' + newvalues[key] + '\n')
			if quotes_around_value:
				file.append(commentprefix + key + delimeter + '"' + newvalues[key] + '"\n')
			else:
				if quotes_around_value:
					newvalues[key] = '"' + newvalues[key] + '"'
				# Only the printing of values is required.
				if only_value:
					file.append(newvalues[key] + '\n')
				else:
					file.append(key + delimeter + newvalues[key]+'\n')
	

		f = open(filename, 'w')
		f.writelines(file)
		f.flush()
		f.close()

		self._logger.log("Chroot environment ready.")

	##
	# Installs a list of packages specified in the profile. Will install also
	# any dependencies.
	##
	def set_etc_portage(self):
		etc_portage = self._install_profile.get_etc_portage()

		# Loop through the required files.
		for file in etc_portage:
			contents = enumerate(etc_portage[file])
			self._logger.log("Configuring /etc/portage/" + file)
			self._edit_config(self._chroot_dir + "/etc/portage/" + file, {"COMMENT": "GLI additions ===>"})

			# Set up the contents hash to pass to the config writer.
			contents = {}
			for key,value in enumerate(etc_portage[file]):
				contents[str(key)] = string.strip(value)

			# Write out the contents in one go.
			self._edit_config(self._chroot_dir + "/etc/portage/" + file, contents, "", False, True)

			self._edit_config(self._chroot_dir + "/etc/make.conf", {"COMMENT": "<=== End GLI additions"})
			self._logger.log("Finished configuring /etc/portage/" + file)

	# Installs a list of packages specified in the profile. Will install also
	# any dependencies.
	def install_packages(self):
		installpackages = self._install_profile.get_install_packages()

		for package in installpackages:
			self._logger.log("Starting emerge " + package)
			status = self._emerge(package)
			if not GLIUtility.exitsuccess(status):
				self._logger.log("Could not emerge " + package + "!")
			#	raise GLIException("InstallPackagesError", 'warning', 'install_packages', "Could not emerge " + package + "!")
			else:
				self._logger.log("Emerged package: " + package)

	##
	# Will set the list of services to runlevel default.  This is a temporary solution!

	def configure_make_conf(self):
		# Get make.conf options
		options = self._install_profile.get_make_conf()

		if options.keys():
			self._edit_config(self._chroot_dir + "/etc/make.conf", {"SPACER": ""})
			self._edit_config(self._chroot_dir + "/etc/make.conf", {"COMMENT": "GLI additions ===>"})

		# For each configuration option...
		for key in options.keys():
		

			self._edit_config(self._chroot_dir + "/etc/make.conf", {key: options[key]})
		self._logger.log("Make.conf configured")

		if options.keys():
			self._edit_config(self._chroot_dir + "/etc/make.conf", {"COMMENT": "<=== End GLI additions"})

	##
	# This will get/update the portage tree.  If you want to snapshot or mount /usr/portage use "custom".
	def install_portage_tree(self):

	##
	# Fetches desired kernel sources, unless you're using a livecd-kernel in which case it does freaky stuff.
	def emerge_kernel_sources(self):
		self._logger.log("Starting emerge_kernel")
		
		kernel_pkg = self._install_profile.get_kernel_source_pkg()
#		if kernel_pkg:

			self._logger.log("Genkernel emerged.  Beginning kernel compile.")
			# Null the genkernel_options
			genkernel_options = ""

			# If the uri for the kernel config is not null, then
			if kernel_config_uri != "":
				GLIUtility.get_uri(kernel_config_uri, self._chroot_dir + "/root/kernel_config")
				genkernel_options = genkernel_options + " --kernel-config=/root/kernel_config"
				
			# Decide whether to use bootsplash or not
			if self._install_profile.get_kernel_bootsplash():
				genkernel_options = genkernel_options + " --bootsplash"

			exitstatus = GLIUtility.spawn("rm "+self._chroot_dir+"/root/kernel_script")
			#it's not important if this fails.
			self._logger.log("Custom kernel complete")


	##
	# Installs the kernels as defined in the install profile.
	def install_kernel(self):
		self._logger.log("Checking for kernels to install.")

		# Get the kernels to install.
		kernels = self._install_profile.get_kernels()

		# Install each kernel.
		for kernel in kernels:
			if (kernel['type'] == 'precompiled'):
				self._install_kernel_precompiled(kernel['kernel']);
			elif (kernel['type'] == 'emerge'):
				self._install_kernel_emerge;

	##
	# Function to install a precompiled kernel.
	def _install_kernel_precompiled(self, kernel):
		self._logger.log("Installing precompiled kernel " + kernel)
		if (GLIUtility.spawn("emerge -K " + kernel, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)):
			raise GLIException("KernelInstallError", 'fatal', 'install_kernel', "Could not install precompiled kernel!")
		self._logger.log("Kernel install finished.")

	##
	# Installs and sets up logging daemon on the new system. Adds to runlevel
	# too.
	def install_logging_daemon(self):
		
		# Get loggin daemon info




		parser.addHandler('gli-profile/cron-daemon', self.set_cron_daemon_pkg)
		parser.addHandler('gli-profile/root-pass-hash', self.set_root_pass_hash)
		parser.addHandler('gli-profile/kernel-config', self.set_kernel_config_uri)
		parser.addHandler('gli-profile/kernels/kernel', self.set_kernel)
		parser.addHandler('gli-profile/domainname', self.set_domainname)
		parser.addHandler('gli-profile/portage-snapshot', self.set_portage_tree_snapshot_uri)
		parser.addHandler('gli-profile/time-zone', self.set_time_zone)

		parser.addHandler('gli-profile/make-conf/variable', self.make_conf_add_var)
		parser.addHandler('gli-profile/rc-conf/variable', self.rc_conf_add_var)
		parser.addHandler('gli-profile/network-interfaces/device', self.add_network_interface)
		parser.addHandler('gli-profile/etc-portage/file', self.set_etc_portage)
		parser.addHandler('gli-profile/install-packages', self.set_install_packages)
		parser.addHandler('gli-profile/fstab/partition', self.add_fstab_partition)
		parser.addHandler('gli-profile/partitions/device', self.add_partitions_device, call_on_null=True)

		self._boot_loader_pkg = ""
		self._kernel_modules = []
		self._kernel_config_uri = ""
		self._kernels = []
		self._bootloader_kernel_args = ""
		self._kernel_initrd = True
		self._kernel_bootsplash = False

		self._dns_servers = ()
		self._default_gateway = ()
		self._fstab = {}
		self._etc_portage = {}
		self._install_packages = ()
		self._services = ()
		self._mta = ""

		self._kernel_config_uri = kernel_config_uri

	##
	# Returns the kernels that need to be installed and how.
	def get_kernels(self):
		"returns kernels"
		return self._kernels

	##
	# Brief description of function
	# @param xml_path Used internally by the XML parser. Should be None when calling directly
	# @param kernels Parameter description
	# @param xml_attr Parameter description
	def set_kernel(self, xml_path, kernel, attr=None):
		"""
		kernels is a hash containing all the kernels to be installed, the
		method to install them and where to fetch from if so required.
		"""

		kernel_type = str(attr.getValue('type'))

		# Check type
		if type(kernel) != str:
			raise GLIException("KernelError", 'fatal', 'set_kernel',  "Must be a string!")

		self._kernels.append({'type': kernel_type, 'kernel': kernel})

	##
	# Brief description of function
	def get_bootloader_kernel_args(self):
		"returns kernel arguments"

		"""
		make_conf is a dictionary that will be set to _make_conf

		There is no checking that needs to be done, so please sure sure that
		the make_conf dictionary that is passed in is valid.
		"""

		self._make_conf = make_conf

		return self._fstab			
		
	##
	# Sets up the list of packages to be installed.
	# @param xml_path         Used internally by the XML parser. Should be
	#                         None when calling directly
	# @param install_packages The packages to install.
	# @param xml_attr         Parameter description
	def set_etc_portage(self, xml_path, file_entries, xml_attr):

		if type(file_entries) == str:
			file_entries = string.split(file_entries, "\n")
		else:
			raise GLIException("EtcPortageError", 'fatal', 'set_etc_portage',  "Invalid input!")

		for entry in file_entries:
			if not GLIUtility.is_realstring(entry):
				raise GLIException("EtcPortageError", 'fatal', 'set_etc_packages',  entry + " must be a valid string!")

		self._etc_portage[xml_attr['name']] = file_entries
 
	##
	# Returns a hash/array of /etc/portage files to configure.
	def get_etc_portage(self):
		return self._etc_portage

	##
	# Sets up the list of packages to be installed.
	# @param xml_path         Used internally by the XML parser. Should be
	#                         None when calling directly
	# @param install_packages The packages to install.
	# @param xml_attr         Parameter description
	def set_install_packages(self, xml_path, install_packages, xml_attr):
		"""
		Set the packages to be installed for the post-installed system.
		"""

		if type(install_packages) == str:
			install_packages = string.split(install_packages, "\n")
		else:
			raise GLIException("InstallPackagesError", 'fatal', 'set_install_packages',  "Invalid input!")


Lines 441-447 Link Here

(-)GLIUtility.py (-2 / +3 lines)
441	tarball_filename = tarball_uri.split("/")[-1]	441	tarball_filename = tarball_uri.split("/")[-1]
442		442
443	# Get the tarball	443	# Get the tarball
444	get_uri(tarball_uri, temp_directory + "/" + tarball_filename)	444	if (get_uri(tarball_uri, temp_directory + "/" + tarball_filename)) == 0:
		445	return False
445		446
446	# Reset tar options	447	# Reset tar options
447	tar_options = "xv"	448	tar_options = "xv"
Lines 462-468 Link Here
462	exitstatus = spawn("tar -" + tar_options + " -f " + temp_directory + "/" + tarball_filename + " -C " + target_directory, display_on_tty8=True, logfile="/tmp/compile_output.log", append_log=True) # change this to the logfile variable	463	exitstatus = spawn("tar -" + tar_options + " -f " + temp_directory + "/" + tarball_filename + " -C " + target_directory, display_on_tty8=True, logfile="/tmp/compile_output.log", append_log=True) # change this to the logfile variable
463		464
464	if not exitsuccess(exitstatus):	465	if not exitsuccess(exitstatus):
465	raise GLIException("UnpackTarballError", 'fatal', 'fetch_and_unpack_tarball',"Could not unpack tarball!")	466	raise GLIException("UnpackTarballError", 'fatal', 'fetch_and_unpack_tarball', "Could not unpack tarball!")
466		467
467		468
468	def generate_random_password():	469	def generate_random_password():




		if path in self._fntable.keys():
			for fn in self._fntable[path]:
				if self._xml_current_data != "" or fn[1]:
					fn[0](path, string.strip(self._xml_current_data), self._xml_attrs[-1])

		# Keep the XML state
		self._xml_current_data = ""

        
		Called when the SAX parser encounters character data.
		"""

		# This converts data to a string instead of being Unicode
		# Maybe we should use Unicode strings instead of normal strings?
		self._xml_current_data += str(data)

	##
	# Brief description of function

Lines 21-26 Link Here

(-)tests/install.py (+8 lines)
21	print "\ttimezone set timezone"	21	print "\ttimezone set timezone"
22	print "\temerge_kernel install the kernel sources"	22	print "\temerge_kernel install the kernel sources"
23	print "\tbuild_kernel build the kernel"	23	print "\tbuild_kernel build the kernel"
		24	print "\tinstall_kernel install just the kernel"
24	print "\tlogger install logger"	25	print "\tlogger install logger"
25	print "\tcrond install cron daemon"	26	print "\tcrond install cron daemon"
26	print "\tfstools install filesystem tools"	27	print "\tfstools install filesystem tools"
Lines 28-33 Link Here
28	print "\tbootloader install and configure bootloader"	29	print "\tbootloader install and configure bootloader"
29	print "\tconfig_files update config files"	30	print "\tconfig_files update config files"
30	print "\tupdate_rc_conf update rc.conf"	31	print "\tupdate_rc_conf update rc.conf"
		32	print "\tset_users set up the users"
		33	print "\tetc_portage set up the files in /etc/portage"
		34	print "\tinstall_packages install required packages"
31	print "\tunmount unmount all filesystems"	35	print "\tunmount unmount all filesystems"
32		36
33	def not_working():	37	def not_working():
Lines 68-73 Link Here
68	'timezone': archtemplate.set_timezone,	72	'timezone': archtemplate.set_timezone,
69	'emerge_kernel': archtemplate.emerge_kernel_sources,	73	'emerge_kernel': archtemplate.emerge_kernel_sources,
70	'build_kernel': archtemplate.build_kernel,	74	'build_kernel': archtemplate.build_kernel,
		75	'install_kernel': archtemplate.install_kernel,
71	'logger': archtemplate.install_logging_daemon,	76	'logger': archtemplate.install_logging_daemon,
72	'crond': archtemplate.install_cron_daemon,	77	'crond': archtemplate.install_cron_daemon,
73	'fstools': archtemplate.install_filesystem_tools,	78	'fstools': archtemplate.install_filesystem_tools,
Lines 75-80 Link Here
75	'bootloader': archtemplate.install_bootloader,	80	'bootloader': archtemplate.install_bootloader,
76	'config_files': archtemplate.update_config_files,	81	'config_files': archtemplate.update_config_files,
77	'update_rc_conf': archtemplate.configure_rc_conf,	82	'update_rc_conf': archtemplate.configure_rc_conf,
		83	'set_users': archtemplate.set_users,
		84	'etc_portage': archtemplate.set_etc_portage,
		85	'install_packages': archtemplate.install_packages,
78	'unmount': not_working	86	'unmount': not_working
79	}	87	}
80		88

Return to bug 89683

Lines 55-60 Link Here

(-)GLIArchitectureTemplate.py (-35 / +102 lines)
55	(self.set_timezone, "Setting timezone"),	55	(self.set_timezone, "Setting timezone"),
56	(self.emerge_kernel_sources, "Emerge kernel sources"),	56	(self.emerge_kernel_sources, "Emerge kernel sources"),
57	(self.build_kernel, "Building kernel"),	57	(self.build_kernel, "Building kernel"),
		58	(self.install_kernel, "Installing a kernel"),
58	(self.install_logging_daemon, "Logger"),	59	(self.install_logging_daemon, "Logger"),
59	(self.install_cron_daemon, "Cron daemon"),	60	(self.install_cron_daemon, "Cron daemon"),
60	(self.install_filesystem_tools, "Installing filesystem tools"),	61	(self.install_filesystem_tools, "Installing filesystem tools"),
Lines 140-159 Link Here
140	return GLIUtility.spawn("emerge " + package, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)	141	return GLIUtility.spawn("emerge " + package, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)
141		142
142	##	143	##
143	# Private Function. Will edit a config file and insert a value or two overwriting the previous value	144	# Private Function. Will edit a config file and insert a value or two
144	# (actually it only just comments out the old one)	145	# overridding the previous value (comments out the old values).
145	# @param filename file to be edited	146	#
146	# @param newvalues a dictionary of VARIABLE:VALUE pairs	147	# @param filename File to be edited.
147	# @param delimeter='=' what is between the key and the value	148	# @param newvalues A dictionary of VARIABLE:VALUE pairs.
148	# @param quotes_around_value=True whether there are quotes around the value or not (ex. "local" vs. localhost)	149	# @param delimeter='=' What is between the key and the value.
149	def _edit_config(self, filename, newvalues, delimeter='=', quotes_around_value=True):	150	# @param quotes_around_value=True Whether there are quotes around the
150	if not GLIUtility.is_file(filename):	151	# value or not (ex. "local" vs. localhost).
151	raise GLIException("NoSuchFileError", 'notice','_edit_config',filename + ' does not exist!')	152	# @param only_value=False Ignore the keys and output only a value.
152		153	# @param create=True Create the file if it doesn't exist.
153	f = open(filename)	154	def _edit_config(self, filename, newvalues, delimeter='=', quotes_around_value=True, only_value=False, create=True):
154	file = f.readlines()	155	if GLIUtility.is_file(filename):
155	f.close()	156	f = open(filename)
156		157	file = f.readlines()
		158	f.close()
		159	else:
		160	# File does not exist, check if creation is not allowed.
		161	if not create:
		162	raise GLIException("NoSuchFileError", 'notice','_edit_config',filename + ' does not exist!')
		163	else:
		164	file = []
		165
157	for key in newvalues.keys():	166	for key in newvalues.keys():
158	regexpr = '^\s#?\s' + key + '\s' + delimeter + '.$'	167	regexpr = '^\s#?\s' + key + '\s' + delimeter + '.$'
159	regexpr = re.compile(regexpr)	168	regexpr = re.compile(regexpr)
Lines 162-178 Link Here
162	if regexpr.match(file[i]):	171	if regexpr.match(file[i]):
163	if not file[i][0] == '#':	172	if not file[i][0] == '#':
164	file[i] = '#' + file[i]	173	file[i] = '#' + file[i]
165		174
166	file.append('\n# Added by GLI\n')	175	if key == "SPACER":
167	commentprefix = ""	176	file.append('\n')
168	if newvalues[key] == "COMMENT" or newvalues[key] == "##comment##":	177	elif key == "COMMENT" or key == "##comment##":
169	commentprefix = "#"	178	file.append('# ' + newvalues[key] + '\n')
170	if quotes_around_value:
171	file.append(commentprefix + key + delimeter + '"' + newvalues[key] + '"\n')
172	else:	179	else:
173	file.append(commentprefix + key + delimeter + newvalues[key]+'\n')	180	if quotes_around_value:
		181	newvalues[key] = '"' + newvalues[key] + '"'
		182	# Only the printing of values is required.
		183	if only_value:
		184	file.append(newvalues[key] + '\n')
		185	else:
		186	file.append(key + delimeter + newvalues[key]+'\n')
174		187
175	f = open(filename,'w')	188
		189	f = open(filename, 'w')
176	f.writelines(file)	190	f.writelines(file)
177	f.flush()	191	f.flush()
178	f.close()	192	f.close()
Lines 231-247 Link Here
231	self._logger.log("Chroot environment ready.")	245	self._logger.log("Chroot environment ready.")
232		246
233	##	247	##
234	# Installs a list of packages specified in the profile. Will install any extra software!	248	# Installs a list of packages specified in the profile. Will install also
235	# In the future this function will lead to better things. It may even wipe your ass for you.	249	# any dependencies.
		250	##
		251	def set_etc_portage(self):
		252	etc_portage = self._install_profile.get_etc_portage()
		253
		254	# Loop through the required files.
		255	for file in etc_portage:
		256	contents = enumerate(etc_portage[file])
		257	self._logger.log("Configuring /etc/portage/" + file)
		258	self._edit_config(self._chroot_dir + "/etc/portage/" + file, {"COMMENT": "GLI additions ===>"})
		259
		260	# Set up the contents hash to pass to the config writer.
		261	contents = {}
		262	for key,value in enumerate(etc_portage[file]):
		263	contents[str(key)] = string.strip(value)
		264
		265	# Write out the contents in one go.
		266	self._edit_config(self._chroot_dir + "/etc/portage/" + file, contents, "", False, True)
		267
		268	self._edit_config(self._chroot_dir + "/etc/make.conf", {"COMMENT": "<=== End GLI additions"})
		269	self._logger.log("Finished configuring /etc/portage/" + file)
		270
		271	# Installs a list of packages specified in the profile. Will install also
		272	# any dependencies.
236	def install_packages(self):	273	def install_packages(self):
237	installpackages = self._install_profile.get_install_packages()	274	installpackages = self._install_profile.get_install_packages()
		275
238	for package in installpackages:	276	for package in installpackages:
		277	self._logger.log("Starting emerge " + package)
239	status = self._emerge(package)	278	status = self._emerge(package)
240	if not GLIUtility.exitsuccess(status):	279	if not GLIUtility.exitsuccess(status):
241	self._logger.log("Could not emerge " + package + "!")	280	self._logger.log("Could not emerge " + package + "!")
242	# raise GLIException("InstallPackagesError", 'warning', 'install_packages', "Could not emerge " + package + "!")	281	# raise GLIException("InstallPackagesError", 'warning', 'install_packages', "Could not emerge " + package + "!")
243	else:	282	else:
244	self._logger.log("Emerged package: "+package)	283	self._logger.log("Emerged package: " + package)
245		284
246	##	285	##
247	# Will set the list of services to runlevel default. This is a temporary solution!	286	# Will set the list of services to runlevel default. This is a temporary solution!
Lines 349-355 Link Here
349	def configure_make_conf(self):	388	def configure_make_conf(self):
350	# Get make.conf options	389	# Get make.conf options
351	options = self._install_profile.get_make_conf()	390	options = self._install_profile.get_make_conf()
352		391
		392	if options.keys():
		393	self._edit_config(self._chroot_dir + "/etc/make.conf", {"SPACER": ""})
		394	self._edit_config(self._chroot_dir + "/etc/make.conf", {"COMMENT": "GLI additions ===>"})
		395
353	# For each configuration option...	396	# For each configuration option...
354	for key in options.keys():	397	for key in options.keys():
355		398
Lines 357-362 Link Here
357	self._edit_config(self._chroot_dir + "/etc/make.conf", {key: options[key]})	400	self._edit_config(self._chroot_dir + "/etc/make.conf", {key: options[key]})
358	self._logger.log("Make.conf configured")	401	self._logger.log("Make.conf configured")
359		402
		403	if options.keys():
		404	self._edit_config(self._chroot_dir + "/etc/make.conf", {"COMMENT": "<=== End GLI additions"})
		405
360	##	406	##
361	# This will get/update the portage tree. If you want to snapshot or mount /usr/portage use "custom".	407	# This will get/update the portage tree. If you want to snapshot or mount /usr/portage use "custom".
362	def install_portage_tree(self):	408	def install_portage_tree(self):
Lines 446-451 Link Here
446	##	492	##
447	# Fetches desired kernel sources, unless you're using a livecd-kernel in which case it does freaky stuff.	493	# Fetches desired kernel sources, unless you're using a livecd-kernel in which case it does freaky stuff.
448	def emerge_kernel_sources(self):	494	def emerge_kernel_sources(self):
		495	self._logger.log("Starting emerge_kernel")
449		496
450	kernel_pkg = self._install_profile.get_kernel_source_pkg()	497	kernel_pkg = self._install_profile.get_kernel_source_pkg()
451	# if kernel_pkg:	498	# if kernel_pkg:
Lines 509-520 Link Here
509	self._logger.log("Genkernel emerged. Beginning kernel compile.")	556	self._logger.log("Genkernel emerged. Beginning kernel compile.")
510	# Null the genkernel_options	557	# Null the genkernel_options
511	genkernel_options = ""	558	genkernel_options = ""
512		559
513	# If the uri for the kernel config is not null, then
514	if kernel_config_uri != "":
515	GLIUtility.get_uri(kernel_config_uri, self._chroot_dir + "/root/kernel_config")
516	genkernel_options = genkernel_options + " --kernel-config=/root/kernel_config"
517
518	# Decide whether to use bootsplash or not	560	# Decide whether to use bootsplash or not
519	if self._install_profile.get_kernel_bootsplash():	561	if self._install_profile.get_kernel_bootsplash():
520	genkernel_options = genkernel_options + " --bootsplash"	562	genkernel_options = genkernel_options + " --bootsplash"
Lines 567-575 Link Here
567	exitstatus = GLIUtility.spawn("rm "+self._chroot_dir+"/root/kernel_script")	609	exitstatus = GLIUtility.spawn("rm "+self._chroot_dir+"/root/kernel_script")
568	#it's not important if this fails.	610	#it's not important if this fails.
569	self._logger.log("Custom kernel complete")	611	self._logger.log("Custom kernel complete")
570		612
		613
		614	##
		615	# Installs the kernels as defined in the install profile.
		616	def install_kernel(self):
		617	self._logger.log("Checking for kernels to install.")
		618
		619	# Get the kernels to install.
		620	kernels = self._install_profile.get_kernels()
		621
		622	# Install each kernel.
		623	for kernel in kernels:
		624	if (kernel['type'] == 'precompiled'):
		625	self._install_kernel_precompiled(kernel['kernel']);
		626	elif (kernel['type'] == 'emerge'):
		627	self._install_kernel_emerge;
		628
		629	##
		630	# Function to install a precompiled kernel.
		631	def _install_kernel_precompiled(self, kernel):
		632	self._logger.log("Installing precompiled kernel " + kernel)
		633	if (GLIUtility.spawn("emerge -K " + kernel, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)):
		634	raise GLIException("KernelInstallError", 'fatal', 'install_kernel', "Could not install precompiled kernel!")
		635	self._logger.log("Kernel install finished.")
		636
571	##	637	##
572	# Installs and sets up logging daemon on the new system. adds to runlevel too.	638	# Installs and sets up logging daemon on the new system. Adds to runlevel
		639	# too.
573	def install_logging_daemon(self):	640	def install_logging_daemon(self):
574		641
575	# Get loggin daemon info	642	# Get loggin daemon info

Lines 40-45 Link Here

(-)GLIInstallProfile.py (-7 / +61 lines)
40	parser.addHandler('gli-profile/cron-daemon', self.set_cron_daemon_pkg)	40	parser.addHandler('gli-profile/cron-daemon', self.set_cron_daemon_pkg)
41	parser.addHandler('gli-profile/root-pass-hash', self.set_root_pass_hash)	41	parser.addHandler('gli-profile/root-pass-hash', self.set_root_pass_hash)
42	parser.addHandler('gli-profile/kernel-config', self.set_kernel_config_uri)	42	parser.addHandler('gli-profile/kernel-config', self.set_kernel_config_uri)
		43	parser.addHandler('gli-profile/kernels/kernel', self.set_kernel)
43	parser.addHandler('gli-profile/domainname', self.set_domainname)	44	parser.addHandler('gli-profile/domainname', self.set_domainname)
44	parser.addHandler('gli-profile/portage-snapshot', self.set_portage_tree_snapshot_uri)	45	parser.addHandler('gli-profile/portage-snapshot', self.set_portage_tree_snapshot_uri)
45	parser.addHandler('gli-profile/time-zone', self.set_time_zone)	46	parser.addHandler('gli-profile/time-zone', self.set_time_zone)
Lines 56-61 Link Here
56	parser.addHandler('gli-profile/make-conf/variable', self.make_conf_add_var)	57	parser.addHandler('gli-profile/make-conf/variable', self.make_conf_add_var)
57	parser.addHandler('gli-profile/rc-conf/variable', self.rc_conf_add_var)	58	parser.addHandler('gli-profile/rc-conf/variable', self.rc_conf_add_var)
58	parser.addHandler('gli-profile/network-interfaces/device', self.add_network_interface)	59	parser.addHandler('gli-profile/network-interfaces/device', self.add_network_interface)
		60	parser.addHandler('gli-profile/etc-portage/file', self.set_etc_portage)
59	parser.addHandler('gli-profile/install-packages', self.set_install_packages)	61	parser.addHandler('gli-profile/install-packages', self.set_install_packages)
60	parser.addHandler('gli-profile/fstab/partition', self.add_fstab_partition)	62	parser.addHandler('gli-profile/fstab/partition', self.add_fstab_partition)
61	parser.addHandler('gli-profile/partitions/device', self.add_partitions_device, call_on_null=True)	63	parser.addHandler('gli-profile/partitions/device', self.add_partitions_device, call_on_null=True)
Lines 74-79 Link Here
74	self._boot_loader_pkg = ""	76	self._boot_loader_pkg = ""
75	self._kernel_modules = []	77	self._kernel_modules = []
76	self._kernel_config_uri = ""	78	self._kernel_config_uri = ""
		79	self._kernels = []
77	self._bootloader_kernel_args = ""	80	self._bootloader_kernel_args = ""
78	self._kernel_initrd = True	81	self._kernel_initrd = True
79	self._kernel_bootsplash = False	82	self._kernel_bootsplash = False
Lines 100-105 Link Here
100	self._dns_servers = ()	103	self._dns_servers = ()
101	self._default_gateway = ()	104	self._default_gateway = ()
102	self._fstab = {}	105	self._fstab = {}
		106	self._etc_portage = {}
103	self._install_packages = ()	107	self._install_packages = ()
104	self._services = ()	108	self._services = ()
105	self._mta = ""	109	self._mta = ""
Lines 254-259 Link Here
254	self._kernel_config_uri = kernel_config_uri	258	self._kernel_config_uri = kernel_config_uri
255		259
256	##	260	##
		261	# Returns the kernels that need to be installed and how.
		262	def get_kernels(self):
		263	"returns kernels"
		264	return self._kernels
		265
		266	##
		267	# Brief description of function
		268	# @param xml_path Used internally by the XML parser. Should be None when calling directly
		269	# @param kernels Parameter description
		270	# @param xml_attr Parameter description
		271	def set_kernel(self, xml_path, kernel, attr=None):
		272	"""
		273	kernels is a hash containing all the kernels to be installed, the
		274	method to install them and where to fetch from if so required.
		275	"""
		276
		277	kernel_type = str(attr.getValue('type'))
		278
		279	# Check type
		280	if type(kernel) != str:
		281	raise GLIException("KernelError", 'fatal', 'set_kernel', "Must be a string!")
		282
		283	self._kernels.append({'type': kernel_type, 'kernel': kernel})
		284
		285	##
257	# Brief description of function	286	# Brief description of function
258	def get_bootloader_kernel_args(self):	287	def get_bootloader_kernel_args(self):
259	"returns kernel arguments"	288	"returns kernel arguments"
Lines 1007-1014 Link Here
1007	"""	1036	"""
1008	make_conf is a dictionary that will be set to _make_conf	1037	make_conf is a dictionary that will be set to _make_conf
1009		1038
1010	There is no checking that needs to be done, so please sure sure that the make_conf dictionary	1039	There is no checking that needs to be done, so please sure sure that
1011	that is passed in is valid.	1040	the make_conf dictionary that is passed in is valid.
1012	"""	1041	"""
1013		1042
1014	self._make_conf = make_conf	1043	self._make_conf = make_conf
Lines 1212-1228 Link Here
1212	return self._fstab	1241	return self._fstab
1213		1242
1214	##	1243	##
1215	# Brief description of function	1244	# Sets up the list of packages to be installed.
1216	# @param xml_path Used internally by the XML parser. Should be None when calling directly	1245	# @param xml_path Used internally by the XML parser. Should be
1217	# @param install_packages Parameter description	1246	# None when calling directly
1218	# @param xml_attr Parameter description	1247	# @param install_packages The packages to install.
		1248	# @param xml_attr Parameter description
		1249	def set_etc_portage(self, xml_path, file_entries, xml_attr):
		1250
		1251	if type(file_entries) == str:
		1252	file_entries = string.split(file_entries, "\n")
		1253	else:
		1254	raise GLIException("EtcPortageError", 'fatal', 'set_etc_portage', "Invalid input!")
		1255
		1256	for entry in file_entries:
		1257	if not GLIUtility.is_realstring(entry):
		1258	raise GLIException("EtcPortageError", 'fatal', 'set_etc_packages', entry + " must be a valid string!")
		1259
		1260	self._etc_portage[xml_attr['name']] = file_entries
		1261
		1262	##
		1263	# Returns a hash/array of /etc/portage files to configure.
		1264	def get_etc_portage(self):
		1265	return self._etc_portage
		1266
		1267	##
		1268	# Sets up the list of packages to be installed.
		1269	# @param xml_path Used internally by the XML parser. Should be
		1270	# None when calling directly
		1271	# @param install_packages The packages to install.
		1272	# @param xml_attr Parameter description
1219	def set_install_packages(self, xml_path, install_packages, xml_attr):	1273	def set_install_packages(self, xml_path, install_packages, xml_attr):
1220	"""	1274	"""
1221	Set the packages to be installed for the post-installed system.	1275	Set the packages to be installed for the post-installed system.
1222	"""	1276	"""
1223		1277
1224	if type(install_packages) == str:	1278	if type(install_packages) == str:
1225	install_packages = string.split(install_packages)	1279	install_packages = string.split(install_packages, "\n")
1226	else:	1280	else:
1227	raise GLIException("InstallPackagesError", 'fatal', 'set_install_packages', "Invalid input!")	1281	raise GLIException("InstallPackagesError", 'fatal', 'set_install_packages', "Invalid input!")
1228		1282

Lines 68-74 Link Here

(-)SimpleXMLParser.py (-3 / +3 lines)
68	if path in self._fntable.keys():	68	if path in self._fntable.keys():
69	for fn in self._fntable[path]:	69	for fn in self._fntable[path]:
70	if self._xml_current_data != "" or fn[1]:	70	if self._xml_current_data != "" or fn[1]:
71	fn[0](path, self._xml_current_data, self._xml_attrs[-1])	71	fn[0](path, string.strip(self._xml_current_data), self._xml_attrs[-1])
72		72
73	# Keep the XML state	73	# Keep the XML state
74	self._xml_current_data = ""	74	self._xml_current_data = ""
Lines 85-94 Link Here
85		85
86	Called when the SAX parser encounters character data.	86	Called when the SAX parser encounters character data.
87	"""	87	"""
88		88
89	# This converts data to a string instead of being Unicode	89	# This converts data to a string instead of being Unicode
90	# Maybe we should use Unicode strings instead of normal strings?	90	# Maybe we should use Unicode strings instead of normal strings?
91	self._xml_current_data += string.strip(str(data))	91	self._xml_current_data += str(data)
92		92
93	##	93	##
94	# Brief description of function	94	# Brief description of function