Mini Shell
"""
Utilities for managing kickstart
.. versionadded:: 2015.8.0
"""
import argparse
import shlex
import salt.utils.files
import salt.utils.yaml
def clean_args(args):
"""
Cleans up the args that weren't passed in
"""
for arg in list(args):
if not args[arg]:
del args[arg]
return args
def parse_auth(rule):
"""
Parses the auth/authconfig line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
noargs = (
"back",
"test",
"nostart",
"kickstart",
"probe",
"enablecache",
"disablecache",
"disablenis",
"enableshadow",
"disableshadow",
"enablemd5",
"disablemd5",
"enableldap",
"enableldapauth",
"enableldaptls",
"disableldap",
"disableldapauth",
"enablekrb5kdcdns",
"disablekrb5kdcdns",
"enablekrb5realmdns",
"disablekrb5realmdns",
"disablekrb5",
"disablehe-siod",
"enablesmbauth",
"disablesmbauth",
"enablewinbind",
"enablewinbindauth",
"disablewinbind",
"disablewinbindauth",
"enablewinbindusedefaultdomain",
"disablewinbindusedefaultdomain",
"enablewins",
"disablewins",
)
for arg in noargs:
parser.add_argument(f"--{arg}", dest=arg, action="store_true")
parser.add_argument("--enablenis", dest="enablenis", action="store")
parser.add_argument("--hesiodrhs", dest="hesiodrhs", action="store")
parser.add_argument("--krb5adminserver", dest="krb5adminserver", action="append")
parser.add_argument("--krb5kdc", dest="krb5kdc", action="append")
parser.add_argument("--ldapbasedn", dest="ldapbasedn", action="store")
parser.add_argument("--ldapserver", dest="ldapserver", action="append")
parser.add_argument("--nisserver", dest="nisserver", action="append")
parser.add_argument("--passalgo", dest="passalgo", action="store")
parser.add_argument("--smbidmapgid", dest="smbidmapgid", action="store")
parser.add_argument("--smbidmapuid", dest="smbidmapuid", action="store")
parser.add_argument("--smbrealm", dest="smbrealm", action="store")
parser.add_argument(
"--smbsecurity",
dest="smbsecurity",
action="store",
choices=["user", "server", "domain", "dns"],
)
parser.add_argument("--smbservers", dest="smbservers", action="store")
parser.add_argument("--smbworkgroup", dest="smbworkgroup", action="store")
parser.add_argument("--winbindjoin", dest="winbindjoin", action="store")
parser.add_argument("--winbindseparator", dest="winbindseparator", action="store")
parser.add_argument(
"--winbindtemplatehomedir", dest="winbindtemplatehomedir", action="store"
)
parser.add_argument(
"--winbindtemplateprimarygroup",
dest="winbindtemplateprimarygroup",
action="store",
)
parser.add_argument(
"--winbindtemplateshell", dest="winbindtemplateshell", action="store"
)
parser.add_argument("--enablekrb5", dest="enablekrb5", action="store_true")
if "--enablekrb5" in rules:
parser.add_argument(
"--krb5realm", dest="krb5realm", action="store", required=True
)
parser.add_argument("--enablehesiod", dest="enablehesiod", action="store_true")
if "--enablehesiod" in rules:
parser.add_argument(
"--hesiodlhs", dest="hesiodlhs", action="store", required=True
)
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_autopart(rule):
"""
Parse the autopart line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--type", dest="type", action="store")
parser.add_argument("--encrypted", dest="encrypted", action="store_true")
parser.add_argument("--passphrase", dest="passphrase", action="store")
parser.add_argument("--escrowcert", dest="escrowcert", action="store")
parser.add_argument("--backuppassphrase", dest="backuppassphrase", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_autostep(rule):
"""
Parse the autostep line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--autoscreenshot", dest="autoscreenshot", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_bootloader(rule):
"""
Parse the bootloader line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--append", dest="append", action="store")
parser.add_argument("--driveorder", dest="driveorder", action="store")
parser.add_argument("--location", dest="location", action="store")
parser.add_argument("--password", dest="password", action="store")
parser.add_argument("--md5pass", dest="md5pass", action="store")
parser.add_argument("--upgrade", dest="upgrade", action="store_true")
parser.add_argument("--timeout", dest="timeout", action="store")
parser.add_argument("--boot-drive", dest="bootdrive", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_btrfs(rule):
"""
Parse the btrfs line
TODO: finish up the weird parsing on this one
http://fedoraproject.org/wiki/Anaconda/Kickstart#btrfs
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--data", dest="data", action="store")
parser.add_argument("--metadata", dest="metadata", action="store")
parser.add_argument("--label", dest="label", action="store")
parser.add_argument("--noformat", dest="noformat", action="store_true")
parser.add_argument("--useexisting", dest="useexisting", action="store_true")
parser.add_argument("--subvol", dest="subvol", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_clearpart(rule):
"""
Parse the clearpart line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--all", dest="all", action="store_true")
parser.add_argument("--drives", dest="drives", action="store")
parser.add_argument("--init_label", dest="init_label", action="store_true")
parser.add_argument("--linux", dest="linux", action="store_true")
parser.add_argument("--none", dest="none", action="store_true")
parser.add_argument("--initlabel", dest="init_label", action="store_true")
parser.add_argument("--list", dest="list", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_device(rule):
"""
Parse the device line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
modulename = rules.pop(0)
parser.add_argument("--opts", dest="opts", action="store")
args = clean_args(vars(parser.parse_args(rules)))
args["modulename"] = modulename
parser = None
return args
def parse_dmraid(rule):
"""
Parse the dmraid line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--dev", dest="dev", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_driverdisk(rule):
"""
Parse the driverdisk line
"""
if "--" not in rule:
return {"partition": rule}
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--source", dest="source", action="store")
parser.add_argument("--biospart", dest="biospart", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_firewall(rule):
"""
Parse the firewall line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--enable", "--enabled", dest="enable", action="store_true")
parser.add_argument("--disable", "--disabled", dest="disable", action="store_true")
parser.add_argument("--port", dest="port", action="store")
parser.add_argument("--service", dest="service", action="store")
parser.add_argument("--ssh", dest="ssh", action="store_true")
parser.add_argument("--smtp", dest="smtp", action="store_true")
parser.add_argument("--http", dest="http", action="store_true")
parser.add_argument("--ftp", dest="ftp", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_firstboot(rule):
"""
Parse the firstboot line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--enable", "--enabled", dest="enable", action="store_true")
parser.add_argument("--disable", "--disabled", dest="disable", action="store_true")
parser.add_argument("--reconfig", dest="reconfig", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_group(rule):
"""
Parse the group line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--gid", dest="gid", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_harddrive(rule):
"""
Parse the harddrive line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--biospart", dest="biospart", action="store")
parser.add_argument("--partition", dest="partition", action="store")
parser.add_argument("--dir", dest="dir", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_ignoredisk(rule):
"""
Parse the ignoredisk line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--drives", dest="drives", action="store")
parser.add_argument("--only-use", dest="only-use", action="store")
parser.add_argument("--interactive", dest="interactive", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_iscsi(rule):
"""
Parse the iscsi line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--ipaddr", dest="ipaddr", action="store")
parser.add_argument("--port", dest="port", action="store")
parser.add_argument("--target", dest="target", action="store")
parser.add_argument("--iface", dest="iface", action="store")
parser.add_argument("--user", dest="user", action="store")
parser.add_argument("--password", dest="password", action="store")
parser.add_argument("--reverse-user", dest="reverse-user", action="store")
parser.add_argument("--reverse-password", dest="reverse-password", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_iscsiname(rule):
"""
Parse the iscsiname line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
# parser.add_argument('iqn')
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_keyboard(rule):
"""
Parse the keyboard line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--vckeymap", dest="vckeymap", action="store")
parser.add_argument("--xlayouts", dest="xlayouts", action="store")
parser.add_argument("--switch", dest="switch", action="store")
parser.add_argument("keyboard")
args = clean_args(vars(parser.parse_args(rules)))
if "keyboard" in args and "xlayouts" not in args:
args["xlayouts"] = args["keyboard"]
parser = None
return args
def parse_lang(rule):
"""
Parse the lang line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("lang")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_logvol(rule):
"""
Parse the logvol line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("mntpoint")
parser.add_argument("--noformat", dest="noformat", action="store_true")
parser.add_argument("--useexisting", dest="useexisting", action="store_true")
parser.add_argument("--fstype", dest="fstype", action="store")
parser.add_argument("--fsoptions", dest="fsoptions", action="store")
parser.add_argument("--grow", dest="grow", action="store_true")
parser.add_argument("--maxsize", dest="maxsize", action="store")
parser.add_argument("--recommended", dest="recommended", action="store_true")
parser.add_argument("--percent", dest="percent", action="store_true")
parser.add_argument("--encrypted", dest="encrypted", action="store_true")
parser.add_argument("--passphrase", dest="passphrase", action="store")
parser.add_argument("--escrowcert", dest="escrowcert", action="store")
parser.add_argument(
"--backuppassphrase", dest="backuppassphrase", action="store_true"
)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--vgname", dest="vgname", action="store")
parser.add_argument("--size", dest="size", action="store")
parser.add_argument("--label", dest="label", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_logging(rule):
"""
Parse the logging line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--host", dest="host", action="store")
parser.add_argument("--port", dest="port", action="store")
parser.add_argument(
"--level",
dest="level",
action="store",
choices=["debug", "info", "warning", "error", "critical"],
)
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_monitor(rule):
"""
Parse the monitor line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--hsync", dest="hsync", action="store")
parser.add_argument("--monitor", dest="monitor", action="store")
parser.add_argument("--noprobe", dest="noprobe", action="store_true")
parser.add_argument("--vsync", dest="vsync", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_multipath(rule):
"""
Parse the multipath line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--device", dest="device", action="store")
parser.add_argument("--rule", dest="rule", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_network(rule):
"""
Parse the network line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument(
"--bootproto",
dest="bootproto",
action="store",
choices=["dhcp", "bootp", "static", "ibft"],
)
parser.add_argument("--device", dest="device", action="store")
parser.add_argument("--ip", dest="ip", action="store")
parser.add_argument("--ipv6", dest="ipv6", action="store")
parser.add_argument("--gateway", dest="gateway", action="store")
parser.add_argument("--nodefroute", dest="nodefroute", action="store_true")
parser.add_argument("--nameserver", dest="nameserver", action="store")
parser.add_argument("--nodns", dest="nodns", action="store_true")
parser.add_argument("--netmask", dest="netmask", action="store")
parser.add_argument("--hostname", dest="hostname", action="store")
parser.add_argument("--ethtool", dest="ethtool", action="store")
parser.add_argument("--essid", dest="essid", action="store")
parser.add_argument("--wepkey", dest="wepkey", action="store")
parser.add_argument("--wpakey", dest="wpakey", action="store")
parser.add_argument("--onboot", dest="onboot", action="store")
parser.add_argument("--dhcpclass", dest="dhcpclass", action="store")
parser.add_argument("--mtu", dest="mtu", action="store")
parser.add_argument("--noipv4", dest="noipv4", action="store_true")
parser.add_argument("--noipv6", dest="noipv6", action="store_true")
parser.add_argument("--activate", dest="activate", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_nfs(rule):
"""
Parse the nfs line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--server", dest="server", action="store")
parser.add_argument("--dir", dest="dir", action="store")
parser.add_argument("--opts", dest="opts", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_partition(rule):
"""
Parse the partition line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("mntpoint")
parser.add_argument("--size", dest="size", action="store")
parser.add_argument("--grow", dest="grow", action="store_true")
parser.add_argument("--maxsize", dest="maxsize", action="store")
parser.add_argument("--noformat", dest="noformat", action="store_true")
parser.add_argument("--onpart", "--usepart", dest="onpart", action="store")
parser.add_argument("--ondisk", "--ondrive", dest="ondisk", action="store")
parser.add_argument("--asprimary", dest="asprimary", action="store_true")
parser.add_argument("--fsprofile", dest="fsprofile", action="store")
parser.add_argument("--fstype", dest="fstype", action="store")
parser.add_argument("--fsoptions", dest="fsoptions", action="store")
parser.add_argument("--label", dest="label", action="store")
parser.add_argument("--recommended", dest="recommended", action="store_true")
parser.add_argument("--onbiosdisk", dest="onbiosdisk", action="store")
parser.add_argument("--encrypted", dest="encrypted", action="store_true")
parser.add_argument("--passphrase", dest="passphrase", action="store")
parser.add_argument("--escrowcert", dest="escrowcert", action="store")
parser.add_argument("--backupphrase", dest="backupphrase", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_raid(rule):
"""
Parse the raid line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
partitions = []
newrules = []
for count, rule in enumerate(rules):
if count == 0:
newrules.append(rule)
continue
elif rule.startswith("--"):
newrules.append(rule)
continue
else:
partitions.append(rule)
rules = newrules
parser.add_argument("mntpoint")
parser.add_argument("--level", dest="level", action="store")
parser.add_argument("--device", dest="device", action="store")
parser.add_argument("--spares", dest="spares", action="store")
parser.add_argument("--fstype", dest="fstype", action="store")
parser.add_argument("--fsoptions", dest="fsoptions", action="store")
parser.add_argument("--label", dest="label", action="store")
parser.add_argument("--noformat", dest="noformat", action="store_true")
parser.add_argument("--useexisting", dest="useexisting", action="store_true")
parser.add_argument("--encrypted", dest="encrypted", action="store_true")
parser.add_argument("--passphrase", dest="passphrase", action="store")
parser.add_argument("--escrowcert", dest="escrowcert", action="store")
parser.add_argument("--backuppassphrase", dest="backuppassphrase", action="store")
args = clean_args(vars(parser.parse_args(rules)))
if partitions:
args["partitions"] = partitions
parser = None
return args
def parse_reboot(rule):
"""
Parse the reboot line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--eject", dest="eject", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_repo(rule):
"""
Parse the repo line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--baseurl", dest="baseurl", action="store")
parser.add_argument("--mirrorlist", dest="mirrorlist", action="store")
parser.add_argument("--cost", dest="cost", action="store")
parser.add_argument("--excludepkgs", dest="excludepkgs", action="store")
parser.add_argument("--includepkgs", dest="includepkgs", action="store")
parser.add_argument("--proxy", dest="proxy", action="store")
parser.add_argument("--ignoregroups", dest="ignoregroups", action="store")
parser.add_argument("--noverifyssl", dest="noverifyssl", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_rescue(rule):
"""
Parse the rescue line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--nomount", dest="nomount", action="store_true")
parser.add_argument("--romount", dest="romount", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_rootpw(rule):
"""
Parse the rootpw line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--iscrypted", dest="iscrypted", action="store_true")
parser.add_argument("--plaintext", dest="plaintext", action="store_true")
parser.add_argument("--lock", dest="lock", action="store_true")
parser.add_argument("password")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_selinux(rule):
"""
Parse the selinux line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--disabled", dest="disabled", action="store_true")
parser.add_argument("--enforcing", dest="enforcing", action="store_true")
parser.add_argument("--permissive", dest="permissive", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_services(rule):
"""
Parse the services line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--disabled", dest="disabled", action="store")
parser.add_argument("--enabled", dest="enabled", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_sshpw(rule):
"""
Parse the sshpw line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--username", dest="username", action="store")
parser.add_argument("--iscrypted", dest="iscrypted", action="store_true")
parser.add_argument("--plaintext", dest="plaintext", action="store_true")
parser.add_argument("--lock", dest="lock", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_timezone(rule):
"""
Parse the timezone line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--utc", dest="utc", action="store_true")
parser.add_argument("--nontp", dest="nontp", action="store_true")
parser.add_argument("--ntpservers", dest="ntpservers", action="store")
parser.add_argument("--isUtc", dest="isutc", action="store_true")
parser.add_argument("timezone")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_updates(rule):
"""
Parse the updates line
"""
rules = shlex.split(rule)
rules.pop(0)
return {"url": rules[0]} if rules else True
def parse_upgrade(rule):
"""
Parse the upgrade line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--root-device", dest="root-device", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
if args:
return args
return True
def parse_url(rule):
"""
Parse the url line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--url", dest="url", action="store")
parser.add_argument("--proxy", dest="proxy", action="store")
parser.add_argument("--noverifyssl", dest="noverifyssl", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_user(rule):
"""
Parse the user line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--name", dest="name", action="store")
parser.add_argument("--gecos", dest="gecos", action="store")
parser.add_argument("--groups", dest="groups", action="store")
parser.add_argument("--homedir", dest="homedir", action="store")
parser.add_argument("--lock", dest="lock", action="store_true")
parser.add_argument("--password", dest="password", action="store")
parser.add_argument("--iscrypted", dest="iscrypted", action="store_true")
parser.add_argument("--plaintext", dest="plaintext", action="store_true")
parser.add_argument("--shell", dest="shell", action="store")
parser.add_argument("--uid", dest="uid", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_vnc(rule):
"""
Parse the vnc line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--host", dest="host", action="store")
parser.add_argument("--port", dest="port", action="store")
parser.add_argument("--password", dest="password", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_volgroup(rule):
"""
Parse the volgroup line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
partitions = []
newrules = []
for count, rule in enumerate(rules):
if count == 0:
newrules.append(rule)
continue
elif rule.startswith("--"):
newrules.append(rule)
continue
else:
partitions.append(rule)
rules = newrules
parser.add_argument("name")
parser.add_argument("--noformat", dest="noformat", action="store_true")
parser.add_argument("--useexisting", dest="useexisting", action="store_true")
parser.add_argument("--pesize", dest="pesize", action="store")
parser.add_argument("--reserved-space", dest="reserved-space", action="store")
parser.add_argument("--reserved-percent", dest="reserved-percent", action="store")
args = clean_args(vars(parser.parse_args(rules)))
if partitions:
args["partitions"] = partitions
parser = None
return args
def parse_xconfig(rule):
"""
Parse the xconfig line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--defaultdesktop", dest="defaultdesktop", action="store")
parser.add_argument("--startxonboot", dest="startxonboot", action="store_true")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def parse_zfcp(rule):
"""
Parse the zfcp line
"""
parser = argparse.ArgumentParser()
rules = shlex.split(rule)
rules.pop(0)
parser.add_argument("--devnum", dest="devnum", action="store")
parser.add_argument("--fcplun", dest="fcplun", action="store")
parser.add_argument("--wwpn", dest="wwpn", action="store")
args = clean_args(vars(parser.parse_args(rules)))
parser = None
return args
def mksls(src, dst=None):
"""
Convert a kickstart file to an SLS file
"""
mode = "command"
sls = {}
ks_opts = {}
with salt.utils.files.fopen(src, "r") as fh_:
for line in fh_:
if line.startswith("#"):
continue
if mode == "command":
if line.startswith("auth ") or line.startswith("authconfig "):
ks_opts["auth"] = parse_auth(line)
elif line.startswith("autopart"):
ks_opts["autopath"] = parse_autopart(line)
elif line.startswith("autostep"):
ks_opts["autostep"] = parse_autostep(line)
elif line.startswith("bootloader"):
ks_opts["bootloader"] = parse_bootloader(line)
elif line.startswith("btrfs"):
ks_opts["btrfs"] = parse_btrfs(line)
elif line.startswith("cdrom"):
ks_opts["cdrom"] = True
elif line.startswith("clearpart"):
ks_opts["clearpart"] = parse_clearpart(line)
elif line.startswith("cmdline"):
ks_opts["cmdline"] = True
elif line.startswith("device"):
ks_opts["device"] = parse_device(line)
elif line.startswith("dmraid"):
ks_opts["dmraid"] = parse_dmraid(line)
elif line.startswith("driverdisk"):
ks_opts["driverdisk"] = parse_driverdisk(line)
elif line.startswith("firewall"):
ks_opts["firewall"] = parse_firewall(line)
elif line.startswith("firstboot"):
ks_opts["firstboot"] = parse_firstboot(line)
elif line.startswith("group"):
ks_opts["group"] = parse_group(line)
elif line.startswith("graphical"):
ks_opts["graphical"] = True
elif line.startswith("halt"):
ks_opts["halt"] = True
elif line.startswith("harddrive"):
ks_opts["harddrive"] = True
elif line.startswith("ignoredisk"):
ks_opts["ignoredisk"] = parse_ignoredisk(line)
elif line.startswith("install"):
ks_opts["install"] = True
elif line.startswith("iscsi"):
ks_opts["iscsi"] = parse_iscsi(line)
elif line.startswith("iscsiname"):
ks_opts["iscsiname"] = parse_iscsiname(line)
elif line.startswith("keyboard"):
ks_opts["keyboard"] = parse_keyboard(line)
elif line.startswith("lang"):
ks_opts["lang"] = parse_lang(line)
elif line.startswith("logvol"):
if "logvol" not in ks_opts:
ks_opts["logvol"] = []
ks_opts["logvol"].append(parse_logvol(line))
elif line.startswith("logging"):
ks_opts["logging"] = parse_logging(line)
elif line.startswith("mediacheck"):
ks_opts["mediacheck"] = True
elif line.startswith("monitor"):
ks_opts["monitor"] = parse_monitor(line)
elif line.startswith("multipath"):
ks_opts["multipath"] = parse_multipath(line)
elif line.startswith("network"):
if "network" not in ks_opts:
ks_opts["network"] = []
ks_opts["network"].append(parse_network(line))
elif line.startswith("nfs"):
ks_opts["nfs"] = True
elif line.startswith("part ") or line.startswith("partition"):
if "part" not in ks_opts:
ks_opts["part"] = []
ks_opts["part"].append(parse_partition(line))
elif line.startswith("poweroff"):
ks_opts["poweroff"] = True
elif line.startswith("raid"):
if "raid" not in ks_opts:
ks_opts["raid"] = []
ks_opts["raid"].append(parse_raid(line))
elif line.startswith("reboot"):
ks_opts["reboot"] = parse_reboot(line)
elif line.startswith("repo"):
ks_opts["repo"] = parse_repo(line)
elif line.startswith("rescue"):
ks_opts["rescue"] = parse_rescue(line)
elif line.startswith("rootpw"):
ks_opts["rootpw"] = parse_rootpw(line)
elif line.startswith("selinux"):
ks_opts["selinux"] = parse_selinux(line)
elif line.startswith("services"):
ks_opts["services"] = parse_services(line)
elif line.startswith("shutdown"):
ks_opts["shutdown"] = True
elif line.startswith("sshpw"):
ks_opts["sshpw"] = parse_sshpw(line)
elif line.startswith("skipx"):
ks_opts["skipx"] = True
elif line.startswith("text"):
ks_opts["text"] = True
elif line.startswith("timezone"):
ks_opts["timezone"] = parse_timezone(line)
elif line.startswith("updates"):
ks_opts["updates"] = parse_updates(line)
elif line.startswith("upgrade"):
ks_opts["upgrade"] = parse_upgrade(line)
elif line.startswith("url"):
ks_opts["url"] = True
elif line.startswith("user"):
ks_opts["user"] = parse_user(line)
elif line.startswith("vnc"):
ks_opts["vnc"] = parse_vnc(line)
elif line.startswith("volgroup"):
ks_opts["volgroup"] = parse_volgroup(line)
elif line.startswith("xconfig"):
ks_opts["xconfig"] = parse_xconfig(line)
elif line.startswith("zerombr"):
ks_opts["zerombr"] = True
elif line.startswith("zfcp"):
ks_opts["zfcp"] = parse_zfcp(line)
if line.startswith("%include"):
rules = shlex.split(line)
if not ks_opts["include"]:
ks_opts["include"] = []
ks_opts["include"].append(rules[1])
if line.startswith("%ksappend"):
rules = shlex.split(line)
if not ks_opts["ksappend"]:
ks_opts["ksappend"] = []
ks_opts["ksappend"].append(rules[1])
if line.startswith("%packages"):
mode = "packages"
if "packages" not in ks_opts:
ks_opts["packages"] = {"packages": {}}
parser = argparse.ArgumentParser()
opts = shlex.split(line)
opts.pop(0)
parser.add_argument("--default", dest="default", action="store_true")
parser.add_argument(
"--excludedocs", dest="excludedocs", action="store_true"
)
parser.add_argument(
"--ignoremissing", dest="ignoremissing", action="store_true"
)
parser.add_argument("--instLangs", dest="instLangs", action="store")
parser.add_argument("--multilib", dest="multilib", action="store_true")
parser.add_argument(
"--nodefaults", dest="nodefaults", action="store_true"
)
parser.add_argument("--optional", dest="optional", action="store_true")
parser.add_argument("--nobase", dest="nobase", action="store_true")
args = clean_args(vars(parser.parse_args(opts)))
ks_opts["packages"]["options"] = args
continue
if line.startswith("%pre"):
mode = "pre"
parser = argparse.ArgumentParser()
opts = shlex.split(line)
opts.pop(0)
parser.add_argument("--interpreter", dest="interpreter", action="store")
parser.add_argument(
"--erroronfail", dest="erroronfail", action="store_true"
)
parser.add_argument("--log", dest="log", action="store")
args = clean_args(vars(parser.parse_args(opts)))
ks_opts["pre"] = {"options": args, "script": ""}
continue
if line.startswith("%post"):
mode = "post"
parser = argparse.ArgumentParser()
opts = shlex.split(line)
opts.pop(0)
parser.add_argument("--nochroot", dest="nochroot", action="store_true")
parser.add_argument("--interpreter", dest="interpreter", action="store")
parser.add_argument(
"--erroronfail", dest="erroronfail", action="store_true"
)
parser.add_argument("--log", dest="log", action="store")
args = clean_args(vars(parser.parse_args(opts)))
ks_opts["post"] = {"options": args, "script": ""}
continue
if line.startswith("%end"):
mode = None
if mode == "packages":
if line.startswith("-"):
package = line.replace("-", "", 1).strip()
ks_opts["packages"]["packages"][package] = False
else:
ks_opts["packages"]["packages"][line.strip()] = True
if mode == "pre":
ks_opts["pre"]["script"] += line
if mode == "post":
ks_opts["post"]["script"] += line
# Set language
sls[ks_opts["lang"]["lang"]] = {"locale": ["system"]}
# Set keyboard
sls[ks_opts["keyboard"]["xlayouts"]] = {"keyboard": ["system"]}
# Set timezone
sls[ks_opts["timezone"]["timezone"]] = {"timezone": ["system"]}
if "utc" in ks_opts["timezone"]:
sls[ks_opts["timezone"]["timezone"]]["timezone"].append("utc")
# Set network
if "network" in ks_opts:
for interface in ks_opts["network"]:
device = interface.get("device", None)
if device is not None:
del interface["device"]
sls[device] = {"proto": interface["bootproto"]}
del interface["bootproto"]
if "onboot" in interface:
if "no" in interface["onboot"]:
sls[device]["enabled"] = False
else:
sls[device]["enabled"] = True
del interface["onboot"]
if "noipv4" in interface:
sls[device]["ipv4"] = {"enabled": False}
del interface["noipv4"]
if "noipv6" in interface:
sls[device]["ipv6"] = {"enabled": False}
del interface["noipv6"]
for option in interface:
if type(interface[option]) is bool:
sls[device][option] = {"enabled": [interface[option]]}
else:
sls[device][option] = interface[option]
if "hostname" in interface:
sls["system"] = {
"network.system": {
"enabled": True,
"hostname": interface["hostname"],
"apply_hostname": True,
}
}
# Set selinux
if "selinux" in ks_opts:
for mode in ks_opts["selinux"]:
sls[mode] = {"selinux": ["mode"]}
# Get package data together
if "nobase" not in ks_opts["packages"]["options"]:
sls["base"] = {"pkg_group": ["installed"]}
packages = ks_opts["packages"]["packages"]
for package in packages:
if not packages[package]:
continue
if package and packages[package] is True:
if package.startswith("@"):
pkg_group = package.replace("@", "", 1)
sls[pkg_group] = {"pkg_group": ["installed"]}
else:
sls[package] = {"pkg": ["installed"]}
elif packages[package] is False:
sls[package] = {"pkg": ["absent"]}
if dst:
with salt.utils.files.fopen(dst, "w") as fp_:
salt.utils.yaml.safe_dump(sls, fp_, default_flow_style=False)
else:
return salt.utils.yaml.safe_dump(sls, default_flow_style=False)
Zerion Mini Shell 1.0