def main(): opts = parse_args() if not opts.kscfg: print(_("Need to specify a config to flatten"), file=sys.stderr) sys.exit(1) ksversion = makeVersion(opts.version) ksparser = pykickstart.parser.KickstartParser(ksversion) try: ksparser.readKickstart(opts.kscfg) except IOError as msg: print(_("Failed to read kickstart file '%(filename)s' : %(error_msg)s") % {"filename": opts.kscfg, "error_msg": msg}, file=sys.stderr) sys.exit(1) except pykickstart.errors.KickstartError as e: print(_("Failed to parse kickstart file '%(filename)s' : %(error_msg)s") % {"filename": opts.kscfg, "error_msg": e}, file=sys.stderr) sys.exit(1) if opts.output: try: f = open(opts.output, 'w') except IOError as msg: print(_("Failed to open output file '%(filename)s' : %(error_msg)s") % {"filename": opts.output, "error_msg": msg}, file=sys.stderr) sys.exit(1) else: f = sys.stdout f.write("%s" % ksparser.handler) f.close()
def read_kickstart(path): """Parse a kickstart file and return a KickstartParser instance. This is a simple utility function which takes a path to a kickstart file, parses it and returns a pykickstart KickstartParser instance which can be then passed to an ImageCreator constructor. If an error occurs, a CreatorError exception is thrown. """ version = ksversion.makeVersion() ks = ksparser.KickstartParser(version) try: if "://" not in path: path = "file://%s" % (urllib.request.pathname2url(os.path.abspath(path))) ksdata = urllib.request.urlopen(path).read().decode("utf-8") ks.readKickstartFromString(ksdata, reset=False) # Fallback to e.args[0] is a workaround for bugs in urlgragger and pykickstart. except IOError as e: raise errors.KickstartError("Failed to read kickstart file " "'%s' : %s" % (path, e.strerror or e.args[0])) except kserrors.KickstartError as e: raise errors.KickstartError("Failed to parse kickstart file " "'%s' : %s" % (path, e)) return ks
def main(argv=None): opts = parse_args(argv) if not opts.kscfg: return (1, _("Need to specify a config to flatten")) try: ksversion = makeVersion(opts.version) except KickstartVersionError: print(_("The version %s is not supported by pykickstart") % opts.version) sys.exit(1) ksparser = pykickstart.parser.KickstartParser(ksversion) try: ksparser.readKickstart(opts.kscfg) except IOError as msg: return (1, _("Failed to read kickstart file '%(filename)s' : %(error_msg)s") % {"filename": opts.kscfg, "error_msg": msg}) except pykickstart.errors.KickstartError as e: return (1, _("Failed to parse kickstart file '%(filename)s' : %(error_msg)s") % {"filename": opts.kscfg, "error_msg": e}) if opts.output: try: f = open(opts.output, 'w') except IOError as msg: return (1, _("Failed to open output file '%(filename)s' : %(error_msg)s") % {"filename": opts.output, "error_msg": msg}) else: f = sys.stdout f.write("%s" % ksparser.handler) if opts.output: f.close() return (0, '')
def kickstart(ks, path=settings.KS_DIR): """ return parsed pykickstart object """ ks = "%s%s" % (path, ks) ksparser = KickstartParser(makeVersion()) ksparser.readKickstart(ks) return ksparser
def kickstart(ks, uploaded, path=settings.KS_DIR): """ return parsed pykickstart object """ if not uploaded: ks = "%s%s" % (path, ks) ksparser = DecoratedKickstartParser(makeVersion()) ksparser.readKickstart(ks) return ksparser
def kickstart(ks, path=settings.KS_DIR): """ return parsed pykickstart object """ ks = "%s%s" % (path, ks) ksparser = KickstartParser(makeVersion()) if isinstance(ks, unicode): ks = ks.encode('utf-8') ksparser.readKickstart(ks) return ksparser
def process_kickstart(ksfile): # pykickstart refs # https://jlaska.fedorapeople.org/pykickstart-doc/pykickstart.commands.html ksparser = KickstartParser(makeVersion()) try: ksparser.readKickstart(ksfile) except KickstartError as e: sys.stderr.write(str(e)) sys.exit(1) user_data = '#!/bin/bash' # repo for repo in ksparser.handler.repo.repoList: if repo.mirrorlist: repo_url = 'metalink=%s' % repo.mirrorlist else: repo_url = 'baseurl=%s' % repo.baseurl user_data += """ cat <<"EOF" >/etc/yum.repos.d/%s.repo [%s] name=%s %s enabled=1 gpgcheck=0 EOF """ % (repo.name, repo.name, repo.name, repo_url) # rootpw if ksparser.handler.rootpw.isCrypted: user_data += 'echo "root:%s" | chpasswd -e\n' % ksparser.handler.rootpw.password else: user_data += 'echo "root:%s" | chpasswd\n' % ksparser.handler.rootpw.password # selinux if ksparser.handler.selinux.selinux is 0: selinux_status = 'disabled' elif ksparser.handler.selinux.selinux is 2: selinux_status = 'enforcing' else: selinux_status = 'enforcing' user_data += "sed -i 's/SELINUX=.*/SELINUX=%s/' /etc/selinux/config\n" % selinux_status # %packages packages = [] for group in ksparser.handler.packages.groupList: packages.append("@%s" % group.name) for package in ksparser.handler.packages.packageList: packages.append(package) if packages: user_data += "yum -y install %s\n" % ' '.join(packages) # skip %prep # %post user_data += ksparser.handler.scripts[1].script # remove cloud-init package and reboot user_data += 'yum -y remove cloud-init\nreboot' print user_data
def __init__(self, main_window, kickstart=False): if kickstart: self.ksparser = pykickstart.parser.KickstartParser(makeVersion()) self.storage = Blivet(ksdata=self.ksparser.handler) else: self.storage = Blivet() self.storage.reset() self.main_window = main_window
def kickstart(ks, path=settings.KS_DIR): """ return parsed pykickstart object """ ks = "%s%s" % (path, ks) ksparser = DecoratedKickstartParser(makeVersion()) ksparser.readKickstart(ks) # add the RIT stuff ritPostContents = get_rit_post() ksparser.addScript(ritPostContents, constants.KS_SCRIPT_POST) return ksparser
def __init__(self, ks_path, blacklist=None): self.ks_path = ks_path if blacklist is None: self.blacklist = [] else: self.blacklist = blacklist # create a kickstart parser from the latest version self.ksparser = KickstartParser(makeVersion()) self.yb = yum.YumBase() self._repo_problems = False
def split(self, path): """Split the kickstart given by path into elements.""" self._elements = None self._kickstart_path = path handler = makeVersion() ksparser = SplitKickstartParser(handler, valid_sections=VALID_SECTIONS_ANACONDA) try: result = ksparser.split(path) except KickstartParseError as e: raise SplitKickstartSectionParsingError(e) except KickstartError as e: raise SplitKickstartMissingIncludeError(e) self._elements = result
def __init__(self, kickstart=False): if kickstart: self.ksparser = pykickstart.parser.KickstartParser(makeVersion()) self.storage = blivet.Blivet(ksdata=self.ksparser.handler) else: self.storage = blivet.Blivet() blivet.formats.fs.NTFS._formattable = True self.storage.reset() self.storage.devicetree.populate() self.storage.devicetree.getActiveMounts() self.update_min_sizes_info()
def load_or_default(system_ks_path, ks_template): """ load system ks or default ks """ ksparser = KickstartParser(makeVersion()) try: ksparser.readKickstart(system_ks_path) except (KickstartError, IOError): log_message("Cannot read the system Kickstart at %s." % system_ks_path) try: ksparser.readKickstart(ks_template) except AttributeError: log_message("There is no KS_POSTSCRIPT_TEMPLATE specified in settings.py.", level=logging.DEBUG) except IOError: log_message("Cannot read the Kickstart template %s." % ks_template) return None return ksparser
def load_or_default(system_ks_path): """load system ks or default ks""" ksparser = KickstartParser(makeVersion()) try: ksparser.readKickstart(system_ks_path) except (KickstartError, IOError): log_message("Can't read system kickstart at {0}".format(system_ks_path)) try: ksparser.readKickstart(settings.KS_TEMPLATE) except AttributeError: log_message("There is no KS_TEMPLATE_POSTSCRIPT specified in settings.py") except IOError: log_message("Can't read kickstart template {0}".format(settings.KS_TEMPLATE)) return None return ksparser
def runTest(self): for version, command_map in control.commandMap.items(): handler = makeVersion(version) parser = KickstartParser(handler) for command_name, command_class in command_map.items(): if not issubclass(command_class, DeprecatedCommand): continue with warnings.catch_warnings(record=True): # The deprecated commands should be ignored with # a warning when they are parsed. Make sure that # they will not cause any errors. parser.readKickstartFromString(command_name)
def test_biosboot_bootloader_in_kickstart(self, mock_mountpoints, mock_devices, dbus): """Test that a biosboot bootloader shows up in the ks data.""" # set up biosboot partition biosboot_device_obj = PartitionDevice("biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = formats.get_format("biosboot") # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # initialize ksdata biosboot_blivet_obj = InstallerStorage(makeVersion()) biosboot_blivet_obj.update_ksdata() self.assertIn("part biosboot", str(biosboot_blivet_obj.ksdata))
def invalid_command_test(self): """Test invalid command or option in kickstart. Invalid command or command option in kickstart does not raise KickstartParseError because commands are not parsed in the filter. """ ks_content = """ network --device=ens3 --activate netork --device=ens5 --activate network --device=ens7 --activate network --devce=ens9 --activate """.strip() handler = makeVersion() ksparser = SplitKickstartParser(handler) result = ksparser.split_from_string(ks_content) self.assertEqual(len(result.all_elements), 4)
def test_shutdown_virt(self): """Test a kickstart with reboot instead of shutdown""" opts = DataHolder(no_virt=False, make_fsimage=True, make_pxe_live=False) ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstartFromString( "url --url=http://dl.fedoraproject.com\n" "network --bootproto=dhcp --activate\n" "repo --name=other --baseurl=http://dl.fedoraproject.com\n" "part / --size=4096\n" "reboot\n") errors = check_kickstart(ks, opts) self.assertTrue("must include shutdown when using virt" in errors[0])
def test_split_from_string_filename(self): """Test splitting kickstart supplied by string.""" valid_sections = VALID_SECTIONS_ANACONDA handler = makeVersion() ksparser = SplitKickstartParser(handler, valid_sections) kickstart_files, _output = self._kickstart_flat filename, content = kickstart_files[0] # Kickstart from string has "<MAIN>" as filename result = ksparser.split_from_string(content) for element in result.all_elements: assert element.filename == SplitKickstartParser.unknown_filename # Or the value supplied by filename optional argument result = ksparser.split_from_string(content, filename=filename) for element in result.all_elements: assert element.filename == filename
def test_biosboot_bootloader_in_kickstart(self, mock_mountpoints, mock_devices, dbus): """Test that a biosboot bootloader shows up in the ks data.""" # set up biosboot partition biosboot_device_obj = PartitionDevice("biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = formats.get_format("biosboot") # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # initialize ksdata ksdata = makeVersion() biosboot_blivet_obj = InstallerStorage() update_storage_ksdata(biosboot_blivet_obj, ksdata) self.assertIn("part biosboot", str(ksdata))
def setUp(self): self.setupModules(["_isys", "logging"]) import pyanaconda pyanaconda.anaconda_log = mock.Mock() from pykickstart.version import makeVersion from pyanaconda.flags import flags # set some things specially since we're just testing flags.testing = True # set up ksdata self.ksdata = makeVersion() from pyanaconda.packaging import Payload self.payload = Payload(self.ksdata)
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, mock_bootloader_device, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_bootloader_device.return_value = bootloader_device_obj mock_mountpoints.values.return_value = [] # initialize ksdata prepboot_blivet_obj = InstallerStorage(makeVersion()) prepboot_blivet_obj.update_ksdata() self.assertIn("part prepboot", str(prepboot_blivet_obj.ksdata))
def disk_size_simple_test(self): """Test calculating the disk size with a simple / partition""" opts = DataHolder(no_virt=True, make_fsimage=False, make_iso=False, make_pxe_live=False) ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstartFromString( "url --url=http://dl.fedoraproject.com\n" "network --bootproto=dhcp --activate\n" "repo --name=other --baseurl=http://dl.fedoraproject.com\n" "part / --size=4096\n" "shutdown\n") self.assertEqual(calculate_disk_size(opts, ks), 4098)
def test_nomethod_novirt(self): """Test a kickstart with repo and no url""" opts = DataHolder(no_virt=True, make_fsimage=False, make_pxe_live=False) ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstartFromString( "network --bootproto=dhcp --activate\n" "repo --name=other --baseurl=http://dl.fedoraproject.com\n" "part / --size=4096\n" "shutdown\n") errors = check_kickstart(ks, opts) self.assertTrue("Only url, nfs and ostreesetup" in errors[0]) self.assertTrue("repo can only be used with the url" in errors[1])
def main(): opts = parse_args() if not opts.kscfg: print(_("Need to specify a config to flatten"), file=sys.stderr) sys.exit(1) ksversion = makeVersion(opts.version) ksparser = pykickstart.parser.KickstartParser(ksversion) try: ksparser.readKickstart(opts.kscfg) except IOError as msg: print( _("Failed to read kickstart file '%(filename)s' : %(error_msg)s") % { "filename": opts.kscfg, "error_msg": msg }, file=sys.stderr) sys.exit(1) except pykickstart.errors.KickstartError as e: print( _("Failed to parse kickstart file '%(filename)s' : %(error_msg)s") % { "filename": opts.kscfg, "error_msg": e }, file=sys.stderr) sys.exit(1) if opts.output: try: f = open(opts.output, 'w') except IOError as msg: print( _("Failed to open output file '%(filename)s' : %(error_msg)s") % { "filename": opts.output, "error_msg": msg }, file=sys.stderr) sys.exit(1) else: f = sys.stdout f.write("%s" % ksparser.handler) f.close()
def displaymode_test(self): """Test a kickstart with displaymode set""" opts = DataHolder(no_virt=True, make_fsimage=False, make_pxe_live=False) ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstartFromString( "url --url=http://dl.fedoraproject.com\n" "network --bootproto=dhcp --activate\n" "repo --name=other --baseurl=http://dl.fedoraproject.com\n" "part / --size=4096\n" "shutdown\n" "graphical\n") errors = check_kickstart(ks, opts) self.assertTrue("must not set a display mode" in errors[0])
def read_kickstart(path): """Parse a kickstart file and return a KickstartParser instance. This is a simple utility function which takes a path to a kickstart file, parses it and returns a pykickstart KickstartParser instance which can be then passed to an ImageCreator constructor. If an error occurs, a CreatorError exception is thrown. """ version = ksversion.makeVersion() ks = ksparser.KickstartParser(version) try: ksfile = urlgrabber.urlgrab(path) ks.readKickstart(ksfile) # Fallback to e.args[0] is a workaround for bugs in urlgragger and pykickstart. except IOError, e: raise errors.KickstartError("Failed to read kickstart file " "'%s' : %s" % (path, e.strerror or e.args[0]))
def test_valid_sections(self): """Test setting of valid sections for the parser.""" valid_sections = VALID_SECTIONS_ANACONDA handler = makeVersion() ksparser = SplitKickstartParser(handler, valid_sections) kickstart_files, _output = self._kickstart_flat _filename, content = kickstart_files[0] returned_valid_sections = ksparser.valid_sections # valid_sections returns new list, not a reference to the internal object returned_valid_sections.append("%test") self.assertNotEqual(returned_valid_sections, ksparser.valid_sections) ksparser.valid_sections = ["%packages"] # Invalid section raises exception self.assertRaises(KickstartParseError, ksparser.split_from_string, content) # setting valid sections back to the original, the exception is gone ksparser.valid_sections = valid_sections ksparser.split_from_string(content)
def load_or_default(system_ks_path, ks_template): """ load system ks or default ks """ ksparser = KickstartParser(makeVersion()) try: ksparser.readKickstart(system_ks_path) except (KickstartError, IOError): log_message("Cannot read the system Kickstart at %s." % system_ks_path) try: ksparser.readKickstart(ks_template) except AttributeError: log_message( "There is no KS_POSTSCRIPT_TEMPLATE specified in settings.py.", level=logging.DEBUG) except IOError: log_message("Cannot read the Kickstart template %s." % ks_template) return None return ksparser
def add_repo(self, ksfile, siderepo): """ Add a repository to an existing KS file """ # read ksparser = KickstartParser(makeVersion()) ksparser.readKickstart(ksfile) #obtain the handler dump kshandlers = ksparser.handler # add a repository kshandlers.repo.repoList.extend(['repo --name="siderepo" --baseurl={0:s}\n'.format(siderepo)]) # Write a new ks file outfile = open(ksfile, 'w') outfile.write(kshandlers.__str__()) outfile.close() return
def load_or_default(system_ks_path): """load system ks or default ks""" ksparser = KickstartParser(makeVersion()) try: ksparser.readKickstart(system_ks_path) except (KickstartError, IOError): log_message( "Can't read system kickstart at {0}".format(system_ks_path)) try: ksparser.readKickstart(settings.KS_TEMPLATE) except AttributeError: log_message( "There is no KS_TEMPLATE_POSTSCRIPT specified in settings.py" ) except IOError: log_message("Can't read kickstart template {0}".format( settings.KS_TEMPLATE)) return None return ksparser
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # disable other partitioning modules dbus.return_value.Enabled = False # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_mountpoints.values.return_value = [] # set up the storage prepboot_blivet_obj = InstallerStorage() prepboot_blivet_obj.bootloader.stage1_device = bootloader_device_obj # initialize ksdata ksdata = makeVersion() update_storage_ksdata(prepboot_blivet_obj, ksdata) self.assertIn("part prepboot", str(ksdata))
def test_conflicting_commands(self): """Test conflicting commands in kickstart. Conflicting commands in kickstart do not raise KickstartParseError because commands are not parsed in the filter. """ ks_content = """ # Partitioning conflicts with autopart part /boot --fstype=xfs --onpart=vda1 part pv.100000 --size=18436 --ondisk=vda volgroup Vol00 --pesize=4096 pv.100000 logvol / --fstype=xfs --name=lv_root --vgname=Vol00 --size=15360 logvol /home --fstype=xfs --name=lv_home --vgname=Vol00 --size=1024 logvol swap --fstype=swap --name=lv_swap --vgname=Vol00 --size=2048 autopart --encrypted --passphrase=starost --type=lvm """.strip() handler = makeVersion() ksparser = SplitKickstartParser(handler) result = ksparser.split_from_string(ks_content) assert len(result.all_elements) == 7
def runTest(self): kshandler = makeVersion(DEVEL) self.assertIsNotNone(kshandler) # Did it add the commands, and is there at least one (part) that should be present? ksc = ksshell.KickstartCompleter(kshandler, {}) self.assertTrue(len(ksc.commands) > 0) self.assertIn("part", ksc.commands) # Test tab completion on 'part [TAB]' # Initialize the matches with a mocked input line ksc._init_matches("part ", 5, 5) self.assertEqual(ksc.complete("", 1), "--fstype") # Test tab completion on 'auth[TAB]' ksc._init_matches("auth", 0, 5) # Python 3.5 returns things in a different order, just make sure they are there and different self.assertIn(ksc.complete("", 1), ["auth", "authconfig", "authselect"]) self.assertIn(ksc.complete("", 2), ["auth", "authconfig", "authselect"]) self.assertNotEqual(ksc.complete("", 1), ksc.complete("", 2))
def runTest(self): for version, command_map in control.commandMap.items(): handler = makeVersion(version) parser = KickstartParser(handler) for command_name, command_class in command_map.items(): if not issubclass(command_class, DeprecatedCommand): continue if issubclass(command_class, RemovedCommand): continue with warnings.catch_warnings(record=True): # The deprecated commands should be ignored with # a warning when they are parsed. Make sure that # they will not cause any errors. with self.assertWarns(KickstartDeprecationWarning) as cm: parser.readKickstartFromString(command_name) # Check the warning message. expected = " {} command has been deprecated ".format( command_name) self.assertIn(expected, str(cm.warning))
def bootloader_append(line, kernel_append): """ Insert the kernel_append string into the --append argument :param line: The bootloader ... line :type line: str :param kernel_append: The arguments to append to the --append section :type kernel_append: str Using pykickstart to process the line is the best way to make sure it is parsed correctly, and re-assembled for inclusion into the final kickstart """ ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstartFromString(line) if ks.handler.bootloader.appendLine: ks.handler.bootloader.appendLine += " %s" % kernel_append else: ks.handler.bootloader.appendLine = kernel_append # Converting back to a string includes a comment, return just the bootloader line return str(ks.handler.bootloader).splitlines()[-1]
def main(): ## ## OPTION PROCESSING ## op = argparse.ArgumentParser() op.add_argument("-i", "--input", dest="input", help=_("a basis file to use for seeding the kickstart data (optional)")) op.add_argument("-o", "--output", dest="output", help=_("the location to write the finished kickstart file, or stdout if not given")) op.add_argument("-v", "--version", dest="version", default=DEVEL, help=_("version of kickstart syntax to validate against")) opts = op.parse_args(sys.argv[1:]) ## ## SETTING UP PYKICKSTART ## try: kshandler = makeVersion(opts.version) except KickstartVersionError: print(_("The version %s is not supported by pykickstart") % opts.version) sys.exit(1) ksparser = KickstartParser(kshandler, followIncludes=True, errorsAreFatal=False) if opts.input: try: processedFile = preprocessKickstart(opts.input) ksparser.readKickstart(processedFile) os.remove(processedFile) except KickstartError as e: # Errors should just dump you to the prompt anyway. print(_("Warning: The following error occurred when processing the input file:\n%s\n") % e) internalCommands = {".clear": ClearCommand(), ".show": ShowCommand(), ".quit": QuitCommand()} ## ## SETTING UP READLINE ## readline.parse_and_bind("tab: complete") readline.set_completer(KickstartCompleter(kshandler, internalCommands).complete) # Since everything in kickstart looks like a command line arg, we need to # remove '-' from the delimiter string. delims = readline.get_completer_delims() readline.set_completer_delims(delims.replace('-', '')) ## ## REPL ## print("Press ^D to exit.") while True: try: line = six.moves.input("ks> ") # pylint: disable=no-member except EOFError: # ^D was hit, time to quit. break except KeyboardInterrupt: # ^C was hit, time to quit. Don't be like other programs. break # All internal commands start with a ., so if that's the beginning of the # line, we need to dispatch ourselves. if line.startswith("."): words = line.split() if words[0] in internalCommands: try: internalCommands[words[0]].execute(ksparser) except EOFError: # ".quit" was typed, time to quit. break else: print(_("Internal command %s not recognized.") % words[0]) continue # Now process the line of input as if it were a kickstart file - just an # extremely short one. try: ksparser.readKickstartFromString(line) except KickstartError as e: print(e) # And finally, print the output kickstart file. if opts.output: with open(opts.output, "w") as fd: fd.write(str(ksparser.handler)) else: print("\n" + str(ksparser.handler))
#!/usr/bin/python import sys from pykickstart.parser import * from pykickstart.version import makeVersion ksparser = KickstartParser(makeVersion('RHEL7'),followIncludes=False) ksparser.readKickstart(sys.argv[1]) ksgroups = ksparser.handler.packages.groupList ksgroupnames = [group.name for group in ksgroups] for n in ksgroupnames: print n
def run(self): self.ksHandler = makeVersion() if self.file: self.parser = KickstartParser(self.ksHandler) msg = None try: self.parser.readKickstart(self.file) except (KickstartParseError, KickstartValueError) as e: msg = _("The following error was found while parsing your " "kickstart configuration:\n\n%s" % e) except KickstartError: msg = _( "The kickstart file %s could not be opened.") % self.file if msg: dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, msg) dlg.set_title(_("Error Parsing Kickstart Config")) dlg.set_position(gtk.WIN_POS_CENTER_ON_PARENT) dlg.set_modal(True) dlg.run() dlg.destroy() sys.exit(0) self.xml = xml name_tag = (_("Kickstart")) comment_tag = (_("Create a kickstart file")) self.toplevel = xml.get_widget("main_window") self.toplevel.connect("destroy", self.destroy) self.toplevel.set_icon(iconPixbuf) #bring in widgets from glade file self.options_notebook = xml.get_widget("options_notebook") self.install_radiobutton = xml.get_widget("install_radiobutton") self.category_clist = xml.get_widget("category_clist") self.open_menu = xml.get_widget("open_menu") self.preview_menu = xml.get_widget("preview_menu") self.save_menu = xml.get_widget("save_menu") self.quit_menu = xml.get_widget("quit_menu") self.about_menu = xml.get_widget("about_menu") #populate category list self.category_view = xml.get_widget("list_view") self.category_store = gtk.ListStore(gobject.TYPE_STRING) self.category_view.set_model(self.category_store) col = gtk.TreeViewColumn(_("Subsection"), gtk.CellRendererText(), text=0) col.set_sort_column_id(0) self.category_view.append_column(col) self.category_list = [(_("Basic Configuration")), (_("Installation Method")), (_("Boot Loader Options")), (_("Partition Information")), (_("Network Configuration")), (_("Authentication")), (_("Firewall Configuration")), (_("Display Configuration")), (_("Package Selection")), (_("Pre-Installation Script")), (_("Post-Installation Script"))] for item in self.category_list: iter = self.category_store.append() self.category_store.set_value(iter, 0, item) #bring in basic functions self.basic_class = basic.basic(self, xml, self.options_notebook, self.ksHandler) # Now that we've loaded the UI elements for the first active thing in the notebook, # draw it so we can display a progress bar when yum starts doing stuff. self.toplevel.show() while gtk.events_pending(): gtk.main_iteration() self.bootloader_class = bootloader.bootloader(xml, self.options_notebook, self.ksHandler) self.install_class = install.install(self, xml, self.category_store, self.category_view, self.options_notebook, self.ksHandler) self.partition_class = partition.partition(xml, self.ksHandler) self.network_class = network.network(xml, self.ksHandler) self.auth_class = auth.auth(xml, self.ksHandler) self.firewall_class = firewall.Firewall(xml, self.ksHandler) self.X_class = xconfig.xconfig(xml, self.ksHandler) self.progress_window = progressWindow.ProgressWindow(self.toplevel) self.packages_class = packages.Packages(xml, self.ksHandler, self.progress_window) self.scripts_class = scripts.scripts(xml, self.ksHandler) self.open_menu.connect("activate", self.on_activate_open) self.preview_menu.connect("activate", self.on_activate_preview_options) self.save_menu.connect("activate", self.on_activate_save_options) self.quit_menu.connect("activate", gtk.main_quit) self.about_menu.connect("activate", self.on_about_activate) self.category_view.connect("cursor_changed", self.on_list_view_row_activated) self.options_notebook.connect("switch-page", self.on_notebook_changed) #show gui self.applyKickstart() self.toplevel.show() gtk.main()
def start_build(cfg, dnflock, gitlock, branch, recipe_name, compose_type, test_mode=0): """ Start the build :param cfg: Configuration object :type cfg: ComposerConfig :param dnflock: Lock and YumBase for depsolving :type dnflock: YumLock :param recipe: The recipe to build :type recipe: str :param compose_type: The type of output to create from the recipe :type compose_type: str :returns: Unique ID for the build that can be used to track its status :rtype: str """ share_dir = cfg.get("composer", "share_dir") lib_dir = cfg.get("composer", "lib_dir") # Make sure compose_type is valid if compose_type not in compose_types(share_dir): raise RuntimeError("Invalid compose type (%s), must be one of %s" % (compose_type, compose_types(share_dir))) # Some image types (live-iso) need extra packages for composer to execute the output template with dnflock.lock: extra_pkgs = get_extra_pkgs(dnflock.dbo, share_dir, compose_type) log.debug("Extra packages needed for %s: %s", compose_type, extra_pkgs) with gitlock.lock: (commit_id, recipe) = read_recipe_and_id(gitlock.repo, branch, recipe_name) # Combine modules and packages and depsolve the list module_nver = recipe.module_nver package_nver = recipe.package_nver package_nver.extend([(name, '*') for name in extra_pkgs]) projects = sorted(set(module_nver + package_nver), key=lambda p: p[0].lower()) deps = [] log.info("depsolving %s", recipe["name"]) try: # This can possibly update repodata and reset the YumBase object. with dnflock.lock_check: (installed_size, deps) = projects_depsolve_with_size(dnflock.dbo, projects, recipe.group_names, with_core=False) except ProjectsError as e: log.error("start_build depsolve: %s", str(e)) raise RuntimeError("Problem depsolving %s: %s" % (recipe["name"], str(e))) # Read the kickstart template for this type ks_template_path = joinpaths(share_dir, "composer", compose_type) + ".ks" ks_template = open(ks_template_path, "r").read() # How much space will the packages in the default template take? ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstartFromString(ks_template + "\n%end\n") pkgs = [(name, "*") for name in ks.handler.packages.packageList] grps = [grp.name for grp in ks.handler.packages.groupList] try: with dnflock.lock: (template_size, _) = projects_depsolve_with_size( dnflock.dbo, pkgs, grps, with_core=not ks.handler.packages.nocore) except ProjectsError as e: log.error("start_build depsolve: %s", str(e)) raise RuntimeError("Problem depsolving %s: %s" % (recipe["name"], str(e))) log.debug("installed_size = %d, template_size=%d", installed_size, template_size) # Minimum LMC disk size is 1GiB, and anaconda bumps the estimated size up by 10% (which doesn't always work). installed_size = int((installed_size + template_size)) * 1.2 log.debug("/ partition size = %d", installed_size) # Create the results directory build_id = str(uuid4()) results_dir = joinpaths(lib_dir, "results", build_id) os.makedirs(results_dir) # Write the recipe commit hash commit_path = joinpaths(results_dir, "COMMIT") with open(commit_path, "w") as f: f.write(commit_id) # Write the original recipe recipe_path = joinpaths(results_dir, "blueprint.toml") with open(recipe_path, "w") as f: f.write(recipe.toml()) # Write the frozen recipe frozen_recipe = recipe.freeze(deps) recipe_path = joinpaths(results_dir, "frozen.toml") with open(recipe_path, "w") as f: f.write(frozen_recipe.toml()) # Write out the dependencies to the results dir deps_path = joinpaths(results_dir, "deps.toml") with open(deps_path, "w") as f: f.write(toml.dumps({"packages": deps})) # Save a copy of the original kickstart shutil.copy(ks_template_path, results_dir) with dnflock.lock: repos = list(dnflock.dbo.repos.iter_enabled()) if not repos: raise RuntimeError("No enabled repos, canceling build.") # Create the git rpms, if any, and return the path to the repo under results_dir gitrpm_repo = create_gitrpm_repo(results_dir, recipe) # Create the final kickstart with repos and package list ks_path = joinpaths(results_dir, "final-kickstart.ks") with open(ks_path, "w") as f: ks_url = repo_to_ks(repos[0], "url") log.debug("url = %s", ks_url) f.write('url %s\n' % ks_url) for idx, r in enumerate(repos[1:]): ks_repo = repo_to_ks(r, "baseurl") log.debug("repo composer-%s = %s", idx, ks_repo) f.write('repo --name="composer-%s" %s\n' % (idx, ks_repo)) if gitrpm_repo: log.debug("repo gitrpms = %s", gitrpm_repo) f.write('repo --name="gitrpms" --baseurl="file://%s"\n' % gitrpm_repo) # Setup the disk for booting # TODO Add GPT and UEFI boot support f.write('clearpart --all --initlabel\n') # Write the root partition and it's size in MB (rounded up) f.write('part / --size=%d\n' % ceil(installed_size / 1024**2)) # Some customizations modify the template before writing it f.write(customize_ks_template(ks_template, recipe)) for d in deps: f.write(dep_nevra(d) + "\n") # Include the rpms from the gitrpm repo directory if gitrpm_repo: for rpm in glob(os.path.join(gitrpm_repo, "*.rpm")): f.write(os.path.basename(rpm)[:-4] + "\n") f.write("%end\n") # Other customizations can be appended to the kickstart add_customizations(f, recipe) # Setup the config to pass to novirt_install log_dir = joinpaths(results_dir, "logs/") cfg_args = compose_args(compose_type) # Get the title, project, and release version from the host if not os.path.exists("/etc/os-release"): log.error( "/etc/os-release is missing, cannot determine product or release version" ) os_release = flatconfig("/etc/os-release") log.debug("os_release = %s", dict(os_release.items())) cfg_args["title"] = os_release.get("PRETTY_NAME", "") cfg_args["project"] = os_release.get("NAME", "") cfg_args["releasever"] = os_release.get("VERSION_ID", "") cfg_args["volid"] = "" cfg_args["extra_boot_args"] = get_kernel_append(recipe) cfg_args.update({ "compression": "xz", "compress_args": [], "ks": [ks_path], "logfile": log_dir, "timeout": 60, # 60 minute timeout }) with open(joinpaths(results_dir, "config.toml"), "w") as f: f.write(toml.dumps(cfg_args)) # Set the initial status open(joinpaths(results_dir, "STATUS"), "w").write("WAITING") # Set the test mode, if requested if test_mode > 0: open(joinpaths(results_dir, "TEST"), "w").write("%s" % test_mode) write_timestamp(results_dir, TS_CREATED) log.info("Adding %s (%s %s) to compose queue", build_id, recipe["name"], compose_type) os.symlink(results_dir, joinpaths(lib_dir, "queue/new/", build_id)) return build_id
spokeClass = v except TypeError: pass if not spokeClass: try: spokeClass = getattr(spokeModule, spokeClassName) except KeyError: print "%s %s could not be found in %s" % (SpokeText, spokeClassName, spokeModuleName) sys.exit(1) print "Running %s %s from %s" % (spokeText, spokeClass, spokeModule) platform = getPlatform() ksdata = makeVersion() storage = Storage(data=ksdata, platform=platform) storage.reset() instclass = DefaultInstall() payload = YumPayload(ksdata) payload.setup(storage) spoke = spokeClass(ksdata, storage, payload, instclass) if hasattr(spoke, "register_event_cb"): spoke.register_event_cb("continue", lambda: Gtk.main_quit()) spoke.register_event_cb("quit", lambda: Gtk.main_quit()) spoke.initialize() if not spoke.showable: print "This %s is not showable, but I'll continue anyway." % spokeText
def get_parser(self): """Command sequence tests need a fresh parser for each test""" handler = makeVersion(self.version) return KickstartParser(handler)
def _parse_kickstart(self, path): """ Loads the template with information from the supplied kickstart path. Kickstarts currently populate the meta tag, similar to the following: 'kickstart': { 'platform': '', 'version': 'DEVEL', 'language': 'en_US.UTF-8', 'keyboard': 'us' 'timezone': 'US/Eastern' 'auth': '--useshadow --passalgo=sha512 'selinux': '--enforcing' 'firewall': '--enabled --service=mdns 'xconfig': '--startxonboot' 'part': '/ --size 4096 --fstype ext4', 'services': '--enabled=NetworkManager,ModemManager --disabled=network,sshd' 'commands': [ ], 'scripts': [ ] 'packages': [ ] }, } Args: path: Path to existing kickstart file. Returns: Nothing. Raises: IOError: An error occurred accessing the kickstart file. """ ksversion = makeVersion(DEVEL) ksparser = pykickstart.parser.KickstartParser(ksversion) try: ksparser.readKickstart(path) except IOError as msg: print("Failed to read kickstart file '%(filename)s' : %(error_msg)s" % {"filename": path, "error_msg": msg}, file=sys.stderr) return except pykickstart.errors.KickstartError as e: print("Failed to parse kickstart file '%(filename)s' : %(error_msg)s" % {"filename": path, "error_msg": e}, file=sys.stderr) return handler = ksparser.handler meta = {} if handler.platform: meta['platform'] = handler.platform meta['version'] = versionToString(handler.version) lst = list(handler._writeOrder.keys()) lst.sort() if len(lst): meta['commands'] = [] for prio in lst: for c in handler._writeOrder[prio]: # we don't store null commands (why pykickstart? why?) if c.currentCmd == '': continue elif c.currentCmd == 'repo': for r in c.__str__().split('\n'): # ignore blank lines if len(r.strip()) == 0: continue self._repos.add(Repository(r)) else: meta['commands'].append({ 'command': c.currentCmd, 'priority': c.writePriority, 'data': c.__str__() }) # parse pykickstart script if len(handler.scripts): meta['scripts'] = [] for s in handler.scripts: meta['scripts'].append({ 'data': s.script, 'type': s.type, 'interp': s.interp, 'in_chroot': s.inChroot, 'line_no': s.lineno, 'error_on_fail': s.errorOnFail, }) # parse pykickstart packages packages = handler.packages meta['packages'] = { 'default': packages.default, 'exclude_docs': packages.excludeDocs, 'no_base': not packages.addBase, 'no_core': packages.nocore, 'handle_missing': (packages.handleMissing == pykickstart.constants.KS_MISSING_IGNORE), 'install_langs': packages.instLangs, 'multi_lib': packages.multiLib } if not packages.default: if packages.environment: meta['package']['environment'] = "@^{0}".format(packages.environment) grps = packages.groupList grps.sort() for g in grps: self._packages.add(Package({'n': g.__str__(), 'z': 1})) pkgs = packages.packageList pkgs.sort() for p in pkgs: self._packages.add(Package({'n': p.__str__(), 'z': 1})) grps = packages.excludedGroupList grps.sort() for g in grps: self._packages.add(Package({'n': g.__str__(), 'z': 0})) pkgs = packages.excludedList pkgs.sort() for p in pkgs: self._packages.add(Package({'n': p.__str__(), 'z': 0})) self._meta['kickstart'] = meta
def test_simple_split_kickstart_parser(self): """This test should demonstrate usage and output of the parser.""" ks_content = """ %pre echo PRE %end network --device=ens3 --activate network --device=ens4 --activate %addon pony --fly=True %end firewall --enabled %addon scorched --planet=Earth nuke %end %post --nochroot --interpreter /usr/bin/bash echo POST1 %end """.lstrip() element1 = ("pre", "%pre\necho PRE\n%end\n", 1) element2 = ("network", "network --device=ens3 --activate\n", 4) element3 = ("network", "network --device=ens4 --activate\n", 5) element4 = ("pony", "%addon pony --fly=True\n%end\n", 6) element5 = ("firewall", "firewall --enabled\n", 8) element6 = ("scorched", "%addon scorched --planet=Earth\nnuke\n%end\n", 9) element7 = ( "post", "%post --nochroot --interpreter /usr/bin/bash\necho POST1\n%end\n", 12) expected_result = [ element1, element2, element3, element4, element5, element6, element7 ] filename = "ks.test.simple.cfg" valid_sections = VALID_SECTIONS_ANACONDA handler = makeVersion() ksparser = SplitKickstartParser(handler, valid_sections) # Reading kickstart from file with open(filename, "w") as f: f.write(ks_content) result = ksparser.split(filename) os.remove(filename) for element, expected in zip(result.all_elements, expected_result): assert element.filename == filename assert (element.name, element.content, element.lineno) == expected assert result.get_kickstart_from_elements( result.all_elements) == ks_content # Reading kickstart from string filename = ksparser.unknown_filename result = ksparser.split_from_string(ks_content) for element, expected in zip(result.all_elements, expected_result): assert element.filename == filename assert (element.name, element.content, element.lineno) == expected assert result.get_kickstart_from_elements( result.all_elements) == ks_content # Reading kickstart from string supplying filename filename = "MY_FILENAME" result = ksparser.split_from_string(ks_content, filename=filename) for element, expected in zip(result.all_elements, expected_result): assert element.filename == filename assert (element.name, element.content, element.lineno) == expected # Dumping kickstart assert result.get_kickstart_from_elements( result.all_elements) == ks_content
def handler(self): if self._handler is None: self._handler = makeVersion(self.version) return self._handler
def main(argv=None): op = argparse.ArgumentParser() op.add_argument("-f", "--from", dest="f") op.add_argument("-t", "--to", dest="t") op.add_argument("-l", "--listversions", dest="listversions", action="store_true", default=False, help=_("list the available versions of kickstart syntax")) opts = op.parse_args(argv) if opts.listversions: for key in sorted(versionMap.keys()): print(key) return 0 if not opts.f or not opts.t: print(_("You must specify two syntax versions.")) return 1 try: fromHandler = makeVersion(opts.f) toHandler = makeVersion(opts.t) except KickstartVersionError as exn: print(_("The version %s is not supported by pykickstart") % exn) return 1 fromCmdSet = getCommandSet(fromHandler) toCmdSet = getCommandSet(toHandler) bothSet = fromCmdSet & toCmdSet print(_("The following commands were removed in %s:") % opts.t) printList(sorted(fromCmdSet - toCmdSet)) print(_("The following commands were deprecated in %s:") % opts.t) printList(sorted([cmd for cmd in bothSet if isinstance(toHandler.commands[cmd], DeprecatedCommand)])) print(_("The following commands were added in %s:") % opts.t) printList(sorted(toCmdSet - fromCmdSet)) for cmd in sorted(bothSet): newOptList = [] deprecatedOptList = [] removedOptList = [] fromCmd = fromHandler.commands[cmd] toCmd = toHandler.commands[cmd] if not hasattr(fromCmd, "op") or not hasattr(toCmd, "op"): continue fromOpt = fromCmd.op._actions toOpt = toCmd.op._actions newOptList = getOptSet(toOpt) - getOptSet(fromOpt) removedOptList = getOptSet(fromOpt) - getOptSet(toOpt) deprecatedOptList = getOptSet([cmd for cmd in toOpt if cmd.deprecated]) if len(newOptList) > 0: print(_("The following options were added to the %(command_name)s command in %(version)s:") % {"command_name": cmd, "version": opts.t}) printList(sorted(newOptList)) if len(deprecatedOptList) > 0: print(_("The following options were deprecated from the %(command_name)s command in %(version)s:") % {"command_name": cmd, "version": opts.t}) printList(sorted(deprecatedOptList)) if len(removedOptList) > 0: print(_("The following options were removed from the %(command_name)s command in %(version)s:") % {"command_name": cmd, "version": opts.t}) printList(sorted(removedOptList)) return 0
def execute(self, parser): version = parser.version parser.handler = makeVersion(version)
def run_creator(opts, cancel_func=None): """Run the image creator process :param opts: Commandline options to control the process :type opts: Either a DataHolder or ArgumentParser :param cancel_func: Function that returns True to cancel build :type cancel_func: function :returns: The result directory and the disk image path. :rtype: Tuple of str This function takes the opts arguments and creates the selected output image. See the cmdline --help for livemedia-creator for the possible options (Yes, this is not ideal, but we can fix that later) """ result_dir = None # Parse the kickstart if opts.ks: ks_version = makeVersion() ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False) ks.readKickstart(opts.ks[0]) # live iso usually needs dracut-live so warn the user if it is missing if opts.ks and opts.make_iso: if "dracut-live" not in ks.handler.packages.packageList: log.error("dracut-live package is missing from the kickstart.") raise RuntimeError( "dracut-live package is missing from the kickstart.") # Make the disk or filesystem image if not opts.disk_image and not opts.fs_image: if not opts.ks: raise RuntimeError("Image creation requires a kickstart file") # Check the kickstart for problems errors = check_kickstart(ks, opts) if errors: list(log.error(e) for e in errors) raise RuntimeError("\n".join(errors)) # Make the image. Output of this is either a partitioned disk image or a fsimage try: disk_img = make_image(opts, ks, cancel_func=cancel_func) except InstallError as e: log.error("ERROR: Image creation failed: %s", e) raise RuntimeError("Image creation failed: %s" % e) if opts.image_only: return (result_dir, disk_img) if opts.make_iso: work_dir = tempfile.mkdtemp(prefix="lmc-work-") log.info("working dir is %s", work_dir) if (opts.fs_image or opts.no_virt) and not opts.disk_image: # Create iso from a filesystem image disk_img = opts.fs_image or disk_img if not make_squashfs(opts, disk_img, work_dir): log.error("squashfs.img creation failed") raise RuntimeError("squashfs.img creation failed") if cancel_func and cancel_func(): raise RuntimeError("ISO creation canceled") with Mount(disk_img, opts="loop") as mount_dir: result_dir = make_livecd(opts, mount_dir, work_dir) else: # Create iso from a partitioned disk image disk_img = opts.disk_image or disk_img with PartitionMount(disk_img) as img_mount: if img_mount and img_mount.mount_dir: make_runtime(opts, img_mount.mount_dir, work_dir, calculate_disk_size(opts, ks) / 1024.0) result_dir = make_livecd(opts, img_mount.mount_dir, work_dir) # --iso-only removes the extra build artifacts, keeping only the boot.iso if opts.iso_only and result_dir: boot_iso = joinpaths(result_dir, "images/boot.iso") if not os.path.exists(boot_iso): log.error("%s is missing, skipping --iso-only.", boot_iso) else: iso_dir = tempfile.mkdtemp(prefix="lmc-result-") dest_file = joinpaths(iso_dir, opts.iso_name or "boot.iso") shutil.move(boot_iso, dest_file) shutil.rmtree(result_dir) result_dir = iso_dir # cleanup the mess # cleanup work_dir? if disk_img and not (opts.keep_image or opts.disk_image or opts.fs_image): os.unlink(disk_img) log.info("Disk image erased") disk_img = None elif opts.make_appliance: if not opts.ks: networks = [] else: networks = ks.handler.network.network make_appliance(opts.disk_image or disk_img, opts.app_name, opts.app_template, opts.app_file, networks, opts.ram, opts.vcpus or 1, opts.arch, opts.title, opts.project, opts.releasever) elif opts.make_pxe_live: work_dir = tempfile.mkdtemp(prefix="lmc-work-") log.info("working dir is %s", work_dir) disk_img = opts.fs_image or opts.disk_image or disk_img log.debug("disk image is %s", disk_img) result_dir = make_live_images(opts, work_dir, disk_img) if result_dir is None: log.error("Creating PXE live image failed.") raise RuntimeError("Creating PXE live image failed.") if opts.result_dir != opts.tmp and result_dir: copytree(result_dir, opts.result_dir, preserve=False) shutil.rmtree(result_dir) result_dir = None return (result_dir, disk_img)
help=_("list the available versions of kickstart syntax")) opts = op.parse_args(sys.argv[1:]) if opts.listversions: for key in sorted(versionMap.keys()): print(key) sys.exit(1) if not opts.f or not opts.t: print(_("You must specify two syntax versions.")) sys.exit(1) try: fromHandler = makeVersion(opts.f) toHandler = makeVersion(opts.t) except KickstartVersionError as exn: print(_("The version %s is not supported by pykickstart") % exn) sys.exit(1) fromCmdSet = getCommandSet(fromHandler) toCmdSet = getCommandSet(toHandler) bothSet = fromCmdSet & toCmdSet print(_("The following commands were removed in %s:") % opts.t) printList(sorted(fromCmdSet - toCmdSet)) print(_("The following commands were deprecated in %s:") % opts.t) printList(sorted([cmd for cmd in bothSet if isinstance(toHandler.commands[cmd], DeprecatedCommand)]))
def main(argv): op = argparse.ArgumentParser(usage="%(prog)s [options] ksfile", add_help=False) op.add_argument("ksfile", nargs="?", help=_("filename or URL to read from")) op.add_argument("-e", "--firsterror", dest="firsterror", action="store_true", default=False, help=_("halt after the first error or warning")) op.add_argument("-i", "--followincludes", dest="followincludes", action="store_true", default=False, help=_("parse include files when %%include is seen")) op.add_argument("-l", "--listversions", dest="listversions", action="store_true", default=False, help=_("list the available versions of kickstart syntax")) op.add_argument("-v", "--version", dest="version", default=DEVEL, help=_("version of kickstart syntax to validate against")) op.add_argument("-h", "--help", dest="help", action="store_true", default=False, help=_("show this help message and exit")) opts = op.parse_args(argv) # parse --help manually b/c we don't want to sys.exit before the # tests have finished if opts.help: return (0, op.format_help().split("\n")) if opts.listversions: versions = [] for key in sorted(versionMap.keys()): versions.append(key) return (0, versions) if not opts.ksfile: return (1, op.format_usage().split("\n")) destdir = tempfile.mkdtemp("", "ksvalidator-tmp-", "/tmp") try: f = load_to_file(opts.ksfile, "%s/ks.cfg" % destdir) except KickstartError as e: return (cleanup(destdir), [_("Error reading %(filename)s:\n%(version)s") % {"filename": opts.ksfile, "version": e}]) try: handler = makeVersion(opts.version) except KickstartVersionError: return (cleanup(destdir), [_("The version %s is not supported by pykickstart") % opts.version]) ksparser = KickstartParser(handler, followIncludes=opts.followincludes, errorsAreFatal=opts.firsterror) # turn kickstart parse warnings into errors warnings.filterwarnings(action="error", category=KickstartParseWarning) processedFile = None try: processedFile = preprocessKickstart(f) ksparser.readKickstart(processedFile) return (cleanup(destdir, processedFile, exitval=ksparser.errorsCount), []) except KickstartDeprecationWarning as err: return (cleanup(destdir, processedFile), [_("File uses a deprecated option or command.\n%s") % err]) except KickstartParseError as err: return (cleanup(destdir, processedFile), [str(err)]) except KickstartError: return (cleanup(destdir, processedFile), [_("General kickstart error in input file")]) except Exception as e: return (cleanup(destdir, processedFile), [_("General error in input file: %s") % e])
from pykickstart.parser import * from pykickstart.version import makeVersion ksparser = KickstartParser(makeVersion()) ksparser.readKickstart("ks.cfg")
def to_kickstart(self): """ Represent the template as a kickstart file. Args: None Returns: Kickstart formatted file. """ ksversion = makeVersion(DEVEL) ksparser = pykickstart.parser.KickstartParser(ksversion) handler = ksparser.handler packages = handler.packages if 'kickstart' in self._meta: # populate general # populate commands if 'commands' in self._meta['kickstart']: for c in self._meta['kickstart']['commands']: ksparser.readKickstartFromString(c['data'], reset=False) # populate scripts if 'scripts' in self._meta['kickstart']: for s in self._meta['kickstart']['scripts']: handler.scripts.append( pykickstart.parser.Script(s['data'], interp=s['interp'], inChroot=s['in_chroot'], type=s['type'], lineno=s['line_no'], errorOnFail=s['error_on_fail']) ) # populate general package parameters if 'packages' in self._meta['kickstart']: mp = self._meta['kickstart']['packages'] if 'default' in mp: packages.default = mp['default'] if 'exclude_docs' in mp: packages.excludeDocs = mp['exclude_docs'] if 'no_base' in mp: packages.addBase = not mp['no_base'] if 'no_core' in mp: packages.nocore = mp['no_core'] # if 'handle_missing' in mp: # packages.handleMissing = pykickstart.constants.KS_MISSING_IGNORE if 'install_langs' in mp: packages.instLangs = mp['install_langs'] if 'multi_lib' in mp: packages.multiLib = mp['multi_lib'] # populate repos (technically commands) for r in self.repos: ksparser.readKickstartFromString(r.to_kickstart(), reset=False) # process packages for p in self.packages: if p.included(): packages.packageList.append(p.name) else: packages.excludedList.append(p.name) template = ('# Canvas generated template - {1}\n' '# UUID: {0}\n' '# Author: {2}\n' '# Title: {3}\n' '# Description:\n' "# {4}\n\n").format( self._uuid, self._name, self._user, self._title, self._description ) template += ksparser.handler.__str__() return template
def main(argv): op = argparse.ArgumentParser(usage="%(prog)s [options] ksfile", add_help=False) op.add_argument("ksfile", nargs="?", help=_("filename or URL to read from")) op.add_argument("-e", "--firsterror", dest="firsterror", action="store_true", default=False, help=_("halt after the first error or warning")) op.add_argument("-i", "--followincludes", dest="followincludes", action="store_true", default=False, help=_("parse include files when %%include is seen")) op.add_argument("-l", "--listversions", dest="listversions", action="store_true", default=False, help=_("list the available versions of kickstart syntax")) op.add_argument("-v", "--version", dest="version", default=DEVEL, help=_("version of kickstart syntax to validate against")) op.add_argument("-h", "--help", dest="help", action="store_true", default=False, help=_("show this help message and exit")) opts = op.parse_args(argv) # parse --help manually b/c we don't want to sys.exit before the # tests have finished if opts.help: return (0, op.format_help().split("\n")) if opts.listversions: versions = [] for key in sorted(versionMap.keys()): versions.append(key) return (0, versions) if not opts.ksfile: return (1, op.format_usage().split("\n")) destdir = tempfile.mkdtemp("", "ksvalidator-tmp-", "/tmp") try: f = load_to_file(opts.ksfile, "%s/ks.cfg" % destdir) except KickstartError as e: return (cleanup(destdir), [_("Error reading %(filename)s:\n%(version)s") % {"filename": opts.ksfile, "version": e}]) try: handler = makeVersion(opts.version) except KickstartVersionError: return (cleanup(destdir), [_("The version %s is not supported by pykickstart") % opts.version]) ksparser = KickstartParser(handler, followIncludes=opts.followincludes, errorsAreFatal=opts.firsterror) # turn DeprecationWarnings into errors warnings.filterwarnings("error") processedFile = None try: processedFile = preprocessKickstart(f) ksparser.readKickstart(processedFile) return (cleanup(destdir, processedFile, exitval=ksparser.errorsCount), []) except DeprecationWarning as err: return (cleanup(destdir, processedFile), [_("File uses a deprecated option or command.\n%s") % err]) except KickstartParseError as err: return (cleanup(destdir, processedFile), [str(err)]) except KickstartError: return (cleanup(destdir, processedFile), [_("General kickstart error in input file")]) except Exception as e: return (cleanup(destdir, processedFile), [_("General error in input file: %s") % e])
def on_activate_open(self, *args): fs = gtk.FileChooserDialog(action=gtk.FILE_CHOOSER_ACTION_OPEN, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) fs.set_default_size(-1, -1) fs.set_position(gtk.WIN_POS_CENTER_ON_PARENT) fs.set_transient_for(self.toplevel) result = fs.run() file = fs.get_filename() if result == gtk.RESPONSE_OK: if os.access(file, os.R_OK) == 1: self.ksHandler = makeVersion() self.parser = KickstartParser(self.ksHandler) msg = None try: self.parser.readKickstart(file) except (KickstartParseError, KickstartValueError) as e: msg = _("The following error was found while parsing your " "kickstart configuration:\n\n%s" % e) except KickstartError: msg = _( "The kickstart file %s could not be opened.") % file if msg: dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, msg) dlg.set_title(_("Error Parsing Kickstart Config")) dlg.set_position(gtk.WIN_POS_CENTER_ON_PARENT) dlg.set_modal(True) dlg.run() dlg.destroy() fs.destroy() return # Refresh ksdata pointers in every subclass for the new # data we loaded in from the file. for cl in [ self.basic_class, self.bootloader_class, self.install_class, self.partition_class, self.network_class, self.auth_class, self.X_class, self.firewall_class, self.packages_class, self.scripts_class ]: cl.updateKS(self.ksHandler) self.applyKickstart() self.toplevel.show() else: dlg = gtk.MessageDialog( None, 0, gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, (_("The file \"%s\" cannot be accessed.")) % file) dlg.set_position(gtk.WIN_POS_CENTER_ON_PARENT) dlg.set_icon(iconPixbuf) dlg.run() dlg.destroy() fs.destroy()