diff options
Diffstat (limited to 'scripts/lib/mic/3rdparty/pykickstart/commands')
51 files changed, 6019 insertions, 0 deletions
diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/__init__.py b/scripts/lib/mic/3rdparty/pykickstart/commands/__init__.py new file mode 100644 index 0000000000..da48ff50d5 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/__init__.py @@ -0,0 +1,26 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +import authconfig, autopart, autostep, bootloader, clearpart, device +import deviceprobe, displaymode, dmraid, driverdisk, fcoe, firewall, firstboot +import group, ignoredisk, interactive, iscsi, iscsiname, key, keyboard, lang +import langsupport, lilocheck, logging, logvol, mediacheck, method, monitor +import mouse, multipath, network, partition, raid, reboot, repo, rescue, rootpw +import selinux, services, skipx, sshpw, timezone, updates, upgrade, user, vnc +import volgroup, xconfig, zerombr, zfcp diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/authconfig.py b/scripts/lib/mic/3rdparty/pykickstart/commands/authconfig.py new file mode 100644 index 0000000000..9af9c0ff14 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/authconfig.py @@ -0,0 +1,40 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * + +class FC3_Authconfig(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, *args, **kwargs) + self.authconfig = kwargs.get("authconfig", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.authconfig: + retval += "# System authorization information\nauth %s\n" % self.authconfig + + return retval + + def parse(self, args): + self.authconfig = self.currentLine[len(self.currentCmd):].strip() + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/autopart.py b/scripts/lib/mic/3rdparty/pykickstart/commands/autopart.py new file mode 100644 index 0000000000..cf28b5c7f7 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/autopart.py @@ -0,0 +1,119 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_AutoPart(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=100, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.autopart = kwargs.get("autopart", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.autopart: + retval += "autopart\n" + + return retval + + def parse(self, args): + if len(args) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "autopart") + + self.autopart = True + return self + +class F9_AutoPart(FC3_AutoPart): + removedKeywords = FC3_AutoPart.removedKeywords + removedAttrs = FC3_AutoPart.removedAttrs + + def __init__(self, writePriority=100, *args, **kwargs): + FC3_AutoPart.__init__(self, writePriority=writePriority, *args, **kwargs) + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + self.op = self._getParser() + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.autopart: + retval += "autopart" + + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\""% self.passphrase + + if retval != "": + retval += "\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + self.autopart = True + return self + +class F12_AutoPart(F9_AutoPart): + removedKeywords = F9_AutoPart.removedKeywords + removedAttrs = F9_AutoPart.removedAttrs + + def __init__(self, writePriority=100, *args, **kwargs): + F9_AutoPart.__init__(self, writePriority=writePriority, *args, **kwargs) + + self.escrowcert = kwargs.get("escrowcert", "") + self.backuppassphrase = kwargs.get("backuppassphrase", False) + + def __str__(self): + retval = F9_AutoPart.__str__(self) + + if self.encrypted and self.escrowcert != "": + retval = retval.strip() + + retval += " --escrowcert=\"%s\"" % self.escrowcert + + if self.backuppassphrase: + retval += " --backuppassphrase" + + retval += "\n" + + return retval + + def _getParser(self): + op = F9_AutoPart._getParser(self) + op.add_option("--escrowcert") + op.add_option("--backuppassphrase", action="store_true", default=False) + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/autostep.py b/scripts/lib/mic/3rdparty/pykickstart/commands/autostep.py new file mode 100644 index 0000000000..e6ae71cefc --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/autostep.py @@ -0,0 +1,55 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +class FC3_AutoStep(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.autostep = kwargs.get("autostep", False) + self.autoscreenshot = kwargs.get("autoscreenshot", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.autostep: + if self.autoscreenshot: + retval += "autostep --autoscreenshot\n" + else: + retval += "autostep\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--autoscreenshot", dest="autoscreenshot", + action="store_true", default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + self.autostep = True + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/bootloader.py b/scripts/lib/mic/3rdparty/pykickstart/commands/bootloader.py new file mode 100644 index 0000000000..b227fac3be --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/bootloader.py @@ -0,0 +1,265 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +class FC3_Bootloader(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=10, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.driveorder = kwargs.get("driveorder", []) + self.appendLine = kwargs.get("appendLine", "") + self.forceLBA = kwargs.get("forceLBA", False) + self.linear = kwargs.get("linear", True) + self.location = kwargs.get("location", "") + self.md5pass = kwargs.get("md5pass", "") + self.password = kwargs.get("password", "") + self.upgrade = kwargs.get("upgrade", False) + self.useLilo = kwargs.get("useLilo", False) + + self.deleteRemovedAttrs() + + def _getArgsAsStr(self): + retval = "" + + if self.appendLine != "": + retval += " --append=\"%s\"" % self.appendLine + if self.linear: + retval += " --linear" + if self.location: + retval += " --location=%s" % self.location + if hasattr(self, "forceLBA") and self.forceLBA: + retval += " --lba32" + if self.password != "": + retval += " --password=\"%s\"" % self.password + if self.md5pass != "": + retval += " --md5pass=\"%s\"" % self.md5pass + if self.upgrade: + retval += " --upgrade" + if self.useLilo: + retval += " --useLilo" + if len(self.driveorder) > 0: + retval += " --driveorder=\"%s\"" % ",".join(self.driveorder) + + return retval + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.location != "": + retval += "# System bootloader configuration\nbootloader" + retval += self._getArgsAsStr() + "\n" + + return retval + + def _getParser(self): + def driveorder_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d) + + op = KSOptionParser() + op.add_option("--append", dest="appendLine") + op.add_option("--linear", dest="linear", action="store_true", + default=True) + op.add_option("--nolinear", dest="linear", action="store_false") + op.add_option("--location", dest="location", type="choice", + default="mbr", + choices=["mbr", "partition", "none", "boot"]) + op.add_option("--lba32", dest="forceLBA", action="store_true", + default=False) + op.add_option("--password", dest="password", default="") + op.add_option("--md5pass", dest="md5pass", default="") + op.add_option("--upgrade", dest="upgrade", action="store_true", + default=False) + op.add_option("--useLilo", dest="useLilo", action="store_true", + default=False) + op.add_option("--driveorder", dest="driveorder", action="callback", + callback=driveorder_cb, nargs=1, type="string") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + + if self.currentCmd == "lilo": + self.useLilo = True + + return self + +class FC4_Bootloader(FC3_Bootloader): + removedKeywords = FC3_Bootloader.removedKeywords + ["linear", "useLilo"] + removedAttrs = FC3_Bootloader.removedAttrs + ["linear", "useLilo"] + + def __init__(self, writePriority=10, *args, **kwargs): + FC3_Bootloader.__init__(self, writePriority, *args, **kwargs) + + def _getArgsAsStr(self): + retval = "" + if self.appendLine != "": + retval += " --append=\"%s\"" % self.appendLine + if self.location: + retval += " --location=%s" % self.location + if hasattr(self, "forceLBA") and self.forceLBA: + retval += " --lba32" + if self.password != "": + retval += " --password=\"%s\"" % self.password + if self.md5pass != "": + retval += " --md5pass=\"%s\"" % self.md5pass + if self.upgrade: + retval += " --upgrade" + if len(self.driveorder) > 0: + retval += " --driveorder=\"%s\"" % ",".join(self.driveorder) + return retval + + def _getParser(self): + op = FC3_Bootloader._getParser(self) + op.remove_option("--linear") + op.remove_option("--nolinear") + op.remove_option("--useLilo") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + return self + +class F8_Bootloader(FC4_Bootloader): + removedKeywords = FC4_Bootloader.removedKeywords + removedAttrs = FC4_Bootloader.removedAttrs + + def __init__(self, writePriority=10, *args, **kwargs): + FC4_Bootloader.__init__(self, writePriority, *args, **kwargs) + + self.timeout = kwargs.get("timeout", None) + self.default = kwargs.get("default", "") + + def _getArgsAsStr(self): + ret = FC4_Bootloader._getArgsAsStr(self) + + if self.timeout is not None: + ret += " --timeout=%d" %(self.timeout,) + if self.default: + ret += " --default=%s" %(self.default,) + + return ret + + def _getParser(self): + op = FC4_Bootloader._getParser(self) + op.add_option("--timeout", dest="timeout", type="int") + op.add_option("--default", dest="default") + return op + +class F12_Bootloader(F8_Bootloader): + removedKeywords = F8_Bootloader.removedKeywords + removedAttrs = F8_Bootloader.removedAttrs + + def _getParser(self): + op = F8_Bootloader._getParser(self) + op.add_option("--lba32", dest="forceLBA", deprecated=1, action="store_true") + return op + +class F14_Bootloader(F12_Bootloader): + removedKeywords = F12_Bootloader.removedKeywords + ["forceLBA"] + removedAttrs = F12_Bootloader.removedKeywords + ["forceLBA"] + + def _getParser(self): + op = F12_Bootloader._getParser(self) + op.remove_option("--lba32") + return op + +class F15_Bootloader(F14_Bootloader): + removedKeywords = F14_Bootloader.removedKeywords + removedAttrs = F14_Bootloader.removedAttrs + + def __init__(self, writePriority=10, *args, **kwargs): + F14_Bootloader.__init__(self, writePriority, *args, **kwargs) + + self.isCrypted = kwargs.get("isCrypted", False) + + def _getArgsAsStr(self): + ret = F14_Bootloader._getArgsAsStr(self) + + if self.isCrypted: + ret += " --iscrypted" + + return ret + + def _getParser(self): + def password_cb(option, opt_str, value, parser): + parser.values.isCrypted = True + parser.values.password = value + + op = F14_Bootloader._getParser(self) + op.add_option("--iscrypted", dest="isCrypted", action="store_true", default=False) + op.add_option("--md5pass", action="callback", callback=password_cb, nargs=1, type="string") + return op + +class RHEL5_Bootloader(FC4_Bootloader): + removedKeywords = FC4_Bootloader.removedKeywords + removedAttrs = FC4_Bootloader.removedAttrs + + def __init__(self, writePriority=10, *args, **kwargs): + FC4_Bootloader.__init__(self, writePriority, *args, **kwargs) + + self.hvArgs = kwargs.get("hvArgs", "") + + def _getArgsAsStr(self): + ret = FC4_Bootloader._getArgsAsStr(self) + + if self.hvArgs: + ret += " --hvargs=\"%s\"" %(self.hvArgs,) + + return ret + + def _getParser(self): + op = FC4_Bootloader._getParser(self) + op.add_option("--hvargs", dest="hvArgs", type="string") + return op + +class RHEL6_Bootloader(F12_Bootloader): + removedKeywords = F12_Bootloader.removedKeywords + removedAttrs = F12_Bootloader.removedAttrs + + def __init__(self, writePriority=10, *args, **kwargs): + F12_Bootloader.__init__(self, writePriority, *args, **kwargs) + + self.isCrypted = kwargs.get("isCrypted", False) + + def _getArgsAsStr(self): + ret = F12_Bootloader._getArgsAsStr(self) + + if self.isCrypted: + ret += " --iscrypted" + + return ret + + def _getParser(self): + def password_cb(option, opt_str, value, parser): + parser.values.isCrypted = True + parser.values.password = value + + op = F12_Bootloader._getParser(self) + op.add_option("--iscrypted", dest="isCrypted", action="store_true", default=False) + op.add_option("--md5pass", action="callback", callback=password_cb, nargs=1, type="string") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/clearpart.py b/scripts/lib/mic/3rdparty/pykickstart/commands/clearpart.py new file mode 100644 index 0000000000..a8089fcb99 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/clearpart.py @@ -0,0 +1,86 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +class FC3_ClearPart(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=120, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.drives = kwargs.get("drives", []) + self.initAll = kwargs.get("initAll", False) + self.type = kwargs.get("type", None) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.type is None: + return retval + + if self.type == CLEARPART_TYPE_NONE: + clearstr = "--none" + elif self.type == CLEARPART_TYPE_LINUX: + clearstr = "--linux" + elif self.type == CLEARPART_TYPE_ALL: + clearstr = "--all" + else: + clearstr = "" + + if self.initAll: + initstr = "--initlabel" + else: + initstr = "" + + if len(self.drives) > 0: + drivestr = "--drives=" + ",".join(self.drives) + else: + drivestr = "" + + retval += "# Partition clearing information\nclearpart %s %s %s\n" % (clearstr, initstr, drivestr) + return retval + + def _getParser(self): + def drive_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d) + + op = KSOptionParser() + op.add_option("--all", dest="type", action="store_const", + const=CLEARPART_TYPE_ALL) + op.add_option("--drives", dest="drives", action="callback", + callback=drive_cb, nargs=1, type="string") + op.add_option("--initlabel", dest="initAll", action="store_true", + default=False) + op.add_option("--linux", dest="type", action="store_const", + const=CLEARPART_TYPE_LINUX) + op.add_option("--none", dest="type", action="store_const", + const=CLEARPART_TYPE_NONE) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/device.py b/scripts/lib/mic/3rdparty/pykickstart/commands/device.py new file mode 100644 index 0000000000..321410e2e2 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/device.py @@ -0,0 +1,125 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class F8_DeviceData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.moduleName = kwargs.get("moduleName", "") + self.moduleOpts = kwargs.get("moduleOpts", "") + + def __eq__(self, y): + return self.moduleName == y.moduleName + + def __str__(self): + retval = BaseData.__str__(self) + + if self.moduleName != "": + retval += "device %s" % self.moduleName + + if self.moduleOpts != "": + retval += " --opts=\"%s\"" % self.moduleOpts + + return retval + "\n" + +class FC3_Device(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.type = kwargs.get("type", "") + self.moduleName = kwargs.get("moduleName", "") + self.moduleOpts = kwargs.get("moduleOpts", "") + + def __eq__(self, y): + return self.moduleName == y.moduleName + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.moduleName != "": + retval += "device %s %s" % (self.type, self.moduleName) + + if self.moduleOpts != "": + retval += " --opts=\"%s\"" % self.moduleOpts + + return retval + "\n" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--opts", dest="moduleOpts", default="") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) != 2: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("device command requires two arguments: module type and name")) + + self.moduleOpts = opts.moduleOpts + self.type = extra[0] + self.moduleName = extra[1] + return self + +class F8_Device(FC3_Device): + removedKeywords = FC3_Device.removedKeywords + removedAttrs = FC3_Device.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_Device.__init__(self, writePriority, *args, **kwargs) + self.deviceList = kwargs.get("deviceList", []) + + def __str__(self): + retval = "" + for device in self.deviceList: + retval += device.__str__() + + return retval + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("%s command requires a single argument: %s") % ("device", "module name")) + + dd = F8_DeviceData() + self._setToObj(self.op, opts, dd) + dd.lineno = self.lineno + dd.moduleName = extra[0] + + # Check for duplicates in the data list. + if dd in self.dataList(): + warnings.warn(_("A module with the name %s has already been defined.") % dd.moduleName) + + return dd + + def dataList(self): + return self.deviceList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/deviceprobe.py b/scripts/lib/mic/3rdparty/pykickstart/commands/deviceprobe.py new file mode 100644 index 0000000000..9f462fdff7 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/deviceprobe.py @@ -0,0 +1,40 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * + +class FC3_DeviceProbe(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.deviceprobe = kwargs.get("deviceprobe", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.deviceprobe != "": + retval += "deviceprobe %s\n" % self.deviceprobe + + return retval + + def parse(self, args): + self.deviceprobe = " ".join(args) + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/displaymode.py b/scripts/lib/mic/3rdparty/pykickstart/commands/displaymode.py new file mode 100644 index 0000000000..6a12d58ec2 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/displaymode.py @@ -0,0 +1,68 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_DisplayMode(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.displayMode = kwargs.get("displayMode", None) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.displayMode is None: + return retval + + if self.displayMode == DISPLAY_MODE_CMDLINE: + retval += "cmdline\n" + elif self.displayMode == DISPLAY_MODE_GRAPHICAL: + retval += "# Use graphical install\ngraphical\n" + elif self.displayMode == DISPLAY_MODE_TEXT: + retval += "# Use text mode install\ntext\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 0: + raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % self.currentCmd) + + if self.currentCmd == "cmdline": + self.displayMode = DISPLAY_MODE_CMDLINE + elif self.currentCmd == "graphical": + self.displayMode = DISPLAY_MODE_GRAPHICAL + elif self.currentCmd == "text": + self.displayMode = DISPLAY_MODE_TEXT + + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/dmraid.py b/scripts/lib/mic/3rdparty/pykickstart/commands/dmraid.py new file mode 100644 index 0000000000..993575a041 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/dmraid.py @@ -0,0 +1,91 @@ +# +# Chris Lumens <clumens@redhat.com> +# Peter Jones <pjones@redhat.com> +# +# Copyright 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_DmRaidData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + + self.name = kwargs.get("name", "") + self.devices = kwargs.get("devices", []) + self.dmset = kwargs.get("dmset", None) + + def __eq__(self, y): + return self.name == y.name and self.devices == y.devices + + def __str__(self): + retval = BaseData.__str__(self) + retval += "dmraid --name=%s" % self.name + + for dev in self.devices: + retval += " --dev=\"%s\"" % dev + + return retval + "\n" + +class FC6_DmRaid(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=60, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.dmraids = kwargs.get("dmraids", []) + + def __str__(self): + retval = "" + for dm in self.dmraids: + retval += dm.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--name", dest="name", action="store", type="string", + required=1) + op.add_option("--dev", dest="devices", action="append", type="string", + required=1) + return op + + def parse(self, args): + dm = FC6_DmRaidData() + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + dm.name = dm.name.split('/')[-1] + self._setToObj(self.op, opts, dm) + dm.lineno = self.lineno + + # Check for duplicates in the data list. + if dm in self.dataList(): + warnings.warn(_("A DM RAID device with the name %s and devices %s has already been defined.") % (dm.name, dm.devices)) + + return dm + + def dataList(self): + return self.dmraids diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/driverdisk.py b/scripts/lib/mic/3rdparty/pykickstart/commands/driverdisk.py new file mode 100644 index 0000000000..82a58c0e28 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/driverdisk.py @@ -0,0 +1,184 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_DriverDiskData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + + self.partition = kwargs.get("partition", "") + self.source = kwargs.get("source", "") + self.type = kwargs.get("type", "") + + def _getArgsAsStr(self): + retval = "" + + if self.partition: + retval += "%s" % self.partition + + if hasattr(self, "type") and self.type: + retval += " --type=%s" % self.type + elif self.source: + retval += "--source=%s" % self.source + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "driverdisk %s\n" % self._getArgsAsStr() + return retval + +class FC4_DriverDiskData(FC3_DriverDiskData): + removedKeywords = FC3_DriverDiskData.removedKeywords + removedAttrs = FC3_DriverDiskData.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_DriverDiskData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.biospart = kwargs.get("biospart", "") + + def _getArgsAsStr(self): + retval = "" + + if self.partition: + retval += "%s" % self.partition + + if hasattr(self, "type") and self.type: + retval += " --type=%s" % self.type + elif self.source: + retval += "--source=%s" % self.source + elif self.biospart: + retval += "--biospart=%s" % self.biospart + + return retval + +class F12_DriverDiskData(FC4_DriverDiskData): + removedKeywords = FC4_DriverDiskData.removedKeywords + ["type"] + removedAttrs = FC4_DriverDiskData.removedAttrs + ["type"] + + def __init__(self, *args, **kwargs): + FC4_DriverDiskData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + +F14_DriverDiskData = F12_DriverDiskData + +class FC3_DriverDisk(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.driverdiskList = kwargs.get("driverdiskList", []) + + def __str__(self): + retval = "" + for dd in self.driverdiskList: + retval += dd.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--source") + op.add_option("--type") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one partition may be specified for driverdisk command.")) + + if len(extra) == 1 and opts.source: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --source and partition may be specified for driverdisk command.")) + + if not extra and not opts.source: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --source or partition must be specified for driverdisk command.")) + + ddd = self.handler.DriverDiskData() + self._setToObj(self.op, opts, ddd) + ddd.lineno = self.lineno + if len(extra) == 1: + ddd.partition = extra[0] + + return ddd + + def dataList(self): + return self.driverdiskList + +class FC4_DriverDisk(FC3_DriverDisk): + removedKeywords = FC3_DriverDisk.removedKeywords + removedAttrs = FC3_DriverDisk.removedKeywords + + def _getParser(self): + op = FC3_DriverDisk._getParser(self) + op.add_option("--biospart") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one partition may be specified for driverdisk command.")) + + if len(extra) == 1 and opts.source: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --source and partition may be specified for driverdisk command.")) + elif len(extra) == 1 and opts.biospart: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --biospart and partition may be specified for driverdisk command.")) + elif opts.source and opts.biospart: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --biospart and --source may be specified for driverdisk command.")) + + if not extra and not opts.source and not opts.biospart: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --source, --biospart, or partition must be specified for driverdisk command.")) + + ddd = self.handler.DriverDiskData() + self._setToObj(self.op, opts, ddd) + ddd.lineno = self.lineno + if len(extra) == 1: + ddd.partition = extra[0] + + return ddd + +class F12_DriverDisk(FC4_DriverDisk): + removedKeywords = FC4_DriverDisk.removedKeywords + removedAttrs = FC4_DriverDisk.removedKeywords + + def _getParser(self): + op = FC4_DriverDisk._getParser(self) + op.add_option("--type", deprecated=1) + return op + +class F14_DriverDisk(F12_DriverDisk): + removedKeywords = F12_DriverDisk.removedKeywords + removedAttrs = F12_DriverDisk.removedKeywords + + def _getParser(self): + op = F12_DriverDisk._getParser(self) + op.remove_option("--type") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/fcoe.py b/scripts/lib/mic/3rdparty/pykickstart/commands/fcoe.py new file mode 100644 index 0000000000..33208499b3 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/fcoe.py @@ -0,0 +1,114 @@ +# +# Hans de Goede <hdegoede@redhat.com> +# +# Copyright 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class F12_FcoeData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.nic = kwargs.get("nic", None) + + def __eq__(self, y): + return self.nic == y.nic + + def _getArgsAsStr(self): + retval = "" + + if self.nic: + retval += " --nic=%s" % self.nic + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "fcoe%s\n" % self._getArgsAsStr() + return retval + +class F13_FcoeData(F12_FcoeData): + removedKeywords = F12_FcoeData.removedKeywords + removedAttrs = F12_FcoeData.removedAttrs + + def __init__(self, *args, **kwargs): + F12_FcoeData.__init__(self, *args, **kwargs) + self.dcb = kwargs.get("dcb", False) + + def _getArgsAsStr(self): + retval = F12_FcoeData._getArgsAsStr(self) + + if self.dcb: + retval += " --dcb" + + return retval + +class F12_Fcoe(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=71, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.fcoe = kwargs.get("fcoe", []) + + def __str__(self): + retval = "" + for fcoe in self.fcoe: + retval += fcoe.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--nic", dest="nic", required=1) + return op + + def parse(self, args): + zd = self.handler.FcoeData() + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) > 0: + mapping = {"command": "fcoe", "options": extra} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) + + self._setToObj(self.op, opts, zd) + zd.lineno = self.lineno + + # Check for duplicates in the data list. + if zd in self.dataList(): + warnings.warn(_("A FCOE device with the name %s has already been defined.") % zd.nic) + + return zd + + def dataList(self): + return self.fcoe + +class F13_Fcoe(F12_Fcoe): + removedKeywords = F12_Fcoe.removedKeywords + removedAttrs = F12_Fcoe.removedAttrs + + def _getParser(self): + op = F12_Fcoe._getParser(self) + op.add_option("--dcb", dest="dcb", action="store_true", default=False) + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/firewall.py b/scripts/lib/mic/3rdparty/pykickstart/commands/firewall.py new file mode 100644 index 0000000000..24a01bd610 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/firewall.py @@ -0,0 +1,193 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Firewall(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.enabled = kwargs.get("enabled", None) + self.ports = kwargs.get("ports", []) + self.trusts = kwargs.get("trusts", []) + + def __str__(self): + extra = [] + filteredPorts = [] + + retval = KickstartCommand.__str__(self) + + if self.enabled is None: + return retval + + if self.enabled: + # It's possible we have words in the ports list instead of + # port:proto (s-c-kickstart may do this). So, filter those + # out into their own list leaving what we expect. + for port in self.ports: + if port == "ssh": + extra.append(" --ssh") + elif port == "telnet": + extra.append(" --telnet") + elif port == "smtp": + extra.append(" --smtp") + elif port == "http": + extra.append(" --http") + elif port == "ftp": + extra.append(" --ftp") + else: + filteredPorts.append(port) + + # All the port:proto strings go into a comma-separated list. + portstr = ",".join(filteredPorts) + if len(portstr) > 0: + portstr = " --port=" + portstr + else: + portstr = "" + + extrastr = "".join(extra) + truststr = ",".join(self.trusts) + + if len(truststr) > 0: + truststr = " --trust=" + truststr + + # The output port list consists only of port:proto for + # everything that we don't recognize, and special options for + # those that we do. + retval += "# Firewall configuration\nfirewall --enabled%s%s%s\n" % (extrastr, portstr, truststr) + else: + retval += "# Firewall configuration\nfirewall --disabled\n" + + return retval + + def _getParser(self): + def firewall_port_cb (option, opt_str, value, parser): + for p in value.split(","): + p = p.strip() + if p.find(":") == -1: + p = "%s:tcp" % p + parser.values.ensure_value(option.dest, []).append(p) + + op = KSOptionParser(mapping={"ssh":["22:tcp"], "telnet":["23:tcp"], + "smtp":["25:tcp"], "http":["80:tcp", "443:tcp"], + "ftp":["21:tcp"]}) + + op.add_option("--disable", "--disabled", dest="enabled", + action="store_false") + op.add_option("--enable", "--enabled", dest="enabled", + action="store_true", default=True) + op.add_option("--ftp", "--http", "--smtp", "--ssh", "--telnet", + dest="ports", action="map_extend") + op.add_option("--high", deprecated=1) + op.add_option("--medium", deprecated=1) + op.add_option("--port", dest="ports", action="callback", + callback=firewall_port_cb, nargs=1, type="string") + op.add_option("--trust", dest="trusts", action="append") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) != 0: + mapping = {"command": "firewall", "options": extra} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) + + self._setToSelf(self.op, opts) + return self + +class F9_Firewall(FC3_Firewall): + removedKeywords = FC3_Firewall.removedKeywords + removedAttrs = FC3_Firewall.removedAttrs + + def _getParser(self): + op = FC3_Firewall._getParser(self) + op.remove_option("--high") + op.remove_option("--medium") + return op + +class F10_Firewall(F9_Firewall): + removedKeywords = F9_Firewall.removedKeywords + removedAttrs = F9_Firewall.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + F9_Firewall.__init__(self, writePriority, *args, **kwargs) + self.services = kwargs.get("services", []) + + def __str__(self): + if self.enabled is None: + return "" + + retval = F9_Firewall.__str__(self) + if self.enabled: + retval = retval.strip() + + svcstr = ",".join(self.services) + if len(svcstr) > 0: + svcstr = " --service=" + svcstr + else: + svcstr = "" + + return retval + "%s\n" % svcstr + else: + return retval + + def _getParser(self): + def service_cb (option, opt_str, value, parser): + # python2.4 does not support action="append_const" that we were + # using for these options. Instead, we have to fake it by + # appending whatever the option string is to the service list. + if not value: + parser.values.ensure_value(option.dest, []).append(opt_str[2:]) + return + + for p in value.split(","): + p = p.strip() + parser.values.ensure_value(option.dest, []).append(p) + + op = F9_Firewall._getParser(self) + op.add_option("--service", dest="services", action="callback", + callback=service_cb, nargs=1, type="string") + op.add_option("--ftp", dest="services", action="callback", + callback=service_cb) + op.add_option("--http", dest="services", action="callback", + callback=service_cb) + op.add_option("--smtp", dest="services", action="callback", + callback=service_cb) + op.add_option("--ssh", dest="services", action="callback", + callback=service_cb) + op.add_option("--telnet", deprecated=1) + return op + +class F14_Firewall(F10_Firewall): + removedKeywords = F10_Firewall.removedKeywords + ["telnet"] + removedAttrs = F10_Firewall.removedAttrs + ["telnet"] + + def _getParser(self): + op = F10_Firewall._getParser(self) + op.remove_option("--telnet") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/firstboot.py b/scripts/lib/mic/3rdparty/pykickstart/commands/firstboot.py new file mode 100644 index 0000000000..05c0ac11c6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/firstboot.py @@ -0,0 +1,62 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.options import * + +class FC3_Firstboot(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.firstboot = kwargs.get("firstboot", None) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.firstboot is None: + return retval + + if self.firstboot == FIRSTBOOT_SKIP: + retval += "firstboot --disable\n" + elif self.firstboot == FIRSTBOOT_DEFAULT: + retval += "# Run the Setup Agent on first boot\nfirstboot --enable\n" + elif self.firstboot == FIRSTBOOT_RECONFIG: + retval += "# Run the Setup Agent on first boot\nfirstboot --reconfig\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--disable", "--disabled", dest="firstboot", + action="store_const", const=FIRSTBOOT_SKIP) + op.add_option("--enable", "--enabled", dest="firstboot", + action="store_const", const=FIRSTBOOT_DEFAULT) + op.add_option("--reconfig", dest="firstboot", action="store_const", + const=FIRSTBOOT_RECONFIG) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self.firstboot = opts.firstboot + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/group.py b/scripts/lib/mic/3rdparty/pykickstart/commands/group.py new file mode 100644 index 0000000000..80ba5bdca6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/group.py @@ -0,0 +1,88 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class F12_GroupData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.name = kwargs.get("name", "") + self.gid = kwargs.get("gid", None) + + def __eq__(self, y): + return self.name == y.name + + def __str__(self): + retval = BaseData.__str__(self) + retval += "group" + + if self.name: + retval += " --name=%s" % self.name + if self.gid: + retval += " --gid=%s" % self.gid + + return retval + "\n" + +class F12_Group(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.groupList = kwargs.get("groupList", []) + + def __str__(self): + retval = "" + for user in self.groupList: + retval += user.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--name", required=1) + op.add_option("--gid", type="int") + return op + + def parse(self, args): + gd = self.handler.GroupData() + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToObj(self.op, opts, gd) + gd.lineno = self.lineno + + # Check for duplicates in the data list. + if gd in self.dataList(): + warnings.warn(_("A group with the name %s has already been defined.") % gd.name) + + return gd + + def dataList(self): + return self.groupList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/ignoredisk.py b/scripts/lib/mic/3rdparty/pykickstart/commands/ignoredisk.py new file mode 100644 index 0000000000..676d080836 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/ignoredisk.py @@ -0,0 +1,139 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_IgnoreDisk(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.ignoredisk = kwargs.get("ignoredisk", []) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if len(self.ignoredisk) > 0: + retval += "ignoredisk --drives=%s\n" % ",".join(self.ignoredisk) + + return retval + + def _getParser(self): + def drive_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d) + + op = KSOptionParser() + op.add_option("--drives", dest="ignoredisk", action="callback", + callback=drive_cb, nargs=1, type="string", required=1) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + return self + +class F8_IgnoreDisk(FC3_IgnoreDisk): + removedKeywords = FC3_IgnoreDisk.removedKeywords + removedAttrs = FC3_IgnoreDisk.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_IgnoreDisk.__init__(self, writePriority, *args, **kwargs) + + self.onlyuse = kwargs.get("onlyuse", []) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if len(self.ignoredisk) > 0: + retval += "ignoredisk --drives=%s\n" % ",".join(self.ignoredisk) + elif len(self.onlyuse) > 0: + retval += "ignoredisk --only-use=%s\n" % ",".join(self.onlyuse) + + return retval + + def parse(self, args, errorCheck=True): + retval = FC3_IgnoreDisk.parse(self, args) + + if errorCheck: + if (len(self.ignoredisk) == 0 and len(self.onlyuse) == 0) or (len(self.ignoredisk) > 0 and (len(self.onlyuse) > 0)): + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --drives or --only-use must be specified for ignoredisk command.")) + + return retval + + def _getParser(self): + def drive_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d) + + op = FC3_IgnoreDisk._getParser(self) + op.add_option("--drives", dest="ignoredisk", action="callback", + callback=drive_cb, nargs=1, type="string") + op.add_option("--only-use", dest="onlyuse", action="callback", + callback=drive_cb, nargs=1, type="string") + return op + +class RHEL6_IgnoreDisk(F8_IgnoreDisk): + removedKeywords = F8_IgnoreDisk.removedKeywords + removedAttrs = F8_IgnoreDisk.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + F8_IgnoreDisk.__init__(self, writePriority, *args, **kwargs) + + self.interactive = kwargs.get("interactive", False) + if self.interactive: + self.ignoredisk = [] + + def __str__(self): + retval = F8_IgnoreDisk.__str__(self) + + if self.interactive: + retval = "ignoredisk --interactive\n" + + return retval + + def parse(self, args): + retval = F8_IgnoreDisk.parse(self, args, errorCheck=False) + + howmany = 0 + if len(self.ignoredisk) > 0: + howmany += 1 + if len(self.onlyuse) > 0: + howmany += 1 + if self.interactive: + howmany += 1 + if howmany != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --drives , --only-use , or --interactive must be specified for ignoredisk command.")) + + return retval + + def _getParser(self): + op = F8_IgnoreDisk._getParser(self) + op.add_option("--interactive", dest="interactive", action="store_true", + default=False) + return op + +F14_IgnoreDisk = RHEL6_IgnoreDisk diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/interactive.py b/scripts/lib/mic/3rdparty/pykickstart/commands/interactive.py new file mode 100644 index 0000000000..fa3dc025b1 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/interactive.py @@ -0,0 +1,58 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Interactive(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.interactive = kwargs.get("interactive", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.interactive: + retval += "# Use interactive kickstart installation method\ninteractive\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "interactive") + + self.interactive = True + return self + +class F14_Interactive(DeprecatedCommand): + def __init__(self): + DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/iscsi.py b/scripts/lib/mic/3rdparty/pykickstart/commands/iscsi.py new file mode 100644 index 0000000000..da5a544e86 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/iscsi.py @@ -0,0 +1,133 @@ +# +# Chris Lumens <clumens@redhat.com> +# Peter Jones <pjones@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_IscsiData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.ipaddr = kwargs.get("ipaddr", "") + self.port = kwargs.get("port", "3260") + self.target = kwargs.get("target", "") + self.user = kwargs.get("user", None) + self.password = kwargs.get("password", None) + + def _getArgsAsStr(self): + retval = "" + + if self.target != "": + retval += " --target=%s" % self.target + if self.ipaddr != "": + retval += " --ipaddr=%s" % self.ipaddr + if self.port != "3260": + retval += " --port=%s" % self.port + if self.user is not None: + retval += " --user=%s" % self.user + if self.password is not None: + retval += " --password=%s" % self.password + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "iscsi%s\n" % self._getArgsAsStr() + return retval + +class F10_IscsiData(FC6_IscsiData): + removedKeywords = FC6_IscsiData.removedKeywords + removedAttrs = FC6_IscsiData.removedAttrs + + def __init__(self, *args, **kwargs): + FC6_IscsiData.__init__(self, *args, **kwargs) + self.user_in = kwargs.get("user_in", None) + self.password_in = kwargs.get("password_in", None) + + def _getArgsAsStr(self): + retval = FC6_IscsiData._getArgsAsStr(self) + + if self.user_in is not None: + retval += " --reverse-user=%s" % self.user_in + if self.password_in is not None: + retval += " --reverse-password=%s" % self.password_in + + return retval + +class FC6_Iscsi(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=71, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.iscsi = kwargs.get("iscsi", []) + + def __str__(self): + retval = "" + for iscsi in self.iscsi: + retval += iscsi.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--target", dest="target", action="store", type="string") + op.add_option("--ipaddr", dest="ipaddr", action="store", type="string", + required=1) + op.add_option("--port", dest="port", action="store", type="string") + op.add_option("--user", dest="user", action="store", type="string") + op.add_option("--password", dest="password", action="store", + type="string") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) != 0: + mapping = {"command": "iscsi", "options": extra} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) + + dd = self.handler.IscsiData() + self._setToObj(self.op, opts, dd) + dd.lineno = self.lineno + return dd + + def dataList(self): + return self.iscsi + +class F10_Iscsi(FC6_Iscsi): + removedKeywords = FC6_Iscsi.removedKeywords + removedAttrs = FC6_Iscsi.removedAttrs + + def _getParser(self): + op = FC6_Iscsi._getParser(self) + op.add_option("--reverse-user", dest="user_in", action="store", + type="string") + op.add_option("--reverse-password", dest="password_in", action="store", + type="string") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/iscsiname.py b/scripts/lib/mic/3rdparty/pykickstart/commands/iscsiname.py new file mode 100644 index 0000000000..a87d0637d6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/iscsiname.py @@ -0,0 +1,54 @@ +# +# Chris Lumens <clumens@redhat.com> +# Peter Jones <pjones@redhat.com> +# +# Copyright 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_IscsiName(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=70, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.iscsiname = kwargs.get("iscsiname", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.iscsiname != "": + retval += "iscsiname %s\n" % self.iscsiname + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "iscsiname") + self.iscsiname = extra[0] + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/key.py b/scripts/lib/mic/3rdparty/pykickstart/commands/key.py new file mode 100644 index 0000000000..c20c4231f6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/key.py @@ -0,0 +1,64 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class RHEL5_Key(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.key = kwargs.get("key", "") + self.skip = kwargs.get("skip", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.key == KS_INSTKEY_SKIP: + retval += "key --skip\n" + elif self.key != "": + retval += "key %s\n" % self.key + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--skip", action="store_true", default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + + if self.skip: + self.key = KS_INSTKEY_SKIP + elif len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "key") + else: + self.key = extra[0] + + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/keyboard.py b/scripts/lib/mic/3rdparty/pykickstart/commands/keyboard.py new file mode 100644 index 0000000000..babc2acd4c --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/keyboard.py @@ -0,0 +1,55 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Keyboard(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.keyboard = kwargs.get("keyboard", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.keyboard != "": + retval += "# System keyboard\nkeyboard %s\n" % self.keyboard + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "keyboard") + + self.keyboard = extra[0] + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/lang.py b/scripts/lib/mic/3rdparty/pykickstart/commands/lang.py new file mode 100644 index 0000000000..cf5e46cda7 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/lang.py @@ -0,0 +1,60 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Lang(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.lang = kwargs.get("lang", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.lang != "": + retval += "# System language\nlang %s\n" % self.lang + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "lang") + + self.lang = extra[0] + return self + + def apply(self, instroot="/"): + if self.lang == "": return + f = open(instroot + "/etc/sysconfig/i18n", "w+") + f.write("LANG=\"%s\"\n" %(self.lang,)) + f.close() diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/langsupport.py b/scripts/lib/mic/3rdparty/pykickstart/commands/langsupport.py new file mode 100644 index 0000000000..73a9e537a9 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/langsupport.py @@ -0,0 +1,58 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +class FC3_LangSupport(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.deflang = kwargs.get("deflang", "") + self.supported = kwargs.get("supported", []) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.deflang: + retval += "langsupport --default=%s" % self.deflang + + if self.supported: + retval += " %s" % " ".join(self.supported) + + return retval + "\n" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--default", dest="deflang", default="en_US.UTF-8") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + self.supported = extra + return self + +class FC5_LangSupport(DeprecatedCommand): + def __init__(self): + DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/lilocheck.py b/scripts/lib/mic/3rdparty/pykickstart/commands/lilocheck.py new file mode 100644 index 0000000000..92b3f930b6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/lilocheck.py @@ -0,0 +1,54 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_LiloCheck(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.check = kwargs.get("check", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.check: + retval += "lilocheck\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "lilocheck") + + self.check = True + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/logging.py b/scripts/lib/mic/3rdparty/pykickstart/commands/logging.py new file mode 100644 index 0000000000..698561994d --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/logging.py @@ -0,0 +1,66 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007, 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_Logging(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.host = kwargs.get("host", "") + self.level = kwargs.get("level", "info") + self.port = kwargs.get("port", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + retval += "# Installation logging level\nlogging --level=%s" % self.level + + if self.host != "": + retval += " --host=%s" % self.host + + if self.port != "": + retval += " --port=%s" % self.port + + return retval + "\n" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--host") + op.add_option("--level", type="choice", default="info", + choices=["debug", "info", "warning", "error", "critical"]) + op.add_option("--port") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if opts.port and not opts.host: + raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("Can't specify --port without --host.")) + + self._setToSelf(self.op, opts) + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/logvol.py b/scripts/lib/mic/3rdparty/pykickstart/commands/logvol.py new file mode 100644 index 0000000000..c1b9cc3a61 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/logvol.py @@ -0,0 +1,304 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_LogVolData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.fstype = kwargs.get("fstype", "") + self.grow = kwargs.get("grow", False) + self.maxSizeMB = kwargs.get("maxSizeMB", 0) + self.name = kwargs.get("name", "") + self.format = kwargs.get("format", True) + self.percent = kwargs.get("percent", 0) + self.recommended = kwargs.get("recommended", False) + self.size = kwargs.get("size", None) + self.preexist = kwargs.get("preexist", False) + self.vgname = kwargs.get("vgname", "") + self.mountpoint = kwargs.get("mountpoint", "") + + def __eq__(self, y): + return self.vgname == y.vgname and self.name == y.name + + def _getArgsAsStr(self): + retval = "" + + if self.fstype != "": + retval += " --fstype=\"%s\"" % self.fstype + if self.grow: + retval += " --grow" + if self.maxSizeMB > 0: + retval += " --maxsize=%d" % self.maxSizeMB + if not self.format: + retval += " --noformat" + if self.percent > 0: + retval += " --percent=%d" % self.percent + if self.recommended: + retval += " --recommended" + if self.size > 0: + retval += " --size=%d" % self.size + if self.preexist: + retval += " --useexisting" + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "logvol %s %s --name=%s --vgname=%s\n" % (self.mountpoint, self._getArgsAsStr(), self.name, self.vgname) + return retval + +class FC4_LogVolData(FC3_LogVolData): + removedKeywords = FC3_LogVolData.removedKeywords + removedAttrs = FC3_LogVolData.removedAttrs + + def __init__(self, *args, **kwargs): + FC3_LogVolData.__init__(self, *args, **kwargs) + self.bytesPerInode = kwargs.get("bytesPerInode", 4096) + self.fsopts = kwargs.get("fsopts", "") + + def _getArgsAsStr(self): + retval = FC3_LogVolData._getArgsAsStr(self) + + if hasattr(self, "bytesPerInode") and self.bytesPerInode != 0: + retval += " --bytes-per-inode=%d" % self.bytesPerInode + if self.fsopts != "": + retval += " --fsoptions=\"%s\"" % self.fsopts + + return retval + +class RHEL5_LogVolData(FC4_LogVolData): + removedKeywords = FC4_LogVolData.removedKeywords + removedAttrs = FC4_LogVolData.removedAttrs + + def __init__(self, *args, **kwargs): + FC4_LogVolData.__init__(self, *args, **kwargs) + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + def _getArgsAsStr(self): + retval = FC4_LogVolData._getArgsAsStr(self) + + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\"" % self.passphrase + + return retval + +class F9_LogVolData(FC4_LogVolData): + removedKeywords = FC4_LogVolData.removedKeywords + ["bytesPerInode"] + removedAttrs = FC4_LogVolData.removedAttrs + ["bytesPerInode"] + + def __init__(self, *args, **kwargs): + FC4_LogVolData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.fsopts = kwargs.get("fsopts", "") + self.fsprofile = kwargs.get("fsprofile", "") + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + def _getArgsAsStr(self): + retval = FC4_LogVolData._getArgsAsStr(self) + + if self.fsprofile != "": + retval += " --fsprofile=\"%s\"" % self.fsprofile + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\"" % self.passphrase + + return retval + +class F12_LogVolData(F9_LogVolData): + removedKeywords = F9_LogVolData.removedKeywords + removedAttrs = F9_LogVolData.removedAttrs + + def __init__(self, *args, **kwargs): + F9_LogVolData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.escrowcert = kwargs.get("escrowcert", "") + self.backuppassphrase = kwargs.get("backuppassphrase", False) + + def _getArgsAsStr(self): + retval = F9_LogVolData._getArgsAsStr(self) + + if self.encrypted and self.escrowcert != "": + retval += " --escrowcert=\"%s\"" % self.escrowcert + + if self.backuppassphrase: + retval += " --backuppassphrase" + + return retval + +F14_LogVolData = F12_LogVolData + +class F15_LogVolData(F14_LogVolData): + removedKeywords = F14_LogVolData.removedKeywords + removedAttrs = F14_LogVolData.removedAttrs + + def __init__(self, *args, **kwargs): + F14_LogVolData.__init__(self, *args, **kwargs) + self.label = kwargs.get("label", "") + + def _getArgsAsStr(self): + retval = F14_LogVolData._getArgsAsStr(self) + + if self.label != "": + retval += " --label=\"%s\"" % self.label + + return retval + +class FC3_LogVol(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=133, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.lvList = kwargs.get("lvList", []) + + def __str__(self): + retval = "" + + for part in self.lvList: + retval += part.__str__() + + return retval + + def _getParser(self): + def lv_cb (option, opt_str, value, parser): + parser.values.format = False + parser.values.preexist = True + + op = KSOptionParser() + op.add_option("--fstype", dest="fstype") + op.add_option("--grow", dest="grow", action="store_true", + default=False) + op.add_option("--maxsize", dest="maxSizeMB", action="store", type="int", + nargs=1) + op.add_option("--name", dest="name", required=1) + op.add_option("--noformat", action="callback", callback=lv_cb, + dest="format", default=True, nargs=0) + op.add_option("--percent", dest="percent", action="store", type="int", + nargs=1) + op.add_option("--recommended", dest="recommended", action="store_true", + default=False) + op.add_option("--size", dest="size", action="store", type="int", + nargs=1) + op.add_option("--useexisting", dest="preexist", action="store_true", + default=False) + op.add_option("--vgname", dest="vgname", required=1) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) == 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Mount point required for %s") % "logvol") + + lvd = self.handler.LogVolData() + self._setToObj(self.op, opts, lvd) + lvd.lineno = self.lineno + lvd.mountpoint=extra[0] + + # Check for duplicates in the data list. + if lvd in self.dataList(): + warnings.warn(_("A logical volume with the name %s has already been defined in volume group %s.") % (lvd.device, lvd.vgname)) + + return lvd + + def dataList(self): + return self.lvList + +class FC4_LogVol(FC3_LogVol): + removedKeywords = FC3_LogVol.removedKeywords + removedAttrs = FC3_LogVol.removedAttrs + + def _getParser(self): + op = FC3_LogVol._getParser(self) + op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store", + type="int", nargs=1) + op.add_option("--fsoptions", dest="fsopts") + return op + +class RHEL5_LogVol(FC4_LogVol): + removedKeywords = FC4_LogVol.removedKeywords + removedAttrs = FC4_LogVol.removedAttrs + + def _getParser(self): + op = FC4_LogVol._getParser(self) + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + +class F9_LogVol(FC4_LogVol): + removedKeywords = FC4_LogVol.removedKeywords + removedAttrs = FC4_LogVol.removedAttrs + + def _getParser(self): + op = FC4_LogVol._getParser(self) + op.add_option("--bytes-per-inode", deprecated=1) + op.add_option("--fsprofile", dest="fsprofile", action="store", + type="string", nargs=1) + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + +class F12_LogVol(F9_LogVol): + removedKeywords = F9_LogVol.removedKeywords + removedAttrs = F9_LogVol.removedAttrs + + def _getParser(self): + op = F9_LogVol._getParser(self) + op.add_option("--escrowcert") + op.add_option("--backuppassphrase", action="store_true", default=False) + return op + +class F14_LogVol(F12_LogVol): + removedKeywords = F12_LogVol.removedKeywords + removedAttrs = F12_LogVol.removedAttrs + + def _getParser(self): + op = F12_LogVol._getParser(self) + op.remove_option("--bytes-per-inode") + return op + +class F15_LogVol(F14_LogVol): + removedKeywords = F14_LogVol.removedKeywords + removedAttrs = F14_LogVol.removedAttrs + + def _getParser(self): + op = F14_LogVol._getParser(self) + op.add_option("--label") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/mediacheck.py b/scripts/lib/mic/3rdparty/pykickstart/commands/mediacheck.py new file mode 100644 index 0000000000..388823a839 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/mediacheck.py @@ -0,0 +1,53 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC4_MediaCheck(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.mediacheck = kwargs.get("mediacheck", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + if self.mediacheck: + retval += "mediacheck\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "mediacheck") + + self.mediacheck = True + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/method.py b/scripts/lib/mic/3rdparty/pykickstart/commands/method.py new file mode 100644 index 0000000000..e21064acda --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/method.py @@ -0,0 +1,186 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007, 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Method(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.method = kwargs.get("method", "") + + # Set all these attributes so calls to this command's __call__ + # method can set them. However we don't want to provide them as + # arguments to __init__ because method is special. + self.biospart = None + self.partition = None + self.server = None + self.dir = None + self.url = None + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.method == "cdrom": + retval += "# Use CDROM installation media\ncdrom\n" + elif self.method == "harddrive": + msg = "# Use hard drive installation media\nharddrive --dir=%s" % self.dir + + if self.biospart is not None: + retval += msg + " --biospart=%s\n" % self.biospart + else: + retval += msg + " --partition=%s\n" % self.partition + elif self.method == "nfs": + retval += "# Use NFS installation media\nnfs --server=%s --dir=%s\n" % (self.server, self.dir) + elif self.method == "url": + retval += "# Use network installation\nurl --url=\"%s\"\n" % self.url + + return retval + + def _getParser(self): + op = KSOptionParser() + + # method = "cdrom" falls through to the return + if self.currentCmd == "harddrive": + op.add_option("--biospart", dest="biospart") + op.add_option("--partition", dest="partition") + op.add_option("--dir", dest="dir", required=1) + elif self.currentCmd == "nfs": + op.add_option("--server", dest="server", required=1) + op.add_option("--dir", dest="dir", required=1) + elif self.currentCmd == "url": + op.add_option("--url", dest="url", required=1) + + return op + + def parse(self, args): + self.method = self.currentCmd + + op = self._getParser() + (opts, extra) = op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(op, opts) + + if self.currentCmd == "harddrive": + if self.biospart is None and self.partition is None or \ + self.biospart is not None and self.partition is not None: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of biospart or partition options must be specified.")) + + return self + +class FC6_Method(FC3_Method): + removedKeywords = FC3_Method.removedKeywords + removedAttrs = FC3_Method.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_Method.__init__(self, writePriority, *args, **kwargs) + + # Same reason for this attribute as the comment in FC3_Method. + self.opts = None + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.method == "cdrom": + retval += "# Use CDROM installation media\ncdrom\n" + elif self.method == "harddrive": + msg = "# Use hard drive installation media\nharddrive --dir=%s" % self.dir + + if self.biospart is not None: + retval += msg + " --biospart=%s\n" % self.biospart + else: + retval += msg + " --partition=%s\n" % self.partition + elif self.method == "nfs": + retval += "# Use NFS installation media\nnfs --server=%s --dir=%s" % (self.server, self.dir) + if self.opts is not None: + retval += " --opts=\"%s\"" % self.opts + retval += "\n" + elif self.method == "url": + retval += "# Use network installation\nurl --url=\"%s\"\n" % self.url + + return retval + + def _getParser(self): + op = FC3_Method._getParser(self) + + if self.currentCmd == "nfs": + op.add_option("--opts", dest="opts") + + return op + +class F13_Method(FC6_Method): + removedKeywords = FC6_Method.removedKeywords + removedAttrs = FC6_Method.removedAttrs + + def __init__(self, *args, **kwargs): + FC6_Method.__init__(self, *args, **kwargs) + + # And same as all the other __init__ methods. + self.proxy = "" + + def __str__(self): + retval = FC6_Method.__str__(self) + + if self.method == "url" and self.proxy: + retval = retval.strip() + retval += " --proxy=\"%s\"\n" % self.proxy + + return retval + + def _getParser(self): + op = FC6_Method._getParser(self) + + if self.currentCmd == "url": + op.add_option("--proxy") + + return op + +class F14_Method(F13_Method): + removedKeywords = F13_Method.removedKeywords + removedAttrs = F13_Method.removedAttrs + + def __init__(self, *args, **kwargs): + F13_Method.__init__(self, *args, **kwargs) + + self.noverifyssl = False + + def __str__(self): + retval = F13_Method.__str__(self) + + if self.method == "url" and self.noverifyssl: + retval = retval.strip() + retval += " --noverifyssl\n" + + return retval + + def _getParser(self): + op = F13_Method._getParser(self) + + if self.currentCmd == "url": + op.add_option("--noverifyssl", action="store_true", default=False) + + return op + +RHEL6_Method = F14_Method diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/monitor.py b/scripts/lib/mic/3rdparty/pykickstart/commands/monitor.py new file mode 100644 index 0000000000..8c8c2c4fc9 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/monitor.py @@ -0,0 +1,106 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Monitor(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.hsync = kwargs.get("hsync", "") + self.monitor = kwargs.get("monitor", "") + self.vsync = kwargs.get("vsync", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + retval += "monitor" + + if self.hsync != "": + retval += " --hsync=%s" % self.hsync + if self.monitor != "": + retval += " --monitor=\"%s\"" % self.monitor + if self.vsync != "": + retval += " --vsync=%s" % self.vsync + + if retval != "monitor": + return retval + "\n" + else: + return "" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--hsync") + op.add_option("--monitor") + op.add_option("--vsync") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if extra: + mapping = {"cmd": "monitor", "options": extra} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(cmd)s command: %(options)s") % mapping) + + self._setToSelf(self.op, opts) + return self + +class FC6_Monitor(FC3_Monitor): + removedKeywords = FC3_Monitor.removedKeywords + removedAttrs = FC3_Monitor.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_Monitor.__init__(self, writePriority, *args, **kwargs) + self.probe = kwargs.get("probe", True) + + def __str__(self): + retval = KickstartCommand.__str__(self) + retval += "monitor" + + if self.hsync != "": + retval += " --hsync=%s" % self.hsync + if self.monitor != "": + retval += " --monitor=\"%s\"" % self.monitor + if not self.probe: + retval += " --noprobe" + if self.vsync != "": + retval += " --vsync=%s" % self.vsync + + if retval != "monitor": + return retval + "\n" + else: + return "" + + def _getParser(self): + op = FC3_Monitor._getParser(self) + op.add_option("--noprobe", dest="probe", action="store_false", + default=True) + return op + +class F10_Monitor(DeprecatedCommand): + def __init__(self): + DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/mouse.py b/scripts/lib/mic/3rdparty/pykickstart/commands/mouse.py new file mode 100644 index 0000000000..c643bcedc3 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/mouse.py @@ -0,0 +1,70 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class RHEL3_Mouse(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.device = kwargs.get("device", "") + self.emulthree = kwargs.get("emulthree", False) + self.mouse = kwargs.get("mouse", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + opts = "" + if self.device: + opts += "--device=%s " % self.device + if self.emulthree: + opts += "--emulthree " + + if self.mouse: + retval += "# System mouse\nmouse %s%s\n" % (opts, self.mouse) + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--device", dest="device", default="") + op.add_option("--emulthree", dest="emulthree", default=False, action="store_true") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s requires one argument") % "mouse") + + self.mouse = extra[0] + return self + +class FC3_Mouse(DeprecatedCommand): + def __init__(self): + DeprecatedCommand.__init__(self) diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/multipath.py b/scripts/lib/mic/3rdparty/pykickstart/commands/multipath.py new file mode 100644 index 0000000000..84ba755e68 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/multipath.py @@ -0,0 +1,111 @@ +# +# Chris Lumens <clumens@redhat.com> +# Peter Jones <pjones@redhat.com> +# +# Copyright 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_MpPathData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.mpdev = kwargs.get("mpdev", "") + self.device = kwargs.get("device", "") + self.rule = kwargs.get("rule", "") + + def __str__(self): + return " --device=%s --rule=\"%s\"" % (self.device, self.rule) + +class FC6_MultiPathData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.name = kwargs.get("name", "") + self.paths = kwargs.get("paths", []) + + def __str__(self): + retval = BaseData.__str__(self) + + for path in self.paths: + retval += "multipath --mpdev=%s %s\n" % (self.name, path.__str__()) + + return retval + +class FC6_MultiPath(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=50, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.mpaths = kwargs.get("mpaths", []) + + def __str__(self): + retval = "" + for mpath in self.mpaths: + retval += mpath.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--name", dest="name", action="store", type="string", + required=1) + op.add_option("--device", dest="device", action="store", type="string", + required=1) + op.add_option("--rule", dest="rule", action="store", type="string", + required=1) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + dd = FC6_MpPathData() + self._setToObj(self.op, opts, dd) + dd.lineno = self.lineno + dd.mpdev = dd.mpdev.split('/')[-1] + + parent = None + for x in range(0, len(self.mpaths)): + mpath = self.mpaths[x] + for path in mpath.paths: + if path.device == dd.device: + mapping = {"device": path.device, "multipathdev": path.mpdev} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Device '%(device)s' is already used in multipath '%(multipathdev)s'") % mapping) + if mpath.name == dd.mpdev: + parent = x + + if parent is None: + mpath = FC6_MultiPathData() + return mpath + else: + mpath = self.mpaths[parent] + + return dd + + def dataList(self): + return self.mpaths diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/network.py b/scripts/lib/mic/3rdparty/pykickstart/commands/network.py new file mode 100644 index 0000000000..9b67f92831 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/network.py @@ -0,0 +1,363 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_NetworkData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.bootProto = kwargs.get("bootProto", BOOTPROTO_DHCP) + self.dhcpclass = kwargs.get("dhcpclass", "") + self.device = kwargs.get("device", "") + self.essid = kwargs.get("essid", "") + self.ethtool = kwargs.get("ethtool", "") + self.gateway = kwargs.get("gateway", "") + self.hostname = kwargs.get("hostname", "") + self.ip = kwargs.get("ip", "") + self.mtu = kwargs.get("mtu", "") + self.nameserver = kwargs.get("nameserver", "") + self.netmask = kwargs.get("netmask", "") + self.nodns = kwargs.get("nodns", False) + self.onboot = kwargs.get("onboot", True) + self.wepkey = kwargs.get("wepkey", "") + + def __eq__(self, y): + return self.device and self.device == y.device + + def _getArgsAsStr(self): + retval = "" + + if self.bootProto != "": + retval += " --bootproto=%s" % self.bootProto + if self.dhcpclass != "": + retval += " --dhcpclass=%s" % self.dhcpclass + if self.device != "": + retval += " --device=%s" % self.device + if self.essid != "": + retval += " --essid=\"%s\"" % self.essid + if self.ethtool != "": + retval += " --ethtool=\"%s\"" % self.ethtool + if self.gateway != "": + retval += " --gateway=%s" % self.gateway + if self.hostname != "": + retval += " --hostname=%s" % self.hostname + if self.ip != "": + retval += " --ip=%s" % self.ip + if self.mtu != "": + retval += " --mtu=%s" % self.mtu + if self.nameserver != "": + retval += " --nameserver=%s" % self.nameserver + if self.netmask != "": + retval += " --netmask=%s" % self.netmask + if self.nodns: + retval += " --nodns" + if not self.onboot: + retval += " --onboot=off" + if self.wepkey != "": + retval += " --wepkey=%s" % self.wepkey + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "network %s\n" % self._getArgsAsStr() + return retval + +class FC4_NetworkData(FC3_NetworkData): + removedKeywords = FC3_NetworkData.removedKeywords + removedAttrs = FC3_NetworkData.removedAttrs + + def __init__(self, *args, **kwargs): + FC3_NetworkData.__init__(self, *args, **kwargs) + self.notksdevice = kwargs.get("notksdevice", False) + + def _getArgsAsStr(self): + retval = FC3_NetworkData._getArgsAsStr(self) + + if self.notksdevice: + retval += " --notksdevice" + + return retval + +class FC6_NetworkData(FC4_NetworkData): + removedKeywords = FC4_NetworkData.removedKeywords + removedAttrs = FC4_NetworkData.removedAttrs + + def __init__(self, *args, **kwargs): + FC4_NetworkData.__init__(self, *args, **kwargs) + self.noipv4 = kwargs.get("noipv4", False) + self.noipv6 = kwargs.get("noipv6", False) + + def _getArgsAsStr(self): + retval = FC4_NetworkData._getArgsAsStr(self) + + if self.noipv4: + retval += " --noipv4" + if self.noipv6: + retval += " --noipv6" + + return retval + +class F8_NetworkData(FC6_NetworkData): + removedKeywords = FC6_NetworkData.removedKeywords + removedAttrs = FC6_NetworkData.removedAttrs + + def __init__(self, *args, **kwargs): + FC6_NetworkData.__init__(self, *args, **kwargs) + self.ipv6 = kwargs.get("ipv6", "") + + def _getArgsAsStr(self): + retval = FC6_NetworkData._getArgsAsStr(self) + + if self.ipv6 != "": + retval += " --ipv6" % self.ipv6 + + return retval + +class F16_NetworkData(F8_NetworkData): + removedKeywords = F8_NetworkData.removedKeywords + removedAttrs = F8_NetworkData.removedAttrs + + def __init__(self, *args, **kwargs): + F8_NetworkData.__init__(self, *args, **kwargs) + self.activate = kwargs.get("activate", False) + self.nodefroute = kwargs.get("nodefroute", False) + self.wpakey = kwargs.get("wpakey", "") + + def _getArgsAsStr(self): + retval = F8_NetworkData._getArgsAsStr(self) + + if self.activate: + retval += " --activate" + if self.nodefroute: + retval += " --nodefroute" + if self.wpakey != "": + retval += "--wpakey=%s" % self.wpakey + + return retval + +class RHEL4_NetworkData(FC3_NetworkData): + removedKeywords = FC3_NetworkData.removedKeywords + removedAttrs = FC3_NetworkData.removedAttrs + + def __init__(self, *args, **kwargs): + FC3_NetworkData.__init__(self, *args, **kwargs) + self.notksdevice = kwargs.get("notksdevice", False) + + def _getArgsAsStr(self): + retval = FC3_NetworkData._getArgsAsStr(self) + + if self.notksdevice: + retval += " --notksdevice" + + return retval + +class RHEL6_NetworkData(F8_NetworkData): + removedKeywords = F8_NetworkData.removedKeywords + removedAttrs = F8_NetworkData.removedAttrs + + def __init__(self, *args, **kwargs): + F8_NetworkData.__init__(self, *args, **kwargs) + self.activate = kwargs.get("activate", False) + self.nodefroute = kwargs.get("nodefroute", False) + + def _getArgsAsStr(self): + retval = F8_NetworkData._getArgsAsStr(self) + + if self.activate: + retval += " --activate" + if self.nodefroute: + retval += " --nodefroute" + + return retval + +class FC3_Network(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.bootprotoList = [BOOTPROTO_DHCP, BOOTPROTO_BOOTP, + BOOTPROTO_STATIC] + + self.op = self._getParser() + + self.network = kwargs.get("network", []) + + def __str__(self): + retval = "" + + for nic in self.network: + retval += nic.__str__() + + if retval != "": + return "# Network information\n" + retval + else: + return "" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--bootproto", dest="bootProto", + default=BOOTPROTO_DHCP, + choices=self.bootprotoList) + op.add_option("--dhcpclass", dest="dhcpclass") + op.add_option("--device", dest="device") + op.add_option("--essid", dest="essid") + op.add_option("--ethtool", dest="ethtool") + op.add_option("--gateway", dest="gateway") + op.add_option("--hostname", dest="hostname") + op.add_option("--ip", dest="ip") + op.add_option("--mtu", dest="mtu") + op.add_option("--nameserver", dest="nameserver") + op.add_option("--netmask", dest="netmask") + op.add_option("--nodns", dest="nodns", action="store_true", + default=False) + op.add_option("--onboot", dest="onboot", action="store", + type="ksboolean") + op.add_option("--wepkey", dest="wepkey") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + nd = self.handler.NetworkData() + self._setToObj(self.op, opts, nd) + nd.lineno = self.lineno + + # Check for duplicates in the data list. + if nd in self.dataList(): + warnings.warn(_("A network device with the name %s has already been defined.") % nd.device) + + return nd + + def dataList(self): + return self.network + +class FC4_Network(FC3_Network): + removedKeywords = FC3_Network.removedKeywords + removedAttrs = FC3_Network.removedAttrs + + def _getParser(self): + op = FC3_Network._getParser(self) + op.add_option("--notksdevice", dest="notksdevice", action="store_true", + default=False) + return op + +class FC6_Network(FC4_Network): + removedKeywords = FC4_Network.removedKeywords + removedAttrs = FC4_Network.removedAttrs + + def _getParser(self): + op = FC4_Network._getParser(self) + op.add_option("--noipv4", dest="noipv4", action="store_true", + default=False) + op.add_option("--noipv6", dest="noipv6", action="store_true", + default=False) + return op + +class F8_Network(FC6_Network): + removedKeywords = FC6_Network.removedKeywords + removedAttrs = FC6_Network.removedAttrs + + def _getParser(self): + op = FC6_Network._getParser(self) + op.add_option("--ipv6", dest="ipv6") + return op + +class F9_Network(F8_Network): + removedKeywords = F8_Network.removedKeywords + removedAttrs = F8_Network.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + F8_Network.__init__(self, writePriority, *args, **kwargs) + self.bootprotoList.append(BOOTPROTO_QUERY) + + def _getParser(self): + op = F8_Network._getParser(self) + op.add_option("--bootproto", dest="bootProto", + default=BOOTPROTO_DHCP, + choices=self.bootprotoList) + return op + +class F16_Network(F9_Network): + removedKeywords = F9_Network.removedKeywords + removedAttrs = F9_Network.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + F9_Network.__init__(self, writePriority, *args, **kwargs) + self.bootprotoList.append(BOOTPROTO_IBFT) + + def _getParser(self): + op = F9_Network._getParser(self) + op.add_option("--activate", dest="activate", action="store_true", + default=False) + op.add_option("--nodefroute", dest="nodefroute", action="store_true", + default=False) + op.add_option("--wpakey", dest="wpakey", action="store", default="") + return op + +class RHEL4_Network(FC3_Network): + removedKeywords = FC3_Network.removedKeywords + removedAttrs = FC3_Network.removedAttrs + + def _getParser(self): + op = FC3_Network._getParser(self) + op.add_option("--notksdevice", dest="notksdevice", action="store_true", + default=False) + return op + +class RHEL5_Network(FC6_Network): + removedKeywords = FC6_Network.removedKeywords + removedAttrs = FC6_Network.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC6_Network.__init__(self, writePriority, *args, **kwargs) + self.bootprotoList.append(BOOTPROTO_QUERY) + + def _getParser(self): + op = FC6_Network._getParser(self) + op.add_option("--bootproto", dest="bootProto", + default=BOOTPROTO_DHCP, + choices=self.bootprotoList) + return op + +class RHEL6_Network(F9_Network): + removedKeywords = F9_Network.removedKeywords + removedAttrs = F9_Network.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + F9_Network.__init__(self, writePriority, *args, **kwargs) + self.bootprotoList.append(BOOTPROTO_IBFT) + + def _getParser(self): + op = F9_Network._getParser(self) + op.add_option("--activate", dest="activate", action="store_true", + default=False) + op.add_option("--nodefroute", dest="nodefroute", action="store_true", + default=False) + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/partition.py b/scripts/lib/mic/3rdparty/pykickstart/commands/partition.py new file mode 100644 index 0000000000..e65e012d02 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/partition.py @@ -0,0 +1,353 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_PartData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.active = kwargs.get("active", False) + self.primOnly = kwargs.get("primOnly", False) + self.end = kwargs.get("end", 0) + self.fstype = kwargs.get("fstype", "") + self.grow = kwargs.get("grow", False) + self.maxSizeMB = kwargs.get("maxSizeMB", 0) + self.format = kwargs.get("format", True) + self.onbiosdisk = kwargs.get("onbiosdisk", "") + self.disk = kwargs.get("disk", "") + self.onPart = kwargs.get("onPart", "") + self.recommended = kwargs.get("recommended", False) + self.size = kwargs.get("size", None) + self.start = kwargs.get("start", 0) + self.mountpoint = kwargs.get("mountpoint", "") + + def __eq__(self, y): + if self.mountpoint: + return self.mountpoint == y.mountpoint + else: + return False + + def _getArgsAsStr(self): + retval = "" + + if self.active: + retval += " --active" + if self.primOnly: + retval += " --asprimary" + if hasattr(self, "end") and self.end != 0: + retval += " --end=%s" % self.end + if self.fstype != "": + retval += " --fstype=\"%s\"" % self.fstype + if self.grow: + retval += " --grow" + if self.maxSizeMB > 0: + retval += " --maxsize=%d" % self.maxSizeMB + if not self.format: + retval += " --noformat" + if self.onbiosdisk != "": + retval += " --onbiosdisk=%s" % self.onbiosdisk + if self.disk != "": + retval += " --ondisk=%s" % self.disk + if self.onPart != "": + retval += " --onpart=%s" % self.onPart + if self.recommended: + retval += " --recommended" + if self.size and self.size != 0: + retval += " --size=%s" % self.size + if hasattr(self, "start") and self.start != 0: + retval += " --start=%s" % self.start + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + if self.mountpoint: + mountpoint_str = "%s" % self.mountpoint + else: + mountpoint_str = "(No mount point)" + retval += "part %s%s\n" % (mountpoint_str, self._getArgsAsStr()) + return retval + +class FC4_PartData(FC3_PartData): + removedKeywords = FC3_PartData.removedKeywords + removedAttrs = FC3_PartData.removedAttrs + + def __init__(self, *args, **kwargs): + FC3_PartData.__init__(self, *args, **kwargs) + self.bytesPerInode = kwargs.get("bytesPerInode", 4096) + self.fsopts = kwargs.get("fsopts", "") + self.label = kwargs.get("label", "") + + def _getArgsAsStr(self): + retval = FC3_PartData._getArgsAsStr(self) + + if hasattr(self, "bytesPerInode") and self.bytesPerInode != 0: + retval += " --bytes-per-inode=%d" % self.bytesPerInode + if self.fsopts != "": + retval += " --fsoptions=\"%s\"" % self.fsopts + if self.label != "": + retval += " --label=%s" % self.label + + return retval + +class RHEL5_PartData(FC4_PartData): + removedKeywords = FC4_PartData.removedKeywords + removedAttrs = FC4_PartData.removedAttrs + + def __init__(self, *args, **kwargs): + FC4_PartData.__init__(self, *args, **kwargs) + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + def _getArgsAsStr(self): + retval = FC4_PartData._getArgsAsStr(self) + + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\"" % self.passphrase + + return retval + +class F9_PartData(FC4_PartData): + removedKeywords = FC4_PartData.removedKeywords + ["bytesPerInode"] + removedAttrs = FC4_PartData.removedAttrs + ["bytesPerInode"] + + def __init__(self, *args, **kwargs): + FC4_PartData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.fsopts = kwargs.get("fsopts", "") + self.label = kwargs.get("label", "") + self.fsprofile = kwargs.get("fsprofile", "") + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + def _getArgsAsStr(self): + retval = FC4_PartData._getArgsAsStr(self) + + if self.fsprofile != "": + retval += " --fsprofile=\"%s\"" % self.fsprofile + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\"" % self.passphrase + + return retval + +class F11_PartData(F9_PartData): + removedKeywords = F9_PartData.removedKeywords + ["start", "end"] + removedAttrs = F9_PartData.removedAttrs + ["start", "end"] + +class F12_PartData(F11_PartData): + removedKeywords = F11_PartData.removedKeywords + removedAttrs = F11_PartData.removedAttrs + + def __init__(self, *args, **kwargs): + F11_PartData.__init__(self, *args, **kwargs) + + self.escrowcert = kwargs.get("escrowcert", "") + self.backuppassphrase = kwargs.get("backuppassphrase", False) + + def _getArgsAsStr(self): + retval = F11_PartData._getArgsAsStr(self) + + if self.encrypted and self.escrowcert != "": + retval += " --escrowcert=\"%s\"" % self.escrowcert + + if self.backuppassphrase: + retval += " --backuppassphrase" + + return retval + +F14_PartData = F12_PartData + +class FC3_Partition(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=130, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.partitions = kwargs.get("partitions", []) + + def __str__(self): + retval = "" + + for part in self.partitions: + retval += part.__str__() + + if retval != "": + return "# Disk partitioning information\n" + retval + else: + return "" + + def _getParser(self): + def part_cb (option, opt_str, value, parser): + if value.startswith("/dev/"): + parser.values.ensure_value(option.dest, value[5:]) + else: + parser.values.ensure_value(option.dest, value) + + op = KSOptionParser() + op.add_option("--active", dest="active", action="store_true", + default=False) + op.add_option("--asprimary", dest="primOnly", action="store_true", + default=False) + op.add_option("--end", dest="end", action="store", type="int", + nargs=1) + op.add_option("--fstype", "--type", dest="fstype") + op.add_option("--grow", dest="grow", action="store_true", default=False) + op.add_option("--maxsize", dest="maxSizeMB", action="store", type="int", + nargs=1) + op.add_option("--noformat", dest="format", action="store_false", + default=True) + op.add_option("--onbiosdisk", dest="onbiosdisk") + op.add_option("--ondisk", "--ondrive", dest="disk") + op.add_option("--onpart", "--usepart", dest="onPart", action="callback", + callback=part_cb, nargs=1, type="string") + op.add_option("--recommended", dest="recommended", action="store_true", + default=False) + op.add_option("--size", dest="size", action="store", type="int", + nargs=1) + op.add_option("--start", dest="start", action="store", type="int", + nargs=1) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + pd = self.handler.PartData() + self._setToObj(self.op, opts, pd) + pd.lineno = self.lineno + if extra: + pd.mountpoint = extra[0] + if pd in self.dataList(): + warnings.warn(_("A partition with the mountpoint %s has already been defined.") % pd.mountpoint) + else: + pd.mountpoint = None + + return pd + + def dataList(self): + return self.partitions + +class FC4_Partition(FC3_Partition): + removedKeywords = FC3_Partition.removedKeywords + removedAttrs = FC3_Partition.removedAttrs + + def __init__(self, writePriority=130, *args, **kwargs): + FC3_Partition.__init__(self, writePriority, *args, **kwargs) + + def part_cb (option, opt_str, value, parser): + if value.startswith("/dev/"): + parser.values.ensure_value(option.dest, value[5:]) + else: + parser.values.ensure_value(option.dest, value) + + def _getParser(self): + op = FC3_Partition._getParser(self) + op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store", + type="int", nargs=1) + op.add_option("--fsoptions", dest="fsopts") + op.add_option("--label", dest="label") + return op + +class RHEL5_Partition(FC4_Partition): + removedKeywords = FC4_Partition.removedKeywords + removedAttrs = FC4_Partition.removedAttrs + + def __init__(self, writePriority=130, *args, **kwargs): + FC4_Partition.__init__(self, writePriority, *args, **kwargs) + + def part_cb (option, opt_str, value, parser): + if value.startswith("/dev/"): + parser.values.ensure_value(option.dest, value[5:]) + else: + parser.values.ensure_value(option.dest, value) + + def _getParser(self): + op = FC4_Partition._getParser(self) + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + +class F9_Partition(FC4_Partition): + removedKeywords = FC4_Partition.removedKeywords + removedAttrs = FC4_Partition.removedAttrs + + def __init__(self, writePriority=130, *args, **kwargs): + FC4_Partition.__init__(self, writePriority, *args, **kwargs) + + def part_cb (option, opt_str, value, parser): + if value.startswith("/dev/"): + parser.values.ensure_value(option.dest, value[5:]) + else: + parser.values.ensure_value(option.dest, value) + + def _getParser(self): + op = FC4_Partition._getParser(self) + op.add_option("--bytes-per-inode", deprecated=1) + op.add_option("--fsprofile") + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + +class F11_Partition(F9_Partition): + removedKeywords = F9_Partition.removedKeywords + removedAttrs = F9_Partition.removedAttrs + + def _getParser(self): + op = F9_Partition._getParser(self) + op.add_option("--start", deprecated=1) + op.add_option("--end", deprecated=1) + return op + +class F12_Partition(F11_Partition): + removedKeywords = F11_Partition.removedKeywords + removedAttrs = F11_Partition.removedAttrs + + def _getParser(self): + op = F11_Partition._getParser(self) + op.add_option("--escrowcert") + op.add_option("--backuppassphrase", action="store_true", default=False) + return op + +class F14_Partition(F12_Partition): + removedKeywords = F12_Partition.removedKeywords + removedAttrs = F12_Partition.removedAttrs + + def _getParser(self): + op = F12_Partition._getParser(self) + op.remove_option("--bytes-per-inode") + op.remove_option("--start") + op.remove_option("--end") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/raid.py b/scripts/lib/mic/3rdparty/pykickstart/commands/raid.py new file mode 100644 index 0000000000..0f4c92a107 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/raid.py @@ -0,0 +1,365 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008, 2011 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_RaidData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.device = kwargs.get("device", None) + self.fstype = kwargs.get("fstype", "") + self.level = kwargs.get("level", "") + self.format = kwargs.get("format", True) + self.spares = kwargs.get("spares", 0) + self.preexist = kwargs.get("preexist", False) + self.mountpoint = kwargs.get("mountpoint", "") + self.members = kwargs.get("members", []) + + def __eq__(self, y): + return self.device == y.device + + def _getArgsAsStr(self): + retval = "" + + if self.device != "": + retval += " --device=%s" % self.device + if self.fstype != "": + retval += " --fstype=\"%s\"" % self.fstype + if self.level != "": + retval += " --level=%s" % self.level + if not self.format: + retval += " --noformat" + if self.spares != 0: + retval += " --spares=%d" % self.spares + if self.preexist: + retval += " --useexisting" + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "raid %s%s %s\n" % (self.mountpoint, self._getArgsAsStr(), + " ".join(self.members)) + return retval + +class FC4_RaidData(FC3_RaidData): + removedKeywords = FC3_RaidData.removedKeywords + removedAttrs = FC3_RaidData.removedAttrs + + def __init__(self, *args, **kwargs): + FC3_RaidData.__init__(self, *args, **kwargs) + self.fsopts = kwargs.get("fsopts", "") + + def _getArgsAsStr(self): + retval = FC3_RaidData._getArgsAsStr(self) + + if self.fsopts != "": + retval += " --fsoptions=\"%s\"" % self.fsopts + + return retval + +class FC5_RaidData(FC4_RaidData): + removedKeywords = FC4_RaidData.removedKeywords + removedAttrs = FC4_RaidData.removedAttrs + + def __init__(self, *args, **kwargs): + FC4_RaidData.__init__(self, *args, **kwargs) + self.bytesPerInode = kwargs.get("bytesPerInode", 4096) + + def _getArgsAsStr(self): + retval = FC4_RaidData._getArgsAsStr(self) + + if hasattr(self, "bytesPerInode") and self.bytesPerInode != 0: + retval += " --bytes-per-inode=%d" % self.bytesPerInode + + return retval + +class RHEL5_RaidData(FC5_RaidData): + removedKeywords = FC5_RaidData.removedKeywords + removedAttrs = FC5_RaidData.removedAttrs + + def __init__(self, *args, **kwargs): + FC5_RaidData.__init__(self, *args, **kwargs) + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + def _getArgsAsStr(self): + retval = FC5_RaidData._getArgsAsStr(self) + + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\"" % self.passphrase + + return retval + +F7_RaidData = FC5_RaidData + +class F9_RaidData(FC5_RaidData): + removedKeywords = FC5_RaidData.removedKeywords + ["bytesPerInode"] + removedAttrs = FC5_RaidData.removedAttrs + ["bytesPerInode"] + + def __init__(self, *args, **kwargs): + FC5_RaidData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.fsprofile = kwargs.get("fsprofile", "") + self.encrypted = kwargs.get("encrypted", False) + self.passphrase = kwargs.get("passphrase", "") + + def _getArgsAsStr(self): + retval = FC5_RaidData._getArgsAsStr(self) + + if self.fsprofile != "": + retval += " --fsprofile=\"%s\"" % self.fsprofile + if self.encrypted: + retval += " --encrypted" + + if self.passphrase != "": + retval += " --passphrase=\"%s\"" % self.passphrase + + return retval + +class F12_RaidData(F9_RaidData): + removedKeywords = F9_RaidData.removedKeywords + removedAttrs = F9_RaidData.removedAttrs + + def __init__(self, *args, **kwargs): + F9_RaidData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.escrowcert = kwargs.get("escrowcert", "") + self.backuppassphrase = kwargs.get("backuppassphrase", False) + + def _getArgsAsStr(self): + retval = F9_RaidData._getArgsAsStr(self) + + if self.encrypted and self.escrowcert != "": + retval += " --escrowcert=\"%s\"" % self.escrowcert + + if self.backuppassphrase: + retval += " --backuppassphrase" + return retval + +F13_RaidData = F12_RaidData + +F14_RaidData = F13_RaidData + +class F15_RaidData(F14_RaidData): + removedKeywords = F14_RaidData.removedKeywords + removedAttrs = F14_RaidData.removedAttrs + + def __init__(self, *args, **kwargs): + F14_RaidData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + self.label = kwargs.get("label", "") + + def _getArgsAsStr(self): + retval = F14_RaidData._getArgsAsStr(self) + + if self.label != "": + retval += " --label=%s" % self.label + + return retval + +class FC3_Raid(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=131, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + # A dict of all the RAID levels we support. This means that if we + # support more levels in the future, subclasses don't have to + # duplicate too much. + self.levelMap = { "RAID0": "RAID0", "0": "RAID0", + "RAID1": "RAID1", "1": "RAID1", + "RAID5": "RAID5", "5": "RAID5", + "RAID6": "RAID6", "6": "RAID6" } + + self.raidList = kwargs.get("raidList", []) + + def __str__(self): + retval = "" + + for raid in self.raidList: + retval += raid.__str__() + + return retval + + def _getParser(self): + def raid_cb (option, opt_str, value, parser): + parser.values.format = False + parser.values.preexist = True + + def device_cb (option, opt_str, value, parser): + if value[0:2] == "md": + parser.values.ensure_value(option.dest, value[2:]) + else: + parser.values.ensure_value(option.dest, value) + + def level_cb (option, opt_str, value, parser): + if self.levelMap.has_key(value): + parser.values.ensure_value(option.dest, self.levelMap[value]) + + op = KSOptionParser() + op.add_option("--device", action="callback", callback=device_cb, + dest="device", type="string", nargs=1, required=1) + op.add_option("--fstype", dest="fstype") + op.add_option("--level", dest="level", action="callback", + callback=level_cb, type="string", nargs=1) + op.add_option("--noformat", action="callback", callback=raid_cb, + dest="format", default=True, nargs=0) + op.add_option("--spares", dest="spares", action="store", type="int", + nargs=1, default=0) + op.add_option("--useexisting", dest="preexist", action="store_true", + default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) == 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Mount point required for %s") % "raid") + if len(extra) == 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Partitions required for %s") % "raid") + + rd = self.handler.RaidData() + self._setToObj(self.op, opts, rd) + rd.lineno = self.lineno + + # --device can't just take an int in the callback above, because it + # could be specificed as "mdX", which causes optparse to error when + # it runs int(). + rd.device = int(rd.device) + rd.mountpoint = extra[0] + rd.members = extra[1:] + + # Check for duplicates in the data list. + if rd in self.dataList(): + warnings.warn(_("A RAID device with the name %s has already been defined.") % rd.device) + + return rd + + def dataList(self): + return self.raidList + +class FC4_Raid(FC3_Raid): + removedKeywords = FC3_Raid.removedKeywords + removedAttrs = FC3_Raid.removedAttrs + + def _getParser(self): + op = FC3_Raid._getParser(self) + op.add_option("--fsoptions", dest="fsopts") + return op + +class FC5_Raid(FC4_Raid): + removedKeywords = FC4_Raid.removedKeywords + removedAttrs = FC4_Raid.removedAttrs + + def _getParser(self): + op = FC4_Raid._getParser(self) + op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store", + type="int", nargs=1) + return op + +class RHEL5_Raid(FC5_Raid): + removedKeywords = FC5_Raid.removedKeywords + removedAttrs = FC5_Raid.removedAttrs + + def __init__(self, writePriority=131, *args, **kwargs): + FC5_Raid.__init__(self, writePriority, *args, **kwargs) + + self.levelMap.update({"RAID10": "RAID10", "10": "RAID10"}) + + def _getParser(self): + op = FC5_Raid._getParser(self) + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + +class F7_Raid(FC5_Raid): + removedKeywords = FC5_Raid.removedKeywords + removedAttrs = FC5_Raid.removedAttrs + + def __init__(self, writePriority=131, *args, **kwargs): + FC5_Raid.__init__(self, writePriority, *args, **kwargs) + + self.levelMap.update({"RAID10": "RAID10", "10": "RAID10"}) + +class F9_Raid(F7_Raid): + removedKeywords = F7_Raid.removedKeywords + removedAttrs = F7_Raid.removedAttrs + + def _getParser(self): + op = F7_Raid._getParser(self) + op.add_option("--bytes-per-inode", deprecated=1) + op.add_option("--fsprofile") + op.add_option("--encrypted", action="store_true", default=False) + op.add_option("--passphrase") + return op + +class F12_Raid(F9_Raid): + removedKeywords = F9_Raid.removedKeywords + removedAttrs = F9_Raid.removedAttrs + + def _getParser(self): + op = F9_Raid._getParser(self) + op.add_option("--escrowcert") + op.add_option("--backuppassphrase", action="store_true", default=False) + return op + +class F13_Raid(F12_Raid): + removedKeywords = F12_Raid.removedKeywords + removedAttrs = F12_Raid.removedAttrs + + def __init__(self, writePriority=131, *args, **kwargs): + F12_Raid.__init__(self, writePriority, *args, **kwargs) + + self.levelMap.update({"RAID4": "RAID4", "4": "RAID4"}) + +class F14_Raid(F13_Raid): + removedKeywords = F13_Raid.removedKeywords + removedAttrs = F13_Raid.removedAttrs + + def _getParser(self): + op = F13_Raid._getParser(self) + op.remove_option("--bytes-per-inode") + return op + +class F15_Raid(F14_Raid): + removedKeywords = F14_Raid.removedKeywords + removedAttrs = F14_Raid.removedAttrs + + def _getParser(self): + op = F14_Raid._getParser(self) + op.add_option("--label") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/reboot.py b/scripts/lib/mic/3rdparty/pykickstart/commands/reboot.py new file mode 100644 index 0000000000..391af14c22 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/reboot.py @@ -0,0 +1,79 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +class FC3_Reboot(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.action = kwargs.get("action", None) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.action == KS_REBOOT: + retval += "# Reboot after installation\nreboot\n" + elif self.action == KS_SHUTDOWN: + retval += "# Shutdown after installation\nshutdown\n" + + return retval + + def parse(self, args): + if self.currentCmd == "reboot": + self.action = KS_REBOOT + else: + self.action = KS_SHUTDOWN + + return self + +class FC6_Reboot(FC3_Reboot): + removedKeywords = FC3_Reboot.removedKeywords + removedAttrs = FC3_Reboot.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_Reboot.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.eject = kwargs.get("eject", False) + + def __str__(self): + retval = FC3_Reboot.__str__(self).rstrip() + + if self.eject: + retval += " --eject" + + return retval + "\n" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--eject", dest="eject", action="store_true", + default=False) + return op + + def parse(self, args): + FC3_Reboot.parse(self, args) + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/repo.py b/scripts/lib/mic/3rdparty/pykickstart/commands/repo.py new file mode 100644 index 0000000000..543ef947c1 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/repo.py @@ -0,0 +1,249 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007, 2008, 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_RepoData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.baseurl = kwargs.get("baseurl", "") + self.mirrorlist = kwargs.get("mirrorlist", None) + self.name = kwargs.get("name", "") + + def __eq__(self, y): + return self.name == y.name + + def _getArgsAsStr(self): + retval = "" + + if self.baseurl: + retval += "--baseurl=%s" % self.baseurl + elif self.mirrorlist: + retval += "--mirrorlist=%s" % self.mirrorlist + + return retval + + def __str__(self): + retval = BaseData.__str__(self) + retval += "repo --name=\"%s\" %s\n" % (self.name, self._getArgsAsStr()) + return retval + +class F8_RepoData(FC6_RepoData): + removedKeywords = FC6_RepoData.removedKeywords + removedAttrs = FC6_RepoData.removedAttrs + + def __init__(self, *args, **kwargs): + FC6_RepoData.__init__(self, *args, **kwargs) + self.cost = kwargs.get("cost", None) + self.includepkgs = kwargs.get("includepkgs", []) + self.excludepkgs = kwargs.get("excludepkgs", []) + + def _getArgsAsStr(self): + retval = FC6_RepoData._getArgsAsStr(self) + + if self.cost: + retval += " --cost=%s" % self.cost + if self.includepkgs: + retval += " --includepkgs=\"%s\"" % ",".join(self.includepkgs) + if self.excludepkgs: + retval += " --excludepkgs=\"%s\"" % ",".join(self.excludepkgs) + + return retval + +class F11_RepoData(F8_RepoData): + removedKeywords = F8_RepoData.removedKeywords + removedAttrs = F8_RepoData.removedAttrs + + def __init__(self, *args, **kwargs): + F8_RepoData.__init__(self, *args, **kwargs) + self.ignoregroups = kwargs.get("ignoregroups", None) + + def _getArgsAsStr(self): + retval = F8_RepoData._getArgsAsStr(self) + + if self.ignoregroups: + retval += " --ignoregroups=true" + return retval + +class F13_RepoData(F11_RepoData): + removedKeywords = F11_RepoData.removedKeywords + removedAttrs = F11_RepoData.removedAttrs + + def __init__(self, *args, **kwargs): + F11_RepoData.__init__(self, *args, **kwargs) + self.proxy = kwargs.get("proxy", "") + + def _getArgsAsStr(self): + retval = F11_RepoData._getArgsAsStr(self) + + if self.proxy: + retval += " --proxy=\"%s\"" % self.proxy + + return retval + +class F14_RepoData(F13_RepoData): + removedKeywords = F13_RepoData.removedKeywords + removedAttrs = F13_RepoData.removedAttrs + + def __init__(self, *args, **kwargs): + F13_RepoData.__init__(self, *args, **kwargs) + self.noverifyssl = kwargs.get("noverifyssl", False) + + def _getArgsAsStr(self): + retval = F13_RepoData._getArgsAsStr(self) + + if self.noverifyssl: + retval += " --noverifyssl" + + return retval + +RHEL6_RepoData = F14_RepoData + +F15_RepoData = F14_RepoData + +class FC6_Repo(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + urlRequired = True + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.repoList = kwargs.get("repoList", []) + + def __str__(self): + retval = "" + for repo in self.repoList: + retval += repo.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--name", dest="name", required=1) + op.add_option("--baseurl") + op.add_option("--mirrorlist") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) != 0: + mapping = {"command": "repo", "options": extra} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) + + # This is lame, but I can't think of a better way to make sure only + # one of these two is specified. + if opts.baseurl and opts.mirrorlist: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --baseurl and --mirrorlist may be specified for repo command.")) + + if self.urlRequired and not opts.baseurl and not opts.mirrorlist: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("One of --baseurl or --mirrorlist must be specified for repo command.")) + + rd = self.handler.RepoData() + self._setToObj(self.op, opts, rd) + rd.lineno = self.lineno + + # Check for duplicates in the data list. + if rd in self.dataList(): + warnings.warn(_("A repo with the name %s has already been defined.") % rd.name) + + return rd + + def dataList(self): + return self.repoList + +class F8_Repo(FC6_Repo): + removedKeywords = FC6_Repo.removedKeywords + removedAttrs = FC6_Repo.removedAttrs + + def __str__(self): + retval = "" + for repo in self.repoList: + retval += repo.__str__() + + return retval + + def _getParser(self): + def list_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d) + + op = FC6_Repo._getParser(self) + op.add_option("--cost", action="store", type="int") + op.add_option("--excludepkgs", action="callback", callback=list_cb, + nargs=1, type="string") + op.add_option("--includepkgs", action="callback", callback=list_cb, + nargs=1, type="string") + return op + + def methodToRepo(self): + if not self.handler.method.url: + raise KickstartError, formatErrorMsg(self.handler.method.lineno, msg=_("Method must be a url to be added to the repo list.")) + reponame = "ks-method-url" + repourl = self.handler.method.url + rd = self.handler.RepoData(name=reponame, baseurl=repourl) + return rd + +class F11_Repo(F8_Repo): + removedKeywords = F8_Repo.removedKeywords + removedAttrs = F8_Repo.removedAttrs + + def _getParser(self): + op = F8_Repo._getParser(self) + op.add_option("--ignoregroups", action="store", type="ksboolean") + return op + +class F13_Repo(F11_Repo): + removedKeywords = F11_Repo.removedKeywords + removedAttrs = F11_Repo.removedAttrs + + def _getParser(self): + op = F11_Repo._getParser(self) + op.add_option("--proxy") + return op + +class F14_Repo(F13_Repo): + removedKeywords = F13_Repo.removedKeywords + removedAttrs = F13_Repo.removedAttrs + + def _getParser(self): + op = F13_Repo._getParser(self) + op.add_option("--noverifyssl", action="store_true", default=False) + return op + +RHEL6_Repo = F14_Repo + +class F15_Repo(F14_Repo): + removedKeywords = F14_Repo.removedKeywords + removedAttrs = F14_Repo.removedAttrs + + urlRequired = False diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/rescue.py b/scripts/lib/mic/3rdparty/pykickstart/commands/rescue.py new file mode 100644 index 0000000000..1893d4ea49 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/rescue.py @@ -0,0 +1,68 @@ +# +# Alexander Todorov <atodorov@redhat.com> +# +# Copyright 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class F10_Rescue(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.rescue = False + self.nomount = kwargs.get("nomount", False) + self.romount = kwargs.get("romount", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.rescue: + retval += "rescue" + + if self.nomount: + retval += " --nomount" + if self.romount: + retval += " --romount" + + retval = "# Start rescue mode\n%s\n" % retval + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--nomount", dest="nomount", action="store_true", default=False) + op.add_option("--romount", dest="romount", action="store_true", default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if opts.nomount and opts.romount: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Only one of --nomount and --romount may be specified for rescue command.")) + + self._setToSelf(self.op, opts) + self.rescue = True + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/rootpw.py b/scripts/lib/mic/3rdparty/pykickstart/commands/rootpw.py new file mode 100644 index 0000000000..e038b4525d --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/rootpw.py @@ -0,0 +1,93 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_RootPw(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.isCrypted = kwargs.get("isCrypted", False) + self.password = kwargs.get("password", "") + + def _getArgsAsStr(self): + retval = "" + + if self.isCrypted: + retval += " --iscrypted" + + return retval + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.password != "": + retval += "# Root password\nrootpw%s %s\n" % (self._getArgsAsStr(), self.password) + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--iscrypted", dest="isCrypted", action="store_true", + default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("A single argument is expected for the %s command") % "rootpw") + + self.password = extra[0] + return self + +class F8_RootPw(FC3_RootPw): + removedKeywords = FC3_RootPw.removedKeywords + removedAttrs = FC3_RootPw.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_RootPw.__init__(self, writePriority, *args, **kwargs) + self.lock = kwargs.get("lock", False) + + def _getArgsAsStr(self): + retval = FC3_RootPw._getArgsAsStr(self) + + if self.lock: + retval += " --lock" + + if not self.isCrypted: + retval += " --plaintext" + + return retval + + def _getParser(self): + op = FC3_RootPw._getParser(self) + op.add_option("--lock", dest="lock", action="store_true", default=False) + op.add_option("--plaintext", dest="isCrypted", action="store_false") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/selinux.py b/scripts/lib/mic/3rdparty/pykickstart/commands/selinux.py new file mode 100644 index 0000000000..9f8059c76b --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/selinux.py @@ -0,0 +1,64 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.options import * + +class FC3_SELinux(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.selinux = kwargs.get("selinux", None) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if not retval and self.selinux is None: + return "" + + retval += "# SELinux configuration\n" + + if self.selinux == SELINUX_DISABLED: + retval += "selinux --disabled\n" + elif self.selinux == SELINUX_ENFORCING: + retval += "selinux --enforcing\n" + elif self.selinux == SELINUX_PERMISSIVE: + retval += "selinux --permissive\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--disabled", dest="selinux", action="store_const", + const=SELINUX_DISABLED) + op.add_option("--enforcing", dest="selinux", action="store_const", + const=SELINUX_ENFORCING) + op.add_option("--permissive", dest="selinux", action="store_const", + const=SELINUX_PERMISSIVE) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/services.py b/scripts/lib/mic/3rdparty/pykickstart/commands/services.py new file mode 100644 index 0000000000..2e0eab8007 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/services.py @@ -0,0 +1,71 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_Services(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.disabled = kwargs.get("disabled", []) + self.enabled = kwargs.get("enabled", []) + + def __str__(self): + retval = KickstartCommand.__str__(self) + args = "" + + if len(self.disabled) > 0: + args += " --disabled=\"%s\"" % ",".join(self.disabled) + if len(self.enabled) > 0: + args += " --enabled=\"%s\"" % ",".join(self.enabled) + + if args != "": + retval += "# System services\nservices%s\n" % args + + return retval + + def _getParser(self): + def services_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d.strip()) + + op = KSOptionParser() + op.add_option("--disabled", dest="disabled", action="callback", + callback=services_cb, nargs=1, type="string") + op.add_option("--enabled", dest="enabled", action="callback", + callback=services_cb, nargs=1, type="string") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + + if len(self.disabled) == 0 and len(self.enabled) == 0: + raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("One of --disabled or --enabled must be provided.")) + + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/skipx.py b/scripts/lib/mic/3rdparty/pykickstart/commands/skipx.py new file mode 100644 index 0000000000..36d1a8d5ba --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/skipx.py @@ -0,0 +1,54 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_SkipX(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.skipx = kwargs.get("skipx", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.skipx: + retval += "# Do not configure the X Window System\nskipx\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if len(extra) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "skipx") + + self.skipx = True + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/sshpw.py b/scripts/lib/mic/3rdparty/pykickstart/commands/sshpw.py new file mode 100644 index 0000000000..e7867ebfb2 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/sshpw.py @@ -0,0 +1,105 @@ +# +# Peter Jones <pjones@redhat.com> +# +# Copyright 2009 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class F13_SshPwData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.username = kwargs.get("username", None) + self.isCrypted = kwargs.get("isCrypted", False) + self.password = kwargs.get("password", "") + self.lock = kwargs.get("lock", False) + + def __eq__(self, y): + return self.username == y.username + + def __str__(self): + retval = BaseData.__str__(self) + + retval += "sshpw" + retval += self._getArgsAsStr() + '\n' + + return retval + + def _getArgsAsStr(self): + retval = "" + + retval += " --username=%s" % self.username + if self.lock: + retval += " --lock" + if self.isCrypted: + retval += " --iscrypted" + else: + retval += " --plaintext" + + retval += " %s" % self.password + return retval + +class F13_SshPw(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.sshUserList = kwargs.get("sshUserList", []) + + def __str__(self): + retval = "" + for user in self.sshUserList: + retval += user.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--username", dest="username", required=True) + op.add_option("--iscrypted", dest="isCrypted", action="store_true", + default=False) + op.add_option("--plaintext", dest="isCrypted", action="store_false") + op.add_option("--lock", dest="lock", action="store_true", default=False) + return op + + def parse(self, args): + ud = self.handler.SshPwData() + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToObj(self.op, opts, ud) + ud.lineno = self.lineno + + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("A single argument is expected for the %s command") % "sshpw") + ud.password = extra[0] + + if ud in self.dataList(): + warnings.warn(_("An ssh user with the name %s has already been defined.") % ud.name) + + return ud + + def dataList(self): + return self.sshUserList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/timezone.py b/scripts/lib/mic/3rdparty/pykickstart/commands/timezone.py new file mode 100644 index 0000000000..f5441de593 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/timezone.py @@ -0,0 +1,86 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Timezone(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.isUtc = kwargs.get("isUtc", False) + self.timezone = kwargs.get("timezone", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.timezone != "": + if self.isUtc: + utc = "--utc" + else: + utc = "" + + retval += "# System timezone\ntimezone %s %s\n" %(utc, self.timezone) + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--utc", dest="isUtc", action="store_true", default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + + if len(extra) != 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("A single argument is expected for the %s command") % "timezone") + + self.timezone = extra[0] + return self + +class FC6_Timezone(FC3_Timezone): + removedKeywords = FC3_Timezone.removedKeywords + removedAttrs = FC3_Timezone.removedAttrs + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.timezone != "": + if self.isUtc: + utc = "--isUtc" + else: + utc = "" + + retval += "# System timezone\ntimezone %s %s\n" %(utc, self.timezone) + + return retval + + def _getParser(self): + op = FC3_Timezone._getParser(self) + op.add_option("--utc", "--isUtc", dest="isUtc", action="store_true", default=False) + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/updates.py b/scripts/lib/mic/3rdparty/pykickstart/commands/updates.py new file mode 100644 index 0000000000..53ec49f7b8 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/updates.py @@ -0,0 +1,60 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class F7_Updates(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.url = kwargs.get("url", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.url == "floppy": + retval += "updates\n" + elif self.url != "": + retval += "updates %s\n" % self.url + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 1: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s only takes one argument") % "updates") + elif len(extra) == 0: + self.url = "floppy" + else: + self.url = extra[0] + + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/upgrade.py b/scripts/lib/mic/3rdparty/pykickstart/commands/upgrade.py new file mode 100644 index 0000000000..a68a82d378 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/upgrade.py @@ -0,0 +1,106 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_Upgrade(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.upgrade = kwargs.get("upgrade", None) + self.op = self._getParser() + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.upgrade is None: + return retval + + if self.upgrade: + retval += "# Upgrade existing installation\nupgrade\n" + else: + retval += "# Install OS instead of upgrade\ninstall\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "upgrade") + + if self.currentCmd == "upgrade": + self.upgrade = True + else: + self.upgrade = False + + return self + +class F11_Upgrade(FC3_Upgrade): + removedKeywords = FC3_Upgrade.removedKeywords + removedAttrs = FC3_Upgrade.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_Upgrade.__init__(self, writePriority, *args, **kwargs) + + self.op = self._getParser() + self.root_device = kwargs.get("root_device", None) + + def __str__(self): + if self.upgrade and (self.root_device is not None): + retval = KickstartCommand.__str__(self) + retval += "# Upgrade existing installation\nupgrade --root-device=%s\n" % self.root_device + else: + retval = FC3_Upgrade.__str__(self) + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--root-device", dest="root_device") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 0: + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "upgrade") + + if (opts.root_device is not None) and (opts.root_device == ""): + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not accept empty parameter %s") % ("upgrade", "--root-device")) + else: + self.root_device = opts.root_device + + if self.currentCmd == "upgrade": + self.upgrade = True + else: + self.upgrade = False + + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/user.py b/scripts/lib/mic/3rdparty/pykickstart/commands/user.py new file mode 100644 index 0000000000..189dc7585f --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/user.py @@ -0,0 +1,173 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.constants import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC6_UserData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.groups = kwargs.get("groups", []) + self.homedir = kwargs.get("homedir", "") + self.isCrypted = kwargs.get("isCrypted", False) + self.name = kwargs.get("name", "") + self.password = kwargs.get("password", "") + self.shell = kwargs.get("shell", "") + self.uid = kwargs.get("uid", None) + + def __eq__(self, y): + return self.name == y.name + + def __str__(self): + retval = BaseData.__str__(self) + + if self.uid != "": + retval += "user" + retval += self._getArgsAsStr() + "\n" + + return retval + + def _getArgsAsStr(self): + retval = "" + + if len(self.groups) > 0: + retval += " --groups=%s" % ",".join(self.groups) + if self.homedir: + retval += " --homedir=%s" % self.homedir + if self.name: + retval += " --name=%s" % self.name + if self.password: + retval += " --password=%s" % self.password + if self.isCrypted: + retval += " --iscrypted" + if self.shell: + retval += " --shell=%s" % self.shell + if self.uid: + retval += " --uid=%s" % self.uid + + return retval + +class F8_UserData(FC6_UserData): + removedKeywords = FC6_UserData.removedKeywords + removedAttrs = FC6_UserData.removedAttrs + + def __init__(self, *args, **kwargs): + FC6_UserData.__init__(self, *args, **kwargs) + self.lock = kwargs.get("lock", False) + + def _getArgsAsStr(self): + retval = FC6_UserData._getArgsAsStr(self) + + if self.lock: + retval += " --lock" + + return retval + +class F12_UserData(F8_UserData): + removedKeywords = F8_UserData.removedKeywords + removedAttrs = F8_UserData.removedAttrs + + def __init__(self, *args, **kwargs): + F8_UserData.__init__(self, *args, **kwargs) + self.gecos = kwargs.get("gecos", "") + + def _getArgsAsStr(self): + retval = F8_UserData._getArgsAsStr(self) + + if self.gecos: + retval += " --gecos=\"%s\"" % (self.gecos,) + + return retval + +class FC6_User(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.userList = kwargs.get("userList", []) + + def __str__(self): + retval = "" + for user in self.userList: + retval += user.__str__() + + return retval + + def _getParser(self): + def groups_cb (option, opt_str, value, parser): + for d in value.split(','): + parser.values.ensure_value(option.dest, []).append(d) + + op = KSOptionParser() + op.add_option("--groups", dest="groups", action="callback", + callback=groups_cb, nargs=1, type="string") + op.add_option("--homedir") + op.add_option("--iscrypted", dest="isCrypted", action="store_true", + default=False) + op.add_option("--name", required=1) + op.add_option("--password") + op.add_option("--shell") + op.add_option("--uid", type="int") + return op + + def parse(self, args): + ud = self.handler.UserData() + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToObj(self.op, opts, ud) + ud.lineno = self.lineno + + # Check for duplicates in the data list. + if ud in self.dataList(): + warnings.warn(_("A user with the name %s has already been defined.") % ud.name) + + return ud + + def dataList(self): + return self.userList + +class F8_User(FC6_User): + removedKeywords = FC6_User.removedKeywords + removedAttrs = FC6_User.removedAttrs + + def _getParser(self): + op = FC6_User._getParser(self) + op.add_option("--lock", action="store_true", default=False) + op.add_option("--plaintext", dest="isCrypted", action="store_false") + return op + +class F12_User(F8_User): + removedKeywords = F8_User.removedKeywords + removedAttrs = F8_User.removedAttrs + + def _getParser(self): + op = F8_User._getParser(self) + op.add_option("--gecos", type="string") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/vnc.py b/scripts/lib/mic/3rdparty/pykickstart/commands/vnc.py new file mode 100644 index 0000000000..200ccfba2e --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/vnc.py @@ -0,0 +1,114 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +class FC3_Vnc(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.enabled = kwargs.get("enabled", False) + self.password = kwargs.get("password", "") + self.connect = kwargs.get("connect", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if not self.enabled: + return retval + + retval += "vnc" + + if self.connect != "": + retval += " --connect=%s" % self.connect + if self.password != "": + retval += " --password=%s" % self.password + + return retval + "\n" + + def _getParser(self): + op = KSOptionParser() + op.add_option("--connect") + op.add_option("--password", dest="password") + return op + + def parse(self, args): + self.enabled = True + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToSelf(self.op, opts) + return self + +class FC6_Vnc(FC3_Vnc): + removedKeywords = FC3_Vnc.removedKeywords + ["connect"] + removedAttrs = FC3_Vnc.removedAttrs + ["connect"] + + def __init__(self, writePriority=0, host="", port="", *args, **kwargs): + FC3_Vnc.__init__(self, writePriority, *args, **kwargs) + self.deleteRemovedAttrs() + + self.host = kwargs.get("host", "") + self.port = kwargs.get("port", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if not self.enabled: + return retval + + retval += "vnc" + + if self.host != "": + retval += " --host=%s" % self.host + + if self.port != "": + retval += " --port=%s" % self.port + if self.password != "": + retval += " --password=%s" % self.password + + return retval + "\n" + + def _getParser(self): + def connect_cb (option, opt_str, value, parser): + cargs = value.split(":") + parser.values.ensure_value("host", cargs[0]) + + if len(cargs) > 1: + parser.values.ensure_value("port", cargs[1]) + + op = FC3_Vnc._getParser(self) + op.add_option("--connect", action="callback", callback=connect_cb, + nargs=1, type="string") + op.add_option("--host", dest="host") + op.add_option("--port", dest="port") + return op + +class F9_Vnc(FC6_Vnc): + removedKeywords = FC6_Vnc.removedKeywords + removedAttrs = FC6_Vnc.removedAttrs + + def _getParser(self): + op = FC6_Vnc._getParser(self) + op.remove_option("--connect") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/volgroup.py b/scripts/lib/mic/3rdparty/pykickstart/commands/volgroup.py new file mode 100644 index 0000000000..255c47f0ae --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/volgroup.py @@ -0,0 +1,102 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_VolGroupData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.format = kwargs.get("format", True) + self.pesize = kwargs.get("pesize", 32768) + self.preexist = kwargs.get("preexist", False) + self.vgname = kwargs.get("vgname", "") + self.physvols = kwargs.get("physvols", []) + + def __eq__(self, y): + return self.vgname == y.vgname + + def __str__(self): + retval = BaseData.__str__(self) + retval += "volgroup %s" % self.vgname + + if not self.format: + retval += " --noformat" + if self.pesize != 0: + retval += " --pesize=%d" % self.pesize + if self.preexist: + retval += " --useexisting" + + return retval + " " + " ".join(self.physvols) + "\n" + +class FC3_VolGroup(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=132, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.vgList = kwargs.get("vgList", []) + + def __str__(self): + retval = "" + for vg in self.vgList: + retval += vg.__str__() + + return retval + + def _getParser(self): + # Have to be a little more complicated to set two values. + def vg_cb (option, opt_str, value, parser): + parser.values.format = False + parser.values.preexist = True + + op = KSOptionParser() + op.add_option("--noformat", action="callback", callback=vg_cb, + dest="format", default=True, nargs=0) + op.add_option("--pesize", dest="pesize", type="int", nargs=1, + default=32768) + op.add_option("--useexisting", dest="preexist", action="store_true", + default=False) + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + vg = self.handler.VolGroupData() + self._setToObj(self.op, opts, vg) + vg.lineno = self.lineno + vg.vgname = extra[0] + vg.physvols = extra[1:] + + # Check for duplicates in the data list. + if vg in self.dataList(): + warnings.warn(_("A volgroup with the name %s has already been defined.") % vg.vgname) + + return vg + + def dataList(self): + return self.vgList diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/xconfig.py b/scripts/lib/mic/3rdparty/pykickstart/commands/xconfig.py new file mode 100644 index 0000000000..644ee86743 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/xconfig.py @@ -0,0 +1,184 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007, 2008 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.errors import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_XConfig(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=0, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.card = kwargs.get("card", "") + self.defaultdesktop = kwargs.get("defaultdesktop", "") + self.depth = kwargs.get("depth", 0) + self.hsync = kwargs.get("hsync", "") + self.monitor = kwargs.get("monitor", "") + self.noProbe = kwargs.get("noProbe", False) + self.resolution = kwargs.get("resolution", "") + self.server = kwargs.get("server", "") + self.startX = kwargs.get("startX", False) + self.videoRam = kwargs.get("videoRam", "") + self.vsync = kwargs.get("vsync", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.card != "": + retval += " --card=%s" % self.card + if self.defaultdesktop != "": + retval += " --defaultdesktop=%s" % self.defaultdesktop + if self.depth != 0: + retval += " --depth=%d" % self.depth + if self.hsync != "": + retval += " --hsync=%s" % self.hsync + if self.monitor != "": + retval += " --monitor=%s" % self.monitor + if self.noProbe: + retval += " --noprobe" + if self.resolution != "": + retval += " --resolution=%s" % self.resolution + if self.server != "": + retval += " --server=%s" % self.server + if self.startX: + retval += " --startxonboot" + if self.videoRam != "": + retval += " --videoram=%s" % self.videoRam + if self.vsync != "": + retval += " --vsync=%s" % self.vsync + + if retval != "": + retval = "# X Window System configuration information\nxconfig %s\n" % retval + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--card") + op.add_option("--defaultdesktop") + op.add_option("--depth", action="store", type="int", nargs=1) + op.add_option("--hsync") + op.add_option("--monitor") + op.add_option("--noprobe", dest="noProbe", action="store_true", + default=False) + op.add_option("--resolution") + op.add_option("--server") + op.add_option("--startxonboot", dest="startX", action="store_true", + default=False) + op.add_option("--videoram", dest="videoRam") + op.add_option("--vsync") + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + if extra: + mapping = {"command": "xconfig", "options": extra} + raise KickstartValueError, formatErrorMsg(self.lineno, msg=_("Unexpected arguments to %(command)s command: %(options)s") % mapping) + + self._setToSelf(self.op, opts) + return self + +class FC6_XConfig(FC3_XConfig): + removedKeywords = FC3_XConfig.removedKeywords + ["card", "hsync", "monitor", "noProbe", "vsync"] + removedAttrs = FC3_XConfig.removedAttrs + ["card", "hsync", "monitor", "noProbe", "vsync"] + + def __init__(self, writePriority=0, *args, **kwargs): + FC3_XConfig.__init__(self, writePriority, *args, **kwargs) + self.deleteRemovedAttrs() + + self.driver = kwargs.get("driver", "") + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if hasattr(self, "driver") and self.driver != "": + retval += " --driver=%s" % self.driver + if self.defaultdesktop != "": + retval += " --defaultdesktop=%s" % self.defaultdesktop + if self.depth != 0: + retval += " --depth=%d" % self.depth + if hasattr(self, "resolution") and self.resolution != "": + retval += " --resolution=%s" % self.resolution + if self.startX: + retval += " --startxonboot" + if hasattr(self, "videoRam") and self.videoRam != "": + retval += " --videoram=%s" % self.videoRam + + if retval != "": + retval = "# X Window System configuration information\nxconfig %s\n" % retval + + return retval + + def _getParser(self): + op = FC3_XConfig._getParser(self) + op.add_option("--card", deprecated=1) + op.add_option("--driver", dest="driver") + op.add_option("--hsync", deprecated=1) + op.add_option("--monitor", deprecated=1) + op.add_option("--noprobe", deprecated=1) + op.add_option("--vsync", deprecated=1) + return op + +class F9_XConfig(FC6_XConfig): + removedKeywords = FC6_XConfig.removedKeywords + removedAttrs = FC6_XConfig.removedAttrs + + def _getParser(self): + op = FC6_XConfig._getParser(self) + op.remove_option("--card") + op.remove_option("--hsync") + op.remove_option("--monitor") + op.remove_option("--noprobe") + op.remove_option("--vsync") + return op + +class F10_XConfig(F9_XConfig): + removedKeywords = F9_XConfig.removedKeywords + ["driver", "resolution", "videoRam"] + removedAttrs = F9_XConfig.removedAttrs + ["driver", "resolution", "videoRam"] + + def __init__(self, writePriority=0, *args, **kwargs): + F9_XConfig.__init__(self, writePriority, *args, **kwargs) + self.deleteRemovedAttrs() + + def _getParser(self): + op = F9_XConfig._getParser(self) + op.add_option("--driver", deprecated=1) + op.add_option("--depth", deprecated=1) + op.add_option("--resolution", deprecated=1) + op.add_option("--videoram", deprecated=1) + return op + +class F14_XConfig(F10_XConfig): + removedKeywords = F10_XConfig.removedKeywords + removedAttrs = F10_XConfig.removedAttrs + + def _getParser(self): + op = F10_XConfig._getParser(self) + op.remove_option("--driver") + op.remove_option("--depth") + op.remove_option("--resolution") + op.remove_option("--videoram") + return op diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/zerombr.py b/scripts/lib/mic/3rdparty/pykickstart/commands/zerombr.py new file mode 100644 index 0000000000..79555a9b27 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/zerombr.py @@ -0,0 +1,69 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +import warnings + +from pykickstart.base import * +from pykickstart.options import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_ZeroMbr(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=110, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + self.zerombr = kwargs.get("zerombr", False) + + def __str__(self): + retval = KickstartCommand.__str__(self) + + if self.zerombr: + retval += "# Clear the Master Boot Record\nzerombr\n" + + return retval + + def _getParser(self): + op = KSOptionParser() + return op + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 0: + warnings.warn(_("Ignoring deprecated option on line %s: The zerombr command no longer takes any options. In future releases, this will result in a fatal error from kickstart. Please modify your kickstart file to remove any options.") % self.lineno, DeprecationWarning) + + self.zerombr = True + return self + +class F9_ZeroMbr(FC3_ZeroMbr): + removedKeywords = FC3_ZeroMbr.removedKeywords + removedAttrs = FC3_ZeroMbr.removedAttrs + + def parse(self, args): + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + + if len(extra) > 0: + raise KickstartParseError, formatErrorMsg(self.lineno, msg=_("Kickstart command %s does not take any arguments") % "zerombr") + + self.zerombr = True + return self diff --git a/scripts/lib/mic/3rdparty/pykickstart/commands/zfcp.py b/scripts/lib/mic/3rdparty/pykickstart/commands/zfcp.py new file mode 100644 index 0000000000..1ed2694c89 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/commands/zfcp.py @@ -0,0 +1,134 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005, 2006, 2007 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing to use, modify, +# copy, or redistribute it subject to the terms and conditions of the GNU +# General Public License v.2. This program is distributed in the hope that it +# will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the +# implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 +# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. Any Red Hat +# trademarks that are incorporated in the source code or documentation are not +# subject to the GNU General Public License and may only be used or replicated +# with the express permission of Red Hat, Inc. +# +from pykickstart.base import * +from pykickstart.options import * + +import gettext +import warnings +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class FC3_ZFCPData(BaseData): + removedKeywords = BaseData.removedKeywords + removedAttrs = BaseData.removedAttrs + + def __init__(self, *args, **kwargs): + BaseData.__init__(self, *args, **kwargs) + self.devnum = kwargs.get("devnum", "") + self.wwpn = kwargs.get("wwpn", "") + self.fcplun = kwargs.get("fcplun", "") + self.scsiid = kwargs.get("scsiid", "") + self.scsilun = kwargs.get("scsilun", "") + + def __eq__(self, y): + return self.devnum == y.devnum and self.wwpn == y.wwpn and \ + self.fcplun == y.fcplun and self.scsiid == y.scsiid and \ + self.scsilun == y.scsilun + + def __str__(self): + retval = BaseData.__str__(self) + retval += "zfcp" + + if self.devnum != "": + retval += " --devnum=%s" % self.devnum + if self.wwpn != "": + retval += " --wwpn=%s" % self.wwpn + if self.fcplun != "": + retval += " --fcplun=%s" % self.fcplun + if hasattr(self, "scsiid") and self.scsiid != "": + retval += " --scsiid=%s" % self.scsiid + if hasattr(self, "scsilun") and self.scsilun != "": + retval += " --scsilun=%s" % self.scsilun + + return retval + "\n" + +class F12_ZFCPData(FC3_ZFCPData): + removedKeywords = FC3_ZFCPData.removedKeywords + ["scsiid", "scsilun"] + removedAttrs = FC3_ZFCPData.removedAttrs + ["scsiid", "scsilun"] + + def __init__(self, *args, **kwargs): + FC3_ZFCPData.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + +F14_ZFCPData = F12_ZFCPData + +class FC3_ZFCP(KickstartCommand): + removedKeywords = KickstartCommand.removedKeywords + removedAttrs = KickstartCommand.removedAttrs + + def __init__(self, writePriority=71, *args, **kwargs): + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + self.op = self._getParser() + + self.zfcp = kwargs.get("zfcp", []) + + def __str__(self): + retval = "" + for zfcp in self.zfcp: + retval += zfcp.__str__() + + return retval + + def _getParser(self): + op = KSOptionParser() + op.add_option("--devnum", dest="devnum", required=1) + op.add_option("--fcplun", dest="fcplun", required=1) + op.add_option("--scsiid", dest="scsiid", required=1) + op.add_option("--scsilun", dest="scsilun", required=1) + op.add_option("--wwpn", dest="wwpn", required=1) + return op + + def parse(self, args): + zd = self.handler.ZFCPData() + (opts, extra) = self.op.parse_args(args=args, lineno=self.lineno) + self._setToObj(self.op, opts, zd) + zd.lineno = self.lineno + + # Check for duplicates in the data list. + if zd in self.dataList(): + warnings.warn(_("A zfcp with this information has already been defined.")) + + return zd + + def dataList(self): + return self.zfcp + +class F12_ZFCP(FC3_ZFCP): + removedKeywords = FC3_ZFCP.removedKeywords + removedAttrs = FC3_ZFCP.removedAttrs + ["scsiid", "scsilun"] + + def __init__(self, *args, **kwargs): + FC3_ZFCP.__init__(self, *args, **kwargs) + self.deleteRemovedAttrs() + + def _getParser(self): + op = FC3_ZFCP._getParser(self) + op.add_option("--scsiid", deprecated=1) + op.add_option("--scsilun", deprecated=1) + return op + +class F14_ZFCP(F12_ZFCP): + removedKeywords = F12_ZFCP.removedKeywords + removedAttrs = F12_ZFCP.removedAttrs + + def _getParser(self): + op = F12_ZFCP._getParser(self) + op.remove_option("--scsiid") + op.remove_option("--scsilun") + return op |