diff options
Diffstat (limited to 'scripts/lib/mic/3rdparty')
87 files changed, 13456 insertions, 0 deletions
diff --git a/scripts/lib/mic/3rdparty/pykickstart/__init__.py b/scripts/lib/mic/3rdparty/pykickstart/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/__init__.py diff --git a/scripts/lib/mic/3rdparty/pykickstart/base.py b/scripts/lib/mic/3rdparty/pykickstart/base.py new file mode 100644 index 0000000000..e6c8f56f9d --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/base.py @@ -0,0 +1,466 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 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. +# +""" +Base classes for creating commands and syntax version object. + +This module exports several important base classes: + + BaseData - The base abstract class for all data objects. Data objects + are contained within a BaseHandler object. + + BaseHandler - The base abstract class from which versioned kickstart + handler are derived. Subclasses of BaseHandler hold + BaseData and KickstartCommand objects. + + DeprecatedCommand - An abstract subclass of KickstartCommand that should + be further subclassed by users of this module. When + a subclass is used, a warning message will be + printed. + + KickstartCommand - The base abstract class for all kickstart commands. + Command objects are contained within a BaseHandler + object. +""" +import gettext +gettext.textdomain("pykickstart") +_ = lambda x: gettext.ldgettext("pykickstart", x) + +import types +import warnings +from pykickstart.errors import * +from pykickstart.ko import * +from pykickstart.parser import Packages +from pykickstart.version import versionToString + +### +### COMMANDS +### +class KickstartCommand(KickstartObject): + """The base class for all kickstart commands. This is an abstract class.""" + removedKeywords = [] + removedAttrs = [] + + def __init__(self, writePriority=0, *args, **kwargs): + """Create a new KickstartCommand instance. This method must be + provided by all subclasses, but subclasses must call + KickstartCommand.__init__ first. Instance attributes: + + currentCmd -- The name of the command in the input file that + caused this handler to be run. + currentLine -- The current unprocessed line from the input file + that caused this handler to be run. + handler -- A reference to the BaseHandler subclass this + command is contained withing. This is needed to + allow referencing of Data objects. + lineno -- The current line number in the input file. + writePriority -- An integer specifying when this command should be + printed when iterating over all commands' __str__ + methods. The higher the number, the later this + command will be written. All commands with the + same priority will be written alphabetically. + """ + + # We don't want people using this class by itself. + if self.__class__ is KickstartCommand: + raise TypeError, "KickstartCommand is an abstract class." + + KickstartObject.__init__(self, *args, **kwargs) + + self.writePriority = writePriority + + # These will be set by the dispatcher. + self.currentCmd = "" + self.currentLine = "" + self.handler = None + self.lineno = 0 + + # If a subclass provides a removedKeywords list, remove all the + # members from the kwargs list before we start processing it. This + # ensures that subclasses don't continue to recognize arguments that + # were removed. + for arg in filter(kwargs.has_key, self.removedKeywords): + kwargs.pop(arg) + + def __call__(self, *args, **kwargs): + """Set multiple attributes on a subclass of KickstartCommand at once + via keyword arguments. Valid attributes are anything specified in + a subclass, but unknown attributes will be ignored. + """ + for (key, val) in kwargs.items(): + # Ignore setting attributes that were removed in a subclass, as + # if they were unknown attributes. + if key in self.removedAttrs: + continue + + if hasattr(self, key): + setattr(self, key, val) + + def __str__(self): + """Return a string formatted for output to a kickstart file. This + method must be provided by all subclasses. + """ + return KickstartObject.__str__(self) + + def parse(self, args): + """Parse the list of args and set data on the KickstartCommand object. + This method must be provided by all subclasses. + """ + raise TypeError, "parse() not implemented for KickstartCommand" + + def apply(self, instroot="/"): + """Write out the configuration related to the KickstartCommand object. + Subclasses which do not provide this method will not have their + configuration written out. + """ + return + + def dataList(self): + """For commands that can occur multiple times in a single kickstart + file (like network, part, etc.), return the list that we should + append more data objects to. + """ + return None + + def deleteRemovedAttrs(self): + """Remove all attributes from self that are given in the removedAttrs + list. This method should be called from __init__ in a subclass, + but only after the superclass's __init__ method has been called. + """ + for attr in filter(lambda k: hasattr(self, k), self.removedAttrs): + delattr(self, attr) + + # Set the contents of the opts object (an instance of optparse.Values + # returned by parse_args) as attributes on the KickstartCommand object. + # It's useful to call this from KickstartCommand subclasses after parsing + # the arguments. + def _setToSelf(self, optParser, opts): + self._setToObj(optParser, opts, self) + + # Sets the contents of the opts object (an instance of optparse.Values + # returned by parse_args) as attributes on the provided object obj. It's + # useful to call this from KickstartCommand subclasses that handle lists + # of objects (like partitions, network devices, etc.) and need to populate + # a Data object. + def _setToObj(self, optParser, opts, obj): + for key in filter (lambda k: getattr(opts, k) != None, optParser.keys()): + setattr(obj, key, getattr(opts, key)) + +class DeprecatedCommand(KickstartCommand): + """Specify that a command is deprecated and no longer has any function. + Any command that is deprecated should be subclassed from this class, + only specifying an __init__ method that calls the superclass's __init__. + This is an abstract class. + """ + def __init__(self, writePriority=None, *args, **kwargs): + # We don't want people using this class by itself. + if self.__class__ is KickstartCommand: + raise TypeError, "DeprecatedCommand is an abstract class." + + # Create a new DeprecatedCommand instance. + KickstartCommand.__init__(self, writePriority, *args, **kwargs) + + def __str__(self): + """Placeholder since DeprecatedCommands don't work anymore.""" + return "" + + def parse(self, args): + """Print a warning message if the command is seen in the input file.""" + mapping = {"lineno": self.lineno, "cmd": self.currentCmd} + warnings.warn(_("Ignoring deprecated command on line %(lineno)s: The %(cmd)s command has been deprecated and no longer has any effect. It may be removed from future releases, which will result in a fatal error from kickstart. Please modify your kickstart file to remove this command.") % mapping, DeprecationWarning) + + +### +### HANDLERS +### +class BaseHandler(KickstartObject): + """Each version of kickstart syntax is provided by a subclass of this + class. These subclasses are what users will interact with for parsing, + extracting data, and writing out kickstart files. This is an abstract + class. + + version -- The version this syntax handler supports. This is set by + a class attribute of a BaseHandler subclass and is used to + set up the command dict. It is for read-only use. + """ + version = None + + def __init__(self, mapping=None, dataMapping=None, commandUpdates=None, + dataUpdates=None, *args, **kwargs): + """Create a new BaseHandler instance. This method must be provided by + all subclasses, but subclasses must call BaseHandler.__init__ first. + + mapping -- A custom map from command strings to classes, + useful when creating your own handler with + special command objects. It is otherwise unused + and rarely needed. If you give this argument, + the mapping takes the place of the default one + and so must include all commands you want + recognized. + dataMapping -- This is the same as mapping, but for data + objects. All the same comments apply. + commandUpdates -- This is similar to mapping, but does not take + the place of the defaults entirely. Instead, + this mapping is applied after the defaults and + updates it with just the commands you want to + modify. + dataUpdates -- This is the same as commandUpdates, but for + data objects. + + + Instance attributes: + + commands -- A mapping from a string command to a KickstartCommand + subclass object that handles it. Multiple strings can + map to the same object, but only one instance of the + command object should ever exist. Most users should + never have to deal with this directly, as it is + manipulated internally and called through dispatcher. + currentLine -- The current unprocessed line from the input file + that caused this handler to be run. + packages -- An instance of pykickstart.parser.Packages which + describes the packages section of the input file. + platform -- A string describing the hardware platform, which is + needed only by system-config-kickstart. + scripts -- A list of pykickstart.parser.Script instances, which is + populated by KickstartParser.addScript and describes the + %pre/%post/%traceback script section of the input file. + """ + + # We don't want people using this class by itself. + if self.__class__ is BaseHandler: + raise TypeError, "BaseHandler is an abstract class." + + KickstartObject.__init__(self, *args, **kwargs) + + # This isn't really a good place for these, but it's better than + # everything else I can think of. + self.scripts = [] + self.packages = Packages() + self.platform = "" + + # These will be set by the dispatcher. + self.commands = {} + self.currentLine = 0 + + # A dict keyed by an integer priority number, with each value being a + # list of KickstartCommand subclasses. This dict is maintained by + # registerCommand and used in __str__. No one else should be touching + # it. + self._writeOrder = {} + + self._registerCommands(mapping, dataMapping, commandUpdates, dataUpdates) + + def __str__(self): + """Return a string formatted for output to a kickstart file.""" + retval = "" + + if self.platform != "": + retval += "#platform=%s\n" % self.platform + + retval += "#version=%s\n" % versionToString(self.version) + + lst = self._writeOrder.keys() + lst.sort() + + for prio in lst: + for obj in self._writeOrder[prio]: + retval += obj.__str__() + + for script in self.scripts: + retval += script.__str__() + + retval += self.packages.__str__() + + return retval + + def _insertSorted(self, lst, obj): + length = len(lst) + i = 0 + + while i < length: + # If the two classes have the same name, it's because we are + # overriding an existing class with one from a later kickstart + # version, so remove the old one in favor of the new one. + if obj.__class__.__name__ > lst[i].__class__.__name__: + i += 1 + elif obj.__class__.__name__ == lst[i].__class__.__name__: + lst[i] = obj + return + elif obj.__class__.__name__ < lst[i].__class__.__name__: + break + + if i >= length: + lst.append(obj) + else: + lst.insert(i, obj) + + def _setCommand(self, cmdObj): + # Add an attribute on this version object. We need this to provide a + # way for clients to access the command objects. We also need to strip + # off the version part from the front of the name. + if cmdObj.__class__.__name__.find("_") != -1: + name = unicode(cmdObj.__class__.__name__.split("_", 1)[1]) + else: + name = unicode(cmdObj.__class__.__name__).lower() + + setattr(self, name.lower(), cmdObj) + + # Also, add the object into the _writeOrder dict in the right place. + if cmdObj.writePriority is not None: + if self._writeOrder.has_key(cmdObj.writePriority): + self._insertSorted(self._writeOrder[cmdObj.writePriority], cmdObj) + else: + self._writeOrder[cmdObj.writePriority] = [cmdObj] + + def _registerCommands(self, mapping=None, dataMapping=None, commandUpdates=None, + dataUpdates=None): + if mapping == {} or mapping == None: + from pykickstart.handlers.control import commandMap + cMap = commandMap[self.version] + else: + cMap = mapping + + if dataMapping == {} or dataMapping == None: + from pykickstart.handlers.control import dataMap + dMap = dataMap[self.version] + else: + dMap = dataMapping + + if type(commandUpdates) == types.DictType: + cMap.update(commandUpdates) + + if type(dataUpdates) == types.DictType: + dMap.update(dataUpdates) + + for (cmdName, cmdClass) in cMap.iteritems(): + # First make sure we haven't instantiated this command handler + # already. If we have, we just need to make another mapping to + # it in self.commands. + cmdObj = None + + for (key, val) in self.commands.iteritems(): + if val.__class__.__name__ == cmdClass.__name__: + cmdObj = val + break + + # If we didn't find an instance in self.commands, create one now. + if cmdObj == None: + cmdObj = cmdClass() + self._setCommand(cmdObj) + + # Finally, add the mapping to the commands dict. + self.commands[cmdName] = cmdObj + self.commands[cmdName].handler = self + + # We also need to create attributes for the various data objects. + # No checks here because dMap is a bijection. At least, that's what + # the comment says. Hope no one screws that up. + for (dataName, dataClass) in dMap.iteritems(): + setattr(self, dataName, dataClass) + + def dispatcher(self, args, lineno): + """Call the appropriate KickstartCommand handler for the current line + in the kickstart file. A handler for the current command should + be registered, though a handler of None is not an error. Returns + the data object returned by KickstartCommand.parse. + + args -- A list of arguments to the current command + lineno -- The line number in the file, for error reporting + """ + cmd = args[0] + + if not self.commands.has_key(cmd): + raise KickstartParseError, formatErrorMsg(lineno, msg=_("Unknown command: %s" % cmd)) + elif self.commands[cmd] != None: + self.commands[cmd].currentCmd = cmd + self.commands[cmd].currentLine = self.currentLine + self.commands[cmd].lineno = lineno + + # The parser returns the data object that was modified. This could + # be a BaseData subclass that should be put into a list, or it + # could be the command handler object itself. + obj = self.commands[cmd].parse(args[1:]) + lst = self.commands[cmd].dataList() + if lst is not None: + lst.append(obj) + + return obj + + def maskAllExcept(self, lst): + """Set all entries in the commands dict to None, except the ones in + the lst. All other commands will not be processed. + """ + self._writeOrder = {} + + for (key, val) in self.commands.iteritems(): + if not key in lst: + self.commands[key] = None + + def hasCommand(self, cmd): + """Return true if there is a handler for the string cmd.""" + return hasattr(self, cmd) + + +### +### DATA +### +class BaseData(KickstartObject): + """The base class for all data objects. This is an abstract class.""" + removedKeywords = [] + removedAttrs = [] + + def __init__(self, *args, **kwargs): + """Create a new BaseData instance. + + lineno -- Line number in the ks-file where this object was defined + """ + + # We don't want people using this class by itself. + if self.__class__ is BaseData: + raise TypeError, "BaseData is an abstract class." + + KickstartObject.__init__(self, *args, **kwargs) + self.lineno = 0 + + def __str__(self): + """Return a string formatted for output to a kickstart file.""" + return "" + + def __call__(self, *args, **kwargs): + """Set multiple attributes on a subclass of BaseData at once via + keyword arguments. Valid attributes are anything specified in a + subclass, but unknown attributes will be ignored. + """ + for (key, val) in kwargs.items(): + # Ignore setting attributes that were removed in a subclass, as + # if they were unknown attributes. + if key in self.removedAttrs: + continue + + if hasattr(self, key): + setattr(self, key, val) + + def deleteRemovedAttrs(self): + """Remove all attributes from self that are given in the removedAttrs + list. This method should be called from __init__ in a subclass, + but only after the superclass's __init__ method has been called. + """ + for attr in filter(lambda k: hasattr(self, k), self.removedAttrs): + delattr(self, attr) 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 diff --git a/scripts/lib/mic/3rdparty/pykickstart/constants.py b/scripts/lib/mic/3rdparty/pykickstart/constants.py new file mode 100644 index 0000000000..5e12fc80ec --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/constants.py @@ -0,0 +1,57 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2005-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. +# +CLEARPART_TYPE_LINUX = 0 +CLEARPART_TYPE_ALL = 1 +CLEARPART_TYPE_NONE = 2 + +DISPLAY_MODE_CMDLINE = 0 +DISPLAY_MODE_GRAPHICAL = 1 +DISPLAY_MODE_TEXT = 2 + +FIRSTBOOT_DEFAULT = 0 +FIRSTBOOT_SKIP = 1 +FIRSTBOOT_RECONFIG = 2 + +KS_MISSING_PROMPT = 0 +KS_MISSING_IGNORE = 1 + +SELINUX_DISABLED = 0 +SELINUX_ENFORCING = 1 +SELINUX_PERMISSIVE = 2 + +KS_SCRIPT_PRE = 0 +KS_SCRIPT_POST = 1 +KS_SCRIPT_TRACEBACK = 2 + +KS_WAIT = 0 +KS_REBOOT = 1 +KS_SHUTDOWN = 2 + +KS_INSTKEY_SKIP = -99 + +BOOTPROTO_DHCP = "dhcp" +BOOTPROTO_BOOTP = "bootp" +BOOTPROTO_STATIC = "static" +BOOTPROTO_QUERY = "query" +BOOTPROTO_IBFT = "ibft" + +GROUP_REQUIRED = 0 +GROUP_DEFAULT = 1 +GROUP_ALL = 2 diff --git a/scripts/lib/mic/3rdparty/pykickstart/errors.py b/scripts/lib/mic/3rdparty/pykickstart/errors.py new file mode 100644 index 0000000000..a234d99d43 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/errors.py @@ -0,0 +1,103 @@ +# +# errors.py: Kickstart error handling. +# +# Chris Lumens <clumens@redhat.com> +# +# 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. +# +""" +Error handling classes and functions. + +This module exports a single function: + + formatErrorMsg - Properly formats an error message. + +It also exports several exception classes: + + KickstartError - A generic exception class. + + KickstartParseError - An exception for errors relating to parsing. + + KickstartValueError - An exception for errors relating to option + processing. + + KickstartVersionError - An exception for errors relating to unsupported + syntax versions. +""" +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +def formatErrorMsg(lineno, msg=""): + """Properly format the error message msg for inclusion in an exception.""" + if msg != "": + mapping = {"lineno": lineno, "msg": msg} + return _("The following problem occurred on line %(lineno)s of the kickstart file:\n\n%(msg)s\n") % mapping + else: + return _("There was a problem reading from line %s of the kickstart file") % lineno + +class KickstartError(Exception): + """A generic exception class for unspecific error conditions.""" + def __init__(self, val = ""): + """Create a new KickstartError exception instance with the descriptive + message val. val should be the return value of formatErrorMsg. + """ + Exception.__init__(self) + self.value = val + + def __str__ (self): + return self.value + +class KickstartParseError(KickstartError): + """An exception class for errors when processing the input file, such as + unknown options, commands, or sections. + """ + def __init__(self, msg): + """Create a new KickstartParseError exception instance with the + descriptive message val. val should be the return value of + formatErrorMsg. + """ + KickstartError.__init__(self, msg) + + def __str__(self): + return self.value + +class KickstartValueError(KickstartError): + """An exception class for errors when processing arguments to commands, + such as too many arguments, too few arguments, or missing required + arguments. + """ + def __init__(self, msg): + """Create a new KickstartValueError exception instance with the + descriptive message val. val should be the return value of + formatErrorMsg. + """ + KickstartError.__init__(self, msg) + + def __str__ (self): + return self.value + +class KickstartVersionError(KickstartError): + """An exception class for errors related to using an incorrect version of + kickstart syntax. + """ + def __init__(self, msg): + """Create a new KickstartVersionError exception instance with the + descriptive message val. val should be the return value of + formatErrorMsg. + """ + KickstartError.__init__(self, msg) + + def __str__ (self): + return self.value diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/__init__.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/__init__.py diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/control.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/control.py new file mode 100644 index 0000000000..d8c8f2b899 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/control.py @@ -0,0 +1,1307 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2007, 2008, 2009, 2010 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.version import * +from pykickstart.commands import * + +# This map is keyed on kickstart syntax version as provided by +# pykickstart.version. Within each sub-dict is a mapping from command name +# to the class that handles it. This is an onto mapping - that is, multiple +# command names can map to the same class. However, the Handler will ensure +# that only one instance of each class ever exists. +commandMap = { + FC3: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC3_Bootloader, + "cdrom": method.FC3_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "driverdisk": driverdisk.FC3_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC3_Reboot, + "harddrive": method.FC3_Method, + "ignoredisk": ignoredisk.FC3_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC3_LangSupport, + "lilo": bootloader.FC3_Bootloader, + "lilocheck": lilocheck.FC3_LiloCheck, + "logvol": logvol.FC3_LogVol, + "monitor": monitor.FC3_Monitor, + "mouse": mouse.FC3_Mouse, + "network": network.FC3_Network, + "nfs": method.FC3_Method, + "part": partition.FC3_Partition, + "partition": partition.FC3_Partition, + "poweroff": reboot.FC3_Reboot, + "raid": raid.FC3_Raid, + "reboot": reboot.FC3_Reboot, + "rootpw": rootpw.FC3_RootPw, + "selinux": selinux.FC3_SELinux, + "shutdown": reboot.FC3_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC3_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC3_Method, + "vnc": vnc.FC3_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC3_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on fc3 + FC4: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC4_Bootloader, + "cdrom": method.FC3_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC3_Reboot, + "harddrive": method.FC3_Method, + "ignoredisk": ignoredisk.FC3_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC3_LangSupport, + "logvol": logvol.FC4_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC3_Monitor, + "mouse": mouse.FC3_Mouse, + "network": network.FC4_Network, + "nfs": method.FC3_Method, + "part": partition.FC4_Partition, + "partition": partition.FC4_Partition, + "poweroff": reboot.FC3_Reboot, + "raid": raid.FC4_Raid, + "reboot": reboot.FC3_Reboot, + "rootpw": rootpw.FC3_RootPw, + "selinux": selinux.FC3_SELinux, + "shutdown": reboot.FC3_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC3_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC3_Method, + "vnc": vnc.FC3_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC3_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on fc4 + FC5: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC4_Bootloader, + "cdrom": method.FC3_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC3_Reboot, + "harddrive": method.FC3_Method, + "ignoredisk": ignoredisk.FC3_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC5_LangSupport, + "logvol": logvol.FC4_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC3_Monitor, + "mouse": mouse.FC3_Mouse, + "network": network.FC4_Network, + "nfs": method.FC3_Method, + "part": partition.FC4_Partition, + "partition": partition.FC4_Partition, + "poweroff": reboot.FC3_Reboot, + "raid": raid.FC5_Raid, + "reboot": reboot.FC3_Reboot, + "rootpw": rootpw.FC3_RootPw, + "selinux": selinux.FC3_SELinux, + "shutdown": reboot.FC3_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC3_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC3_Method, + "vnc": vnc.FC3_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC3_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on fc5 + FC6: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC4_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.FC3_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.FC6_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC5_LangSupport, + "logging": logging.FC6_Logging, + "logvol": logvol.FC4_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC6_Monitor, + "mouse": mouse.FC3_Mouse, + "multipath": multipath.FC6_MultiPath, + "network": network.FC6_Network, + "nfs": method.FC6_Method, + "part": partition.FC4_Partition, + "partition": partition.FC4_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.FC5_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.FC6_Repo, + "rootpw": rootpw.FC3_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "user": user.FC6_User, + "url": method.FC6_Method, + "vnc": vnc.FC6_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC6_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on fc6 + F7: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC4_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.FC3_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.FC6_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.FC4_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC6_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.FC6_Network, + "nfs": method.FC6_Method, + "part": partition.FC4_Partition, + "partition": partition.FC4_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F7_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.FC6_Repo, + "rootpw": rootpw.FC3_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC6_Method, + "user": user.FC6_User, + "vnc": vnc.FC6_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC6_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on f7 + F8: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F8_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.FC6_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.FC4_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC6_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F8_Network, + "nfs": method.FC6_Method, + "part": partition.FC4_Partition, + "partition": partition.FC4_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F7_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F8_Repo, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC6_Method, + "user": user.F8_User, + "vnc": vnc.FC6_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC6_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on f8 + F9: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F9_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F8_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.F9_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.FC6_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F9_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC6_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.FC6_Method, + "part": partition.F9_Partition, + "partition": partition.F9_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F9_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F8_Repo, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC6_Method, + "user": user.F8_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F9_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on f9 + F10: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F9_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F8_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.F10_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F9_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.FC6_Method, + "part": partition.F9_Partition, + "partition": partition.F9_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F9_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F8_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC6_Method, + "user": user.F8_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F10_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on f10 + F11: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F9_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F8_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.F10_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F9_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.FC6_Method, + "part": partition.F11_Partition, + "partition": partition.F11_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F9_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F11_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.FC6_Method, + "user": user.F8_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F10_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on f11 + F12: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F12_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F12_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F12_DriverDisk, + "fcoe": fcoe.F12_Fcoe, + "firewall": firewall.F10_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "group": group.F12_Group, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F12_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.FC6_Method, + "part": partition.F12_Partition, + "partition": partition.F12_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F12_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F11_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.FC6_Method, + "user": user.F12_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F10_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.F12_ZFCP, + }, + + # based on f12 + F13: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F12_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F12_Bootloader, + "cdrom": method.F13_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F12_DriverDisk, + "fcoe": fcoe.F13_Fcoe, + "firewall": firewall.F10_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "group": group.F12_Group, + "halt": reboot.FC6_Reboot, + "harddrive": method.F13_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F12_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.F13_Method, + "part": partition.F12_Partition, + "partition": partition.F12_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F13_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F13_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "sshpw": sshpw.F13_SshPw, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.F13_Method, + "user": user.F12_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F10_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.F12_ZFCP, + }, + + # based on f13 + F14: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F12_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F14_Bootloader, + "cdrom": method.F14_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F14_DriverDisk, + "fcoe": fcoe.F13_Fcoe, + "firewall": firewall.F14_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "group": group.F12_Group, + "halt": reboot.FC6_Reboot, + "harddrive": method.F14_Method, + "ignoredisk": ignoredisk.F14_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "interactive": interactive.F14_Interactive, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F14_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.F14_Method, + "part": partition.F14_Partition, + "partition": partition.F14_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F14_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F14_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "sshpw": sshpw.F13_SshPw, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.F14_Method, + "user": user.F12_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F14_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.F14_ZFCP, + }, + + # based on f14 + F15: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F12_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F15_Bootloader, + "cdrom": method.F14_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F14_DriverDisk, + "fcoe": fcoe.F13_Fcoe, + "firewall": firewall.F14_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "group": group.F12_Group, + "halt": reboot.FC6_Reboot, + "harddrive": method.F14_Method, + "ignoredisk": ignoredisk.F14_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F15_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F9_Network, + "nfs": method.F14_Method, + "part": partition.F14_Partition, + "partition": partition.F14_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F15_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F15_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "sshpw": sshpw.F13_SshPw, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.F14_Method, + "user": user.F12_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F14_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.F14_ZFCP, + }, + + # based on f15 + F16: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F12_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.F15_Bootloader, + "cdrom": method.F14_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F14_DriverDisk, + "fcoe": fcoe.F13_Fcoe, + "firewall": firewall.F14_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "group": group.F12_Group, + "halt": reboot.FC6_Reboot, + "harddrive": method.F14_Method, + "ignoredisk": ignoredisk.F14_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F15_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.F16_Network, + "nfs": method.F14_Method, + "part": partition.F14_Partition, + "partition": partition.F14_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F15_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.F15_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "sshpw": sshpw.F13_SshPw, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.F14_Method, + "user": user.F12_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F14_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.F14_ZFCP, + }, + + # based on fc1 + RHEL3: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC3_Bootloader, + "cdrom": method.FC3_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "driverdisk": driverdisk.FC3_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC3_Reboot, + "harddrive": method.FC3_Method, + "ignoredisk": ignoredisk.FC3_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC3_LangSupport, + "lilo": bootloader.FC3_Bootloader, + "lilocheck": lilocheck.FC3_LiloCheck, + "logvol": logvol.FC3_LogVol, + "monitor": monitor.FC3_Monitor, + "mouse": mouse.RHEL3_Mouse, + "network": network.FC3_Network, + "nfs": method.FC3_Method, + "part": partition.FC3_Partition, + "partition": partition.FC3_Partition, + "poweroff": reboot.FC3_Reboot, + "raid": raid.FC3_Raid, + "reboot": reboot.FC3_Reboot, + "rootpw": rootpw.FC3_RootPw, + "shutdown": reboot.FC3_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC3_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC3_Method, + "vnc": vnc.FC3_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC3_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + }, + + # based on fc3 + RHEL4: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.FC3_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.FC3_Bootloader, + "cdrom": method.FC3_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "driverdisk": driverdisk.FC4_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC3_Reboot, + "harddrive": method.FC3_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC3_LangSupport, + "lilo": bootloader.FC3_Bootloader, + "lilocheck": lilocheck.FC3_LiloCheck, + "logvol": logvol.FC3_LogVol, + "monitor": monitor.FC3_Monitor, + "mouse": mouse.FC3_Mouse, + "network": network.RHEL4_Network, + "nfs": method.FC3_Method, + "part": partition.FC3_Partition, + "partition": partition.FC3_Partition, + "poweroff": reboot.FC3_Reboot, + "raid": raid.FC3_Raid, + "reboot": reboot.FC3_Reboot, + "rootpw": rootpw.FC3_RootPw, + "selinux": selinux.FC3_SELinux, + "shutdown": reboot.FC3_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC3_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "url": method.FC3_Method, + "vnc": vnc.FC3_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC3_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on fc6 + RHEL5: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F9_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.RHEL5_Bootloader, + "cdrom": method.FC6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.FC3_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F12_DriverDisk, + "firewall": firewall.FC3_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "halt": reboot.FC6_Reboot, + "harddrive": method.FC6_Method, + "ignoredisk": ignoredisk.F8_IgnoreDisk, + "install": upgrade.FC3_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.FC6_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "key": key.RHEL5_Key, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "langsupport": langsupport.FC5_LangSupport, + "logging": logging.FC6_Logging, + "logvol": logvol.RHEL5_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.FC6_Monitor, + "mouse": mouse.FC3_Mouse, + "multipath": multipath.FC6_MultiPath, + "network": network.RHEL5_Network, + "nfs": method.FC6_Method, + "part": partition.RHEL5_Partition, + "partition": partition.RHEL5_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.RHEL5_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.FC6_Repo, + "rootpw": rootpw.FC3_RootPw, + "services": services.FC6_Services, + "selinux": selinux.FC3_SELinux, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "upgrade": upgrade.FC3_Upgrade, + "user": user.FC6_User, + "url": method.FC6_Method, + "vnc": vnc.FC6_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.FC6_XConfig, + "zerombr": zerombr.FC3_ZeroMbr, + "zfcp": zfcp.FC3_ZFCP, + }, + + # based on f13ish + RHEL6: { + "auth": authconfig.FC3_Authconfig, + "authconfig": authconfig.FC3_Authconfig, + "autopart": autopart.F12_AutoPart, + "autostep": autostep.FC3_AutoStep, + "bootloader": bootloader.RHEL6_Bootloader, + "cdrom": method.RHEL6_Method, + "clearpart": clearpart.FC3_ClearPart, + "cmdline": displaymode.FC3_DisplayMode, + "device": device.F8_Device, + "deviceprobe": deviceprobe.FC3_DeviceProbe, + "dmraid": dmraid.FC6_DmRaid, + "driverdisk": driverdisk.F12_DriverDisk, + "fcoe": fcoe.F13_Fcoe, + "firewall": firewall.F10_Firewall, + "firstboot": firstboot.FC3_Firstboot, + "graphical": displaymode.FC3_DisplayMode, + "group": group.F12_Group, + "halt": reboot.FC6_Reboot, + "harddrive": method.RHEL6_Method, + "ignoredisk": ignoredisk.RHEL6_IgnoreDisk, + "install": upgrade.F11_Upgrade, + "interactive": interactive.FC3_Interactive, + "iscsi": iscsi.F10_Iscsi, + "iscsiname": iscsiname.FC6_IscsiName, + "keyboard": keyboard.FC3_Keyboard, + "lang": lang.FC3_Lang, + "logging": logging.FC6_Logging, + "logvol": logvol.F12_LogVol, + "mediacheck": mediacheck.FC4_MediaCheck, + "monitor": monitor.F10_Monitor, + "multipath": multipath.FC6_MultiPath, + "network": network.RHEL6_Network, + "nfs": method.RHEL6_Method, + "part": partition.F12_Partition, + "partition": partition.F12_Partition, + "poweroff": reboot.FC6_Reboot, + "raid": raid.F13_Raid, + "reboot": reboot.FC6_Reboot, + "repo": repo.RHEL6_Repo, + "rescue": rescue.F10_Rescue, + "rootpw": rootpw.F8_RootPw, + "selinux": selinux.FC3_SELinux, + "services": services.FC6_Services, + "shutdown": reboot.FC6_Reboot, + "skipx": skipx.FC3_SkipX, + "sshpw": sshpw.F13_SshPw, + "text": displaymode.FC3_DisplayMode, + "timezone": timezone.FC6_Timezone, + "updates": updates.F7_Updates, + "upgrade": upgrade.F11_Upgrade, + "url": method.RHEL6_Method, + "user": user.F12_User, + "vnc": vnc.F9_Vnc, + "volgroup": volgroup.FC3_VolGroup, + "xconfig": xconfig.F10_XConfig, + "zerombr": zerombr.F9_ZeroMbr, + "zfcp": zfcp.F12_ZFCP, + } +} + +# This map is keyed on kickstart syntax version as provided by +# pykickstart.version. Within each sub-dict is a mapping from a data object +# name to the class that provides it. This is a bijective mapping - that is, +# each name maps to exactly one data class and all data classes have a name. +# More than one instance of each class is allowed to exist, however. +dataMap = { + FC3: { + "DriverDiskData": driverdisk.FC3_DriverDiskData, + "LogVolData": logvol.FC3_LogVolData, + "NetworkData": network.FC3_NetworkData, + "PartData": partition.FC3_PartData, + "RaidData": raid.FC3_RaidData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + FC4: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "LogVolData": logvol.FC4_LogVolData, + "NetworkData": network.FC4_NetworkData, + "PartData": partition.FC4_PartData, + "RaidData": raid.FC4_RaidData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + FC5: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "LogVolData": logvol.FC4_LogVolData, + "NetworkData": network.FC4_NetworkData, + "PartData": partition.FC4_PartData, + "RaidData": raid.FC5_RaidData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + FC6: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.FC6_IscsiData, + "LogVolData": logvol.FC4_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.FC6_NetworkData, + "PartData": partition.FC4_PartData, + "RaidData": raid.FC5_RaidData, + "RepoData": repo.FC6_RepoData, + "UserData": user.FC6_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + F7: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.FC6_IscsiData, + "LogVolData": logvol.FC4_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.FC6_NetworkData, + "PartData": partition.FC4_PartData, + "RaidData": raid.F7_RaidData, + "RepoData": repo.FC6_RepoData, + "UserData": user.FC6_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + F8: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.FC6_IscsiData, + "LogVolData": logvol.FC4_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.FC4_PartData, + "RaidData": raid.F7_RaidData, + "RepoData": repo.F8_RepoData, + "UserData": user.F8_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + F9: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.FC6_IscsiData, + "LogVolData": logvol.F9_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F9_PartData, + "RaidData": raid.F9_RaidData, + "RepoData": repo.F8_RepoData, + "UserData": user.F8_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + F10: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F9_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F9_PartData, + "RaidData": raid.F9_RaidData, + "RepoData": repo.F8_RepoData, + "UserData": user.F8_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + F11: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F9_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F11_PartData, + "RaidData": raid.F9_RaidData, + "RepoData": repo.F11_RepoData, + "UserData": user.F8_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + F12: { + "DriverDiskData": driverdisk.F12_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "FcoeData": fcoe.F12_FcoeData, + "GroupData": group.F12_GroupData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F12_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F12_PartData, + "RaidData": raid.F12_RaidData, + "RepoData": repo.F11_RepoData, + "UserData": user.F12_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.F12_ZFCPData, + }, + F13: { + "DriverDiskData": driverdisk.F12_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "FcoeData": fcoe.F13_FcoeData, + "GroupData": group.F12_GroupData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F12_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F12_PartData, + "RaidData": raid.F13_RaidData, + "RepoData": repo.F13_RepoData, + "SshPwData": sshpw.F13_SshPwData, + "UserData": user.F12_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.F12_ZFCPData, + }, + F14: { + "DriverDiskData": driverdisk.F14_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "FcoeData": fcoe.F13_FcoeData, + "GroupData": group.F12_GroupData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F14_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F14_PartData, + "RaidData": raid.F14_RaidData, + "RepoData": repo.F14_RepoData, + "SshPwData": sshpw.F13_SshPwData, + "UserData": user.F12_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.F14_ZFCPData, + }, + F15: { + "DriverDiskData": driverdisk.F14_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "FcoeData": fcoe.F13_FcoeData, + "GroupData": group.F12_GroupData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F15_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F8_NetworkData, + "PartData": partition.F14_PartData, + "RaidData": raid.F15_RaidData, + "RepoData": repo.F15_RepoData, + "SshPwData": sshpw.F13_SshPwData, + "UserData": user.F12_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.F14_ZFCPData, + }, + F16: { + "DriverDiskData": driverdisk.F14_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "FcoeData": fcoe.F13_FcoeData, + "GroupData": group.F12_GroupData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F15_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.F16_NetworkData, + "PartData": partition.F14_PartData, + "RaidData": raid.F15_RaidData, + "RepoData": repo.F15_RepoData, + "SshPwData": sshpw.F13_SshPwData, + "UserData": user.F12_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.F14_ZFCPData, + }, + RHEL3: { + "DriverDiskData": driverdisk.FC3_DriverDiskData, + "LogVolData": logvol.FC3_LogVolData, + "NetworkData": network.RHEL4_NetworkData, + "PartData": partition.FC3_PartData, + "RaidData": raid.FC3_RaidData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + RHEL4: { + "DriverDiskData": driverdisk.FC4_DriverDiskData, + "LogVolData": logvol.FC3_LogVolData, + "NetworkData": network.RHEL4_NetworkData, + "PartData": partition.FC3_PartData, + "RaidData": raid.FC3_RaidData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + RHEL5: { + "DriverDiskData": driverdisk.F12_DriverDiskData, + "DmRaidData": dmraid.FC6_DmRaidData, + "IscsiData": iscsi.FC6_IscsiData, + "LogVolData": logvol.RHEL5_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.FC6_NetworkData, + "PartData": partition.RHEL5_PartData, + "RaidData": raid.RHEL5_RaidData, + "RepoData": repo.FC6_RepoData, + "UserData": user.FC6_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.FC3_ZFCPData, + }, + RHEL6: { + "DriverDiskData": driverdisk.F12_DriverDiskData, + "DeviceData": device.F8_DeviceData, + "DmRaidData": dmraid.FC6_DmRaidData, + "FcoeData": fcoe.F13_FcoeData, + "GroupData": group.F12_GroupData, + "IscsiData": iscsi.F10_IscsiData, + "LogVolData": logvol.F12_LogVolData, + "MultiPathData": multipath.FC6_MultiPathData, + "NetworkData": network.RHEL6_NetworkData, + "PartData": partition.F12_PartData, + "RaidData": raid.F13_RaidData, + "RepoData": repo.RHEL6_RepoData, + "SshPwData": sshpw.F13_SshPwData, + "UserData": user.F12_UserData, + "VolGroupData": volgroup.FC3_VolGroupData, + "ZFCPData": zfcp.F12_ZFCPData, + } +} diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f10.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f10.py new file mode 100644 index 0000000000..17c8211bbf --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f10.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@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.version import * + +class F10Handler(BaseHandler): + version = F10 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f11.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f11.py new file mode 100644 index 0000000000..d21aee3e8b --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f11.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@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.version import * + +class F11Handler(BaseHandler): + version = F11 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f12.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f12.py new file mode 100644 index 0000000000..cea3ecef6b --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f12.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class F12Handler(BaseHandler): + version = F12 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f13.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f13.py new file mode 100644 index 0000000000..b94c738f79 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f13.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class F13Handler(BaseHandler): + version = F13 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f14.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f14.py new file mode 100644 index 0000000000..478f75d15e --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f14.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2010 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.version import * + +class F14Handler(BaseHandler): + version = F14 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f15.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f15.py new file mode 100644 index 0000000000..12aecb4c1a --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f15.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2010 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.version import * + +class F15Handler(BaseHandler): + version = F15 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f16.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f16.py new file mode 100644 index 0000000000..3c52f8d754 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f16.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 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.version import * + +class F16Handler(BaseHandler): + version = F16 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f7.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f7.py new file mode 100644 index 0000000000..5e856ea983 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f7.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class F7Handler(BaseHandler): + version = F7 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f8.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f8.py new file mode 100644 index 0000000000..1a978810f4 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f8.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class F8Handler(BaseHandler): + version = F8 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/f9.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/f9.py new file mode 100644 index 0000000000..116f1b57c9 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/f9.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class F9Handler(BaseHandler): + version = F9 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc3.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc3.py new file mode 100644 index 0000000000..a115dc2646 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc3.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class FC3Handler(BaseHandler): + version = FC3 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc4.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc4.py new file mode 100644 index 0000000000..fd47b732ef --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc4.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class FC4Handler(BaseHandler): + version = FC4 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc5.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc5.py new file mode 100644 index 0000000000..bcdc29d23a --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc5.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class FC5Handler(BaseHandler): + version = FC5 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/fc6.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc6.py new file mode 100644 index 0000000000..c83a929f84 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/fc6.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@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.version import * + +class FC6Handler(BaseHandler): + version = FC6 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel3.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel3.py new file mode 100644 index 0000000000..131763c2a8 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel3.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class RHEL3Handler(BaseHandler): + version = RHEL3 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel4.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel4.py new file mode 100644 index 0000000000..3496c43ea5 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel4.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class RHEL4Handler(BaseHandler): + version = RHEL4 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel5.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel5.py new file mode 100644 index 0000000000..abb7a8d36c --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel5.py @@ -0,0 +1,24 @@ +# +# 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.version import * + +class RHEL5Handler(BaseHandler): + version = RHEL5 diff --git a/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel6.py b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel6.py new file mode 100644 index 0000000000..7202419780 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/handlers/rhel6.py @@ -0,0 +1,24 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2010 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.version import * + +class RHEL6Handler(BaseHandler): + version = RHEL6 diff --git a/scripts/lib/mic/3rdparty/pykickstart/ko.py b/scripts/lib/mic/3rdparty/pykickstart/ko.py new file mode 100644 index 0000000000..1350d19c70 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/ko.py @@ -0,0 +1,37 @@ +# +# 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. +# +""" +Base classes for internal pykickstart use. + +The module exports the following important classes: + + KickstartObject - The base class for all classes in pykickstart +""" + +class KickstartObject(object): + """The base class for all other classes in pykickstart.""" + def __init__(self, *args, **kwargs): + """Create a new KickstartObject instance. All other classes in + pykickstart should be derived from this one. Instance attributes: + """ + pass + + def __str__(self): + return "" diff --git a/scripts/lib/mic/3rdparty/pykickstart/options.py b/scripts/lib/mic/3rdparty/pykickstart/options.py new file mode 100644 index 0000000000..341c5d7298 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/options.py @@ -0,0 +1,204 @@ +# +# 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. +# +""" +Specialized option handling. + +This module exports two classes: + + KSOptionParser - A specialized subclass of OptionParser to be used + in BaseHandler subclasses. + + KSOption - A specialized subclass of Option. +""" +import warnings +from copy import copy +from optparse import * + +from constants import * +from errors import * +from version import * + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +class KSOptionParser(OptionParser): + """A specialized subclass of optparse.OptionParser to handle extra option + attribute checking, work error reporting into the KickstartParseError + framework, and to turn off the default help. + """ + def exit(self, status=0, msg=None): + pass + + def error(self, msg): + if self.lineno != None: + raise KickstartParseError, formatErrorMsg(self.lineno, msg=msg) + else: + raise KickstartParseError, msg + + def keys(self): + retval = [] + + for opt in self.option_list: + if opt not in retval: + retval.append(opt.dest) + + return retval + + def _init_parsing_state (self): + OptionParser._init_parsing_state(self) + self.option_seen = {} + + def check_values (self, values, args): + def seen(self, option): + return self.option_seen.has_key(option) + + def usedTooNew(self, option): + return option.introduced and option.introduced > self.version + + def usedDeprecated(self, option): + return option.deprecated + + def usedRemoved(self, option): + return option.removed and option.removed <= self.version + + for option in filter(lambda o: isinstance(o, Option), self.option_list): + if option.required and not seen(self, option): + raise KickstartValueError, formatErrorMsg(self.lineno, _("Option %s is required") % option) + elif seen(self, option) and usedTooNew(self, option): + mapping = {"option": option, "intro": versionToString(option.introduced), + "version": versionToString(self.version)} + self.error(_("The %(option)s option was introduced in version %(intro)s, but you are using kickstart syntax version %(version)s.") % mapping) + elif seen(self, option) and usedRemoved(self, option): + mapping = {"option": option, "removed": versionToString(option.removed), + "version": versionToString(self.version)} + + if option.removed == self.version: + self.error(_("The %(option)s option is no longer supported.") % mapping) + else: + self.error(_("The %(option)s option was removed in version %(removed)s, but you are using kickstart syntax version %(version)s.") % mapping) + elif seen(self, option) and usedDeprecated(self, option): + mapping = {"lineno": self.lineno, "option": option} + warnings.warn(_("Ignoring deprecated option on line %(lineno)s: The %(option)s option has been deprecated and no longer has any effect. It may be removed from future releases, which will result in a fatal error from kickstart. Please modify your kickstart file to remove this option.") % mapping, DeprecationWarning) + + return (values, args) + + def parse_args(self, *args, **kwargs): + if kwargs.has_key("lineno"): + self.lineno = kwargs.pop("lineno") + + return OptionParser.parse_args(self, **kwargs) + + def __init__(self, mapping=None, version=None): + """Create a new KSOptionParser instance. Each KickstartCommand + subclass should create one instance of KSOptionParser, providing + at least the lineno attribute. mapping and version are not required. + Instance attributes: + + mapping -- A mapping from option strings to different values. + version -- The version of the kickstart syntax we are checking + against. + """ + OptionParser.__init__(self, option_class=KSOption, + add_help_option=False, + conflict_handler="resolve") + if mapping is None: + self.map = {} + else: + self.map = mapping + + self.lineno = None + self.option_seen = {} + self.version = version + +def _check_ksboolean(option, opt, value): + if value.lower() in ("on", "yes", "true", "1"): + return True + elif value.lower() in ("off", "no", "false", "0"): + return False + else: + mapping = {"opt": opt, "value": value} + raise OptionValueError(_("Option %(opt)s: invalid boolean value: %(value)r") % mapping) + +def _check_string(option, opt, value): + if len(value) > 2 and value.startswith("--"): + mapping = {"opt": opt, "value": value} + raise OptionValueError(_("Option %(opt)s: invalid string value: %(value)r") % mapping) + else: + return value + +# Creates a new Option class that supports several new attributes: +# - required: any option with this attribute must be supplied or an exception +# is thrown +# - introduced: the kickstart syntax version that this option first appeared +# in - an exception will be raised if the option is used and +# the specified syntax version is less than the value of this +# attribute +# - deprecated: the kickstart syntax version that this option was deprecated +# in - a DeprecationWarning will be thrown if the option is +# used and the specified syntax version is greater than the +# value of this attribute +# - removed: the kickstart syntax version that this option was removed in - an +# exception will be raised if the option is used and the specified +# syntax version is greated than the value of this attribute +# Also creates a new type: +# - ksboolean: support various kinds of boolean values on an option +# And two new actions: +# - map : allows you to define an opt -> val mapping such that dest gets val +# when opt is seen +# - map_extend: allows you to define an opt -> [val1, ... valn] mapping such +# that dest gets a list of vals built up when opt is seen +class KSOption (Option): + ATTRS = Option.ATTRS + ['introduced', 'deprecated', 'removed', 'required'] + ACTIONS = Option.ACTIONS + ("map", "map_extend",) + STORE_ACTIONS = Option.STORE_ACTIONS + ("map", "map_extend",) + + TYPES = Option.TYPES + ("ksboolean", "string") + TYPE_CHECKER = copy(Option.TYPE_CHECKER) + TYPE_CHECKER["ksboolean"] = _check_ksboolean + TYPE_CHECKER["string"] = _check_string + + def _check_required(self): + if self.required and not self.takes_value(): + raise OptionError(_("Required flag set for option that doesn't take a value"), self) + + # Make sure _check_required() is called from the constructor! + CHECK_METHODS = Option.CHECK_METHODS + [_check_required] + + def process (self, opt, value, values, parser): + Option.process(self, opt, value, values, parser) + parser.option_seen[self] = 1 + + # Override default take_action method to handle our custom actions. + def take_action(self, action, dest, opt, value, values, parser): + if action == "map": + values.ensure_value(dest, parser.map[opt.lstrip('-')]) + elif action == "map_extend": + values.ensure_value(dest, []).extend(parser.map[opt.lstrip('-')]) + else: + Option.take_action(self, action, dest, opt, value, values, parser) + + def takes_value(self): + # Deprecated options don't take a value. + return Option.takes_value(self) and not self.deprecated + + def __init__(self, *args, **kwargs): + self.deprecated = False + self.required = False + Option.__init__(self, *args, **kwargs) diff --git a/scripts/lib/mic/3rdparty/pykickstart/parser.py b/scripts/lib/mic/3rdparty/pykickstart/parser.py new file mode 100644 index 0000000000..840a448673 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/parser.py @@ -0,0 +1,702 @@ +# +# parser.py: Kickstart file parser. +# +# 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. +# +""" +Main kickstart file processing module. + +This module exports several important classes: + + Script - Representation of a single %pre, %post, or %traceback script. + + Packages - Representation of the %packages section. + + KickstartParser - The kickstart file parser state machine. +""" + +from collections import Iterator +import os +import shlex +import sys +import tempfile +from copy import copy +from optparse import * +from urlgrabber import urlread +import urlgrabber.grabber as grabber + +import constants +from errors import KickstartError, KickstartParseError, KickstartValueError, formatErrorMsg +from ko import KickstartObject +from sections import * +import version + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +STATE_END = "end" +STATE_COMMANDS = "commands" + +ver = version.DEVEL + +def _preprocessStateMachine (lineIter): + l = None + lineno = 0 + + # Now open an output kickstart file that we are going to write to one + # line at a time. + (outF, outName) = tempfile.mkstemp("-ks.cfg", "", "/tmp") + + while True: + try: + l = lineIter.next() + except StopIteration: + break + + # At the end of the file? + if l == "": + break + + lineno += 1 + url = None + + ll = l.strip() + if not ll.startswith("%ksappend"): + os.write(outF, l) + continue + + # Try to pull down the remote file. + try: + ksurl = ll.split(' ')[1] + except: + raise KickstartParseError, formatErrorMsg(lineno, msg=_("Illegal url for %%ksappend: %s") % ll) + + try: + url = grabber.urlopen(ksurl) + except grabber.URLGrabError, e: + raise KickstartError, formatErrorMsg(lineno, msg=_("Unable to open %%ksappend file: %s") % e.strerror) + else: + # Sanity check result. Sometimes FTP doesn't catch a file + # is missing. + try: + if url.size < 1: + raise KickstartError, formatErrorMsg(lineno, msg=_("Unable to open %%ksappend file")) + except: + raise KickstartError, formatErrorMsg(lineno, msg=_("Unable to open %%ksappend file")) + + # If that worked, write the remote file to the output kickstart + # file in one burst. Then close everything up to get ready to + # read ahead in the input file. This allows multiple %ksappend + # lines to exist. + if url is not None: + os.write(outF, url.read()) + url.close() + + # All done - close the temp file and return its location. + os.close(outF) + return outName + +def preprocessFromString (s): + """Preprocess the kickstart file, provided as the string str. This + method is currently only useful for handling %ksappend lines, + which need to be fetched before the real kickstart parser can be + run. Returns the location of the complete kickstart file. + """ + i = iter(s.splitlines(True) + [""]) + rc = _preprocessStateMachine (i.next) + return rc + +def preprocessKickstart (f): + """Preprocess the kickstart file, given by the filename file. This + method is currently only useful for handling %ksappend lines, + which need to be fetched before the real kickstart parser can be + run. Returns the location of the complete kickstart file. + """ + try: + fh = urlopen(f) + except grabber.URLGrabError, e: + raise KickstartError, formatErrorMsg(0, msg=_("Unable to open input kickstart file: %s") % e.strerror) + + rc = _preprocessStateMachine (iter(fh.readlines())) + fh.close() + return rc + +class PutBackIterator(Iterator): + def __init__(self, iterable): + self._iterable = iter(iterable) + self._buf = None + + def __iter__(self): + return self + + def put(self, s): + self._buf = s + + def next(self): + if self._buf: + retval = self._buf + self._buf = None + return retval + else: + return self._iterable.next() + +### +### SCRIPT HANDLING +### +class Script(KickstartObject): + """A class representing a single kickstart script. If functionality beyond + just a data representation is needed (for example, a run method in + anaconda), Script may be subclassed. Although a run method is not + provided, most of the attributes of Script have to do with running the + script. Instances of Script are held in a list by the Version object. + """ + def __init__(self, script, *args , **kwargs): + """Create a new Script instance. Instance attributes: + + errorOnFail -- If execution of the script fails, should anaconda + stop, display an error, and then reboot without + running any other scripts? + inChroot -- Does the script execute in anaconda's chroot + environment or not? + interp -- The program that should be used to interpret this + script. + lineno -- The line number this script starts on. + logfile -- Where all messages from the script should be logged. + script -- A string containing all the lines of the script. + type -- The type of the script, which can be KS_SCRIPT_* from + pykickstart.constants. + """ + KickstartObject.__init__(self, *args, **kwargs) + self.script = "".join(script) + + self.interp = kwargs.get("interp", "/bin/sh") + self.inChroot = kwargs.get("inChroot", False) + self.lineno = kwargs.get("lineno", None) + self.logfile = kwargs.get("logfile", None) + self.errorOnFail = kwargs.get("errorOnFail", False) + self.type = kwargs.get("type", constants.KS_SCRIPT_PRE) + + def __str__(self): + """Return a string formatted for output to a kickstart file.""" + retval = "" + + if self.type == constants.KS_SCRIPT_PRE: + retval += '\n%pre' + elif self.type == constants.KS_SCRIPT_POST: + retval += '\n%post' + elif self.type == constants.KS_SCRIPT_TRACEBACK: + retval += '\n%traceback' + + if self.interp != "/bin/sh" and self.interp != "": + retval += " --interpreter=%s" % self.interp + if self.type == constants.KS_SCRIPT_POST and not self.inChroot: + retval += " --nochroot" + if self.logfile != None: + retval += " --logfile %s" % self.logfile + if self.errorOnFail: + retval += " --erroronfail" + + if self.script.endswith("\n"): + if ver >= version.F8: + return retval + "\n%s%%end\n" % self.script + else: + return retval + "\n%s\n" % self.script + else: + if ver >= version.F8: + return retval + "\n%s\n%%end\n" % self.script + else: + return retval + "\n%s\n" % self.script + + +## +## PACKAGE HANDLING +## +class Group: + """A class representing a single group in the %packages section.""" + def __init__(self, name="", include=constants.GROUP_DEFAULT): + """Create a new Group instance. Instance attributes: + + name -- The group's identifier + include -- The level of how much of the group should be included. + Values can be GROUP_* from pykickstart.constants. + """ + self.name = name + self.include = include + + def __str__(self): + """Return a string formatted for output to a kickstart file.""" + if self.include == constants.GROUP_REQUIRED: + return "@%s --nodefaults" % self.name + elif self.include == constants.GROUP_ALL: + return "@%s --optional" % self.name + else: + return "@%s" % self.name + + def __cmp__(self, other): + if self.name < other.name: + return -1 + elif self.name > other.name: + return 1 + return 0 + +class Packages(KickstartObject): + """A class representing the %packages section of the kickstart file.""" + def __init__(self, *args, **kwargs): + """Create a new Packages instance. Instance attributes: + + addBase -- Should the Base group be installed even if it is + not specified? + default -- Should the default package set be selected? + excludedList -- A list of all the packages marked for exclusion in + the %packages section, without the leading minus + symbol. + excludeDocs -- Should documentation in each package be excluded? + groupList -- A list of Group objects representing all the groups + specified in the %packages section. Names will be + stripped of the leading @ symbol. + excludedGroupList -- A list of Group objects representing all the + groups specified for removal in the %packages + section. Names will be stripped of the leading + -@ symbols. + handleMissing -- If unknown packages are specified in the %packages + section, should it be ignored or not? Values can + be KS_MISSING_* from pykickstart.constants. + packageList -- A list of all the packages specified in the + %packages section. + instLangs -- A list of languages to install. + """ + KickstartObject.__init__(self, *args, **kwargs) + + self.addBase = True + self.default = False + self.excludedList = [] + self.excludedGroupList = [] + self.excludeDocs = False + self.groupList = [] + self.handleMissing = constants.KS_MISSING_PROMPT + self.packageList = [] + self.instLangs = None + + def __str__(self): + """Return a string formatted for output to a kickstart file.""" + pkgs = "" + + if not self.default: + grps = self.groupList + grps.sort() + for grp in grps: + pkgs += "%s\n" % grp.__str__() + + p = self.packageList + p.sort() + for pkg in p: + pkgs += "%s\n" % pkg + + grps = self.excludedGroupList + grps.sort() + for grp in grps: + pkgs += "-%s\n" % grp.__str__() + + p = self.excludedList + p.sort() + for pkg in p: + pkgs += "-%s\n" % pkg + + if pkgs == "": + return "" + + retval = "\n%packages" + + if self.default: + retval += " --default" + if self.excludeDocs: + retval += " --excludedocs" + if not self.addBase: + retval += " --nobase" + if self.handleMissing == constants.KS_MISSING_IGNORE: + retval += " --ignoremissing" + if self.instLangs: + retval += " --instLangs=%s" % self.instLangs + + if ver >= version.F8: + return retval + "\n" + pkgs + "\n%end\n" + else: + return retval + "\n" + pkgs + "\n" + + def _processGroup (self, line): + op = OptionParser() + op.add_option("--nodefaults", action="store_true", default=False) + op.add_option("--optional", action="store_true", default=False) + + (opts, extra) = op.parse_args(args=line.split()) + + if opts.nodefaults and opts.optional: + raise KickstartValueError, _("Group cannot specify both --nodefaults and --optional") + + # If the group name has spaces in it, we have to put it back together + # now. + grp = " ".join(extra) + + if opts.nodefaults: + self.groupList.append(Group(name=grp, include=constants.GROUP_REQUIRED)) + elif opts.optional: + self.groupList.append(Group(name=grp, include=constants.GROUP_ALL)) + else: + self.groupList.append(Group(name=grp, include=constants.GROUP_DEFAULT)) + + def add (self, pkgList): + """Given a list of lines from the input file, strip off any leading + symbols and add the result to the appropriate list. + """ + existingExcludedSet = set(self.excludedList) + existingPackageSet = set(self.packageList) + newExcludedSet = set() + newPackageSet = set() + + excludedGroupList = [] + + for pkg in pkgList: + stripped = pkg.strip() + + if stripped[0] == "@": + self._processGroup(stripped[1:]) + elif stripped[0] == "-": + if stripped[1] == "@": + excludedGroupList.append(Group(name=stripped[2:])) + else: + newExcludedSet.add(stripped[1:]) + else: + newPackageSet.add(stripped) + + # Groups have to be excluded in two different ways (note: can't use + # sets here because we have to store objects): + excludedGroupNames = map(lambda g: g.name, excludedGroupList) + + # First, an excluded group may be cancelling out a previously given + # one. This is often the case when using %include. So there we should + # just remove the group from the list. + self.groupList = filter(lambda g: g.name not in excludedGroupNames, self.groupList) + + # Second, the package list could have included globs which are not + # processed by pykickstart. In that case we need to preserve a list of + # excluded groups so whatever tool doing package/group installation can + # take appropriate action. + self.excludedGroupList.extend(excludedGroupList) + + existingPackageSet = (existingPackageSet - newExcludedSet) | newPackageSet + existingExcludedSet = (existingExcludedSet - existingPackageSet) | newExcludedSet + + self.packageList = list(existingPackageSet) + self.excludedList = list(existingExcludedSet) + + +### +### PARSER +### +class KickstartParser: + """The kickstart file parser class as represented by a basic state + machine. To create a specialized parser, make a subclass and override + any of the methods you care about. Methods that don't need to do + anything may just pass. However, _stateMachine should never be + overridden. + """ + def __init__ (self, handler, followIncludes=True, errorsAreFatal=True, + missingIncludeIsFatal=True): + """Create a new KickstartParser instance. Instance attributes: + + errorsAreFatal -- Should errors cause processing to halt, or + just print a message to the screen? This + is most useful for writing syntax checkers + that may want to continue after an error is + encountered. + followIncludes -- If %include is seen, should the included + file be checked as well or skipped? + handler -- An instance of a BaseHandler subclass. If + None, the input file will still be parsed + but no data will be saved and no commands + will be executed. + missingIncludeIsFatal -- Should missing include files be fatal, even + if errorsAreFatal is False? + """ + self.errorsAreFatal = errorsAreFatal + self.followIncludes = followIncludes + self.handler = handler + self.currentdir = {} + self.missingIncludeIsFatal = missingIncludeIsFatal + + self._state = STATE_COMMANDS + self._includeDepth = 0 + self._line = "" + + self.version = self.handler.version + + global ver + ver = self.version + + self._sections = {} + self.setupSections() + + def _reset(self): + """Reset the internal variables of the state machine for a new kickstart file.""" + self._state = STATE_COMMANDS + self._includeDepth = 0 + + def getSection(self, s): + """Return a reference to the requested section (s must start with '%'s), + or raise KeyError if not found. + """ + return self._sections[s] + + def handleCommand (self, lineno, args): + """Given the list of command and arguments, call the Version's + dispatcher method to handle the command. Returns the command or + data object returned by the dispatcher. This method may be + overridden in a subclass if necessary. + """ + if self.handler: + self.handler.currentCmd = args[0] + self.handler.currentLine = self._line + retval = self.handler.dispatcher(args, lineno) + + return retval + + def registerSection(self, obj): + """Given an instance of a Section subclass, register the new section + with the parser. Calling this method means the parser will + recognize your new section and dispatch into the given object to + handle it. + """ + if not obj.sectionOpen: + raise TypeError, "no sectionOpen given for section %s" % obj + + if not obj.sectionOpen.startswith("%"): + raise TypeError, "section %s tag does not start with a %%" % obj.sectionOpen + + self._sections[obj.sectionOpen] = obj + + def _finalize(self, obj): + """Called at the close of a kickstart section to take any required + actions. Internally, this is used to add scripts once we have the + whole body read. + """ + obj.finalize() + self._state = STATE_COMMANDS + + def _handleSpecialComments(self, line): + """Kickstart recognizes a couple special comments.""" + if self._state != STATE_COMMANDS: + return + + # Save the platform for s-c-kickstart. + if line[:10] == "#platform=": + self.handler.platform = self._line[11:] + + def _readSection(self, lineIter, lineno): + obj = self._sections[self._state] + + while True: + try: + line = lineIter.next() + if line == "": + # This section ends at the end of the file. + if self.version >= version.F8: + raise KickstartParseError, formatErrorMsg(lineno, msg=_("Section does not end with %%end.")) + + self._finalize(obj) + except StopIteration: + break + + lineno += 1 + + # Throw away blank lines and comments, unless the section wants all + # lines. + if self._isBlankOrComment(line) and not obj.allLines: + continue + + if line.startswith("%"): + args = shlex.split(line) + + if args and args[0] == "%end": + # This is a properly terminated section. + self._finalize(obj) + break + elif args and args[0] == "%ksappend": + continue + elif args and (self._validState(args[0]) or args[0] in ["%include", "%ksappend"]): + # This is an unterminated section. + if self.version >= version.F8: + raise KickstartParseError, formatErrorMsg(lineno, msg=_("Section does not end with %%end.")) + + # Finish up. We do not process the header here because + # kicking back out to STATE_COMMANDS will ensure that happens. + lineIter.put(line) + lineno -= 1 + self._finalize(obj) + break + else: + # This is just a line within a section. Pass it off to whatever + # section handles it. + obj.handleLine(line) + + return lineno + + def _validState(self, st): + """Is the given section tag one that has been registered with the parser?""" + return st in self._sections.keys() + + def _tryFunc(self, fn): + """Call the provided function (which doesn't take any arguments) and + do the appropriate error handling. If errorsAreFatal is False, this + function will just print the exception and keep going. + """ + try: + fn() + except Exception, msg: + if self.errorsAreFatal: + raise + else: + print msg + + def _isBlankOrComment(self, line): + return line.isspace() or line == "" or line.lstrip()[0] == '#' + + def _stateMachine(self, lineIter): + # For error reporting. + lineno = 0 + + while True: + # Get the next line out of the file, quitting if this is the last line. + try: + self._line = lineIter.next() + if self._line == "": + break + except StopIteration: + break + + lineno += 1 + + # Eliminate blank lines, whitespace-only lines, and comments. + if self._isBlankOrComment(self._line): + self._handleSpecialComments(self._line) + continue + + # Remove any end-of-line comments. + sanitized = self._line.split("#")[0] + + # Then split the line. + args = shlex.split(sanitized.rstrip()) + + if args[0] == "%include": + # This case comes up primarily in ksvalidator. + if not self.followIncludes: + continue + + if len(args) == 1 or not args[1]: + raise KickstartParseError, formatErrorMsg(lineno) + + self._includeDepth += 1 + + try: + self.readKickstart(args[1], reset=False) + except KickstartError: + # Handle the include file being provided over the + # network in a %pre script. This case comes up in the + # early parsing in anaconda. + if self.missingIncludeIsFatal: + raise + + self._includeDepth -= 1 + continue + + # Now on to the main event. + if self._state == STATE_COMMANDS: + if args[0] == "%ksappend": + # This is handled by the preprocess* functions, so continue. + continue + elif args[0][0] == '%': + # This is the beginning of a new section. Handle its header + # here. + newSection = args[0] + if not self._validState(newSection): + raise KickstartParseError, formatErrorMsg(lineno, msg=_("Unknown kickstart section: %s" % newSection)) + + self._state = newSection + obj = self._sections[self._state] + self._tryFunc(lambda: obj.handleHeader(lineno, args)) + + # This will handle all section processing, kicking us back + # out to STATE_COMMANDS at the end with the current line + # being the next section header, etc. + lineno = self._readSection(lineIter, lineno) + else: + # This is a command in the command section. Dispatch to it. + self._tryFunc(lambda: self.handleCommand(lineno, args)) + elif self._state == STATE_END: + break + + def readKickstartFromString (self, s, reset=True): + """Process a kickstart file, provided as the string str.""" + if reset: + self._reset() + + # Add a "" to the end of the list so the string reader acts like the + # file reader and we only get StopIteration when we're after the final + # line of input. + i = PutBackIterator(s.splitlines(True) + [""]) + self._stateMachine (i) + + def readKickstart(self, f, reset=True): + """Process a kickstart file, given by the filename f.""" + if reset: + self._reset() + + # an %include might not specify a full path. if we don't try to figure + # out what the path should have been, then we're unable to find it + # requiring full path specification, though, sucks. so let's make + # the reading "smart" by keeping track of what the path is at each + # include depth. + if not os.path.exists(f): + if self.currentdir.has_key(self._includeDepth - 1): + if os.path.exists(os.path.join(self.currentdir[self._includeDepth - 1], f)): + f = os.path.join(self.currentdir[self._includeDepth - 1], f) + + cd = os.path.dirname(f) + if not cd.startswith("/"): + cd = os.path.abspath(cd) + self.currentdir[self._includeDepth] = cd + + try: + s = urlread(f) + except grabber.URLGrabError, e: + raise KickstartError, formatErrorMsg(0, msg=_("Unable to open input kickstart file: %s") % e.strerror) + + self.readKickstartFromString(s, reset=False) + + def setupSections(self): + """Install the sections all kickstart files support. You may override + this method in a subclass, but should avoid doing so unless you know + what you're doing. + """ + self._sections = {} + + # Install the sections all kickstart files support. + self.registerSection(PreScriptSection(self.handler, dataObj=Script)) + self.registerSection(PostScriptSection(self.handler, dataObj=Script)) + self.registerSection(TracebackScriptSection(self.handler, dataObj=Script)) + self.registerSection(PackageSection(self.handler)) diff --git a/scripts/lib/mic/3rdparty/pykickstart/sections.py b/scripts/lib/mic/3rdparty/pykickstart/sections.py new file mode 100644 index 0000000000..44df856b8d --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/sections.py @@ -0,0 +1,244 @@ +# +# sections.py: Kickstart file sections. +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 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. +# +""" +This module exports the classes that define a section of a kickstart file. A +section is a chunk of the file starting with a %tag and ending with a %end. +Examples of sections include %packages, %pre, and %post. + +You may use this module to define your own custom sections which will be +treated just the same as a predefined one by the kickstart parser. All that +is necessary is to create a new subclass of Section and call +parser.registerSection with an instance of your new class. +""" +from constants import * +from options import KSOptionParser +from version import * + +class Section(object): + """The base class for defining kickstart sections. You are free to + subclass this as appropriate. + + Class attributes: + + allLines -- Does this section require the parser to call handleLine + for every line in the section, even blanks and comments? + sectionOpen -- The string that denotes the start of this section. You + must start your tag with a percent sign. + timesSeen -- This attribute is for informational purposes only. It is + incremented every time handleHeader is called to keep + track of the number of times a section of this type is + seen. + """ + allLines = False + sectionOpen = "" + timesSeen = 0 + + def __init__(self, handler, **kwargs): + """Create a new Script instance. At the least, you must pass in an + instance of a baseHandler subclass. + + Valid kwargs: + + dataObj -- + """ + self.handler = handler + + self.version = self.handler.version + + self.dataObj = kwargs.get("dataObj", None) + + def finalize(self): + """This method is called when the %end tag for a section is seen. It + is not required to be provided. + """ + pass + + def handleLine(self, line): + """This method is called for every line of a section. Take whatever + action is appropriate. While this method is not required to be + provided, not providing it does not make a whole lot of sense. + + Arguments: + + line -- The complete line, with any trailing newline. + """ + pass + + def handleHeader(self, lineno, args): + """This method is called when the opening tag for a section is seen. + Not all sections will need this method, though all provided with + kickstart include one. + + Arguments: + + args -- A list of all strings passed as arguments to the section + opening tag. + """ + self.timesSeen += 1 + +class NullSection(Section): + """This defines a section that pykickstart will recognize but do nothing + with. If the parser runs across a %section that has no object registered, + it will raise an error. Sometimes, you may want to simply ignore those + sections instead. This class is useful for that purpose. + """ + def __init__(self, *args, **kwargs): + """Create a new NullSection instance. You must pass a sectionOpen + parameter (including a leading '%') for the section you wish to + ignore. + """ + Section.__init__(self, *args, **kwargs) + self.sectionOpen = kwargs.get("sectionOpen") + +class ScriptSection(Section): + allLines = True + + def __init__(self, *args, **kwargs): + Section.__init__(self, *args, **kwargs) + self._script = {} + self._resetScript() + + def _getParser(self): + op = KSOptionParser(self.version) + op.add_option("--erroronfail", dest="errorOnFail", action="store_true", + default=False) + op.add_option("--interpreter", dest="interpreter", default="/bin/sh") + op.add_option("--log", "--logfile", dest="log") + return op + + def _resetScript(self): + self._script = {"interp": "/bin/sh", "log": None, "errorOnFail": False, + "lineno": None, "chroot": False, "body": []} + + def handleLine(self, line): + self._script["body"].append(line) + + def finalize(self): + if " ".join(self._script["body"]).strip() == "": + return + + kwargs = {"interp": self._script["interp"], + "inChroot": self._script["chroot"], + "lineno": self._script["lineno"], + "logfile": self._script["log"], + "errorOnFail": self._script["errorOnFail"], + "type": self._script["type"]} + + s = self.dataObj (self._script["body"], **kwargs) + self._resetScript() + + if self.handler: + self.handler.scripts.append(s) + + def handleHeader(self, lineno, args): + """Process the arguments to a %pre/%post/%traceback header for later + setting on a Script instance once the end of the script is found. + This method may be overridden in a subclass if necessary. + """ + Section.handleHeader(self, lineno, args) + op = self._getParser() + + (opts, extra) = op.parse_args(args=args[1:], lineno=lineno) + + self._script["interp"] = opts.interpreter + self._script["lineno"] = lineno + self._script["log"] = opts.log + self._script["errorOnFail"] = opts.errorOnFail + if hasattr(opts, "nochroot"): + self._script["chroot"] = not opts.nochroot + +class PreScriptSection(ScriptSection): + sectionOpen = "%pre" + + def _resetScript(self): + ScriptSection._resetScript(self) + self._script["type"] = KS_SCRIPT_PRE + +class PostScriptSection(ScriptSection): + sectionOpen = "%post" + + def _getParser(self): + op = ScriptSection._getParser(self) + op.add_option("--nochroot", dest="nochroot", action="store_true", + default=False) + return op + + def _resetScript(self): + ScriptSection._resetScript(self) + self._script["chroot"] = True + self._script["type"] = KS_SCRIPT_POST + +class TracebackScriptSection(ScriptSection): + sectionOpen = "%traceback" + + def _resetScript(self): + ScriptSection._resetScript(self) + self._script["type"] = KS_SCRIPT_TRACEBACK + +class PackageSection(Section): + sectionOpen = "%packages" + + def handleLine(self, line): + if not self.handler: + return + + (h, s, t) = line.partition('#') + line = h.rstrip() + + self.handler.packages.add([line]) + + def handleHeader(self, lineno, args): + """Process the arguments to the %packages header and set attributes + on the Version's Packages instance appropriate. This method may be + overridden in a subclass if necessary. + """ + Section.handleHeader(self, lineno, args) + op = KSOptionParser(version=self.version) + op.add_option("--excludedocs", dest="excludedocs", action="store_true", + default=False) + op.add_option("--ignoremissing", dest="ignoremissing", + action="store_true", default=False) + op.add_option("--nobase", dest="nobase", action="store_true", + default=False) + op.add_option("--ignoredeps", dest="resolveDeps", action="store_false", + deprecated=FC4, removed=F9) + op.add_option("--resolvedeps", dest="resolveDeps", action="store_true", + deprecated=FC4, removed=F9) + op.add_option("--default", dest="defaultPackages", action="store_true", + default=False, introduced=F7) + op.add_option("--instLangs", dest="instLangs", type="string", + default="", introduced=F9) + + (opts, extra) = op.parse_args(args=args[1:], lineno=lineno) + + self.handler.packages.excludeDocs = opts.excludedocs + self.handler.packages.addBase = not opts.nobase + if opts.ignoremissing: + self.handler.packages.handleMissing = KS_MISSING_IGNORE + else: + self.handler.packages.handleMissing = KS_MISSING_PROMPT + + if opts.defaultPackages: + self.handler.packages.default = True + + if opts.instLangs: + self.handler.packages.instLangs = opts.instLangs diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/__init__.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/__init__.py new file mode 100644 index 0000000000..7bcd9d5541 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/__init__.py @@ -0,0 +1,53 @@ +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Library 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +# Copyright 2002-2006 Michael D. Stenner, Ryan Tomayko + +# $Id: __init__.py,v 1.20 2006/09/22 00:58:55 mstenner Exp $ + +"""A high-level cross-protocol url-grabber. + +Using urlgrabber, data can be fetched in three basic ways: + + urlgrab(url) copy the file to the local filesystem + urlopen(url) open the remote file and return a file object + (like urllib2.urlopen) + urlread(url) return the contents of the file as a string + +When using these functions (or methods), urlgrabber supports the +following features: + + * identical behavior for http://, ftp://, and file:// urls + * http keepalive - faster downloads of many files by using + only a single connection + * byte ranges - fetch only a portion of the file + * reget - for a urlgrab, resume a partial download + * progress meters - the ability to report download progress + automatically, even when using urlopen! + * throttling - restrict bandwidth usage + * retries - automatically retry a download if it fails. The + number of retries and failure types are configurable. + * authenticated server access for http and ftp + * proxy support - support for authenticated http and ftp proxies + * mirror groups - treat a list of mirrors as a single source, + automatically switching mirrors if there is a failure. +""" + +__version__ = '3.1.0' +__date__ = '2006/09/21' +__author__ = 'Michael D. Stenner <mstenner@linux.duke.edu>, ' \ + 'Ryan Tomayko <rtomayko@naeblis.cx>' +__url__ = 'http://linux.duke.edu/projects/urlgrabber/' + +from grabber import urlgrab, urlopen, urlread diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/byterange.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/byterange.py new file mode 100644 index 0000000000..001b4e32d6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/byterange.py @@ -0,0 +1,463 @@ +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the +# Free Software Foundation, Inc., +# 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +# This file is part of urlgrabber, a high-level cross-protocol url-grabber +# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko + +# $Id: byterange.py,v 1.12 2006/07/20 20:15:58 mstenner Exp $ + +import os +import stat +import urllib +import urllib2 +import rfc822 + +DEBUG = None + +try: + from cStringIO import StringIO +except ImportError, msg: + from StringIO import StringIO + +class RangeError(IOError): + """Error raised when an unsatisfiable range is requested.""" + pass + +class HTTPRangeHandler(urllib2.BaseHandler): + """Handler that enables HTTP Range headers. + + This was extremely simple. The Range header is a HTTP feature to + begin with so all this class does is tell urllib2 that the + "206 Partial Content" reponse from the HTTP server is what we + expected. + + Example: + import urllib2 + import byterange + + range_handler = range.HTTPRangeHandler() + opener = urllib2.build_opener(range_handler) + + # install it + urllib2.install_opener(opener) + + # create Request and set Range header + req = urllib2.Request('http://www.python.org/') + req.header['Range'] = 'bytes=30-50' + f = urllib2.urlopen(req) + """ + + def http_error_206(self, req, fp, code, msg, hdrs): + # 206 Partial Content Response + r = urllib.addinfourl(fp, hdrs, req.get_full_url()) + r.code = code + r.msg = msg + return r + + def http_error_416(self, req, fp, code, msg, hdrs): + # HTTP's Range Not Satisfiable error + raise RangeError('Requested Range Not Satisfiable') + +class HTTPSRangeHandler(HTTPRangeHandler): + """ Range Header support for HTTPS. """ + + def https_error_206(self, req, fp, code, msg, hdrs): + return self.http_error_206(req, fp, code, msg, hdrs) + + def https_error_416(self, req, fp, code, msg, hdrs): + self.https_error_416(req, fp, code, msg, hdrs) + +class RangeableFileObject: + """File object wrapper to enable raw range handling. + This was implemented primarilary for handling range + specifications for file:// urls. This object effectively makes + a file object look like it consists only of a range of bytes in + the stream. + + Examples: + # expose 10 bytes, starting at byte position 20, from + # /etc/aliases. + >>> fo = RangeableFileObject(file('/etc/passwd', 'r'), (20,30)) + # seek seeks within the range (to position 23 in this case) + >>> fo.seek(3) + # tell tells where your at _within the range_ (position 3 in + # this case) + >>> fo.tell() + # read EOFs if an attempt is made to read past the last + # byte in the range. the following will return only 7 bytes. + >>> fo.read(30) + """ + + def __init__(self, fo, rangetup): + """Create a RangeableFileObject. + fo -- a file like object. only the read() method need be + supported but supporting an optimized seek() is + preferable. + rangetup -- a (firstbyte,lastbyte) tuple specifying the range + to work over. + The file object provided is assumed to be at byte offset 0. + """ + self.fo = fo + (self.firstbyte, self.lastbyte) = range_tuple_normalize(rangetup) + self.realpos = 0 + self._do_seek(self.firstbyte) + + def __getattr__(self, name): + """This effectively allows us to wrap at the instance level. + Any attribute not found in _this_ object will be searched for + in self.fo. This includes methods.""" + if hasattr(self.fo, name): + return getattr(self.fo, name) + raise AttributeError, name + + def tell(self): + """Return the position within the range. + This is different from fo.seek in that position 0 is the + first byte position of the range tuple. For example, if + this object was created with a range tuple of (500,899), + tell() will return 0 when at byte position 500 of the file. + """ + return (self.realpos - self.firstbyte) + + def seek(self,offset,whence=0): + """Seek within the byte range. + Positioning is identical to that described under tell(). + """ + assert whence in (0, 1, 2) + if whence == 0: # absolute seek + realoffset = self.firstbyte + offset + elif whence == 1: # relative seek + realoffset = self.realpos + offset + elif whence == 2: # absolute from end of file + # XXX: are we raising the right Error here? + raise IOError('seek from end of file not supported.') + + # do not allow seek past lastbyte in range + if self.lastbyte and (realoffset >= self.lastbyte): + realoffset = self.lastbyte + + self._do_seek(realoffset - self.realpos) + + def read(self, size=-1): + """Read within the range. + This method will limit the size read based on the range. + """ + size = self._calc_read_size(size) + rslt = self.fo.read(size) + self.realpos += len(rslt) + return rslt + + def readline(self, size=-1): + """Read lines within the range. + This method will limit the size read based on the range. + """ + size = self._calc_read_size(size) + rslt = self.fo.readline(size) + self.realpos += len(rslt) + return rslt + + def _calc_read_size(self, size): + """Handles calculating the amount of data to read based on + the range. + """ + if self.lastbyte: + if size > -1: + if ((self.realpos + size) >= self.lastbyte): + size = (self.lastbyte - self.realpos) + else: + size = (self.lastbyte - self.realpos) + return size + + def _do_seek(self,offset): + """Seek based on whether wrapped object supports seek(). + offset is relative to the current position (self.realpos). + """ + assert offset >= 0 + if not hasattr(self.fo, 'seek'): + self._poor_mans_seek(offset) + else: + self.fo.seek(self.realpos + offset) + self.realpos+= offset + + def _poor_mans_seek(self,offset): + """Seek by calling the wrapped file objects read() method. + This is used for file like objects that do not have native + seek support. The wrapped objects read() method is called + to manually seek to the desired position. + offset -- read this number of bytes from the wrapped + file object. + raise RangeError if we encounter EOF before reaching the + specified offset. + """ + pos = 0 + bufsize = 1024 + while pos < offset: + if (pos + bufsize) > offset: + bufsize = offset - pos + buf = self.fo.read(bufsize) + if len(buf) != bufsize: + raise RangeError('Requested Range Not Satisfiable') + pos+= bufsize + +class FileRangeHandler(urllib2.FileHandler): + """FileHandler subclass that adds Range support. + This class handles Range headers exactly like an HTTP + server would. + """ + def open_local_file(self, req): + import mimetypes + import mimetools + host = req.get_host() + file = req.get_selector() + localfile = urllib.url2pathname(file) + stats = os.stat(localfile) + size = stats[stat.ST_SIZE] + modified = rfc822.formatdate(stats[stat.ST_MTIME]) + mtype = mimetypes.guess_type(file)[0] + if host: + host, port = urllib.splitport(host) + if port or socket.gethostbyname(host) not in self.get_names(): + raise urllib2.URLError('file not on local host') + fo = open(localfile,'rb') + brange = req.headers.get('Range',None) + brange = range_header_to_tuple(brange) + assert brange != () + if brange: + (fb,lb) = brange + if lb == '': lb = size + if fb < 0 or fb > size or lb > size: + raise RangeError('Requested Range Not Satisfiable') + size = (lb - fb) + fo = RangeableFileObject(fo, (fb,lb)) + headers = mimetools.Message(StringIO( + 'Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' % + (mtype or 'text/plain', size, modified))) + return urllib.addinfourl(fo, headers, 'file:'+file) + + +# FTP Range Support +# Unfortunately, a large amount of base FTP code had to be copied +# from urllib and urllib2 in order to insert the FTP REST command. +# Code modifications for range support have been commented as +# follows: +# -- range support modifications start/end here + +from urllib import splitport, splituser, splitpasswd, splitattr, \ + unquote, addclosehook, addinfourl +import ftplib +import socket +import sys +import ftplib +import mimetypes +import mimetools + +class FTPRangeHandler(urllib2.FTPHandler): + def ftp_open(self, req): + host = req.get_host() + if not host: + raise IOError, ('ftp error', 'no host given') + host, port = splitport(host) + if port is None: + port = ftplib.FTP_PORT + + # username/password handling + user, host = splituser(host) + if user: + user, passwd = splitpasswd(user) + else: + passwd = None + host = unquote(host) + user = unquote(user or '') + passwd = unquote(passwd or '') + + try: + host = socket.gethostbyname(host) + except socket.error, msg: + raise urllib2.URLError(msg) + path, attrs = splitattr(req.get_selector()) + dirs = path.split('/') + dirs = map(unquote, dirs) + dirs, file = dirs[:-1], dirs[-1] + if dirs and not dirs[0]: + dirs = dirs[1:] + try: + fw = self.connect_ftp(user, passwd, host, port, dirs) + type = file and 'I' or 'D' + for attr in attrs: + attr, value = splitattr(attr) + if attr.lower() == 'type' and \ + value in ('a', 'A', 'i', 'I', 'd', 'D'): + type = value.upper() + + # -- range support modifications start here + rest = None + range_tup = range_header_to_tuple(req.headers.get('Range',None)) + assert range_tup != () + if range_tup: + (fb,lb) = range_tup + if fb > 0: rest = fb + # -- range support modifications end here + + fp, retrlen = fw.retrfile(file, type, rest) + + # -- range support modifications start here + if range_tup: + (fb,lb) = range_tup + if lb == '': + if retrlen is None or retrlen == 0: + raise RangeError('Requested Range Not Satisfiable due to unobtainable file length.') + lb = retrlen + retrlen = lb - fb + if retrlen < 0: + # beginning of range is larger than file + raise RangeError('Requested Range Not Satisfiable') + else: + retrlen = lb - fb + fp = RangeableFileObject(fp, (0,retrlen)) + # -- range support modifications end here + + headers = "" + mtype = mimetypes.guess_type(req.get_full_url())[0] + if mtype: + headers += "Content-Type: %s\n" % mtype + if retrlen is not None and retrlen >= 0: + headers += "Content-Length: %d\n" % retrlen + sf = StringIO(headers) + headers = mimetools.Message(sf) + return addinfourl(fp, headers, req.get_full_url()) + except ftplib.all_errors, msg: + raise IOError, ('ftp error', msg), sys.exc_info()[2] + + def connect_ftp(self, user, passwd, host, port, dirs): + fw = ftpwrapper(user, passwd, host, port, dirs) + return fw + +class ftpwrapper(urllib.ftpwrapper): + # range support note: + # this ftpwrapper code is copied directly from + # urllib. The only enhancement is to add the rest + # argument and pass it on to ftp.ntransfercmd + def retrfile(self, file, type, rest=None): + self.endtransfer() + if type in ('d', 'D'): cmd = 'TYPE A'; isdir = 1 + else: cmd = 'TYPE ' + type; isdir = 0 + try: + self.ftp.voidcmd(cmd) + except ftplib.all_errors: + self.init() + self.ftp.voidcmd(cmd) + conn = None + if file and not isdir: + # Use nlst to see if the file exists at all + try: + self.ftp.nlst(file) + except ftplib.error_perm, reason: + raise IOError, ('ftp error', reason), sys.exc_info()[2] + # Restore the transfer mode! + self.ftp.voidcmd(cmd) + # Try to retrieve as a file + try: + cmd = 'RETR ' + file + conn = self.ftp.ntransfercmd(cmd, rest) + except ftplib.error_perm, reason: + if str(reason)[:3] == '501': + # workaround for REST not supported error + fp, retrlen = self.retrfile(file, type) + fp = RangeableFileObject(fp, (rest,'')) + return (fp, retrlen) + elif str(reason)[:3] != '550': + raise IOError, ('ftp error', reason), sys.exc_info()[2] + if not conn: + # Set transfer mode to ASCII! + self.ftp.voidcmd('TYPE A') + # Try a directory listing + if file: cmd = 'LIST ' + file + else: cmd = 'LIST' + conn = self.ftp.ntransfercmd(cmd) + self.busy = 1 + # Pass back both a suitably decorated object and a retrieval length + return (addclosehook(conn[0].makefile('rb'), + self.endtransfer), conn[1]) + + +#################################################################### +# Range Tuple Functions +# XXX: These range tuple functions might go better in a class. + +_rangere = None +def range_header_to_tuple(range_header): + """Get a (firstbyte,lastbyte) tuple from a Range header value. + + Range headers have the form "bytes=<firstbyte>-<lastbyte>". This + function pulls the firstbyte and lastbyte values and returns + a (firstbyte,lastbyte) tuple. If lastbyte is not specified in + the header value, it is returned as an empty string in the + tuple. + + Return None if range_header is None + Return () if range_header does not conform to the range spec + pattern. + + """ + global _rangere + if range_header is None: return None + if _rangere is None: + import re + _rangere = re.compile(r'^bytes=(\d{1,})-(\d*)') + match = _rangere.match(range_header) + if match: + tup = range_tuple_normalize(match.group(1,2)) + if tup and tup[1]: + tup = (tup[0],tup[1]+1) + return tup + return () + +def range_tuple_to_header(range_tup): + """Convert a range tuple to a Range header value. + Return a string of the form "bytes=<firstbyte>-<lastbyte>" or None + if no range is needed. + """ + if range_tup is None: return None + range_tup = range_tuple_normalize(range_tup) + if range_tup: + if range_tup[1]: + range_tup = (range_tup[0],range_tup[1] - 1) + return 'bytes=%s-%s' % range_tup + +def range_tuple_normalize(range_tup): + """Normalize a (first_byte,last_byte) range tuple. + Return a tuple whose first element is guaranteed to be an int + and whose second element will be '' (meaning: the last byte) or + an int. Finally, return None if the normalized tuple == (0,'') + as that is equivelant to retrieving the entire file. + """ + if range_tup is None: return None + # handle first byte + fb = range_tup[0] + if fb in (None,''): fb = 0 + else: fb = int(fb) + # handle last byte + try: lb = range_tup[1] + except IndexError: lb = '' + else: + if lb is None: lb = '' + elif lb != '': lb = int(lb) + # check if range is over the entire file + if (fb,lb) == (0,''): return None + # check that the range is valid + if lb < fb: raise RangeError('Invalid byte range: %s-%s' % (fb,lb)) + return (fb,lb) + diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/grabber.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/grabber.py new file mode 100644 index 0000000000..fefdab36f6 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/grabber.py @@ -0,0 +1,1477 @@ +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the +# Free Software Foundation, Inc., +# 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +# This file is part of urlgrabber, a high-level cross-protocol url-grabber +# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko + +"""A high-level cross-protocol url-grabber. + +GENERAL ARGUMENTS (kwargs) + + Where possible, the module-level default is indicated, and legal + values are provided. + + copy_local = 0 [0|1] + + ignored except for file:// urls, in which case it specifies + whether urlgrab should still make a copy of the file, or simply + point to the existing copy. The module level default for this + option is 0. + + close_connection = 0 [0|1] + + tells URLGrabber to close the connection after a file has been + transfered. This is ignored unless the download happens with the + http keepalive handler (keepalive=1). Otherwise, the connection + is left open for further use. The module level default for this + option is 0 (keepalive connections will not be closed). + + keepalive = 1 [0|1] + + specifies whether keepalive should be used for HTTP/1.1 servers + that support it. The module level default for this option is 1 + (keepalive is enabled). + + progress_obj = None + + a class instance that supports the following methods: + po.start(filename, url, basename, length, text) + # length will be None if unknown + po.update(read) # read == bytes read so far + po.end() + + text = None + + specifies an alternativ text item in the beginning of the progress + bar line. If not given, the basename of the file is used. + + throttle = 1.0 + + a number - if it's an int, it's the bytes/second throttle limit. + If it's a float, it is first multiplied by bandwidth. If throttle + == 0, throttling is disabled. If None, the module-level default + (which can be set on default_grabber.throttle) is used. See + BANDWIDTH THROTTLING for more information. + + timeout = None + + a positive float expressing the number of seconds to wait for socket + operations. If the value is None or 0.0, socket operations will block + forever. Setting this option causes urlgrabber to call the settimeout + method on the Socket object used for the request. See the Python + documentation on settimeout for more information. + http://www.python.org/doc/current/lib/socket-objects.html + + bandwidth = 0 + + the nominal max bandwidth in bytes/second. If throttle is a float + and bandwidth == 0, throttling is disabled. If None, the + module-level default (which can be set on + default_grabber.bandwidth) is used. See BANDWIDTH THROTTLING for + more information. + + range = None + + a tuple of the form (first_byte, last_byte) describing a byte + range to retrieve. Either or both of the values may set to + None. If first_byte is None, byte offset 0 is assumed. If + last_byte is None, the last byte available is assumed. Note that + the range specification is python-like in that (0,10) will yeild + the first 10 bytes of the file. + + If set to None, no range will be used. + + reget = None [None|'simple'|'check_timestamp'] + + whether to attempt to reget a partially-downloaded file. Reget + only applies to .urlgrab and (obviously) only if there is a + partially downloaded file. Reget has two modes: + + 'simple' -- the local file will always be trusted. If there + are 100 bytes in the local file, then the download will always + begin 100 bytes into the requested file. + + 'check_timestamp' -- the timestamp of the server file will be + compared to the timestamp of the local file. ONLY if the + local file is newer than or the same age as the server file + will reget be used. If the server file is newer, or the + timestamp is not returned, the entire file will be fetched. + + NOTE: urlgrabber can do very little to verify that the partial + file on disk is identical to the beginning of the remote file. + You may want to either employ a custom "checkfunc" or simply avoid + using reget in situations where corruption is a concern. + + user_agent = 'urlgrabber/VERSION' + + a string, usually of the form 'AGENT/VERSION' that is provided to + HTTP servers in the User-agent header. The module level default + for this option is "urlgrabber/VERSION". + + http_headers = None + + a tuple of 2-tuples, each containing a header and value. These + will be used for http and https requests only. For example, you + can do + http_headers = (('Pragma', 'no-cache'),) + + ftp_headers = None + + this is just like http_headers, but will be used for ftp requests. + + proxies = None + + a dictionary that maps protocol schemes to proxy hosts. For + example, to use a proxy server on host "foo" port 3128 for http + and https URLs: + proxies={ 'http' : 'http://foo:3128', 'https' : 'http://foo:3128' } + note that proxy authentication information may be provided using + normal URL constructs: + proxies={ 'http' : 'http://user:host@foo:3128' } + Lastly, if proxies is None, the default environment settings will + be used. + + prefix = None + + a url prefix that will be prepended to all requested urls. For + example: + g = URLGrabber(prefix='http://foo.com/mirror/') + g.urlgrab('some/file.txt') + ## this will fetch 'http://foo.com/mirror/some/file.txt' + This option exists primarily to allow identical behavior to + MirrorGroup (and derived) instances. Note: a '/' will be inserted + if necessary, so you cannot specify a prefix that ends with a + partial file or directory name. + + opener = None + + Overrides the default urllib2.OpenerDirector provided to urllib2 + when making requests. This option exists so that the urllib2 + handler chain may be customized. Note that the range, reget, + proxy, and keepalive features require that custom handlers be + provided to urllib2 in order to function properly. If an opener + option is provided, no attempt is made by urlgrabber to ensure + chain integrity. You are responsible for ensuring that any + extension handlers are present if said features are required. + + data = None + + Only relevant for the HTTP family (and ignored for other + protocols), this allows HTTP POSTs. When the data kwarg is + present (and not None), an HTTP request will automatically become + a POST rather than GET. This is done by direct passthrough to + urllib2. If you use this, you may also want to set the + 'Content-length' and 'Content-type' headers with the http_headers + option. Note that python 2.2 handles the case of these + badly and if you do not use the proper case (shown here), your + values will be overridden with the defaults. + + +RETRY RELATED ARGUMENTS + + retry = None + + the number of times to retry the grab before bailing. If this is + zero, it will retry forever. This was intentional... really, it + was :). If this value is not supplied or is supplied but is None + retrying does not occur. + + retrycodes = [-1,2,4,5,6,7] + + a sequence of errorcodes (values of e.errno) for which it should + retry. See the doc on URLGrabError for more details on this. You + might consider modifying a copy of the default codes rather than + building yours from scratch so that if the list is extended in the + future (or one code is split into two) you can still enjoy the + benefits of the default list. You can do that with something like + this: + + retrycodes = urlgrabber.grabber.URLGrabberOptions().retrycodes + if 12 not in retrycodes: + retrycodes.append(12) + + checkfunc = None + + a function to do additional checks. This defaults to None, which + means no additional checking. The function should simply return + on a successful check. It should raise URLGrabError on an + unsuccessful check. Raising of any other exception will be + considered immediate failure and no retries will occur. + + If it raises URLGrabError, the error code will determine the retry + behavior. Negative error numbers are reserved for use by these + passed in functions, so you can use many negative numbers for + different types of failure. By default, -1 results in a retry, + but this can be customized with retrycodes. + + If you simply pass in a function, it will be given exactly one + argument: a CallbackObject instance with the .url attribute + defined and either .filename (for urlgrab) or .data (for urlread). + For urlgrab, .filename is the name of the local file. For + urlread, .data is the actual string data. If you need other + arguments passed to the callback (program state of some sort), you + can do so like this: + + checkfunc=(function, ('arg1', 2), {'kwarg': 3}) + + if the downloaded file has filename /tmp/stuff, then this will + result in this call (for urlgrab): + + function(obj, 'arg1', 2, kwarg=3) + # obj.filename = '/tmp/stuff' + # obj.url = 'http://foo.com/stuff' + + NOTE: both the "args" tuple and "kwargs" dict must be present if + you use this syntax, but either (or both) can be empty. + + failure_callback = None + + The callback that gets called during retries when an attempt to + fetch a file fails. The syntax for specifying the callback is + identical to checkfunc, except for the attributes defined in the + CallbackObject instance. The attributes for failure_callback are: + + exception = the raised exception + url = the url we're trying to fetch + tries = the number of tries so far (including this one) + retry = the value of the retry option + + The callback is present primarily to inform the calling program of + the failure, but if it raises an exception (including the one it's + passed) that exception will NOT be caught and will therefore cause + future retries to be aborted. + + The callback is called for EVERY failure, including the last one. + On the last try, the callback can raise an alternate exception, + but it cannot (without severe trickiness) prevent the exception + from being raised. + + interrupt_callback = None + + This callback is called if KeyboardInterrupt is received at any + point in the transfer. Basically, this callback can have three + impacts on the fetch process based on the way it exits: + + 1) raise no exception: the current fetch will be aborted, but + any further retries will still take place + + 2) raise a URLGrabError: if you're using a MirrorGroup, then + this will prompt a failover to the next mirror according to + the behavior of the MirrorGroup subclass. It is recommended + that you raise URLGrabError with code 15, 'user abort'. If + you are NOT using a MirrorGroup subclass, then this is the + same as (3). + + 3) raise some other exception (such as KeyboardInterrupt), which + will not be caught at either the grabber or mirror levels. + That is, it will be raised up all the way to the caller. + + This callback is very similar to failure_callback. They are + passed the same arguments, so you could use the same function for + both. + + urlparser = URLParser() + + The URLParser class handles pre-processing of URLs, including + auth-handling for user/pass encoded in http urls, file handing + (that is, filenames not sent as a URL), and URL quoting. If you + want to override any of this behavior, you can pass in a + replacement instance. See also the 'quote' option. + + quote = None + + Whether or not to quote the path portion of a url. + quote = 1 -> quote the URLs (they're not quoted yet) + quote = 0 -> do not quote them (they're already quoted) + quote = None -> guess what to do + + This option only affects proper urls like 'file:///etc/passwd'; it + does not affect 'raw' filenames like '/etc/passwd'. The latter + will always be quoted as they are converted to URLs. Also, only + the path part of a url is quoted. If you need more fine-grained + control, you should probably subclass URLParser and pass it in via + the 'urlparser' option. + +BANDWIDTH THROTTLING + + urlgrabber supports throttling via two values: throttle and + bandwidth Between the two, you can either specify and absolute + throttle threshold or specify a theshold as a fraction of maximum + available bandwidth. + + throttle is a number - if it's an int, it's the bytes/second + throttle limit. If it's a float, it is first multiplied by + bandwidth. If throttle == 0, throttling is disabled. If None, the + module-level default (which can be set with set_throttle) is used. + + bandwidth is the nominal max bandwidth in bytes/second. If throttle + is a float and bandwidth == 0, throttling is disabled. If None, the + module-level default (which can be set with set_bandwidth) is used. + + THROTTLING EXAMPLES: + + Lets say you have a 100 Mbps connection. This is (about) 10^8 bits + per second, or 12,500,000 Bytes per second. You have a number of + throttling options: + + *) set_bandwidth(12500000); set_throttle(0.5) # throttle is a float + + This will limit urlgrab to use half of your available bandwidth. + + *) set_throttle(6250000) # throttle is an int + + This will also limit urlgrab to use half of your available + bandwidth, regardless of what bandwidth is set to. + + *) set_throttle(6250000); set_throttle(1.0) # float + + Use half your bandwidth + + *) set_throttle(6250000); set_throttle(2.0) # float + + Use up to 12,500,000 Bytes per second (your nominal max bandwidth) + + *) set_throttle(6250000); set_throttle(0) # throttle = 0 + + Disable throttling - this is more efficient than a very large + throttle setting. + + *) set_throttle(0); set_throttle(1.0) # throttle is float, bandwidth = 0 + + Disable throttling - this is the default when the module is loaded. + + SUGGESTED AUTHOR IMPLEMENTATION (THROTTLING) + + While this is flexible, it's not extremely obvious to the user. I + suggest you implement a float throttle as a percent to make the + distinction between absolute and relative throttling very explicit. + + Also, you may want to convert the units to something more convenient + than bytes/second, such as kbps or kB/s, etc. + +""" + +# $Id: grabber.py,v 1.48 2006/09/22 00:58:05 mstenner Exp $ + +import os +import os.path +import sys +import urlparse +import rfc822 +import time +import string +import urllib +import urllib2 +from stat import * # S_* and ST_* + +######################################################################## +# MODULE INITIALIZATION +######################################################################## +try: + exec('from ' + (__name__.split('.'))[0] + ' import __version__') +except: + __version__ = '???' + +import sslfactory + +auth_handler = urllib2.HTTPBasicAuthHandler( \ + urllib2.HTTPPasswordMgrWithDefaultRealm()) + +try: + from i18n import _ +except ImportError, msg: + def _(st): return st + +try: + from httplib import HTTPException +except ImportError, msg: + HTTPException = None + +try: + # This is a convenient way to make keepalive optional. + # Just rename the module so it can't be imported. + import keepalive + from keepalive import HTTPHandler, HTTPSHandler + have_keepalive = True +except ImportError, msg: + have_keepalive = False + +try: + # add in range support conditionally too + import byterange + from byterange import HTTPRangeHandler, HTTPSRangeHandler, \ + FileRangeHandler, FTPRangeHandler, range_tuple_normalize, \ + range_tuple_to_header, RangeError +except ImportError, msg: + range_handlers = () + RangeError = None + have_range = 0 +else: + range_handlers = (HTTPRangeHandler(), HTTPSRangeHandler(), + FileRangeHandler(), FTPRangeHandler()) + have_range = 1 + + +# check whether socket timeout support is available (Python >= 2.3) +import socket +try: + TimeoutError = socket.timeout + have_socket_timeout = True +except AttributeError: + TimeoutError = None + have_socket_timeout = False + +######################################################################## +# functions for debugging output. These functions are here because they +# are also part of the module initialization. +DEBUG = None +def set_logger(DBOBJ): + """Set the DEBUG object. This is called by _init_default_logger when + the environment variable URLGRABBER_DEBUG is set, but can also be + called by a calling program. Basically, if the calling program uses + the logging module and would like to incorporate urlgrabber logging, + then it can do so this way. It's probably not necessary as most + internal logging is only for debugging purposes. + + The passed-in object should be a logging.Logger instance. It will + be pushed into the keepalive and byterange modules if they're + being used. The mirror module pulls this object in on import, so + you will need to manually push into it. In fact, you may find it + tidier to simply push your logging object (or objects) into each + of these modules independently. + """ + + global DEBUG + DEBUG = DBOBJ + if have_keepalive and keepalive.DEBUG is None: + keepalive.DEBUG = DBOBJ + if have_range and byterange.DEBUG is None: + byterange.DEBUG = DBOBJ + if sslfactory.DEBUG is None: + sslfactory.DEBUG = DBOBJ + +def _init_default_logger(): + '''Examines the environment variable URLGRABBER_DEBUG and creates + a logging object (logging.logger) based on the contents. It takes + the form + + URLGRABBER_DEBUG=level,filename + + where "level" can be either an integer or a log level from the + logging module (DEBUG, INFO, etc). If the integer is zero or + less, logging will be disabled. Filename is the filename where + logs will be sent. If it is "-", then stdout will be used. If + the filename is empty or missing, stderr will be used. If the + variable cannot be processed or the logging module cannot be + imported (python < 2.3) then logging will be disabled. Here are + some examples: + + URLGRABBER_DEBUG=1,debug.txt # log everything to debug.txt + URLGRABBER_DEBUG=WARNING,- # log warning and higher to stdout + URLGRABBER_DEBUG=INFO # log info and higher to stderr + + This funtion is called during module initialization. It is not + intended to be called from outside. The only reason it is a + function at all is to keep the module-level namespace tidy and to + collect the code into a nice block.''' + + try: + dbinfo = os.environ['URLGRABBER_DEBUG'].split(',') + import logging + level = logging._levelNames.get(dbinfo[0], int(dbinfo[0])) + if level < 1: raise ValueError() + + formatter = logging.Formatter('%(asctime)s %(message)s') + if len(dbinfo) > 1: filename = dbinfo[1] + else: filename = '' + if filename == '': handler = logging.StreamHandler(sys.stderr) + elif filename == '-': handler = logging.StreamHandler(sys.stdout) + else: handler = logging.FileHandler(filename) + handler.setFormatter(formatter) + DBOBJ = logging.getLogger('urlgrabber') + DBOBJ.addHandler(handler) + DBOBJ.setLevel(level) + except (KeyError, ImportError, ValueError): + DBOBJ = None + set_logger(DBOBJ) + +_init_default_logger() +######################################################################## +# END MODULE INITIALIZATION +######################################################################## + + + +class URLGrabError(IOError): + """ + URLGrabError error codes: + + URLGrabber error codes (0 -- 255) + 0 - everything looks good (you should never see this) + 1 - malformed url + 2 - local file doesn't exist + 3 - request for non-file local file (dir, etc) + 4 - IOError on fetch + 5 - OSError on fetch + 6 - no content length header when we expected one + 7 - HTTPException + 8 - Exceeded read limit (for urlread) + 9 - Requested byte range not satisfiable. + 10 - Byte range requested, but range support unavailable + 11 - Illegal reget mode + 12 - Socket timeout + 13 - malformed proxy url + 14 - HTTPError (includes .code and .exception attributes) + 15 - user abort + + MirrorGroup error codes (256 -- 511) + 256 - No more mirrors left to try + + Custom (non-builtin) classes derived from MirrorGroup (512 -- 767) + [ this range reserved for application-specific error codes ] + + Retry codes (< 0) + -1 - retry the download, unknown reason + + Note: to test which group a code is in, you can simply do integer + division by 256: e.errno / 256 + + Negative codes are reserved for use by functions passed in to + retrygrab with checkfunc. The value -1 is built in as a generic + retry code and is already included in the retrycodes list. + Therefore, you can create a custom check function that simply + returns -1 and the fetch will be re-tried. For more customized + retries, you can use other negative number and include them in + retry-codes. This is nice for outputting useful messages about + what failed. + + You can use these error codes like so: + try: urlgrab(url) + except URLGrabError, e: + if e.errno == 3: ... + # or + print e.strerror + # or simply + print e #### print '[Errno %i] %s' % (e.errno, e.strerror) + """ + pass + +class CallbackObject: + """Container for returned callback data. + + This is currently a dummy class into which urlgrabber can stuff + information for passing to callbacks. This way, the prototype for + all callbacks is the same, regardless of the data that will be + passed back. Any function that accepts a callback function as an + argument SHOULD document what it will define in this object. + + It is possible that this class will have some greater + functionality in the future. + """ + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + +def urlgrab(url, filename=None, **kwargs): + """grab the file at <url> and make a local copy at <filename> + If filename is none, the basename of the url is used. + urlgrab returns the filename of the local file, which may be different + from the passed-in filename if the copy_local kwarg == 0. + + See module documentation for a description of possible kwargs. + """ + return default_grabber.urlgrab(url, filename, **kwargs) + +def urlopen(url, **kwargs): + """open the url and return a file object + If a progress object or throttle specifications exist, then + a special file object will be returned that supports them. + The file object can be treated like any other file object. + + See module documentation for a description of possible kwargs. + """ + return default_grabber.urlopen(url, **kwargs) + +def urlread(url, limit=None, **kwargs): + """read the url into a string, up to 'limit' bytes + If the limit is exceeded, an exception will be thrown. Note that urlread + is NOT intended to be used as a way of saying "I want the first N bytes" + but rather 'read the whole file into memory, but don't use too much' + + See module documentation for a description of possible kwargs. + """ + return default_grabber.urlread(url, limit, **kwargs) + + +class URLParser: + """Process the URLs before passing them to urllib2. + + This class does several things: + + * add any prefix + * translate a "raw" file to a proper file: url + * handle any http or https auth that's encoded within the url + * quote the url + + Only the "parse" method is called directly, and it calls sub-methods. + + An instance of this class is held in the options object, which + means that it's easy to change the behavior by sub-classing and + passing the replacement in. It need only have a method like: + + url, parts = urlparser.parse(url, opts) + """ + + def parse(self, url, opts): + """parse the url and return the (modified) url and its parts + + Note: a raw file WILL be quoted when it's converted to a URL. + However, other urls (ones which come with a proper scheme) may + or may not be quoted according to opts.quote + + opts.quote = 1 --> quote it + opts.quote = 0 --> do not quote it + opts.quote = None --> guess + """ + quote = opts.quote + + if opts.prefix: + url = self.add_prefix(url, opts.prefix) + + parts = urlparse.urlparse(url) + (scheme, host, path, parm, query, frag) = parts + + if not scheme or (len(scheme) == 1 and scheme in string.letters): + # if a scheme isn't specified, we guess that it's "file:" + if url[0] not in '/\\': url = os.path.abspath(url) + url = 'file:' + urllib.pathname2url(url) + parts = urlparse.urlparse(url) + quote = 0 # pathname2url quotes, so we won't do it again + + if scheme in ['http', 'https']: + parts = self.process_http(parts) + + if quote is None: + quote = self.guess_should_quote(parts) + if quote: + parts = self.quote(parts) + + url = urlparse.urlunparse(parts) + return url, parts + + def add_prefix(self, url, prefix): + if prefix[-1] == '/' or url[0] == '/': + url = prefix + url + else: + url = prefix + '/' + url + return url + + def process_http(self, parts): + (scheme, host, path, parm, query, frag) = parts + + if '@' in host and auth_handler: + try: + user_pass, host = host.split('@', 1) + if ':' in user_pass: + user, password = user_pass.split(':', 1) + except ValueError, e: + raise URLGrabError(1, _('Bad URL: %s') % url) + if DEBUG: DEBUG.info('adding HTTP auth: %s, XXXXXXXX', user) + auth_handler.add_password(None, host, user, password) + + return (scheme, host, path, parm, query, frag) + + def quote(self, parts): + """quote the URL + + This method quotes ONLY the path part. If you need to quote + other parts, you should override this and pass in your derived + class. The other alternative is to quote other parts before + passing into urlgrabber. + """ + (scheme, host, path, parm, query, frag) = parts + path = urllib.quote(path) + return (scheme, host, path, parm, query, frag) + + hexvals = '0123456789ABCDEF' + def guess_should_quote(self, parts): + """ + Guess whether we should quote a path. This amounts to + guessing whether it's already quoted. + + find ' ' -> 1 + find '%' -> 1 + find '%XX' -> 0 + else -> 1 + """ + (scheme, host, path, parm, query, frag) = parts + if ' ' in path: + return 1 + ind = string.find(path, '%') + if ind > -1: + while ind > -1: + if len(path) < ind+3: + return 1 + code = path[ind+1:ind+3].upper() + if code[0] not in self.hexvals or \ + code[1] not in self.hexvals: + return 1 + ind = string.find(path, '%', ind+1) + return 0 + return 1 + +class URLGrabberOptions: + """Class to ease kwargs handling.""" + + def __init__(self, delegate=None, **kwargs): + """Initialize URLGrabberOptions object. + Set default values for all options and then update options specified + in kwargs. + """ + self.delegate = delegate + if delegate is None: + self._set_defaults() + self._set_attributes(**kwargs) + + def __getattr__(self, name): + if self.delegate and hasattr(self.delegate, name): + return getattr(self.delegate, name) + raise AttributeError, name + + def raw_throttle(self): + """Calculate raw throttle value from throttle and bandwidth + values. + """ + if self.throttle <= 0: + return 0 + elif type(self.throttle) == type(0): + return float(self.throttle) + else: # throttle is a float + return self.bandwidth * self.throttle + + def derive(self, **kwargs): + """Create a derived URLGrabberOptions instance. + This method creates a new instance and overrides the + options specified in kwargs. + """ + return URLGrabberOptions(delegate=self, **kwargs) + + def _set_attributes(self, **kwargs): + """Update object attributes with those provided in kwargs.""" + self.__dict__.update(kwargs) + if have_range and kwargs.has_key('range'): + # normalize the supplied range value + self.range = range_tuple_normalize(self.range) + if not self.reget in [None, 'simple', 'check_timestamp']: + raise URLGrabError(11, _('Illegal reget mode: %s') \ + % (self.reget, )) + + def _set_defaults(self): + """Set all options to their default values. + When adding new options, make sure a default is + provided here. + """ + self.progress_obj = None + self.throttle = 1.0 + self.bandwidth = 0 + self.retry = None + self.retrycodes = [-1,2,4,5,6,7] + self.checkfunc = None + self.copy_local = 0 + self.close_connection = 0 + self.range = None + self.user_agent = 'urlgrabber/%s' % __version__ + self.keepalive = 1 + self.proxies = None + self.reget = None + self.failure_callback = None + self.interrupt_callback = None + self.prefix = None + self.opener = None + self.cache_openers = True + self.timeout = None + self.text = None + self.http_headers = None + self.ftp_headers = None + self.data = None + self.urlparser = URLParser() + self.quote = None + self.ssl_ca_cert = None + self.ssl_context = None + +class URLGrabber: + """Provides easy opening of URLs with a variety of options. + + All options are specified as kwargs. Options may be specified when + the class is created and may be overridden on a per request basis. + + New objects inherit default values from default_grabber. + """ + + def __init__(self, **kwargs): + self.opts = URLGrabberOptions(**kwargs) + + def _retry(self, opts, func, *args): + tries = 0 + while 1: + # there are only two ways out of this loop. The second has + # several "sub-ways" + # 1) via the return in the "try" block + # 2) by some exception being raised + # a) an excepton is raised that we don't "except" + # b) a callback raises ANY exception + # c) we're not retry-ing or have run out of retries + # d) the URLGrabError code is not in retrycodes + # beware of infinite loops :) + tries = tries + 1 + exception = None + retrycode = None + callback = None + if DEBUG: DEBUG.info('attempt %i/%s: %s', + tries, opts.retry, args[0]) + try: + r = apply(func, (opts,) + args, {}) + if DEBUG: DEBUG.info('success') + return r + except URLGrabError, e: + exception = e + callback = opts.failure_callback + retrycode = e.errno + except KeyboardInterrupt, e: + exception = e + callback = opts.interrupt_callback + + if DEBUG: DEBUG.info('exception: %s', exception) + if callback: + if DEBUG: DEBUG.info('calling callback: %s', callback) + cb_func, cb_args, cb_kwargs = self._make_callback(callback) + obj = CallbackObject(exception=exception, url=args[0], + tries=tries, retry=opts.retry) + cb_func(obj, *cb_args, **cb_kwargs) + + if (opts.retry is None) or (tries == opts.retry): + if DEBUG: DEBUG.info('retries exceeded, re-raising') + raise + + if (retrycode is not None) and (retrycode not in opts.retrycodes): + if DEBUG: DEBUG.info('retrycode (%i) not in list %s, re-raising', + retrycode, opts.retrycodes) + raise + + def urlopen(self, url, **kwargs): + """open the url and return a file object + If a progress object or throttle value specified when this + object was created, then a special file object will be + returned that supports them. The file object can be treated + like any other file object. + """ + opts = self.opts.derive(**kwargs) + (url,parts) = opts.urlparser.parse(url, opts) + def retryfunc(opts, url): + return URLGrabberFileObject(url, filename=None, opts=opts) + return self._retry(opts, retryfunc, url) + + def urlgrab(self, url, filename=None, **kwargs): + """grab the file at <url> and make a local copy at <filename> + If filename is none, the basename of the url is used. + urlgrab returns the filename of the local file, which may be + different from the passed-in filename if copy_local == 0. + """ + opts = self.opts.derive(**kwargs) + (url,parts) = opts.urlparser.parse(url, opts) + (scheme, host, path, parm, query, frag) = parts + if filename is None: + filename = os.path.basename( urllib.unquote(path) ) + if scheme == 'file' and not opts.copy_local: + # just return the name of the local file - don't make a + # copy currently + path = urllib.url2pathname(path) + if host: + path = os.path.normpath('//' + host + path) + if not os.path.exists(path): + raise URLGrabError(2, + _('Local file does not exist: %s') % (path, )) + elif not os.path.isfile(path): + raise URLGrabError(3, + _('Not a normal file: %s') % (path, )) + elif not opts.range: + return path + + def retryfunc(opts, url, filename): + fo = URLGrabberFileObject(url, filename, opts) + try: + fo._do_grab() + if not opts.checkfunc is None: + cb_func, cb_args, cb_kwargs = \ + self._make_callback(opts.checkfunc) + obj = CallbackObject() + obj.filename = filename + obj.url = url + apply(cb_func, (obj, )+cb_args, cb_kwargs) + finally: + fo.close() + return filename + + return self._retry(opts, retryfunc, url, filename) + + def urlread(self, url, limit=None, **kwargs): + """read the url into a string, up to 'limit' bytes + If the limit is exceeded, an exception will be thrown. Note + that urlread is NOT intended to be used as a way of saying + "I want the first N bytes" but rather 'read the whole file + into memory, but don't use too much' + """ + opts = self.opts.derive(**kwargs) + (url,parts) = opts.urlparser.parse(url, opts) + if limit is not None: + limit = limit + 1 + + def retryfunc(opts, url, limit): + fo = URLGrabberFileObject(url, filename=None, opts=opts) + s = '' + try: + # this is an unfortunate thing. Some file-like objects + # have a default "limit" of None, while the built-in (real) + # file objects have -1. They each break the other, so for + # now, we just force the default if necessary. + if limit is None: s = fo.read() + else: s = fo.read(limit) + + if not opts.checkfunc is None: + cb_func, cb_args, cb_kwargs = \ + self._make_callback(opts.checkfunc) + obj = CallbackObject() + obj.data = s + obj.url = url + apply(cb_func, (obj, )+cb_args, cb_kwargs) + finally: + fo.close() + return s + + s = self._retry(opts, retryfunc, url, limit) + if limit and len(s) > limit: + raise URLGrabError(8, + _('Exceeded limit (%i): %s') % (limit, url)) + return s + + def _make_callback(self, callback_obj): + if callable(callback_obj): + return callback_obj, (), {} + else: + return callback_obj + +# create the default URLGrabber used by urlXXX functions. +# NOTE: actual defaults are set in URLGrabberOptions +default_grabber = URLGrabber() + +class URLGrabberFileObject: + """This is a file-object wrapper that supports progress objects + and throttling. + + This exists to solve the following problem: lets say you want to + drop-in replace a normal open with urlopen. You want to use a + progress meter and/or throttling, but how do you do that without + rewriting your code? Answer: urlopen will return a wrapped file + object that does the progress meter and-or throttling internally. + """ + + def __init__(self, url, filename, opts): + self.url = url + self.filename = filename + self.opts = opts + self.fo = None + self._rbuf = '' + self._rbufsize = 1024*8 + self._ttime = time.time() + self._tsize = 0 + self._amount_read = 0 + self._opener = None + self._do_open() + + def __getattr__(self, name): + """This effectively allows us to wrap at the instance level. + Any attribute not found in _this_ object will be searched for + in self.fo. This includes methods.""" + if hasattr(self.fo, name): + return getattr(self.fo, name) + raise AttributeError, name + + def _get_opener(self): + """Build a urllib2 OpenerDirector based on request options.""" + if self.opts.opener: + return self.opts.opener + elif self._opener is None: + handlers = [] + need_keepalive_handler = (have_keepalive and self.opts.keepalive) + need_range_handler = (range_handlers and \ + (self.opts.range or self.opts.reget)) + # if you specify a ProxyHandler when creating the opener + # it _must_ come before all other handlers in the list or urllib2 + # chokes. + if self.opts.proxies: + handlers.append( CachedProxyHandler(self.opts.proxies) ) + + # ------------------------------------------------------- + # OK, these next few lines are a serious kludge to get + # around what I think is a bug in python 2.2's + # urllib2. The basic idea is that default handlers + # get applied first. If you override one (like a + # proxy handler), then the default gets pulled, but + # the replacement goes on the end. In the case of + # proxies, this means the normal handler picks it up + # first and the proxy isn't used. Now, this probably + # only happened with ftp or non-keepalive http, so not + # many folks saw it. The simple approach to fixing it + # is just to make sure you override the other + # conflicting defaults as well. I would LOVE to see + # these go way or be dealt with more elegantly. The + # problem isn't there after 2.2. -MDS 2005/02/24 + if not need_keepalive_handler: + handlers.append( urllib2.HTTPHandler() ) + if not need_range_handler: + handlers.append( urllib2.FTPHandler() ) + # ------------------------------------------------------- + + ssl_factory = sslfactory.get_factory(self.opts.ssl_ca_cert, + self.opts.ssl_context) + + if need_keepalive_handler: + handlers.append(HTTPHandler()) + handlers.append(HTTPSHandler(ssl_factory)) + if need_range_handler: + handlers.extend( range_handlers ) + handlers.append( auth_handler ) + if self.opts.cache_openers: + self._opener = CachedOpenerDirector(ssl_factory, *handlers) + else: + self._opener = ssl_factory.create_opener(*handlers) + # OK, I don't like to do this, but otherwise, we end up with + # TWO user-agent headers. + self._opener.addheaders = [] + return self._opener + + def _do_open(self): + opener = self._get_opener() + + req = urllib2.Request(self.url, self.opts.data) # build request object + self._add_headers(req) # add misc headers that we need + self._build_range(req) # take care of reget and byterange stuff + + fo, hdr = self._make_request(req, opener) + if self.reget_time and self.opts.reget == 'check_timestamp': + # do this if we have a local file with known timestamp AND + # we're in check_timestamp reget mode. + fetch_again = 0 + try: + modified_tuple = hdr.getdate_tz('last-modified') + modified_stamp = rfc822.mktime_tz(modified_tuple) + if modified_stamp > self.reget_time: fetch_again = 1 + except (TypeError,): + fetch_again = 1 + + if fetch_again: + # the server version is newer than the (incomplete) local + # version, so we should abandon the version we're getting + # and fetch the whole thing again. + fo.close() + self.opts.reget = None + del req.headers['Range'] + self._build_range(req) + fo, hdr = self._make_request(req, opener) + + (scheme, host, path, parm, query, frag) = urlparse.urlparse(self.url) + path = urllib.unquote(path) + if not (self.opts.progress_obj or self.opts.raw_throttle() \ + or self.opts.timeout): + # if we're not using the progress_obj, throttling, or timeout + # we can get a performance boost by going directly to + # the underlying fileobject for reads. + self.read = fo.read + if hasattr(fo, 'readline'): + self.readline = fo.readline + elif self.opts.progress_obj: + try: + length = int(hdr['Content-Length']) + length = length + self._amount_read # Account for regets + except (KeyError, ValueError, TypeError): + length = None + + self.opts.progress_obj.start(str(self.filename), + urllib.unquote(self.url), + os.path.basename(path), + length, text=self.opts.text) + self.opts.progress_obj.update(0) + (self.fo, self.hdr) = (fo, hdr) + + def _add_headers(self, req): + if self.opts.user_agent: + req.add_header('User-agent', self.opts.user_agent) + try: req_type = req.get_type() + except ValueError: req_type = None + if self.opts.http_headers and req_type in ('http', 'https'): + for h, v in self.opts.http_headers: + req.add_header(h, v) + if self.opts.ftp_headers and req_type == 'ftp': + for h, v in self.opts.ftp_headers: + req.add_header(h, v) + + def _build_range(self, req): + self.reget_time = None + self.append = 0 + reget_length = 0 + rt = None + if have_range and self.opts.reget and type(self.filename) == type(''): + # we have reget turned on and we're dumping to a file + try: + s = os.stat(self.filename) + except OSError: + pass + else: + self.reget_time = s[ST_MTIME] + reget_length = s[ST_SIZE] + + # Set initial length when regetting + self._amount_read = reget_length + + rt = reget_length, '' + self.append = 1 + + if self.opts.range: + if not have_range: + raise URLGrabError(10, _('Byte range requested but range '\ + 'support unavailable')) + rt = self.opts.range + if rt[0]: rt = (rt[0] + reget_length, rt[1]) + + if rt: + header = range_tuple_to_header(rt) + if header: req.add_header('Range', header) + + def _make_request(self, req, opener): + try: + if have_socket_timeout and self.opts.timeout: + old_to = socket.getdefaulttimeout() + socket.setdefaulttimeout(self.opts.timeout) + try: + fo = opener.open(req) + finally: + socket.setdefaulttimeout(old_to) + else: + fo = opener.open(req) + hdr = fo.info() + except ValueError, e: + raise URLGrabError(1, _('Bad URL: %s') % (e, )) + except RangeError, e: + raise URLGrabError(9, str(e)) + except urllib2.HTTPError, e: + new_e = URLGrabError(14, str(e)) + new_e.code = e.code + new_e.exception = e + raise new_e + except IOError, e: + if hasattr(e, 'reason') and have_socket_timeout and \ + isinstance(e.reason, TimeoutError): + raise URLGrabError(12, _('Timeout: %s') % (e, )) + else: + raise URLGrabError(4, _('IOError: %s') % (e, )) + except OSError, e: + raise URLGrabError(5, _('OSError: %s') % (e, )) + except HTTPException, e: + raise URLGrabError(7, _('HTTP Exception (%s): %s') % \ + (e.__class__.__name__, e)) + else: + return (fo, hdr) + + def _do_grab(self): + """dump the file to self.filename.""" + if self.append: new_fo = open(self.filename, 'ab') + else: new_fo = open(self.filename, 'wb') + bs = 1024*8 + size = 0 + + block = self.read(bs) + size = size + len(block) + while block: + new_fo.write(block) + block = self.read(bs) + size = size + len(block) + + new_fo.close() + try: + modified_tuple = self.hdr.getdate_tz('last-modified') + modified_stamp = rfc822.mktime_tz(modified_tuple) + os.utime(self.filename, (modified_stamp, modified_stamp)) + except (TypeError,), e: pass + + return size + + def _fill_buffer(self, amt=None): + """fill the buffer to contain at least 'amt' bytes by reading + from the underlying file object. If amt is None, then it will + read until it gets nothing more. It updates the progress meter + and throttles after every self._rbufsize bytes.""" + # the _rbuf test is only in this first 'if' for speed. It's not + # logically necessary + if self._rbuf and not amt is None: + L = len(self._rbuf) + if amt > L: + amt = amt - L + else: + return + + # if we've made it here, then we don't have enough in the buffer + # and we need to read more. + + buf = [self._rbuf] + bufsize = len(self._rbuf) + while amt is None or amt: + # first, delay if necessary for throttling reasons + if self.opts.raw_throttle(): + diff = self._tsize/self.opts.raw_throttle() - \ + (time.time() - self._ttime) + if diff > 0: time.sleep(diff) + self._ttime = time.time() + + # now read some data, up to self._rbufsize + if amt is None: readamount = self._rbufsize + else: readamount = min(amt, self._rbufsize) + try: + new = self.fo.read(readamount) + except socket.error, e: + raise URLGrabError(4, _('Socket Error: %s') % (e, )) + except TimeoutError, e: + raise URLGrabError(12, _('Timeout: %s') % (e, )) + except IOError, e: + raise URLGrabError(4, _('IOError: %s') %(e,)) + newsize = len(new) + if not newsize: break # no more to read + + if amt: amt = amt - newsize + buf.append(new) + bufsize = bufsize + newsize + self._tsize = newsize + self._amount_read = self._amount_read + newsize + if self.opts.progress_obj: + self.opts.progress_obj.update(self._amount_read) + + self._rbuf = string.join(buf, '') + return + + def read(self, amt=None): + self._fill_buffer(amt) + if amt is None: + s, self._rbuf = self._rbuf, '' + else: + s, self._rbuf = self._rbuf[:amt], self._rbuf[amt:] + return s + + def readline(self, limit=-1): + i = string.find(self._rbuf, '\n') + while i < 0 and not (0 < limit <= len(self._rbuf)): + L = len(self._rbuf) + self._fill_buffer(L + self._rbufsize) + if not len(self._rbuf) > L: break + i = string.find(self._rbuf, '\n', L) + + if i < 0: i = len(self._rbuf) + else: i = i+1 + if 0 <= limit < len(self._rbuf): i = limit + + s, self._rbuf = self._rbuf[:i], self._rbuf[i:] + return s + + def close(self): + if self.opts.progress_obj: + self.opts.progress_obj.end(self._amount_read) + self.fo.close() + if self.opts.close_connection: + try: self.fo.close_connection() + except: pass + +_handler_cache = [] +def CachedOpenerDirector(ssl_factory = None, *handlers): + for (cached_handlers, opener) in _handler_cache: + if cached_handlers == handlers: + for handler in opener.handlers: + handler.add_parent(opener) + return opener + if not ssl_factory: + ssl_factory = sslfactory.get_factory() + opener = ssl_factory.create_opener(*handlers) + _handler_cache.append( (handlers, opener) ) + return opener + +_proxy_cache = [] +def CachedProxyHandler(proxies): + for (pdict, handler) in _proxy_cache: + if pdict == proxies: + if DEBUG: DEBUG.debug('re-using proxy settings: %s', proxies) + break + else: + for k, v in proxies.items(): + utype, url = urllib.splittype(v) + host, other = urllib.splithost(url) + if (utype is None) or (host is None): + raise URLGrabError(13, _('Bad proxy URL: %s') % v) + + if DEBUG: DEBUG.info('creating new proxy handler: %s', proxies) + handler = urllib2.ProxyHandler(proxies) + _proxy_cache.append( (proxies, handler) ) + return handler + +##################################################################### +# DEPRECATED FUNCTIONS +def set_throttle(new_throttle): + """Deprecated. Use: default_grabber.throttle = new_throttle""" + default_grabber.throttle = new_throttle + +def set_bandwidth(new_bandwidth): + """Deprecated. Use: default_grabber.bandwidth = new_bandwidth""" + default_grabber.bandwidth = new_bandwidth + +def set_progress_obj(new_progress_obj): + """Deprecated. Use: default_grabber.progress_obj = new_progress_obj""" + default_grabber.progress_obj = new_progress_obj + +def set_user_agent(new_user_agent): + """Deprecated. Use: default_grabber.user_agent = new_user_agent""" + default_grabber.user_agent = new_user_agent + +def retrygrab(url, filename=None, copy_local=0, close_connection=0, + progress_obj=None, throttle=None, bandwidth=None, + numtries=3, retrycodes=[-1,2,4,5,6,7], checkfunc=None): + """Deprecated. Use: urlgrab() with the retry arg instead""" + kwargs = {'copy_local' : copy_local, + 'close_connection' : close_connection, + 'progress_obj' : progress_obj, + 'throttle' : throttle, + 'bandwidth' : bandwidth, + 'retry' : numtries, + 'retrycodes' : retrycodes, + 'checkfunc' : checkfunc + } + return urlgrab(url, filename, **kwargs) + + +##################################################################### +# TESTING +def _main_test(): + import sys + try: url, filename = sys.argv[1:3] + except ValueError: + print 'usage:', sys.argv[0], \ + '<url> <filename> [copy_local=0|1] [close_connection=0|1]' + sys.exit() + + kwargs = {} + for a in sys.argv[3:]: + k, v = string.split(a, '=', 1) + kwargs[k] = int(v) + + set_throttle(1.0) + set_bandwidth(32 * 1024) + print "throttle: %s, throttle bandwidth: %s B/s" % (default_grabber.throttle, + default_grabber.bandwidth) + + try: from progress import text_progress_meter + except ImportError, e: pass + else: kwargs['progress_obj'] = text_progress_meter() + + try: name = apply(urlgrab, (url, filename), kwargs) + except URLGrabError, e: print e + else: print 'LOCAL FILE:', name + + +def _retry_test(): + import sys + try: url, filename = sys.argv[1:3] + except ValueError: + print 'usage:', sys.argv[0], \ + '<url> <filename> [copy_local=0|1] [close_connection=0|1]' + sys.exit() + + kwargs = {} + for a in sys.argv[3:]: + k, v = string.split(a, '=', 1) + kwargs[k] = int(v) + + try: from progress import text_progress_meter + except ImportError, e: pass + else: kwargs['progress_obj'] = text_progress_meter() + + def cfunc(filename, hello, there='foo'): + print hello, there + import random + rnum = random.random() + if rnum < .5: + print 'forcing retry' + raise URLGrabError(-1, 'forcing retry') + if rnum < .75: + print 'forcing failure' + raise URLGrabError(-2, 'forcing immediate failure') + print 'success' + return + + kwargs['checkfunc'] = (cfunc, ('hello',), {'there':'there'}) + try: name = apply(retrygrab, (url, filename), kwargs) + except URLGrabError, e: print e + else: print 'LOCAL FILE:', name + +def _file_object_test(filename=None): + import random, cStringIO, sys + if filename is None: + filename = __file__ + print 'using file "%s" for comparisons' % filename + fo = open(filename) + s_input = fo.read() + fo.close() + + for testfunc in [_test_file_object_smallread, + _test_file_object_readall, + _test_file_object_readline, + _test_file_object_readlines]: + fo_input = cStringIO.StringIO(s_input) + fo_output = cStringIO.StringIO() + wrapper = URLGrabberFileObject(fo_input, None, 0) + print 'testing %-30s ' % testfunc.__name__, + testfunc(wrapper, fo_output) + s_output = fo_output.getvalue() + if s_output == s_input: print 'passed' + else: print 'FAILED' + +def _test_file_object_smallread(wrapper, fo_output): + while 1: + s = wrapper.read(23) + fo_output.write(s) + if not s: return + +def _test_file_object_readall(wrapper, fo_output): + s = wrapper.read() + fo_output.write(s) + +def _test_file_object_readline(wrapper, fo_output): + while 1: + s = wrapper.readline() + fo_output.write(s) + if not s: return + +def _test_file_object_readlines(wrapper, fo_output): + li = wrapper.readlines() + fo_output.write(string.join(li, '')) + +if __name__ == '__main__': + _main_test() + _retry_test() + _file_object_test('test') diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/keepalive.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/keepalive.py new file mode 100644 index 0000000000..71393e2b8d --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/keepalive.py @@ -0,0 +1,617 @@ +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the +# Free Software Foundation, Inc., +# 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +# This file is part of urlgrabber, a high-level cross-protocol url-grabber +# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko + +"""An HTTP handler for urllib2 that supports HTTP 1.1 and keepalive. + +>>> import urllib2 +>>> from keepalive import HTTPHandler +>>> keepalive_handler = HTTPHandler() +>>> opener = urllib2.build_opener(keepalive_handler) +>>> urllib2.install_opener(opener) +>>> +>>> fo = urllib2.urlopen('http://www.python.org') + +If a connection to a given host is requested, and all of the existing +connections are still in use, another connection will be opened. If +the handler tries to use an existing connection but it fails in some +way, it will be closed and removed from the pool. + +To remove the handler, simply re-run build_opener with no arguments, and +install that opener. + +You can explicitly close connections by using the close_connection() +method of the returned file-like object (described below) or you can +use the handler methods: + + close_connection(host) + close_all() + open_connections() + +NOTE: using the close_connection and close_all methods of the handler +should be done with care when using multiple threads. + * there is nothing that prevents another thread from creating new + connections immediately after connections are closed + * no checks are done to prevent in-use connections from being closed + +>>> keepalive_handler.close_all() + +EXTRA ATTRIBUTES AND METHODS + + Upon a status of 200, the object returned has a few additional + attributes and methods, which should not be used if you want to + remain consistent with the normal urllib2-returned objects: + + close_connection() - close the connection to the host + readlines() - you know, readlines() + status - the return status (ie 404) + reason - english translation of status (ie 'File not found') + + If you want the best of both worlds, use this inside an + AttributeError-catching try: + + >>> try: status = fo.status + >>> except AttributeError: status = None + + Unfortunately, these are ONLY there if status == 200, so it's not + easy to distinguish between non-200 responses. The reason is that + urllib2 tries to do clever things with error codes 301, 302, 401, + and 407, and it wraps the object upon return. + + For python versions earlier than 2.4, you can avoid this fancy error + handling by setting the module-level global HANDLE_ERRORS to zero. + You see, prior to 2.4, it's the HTTP Handler's job to determine what + to handle specially, and what to just pass up. HANDLE_ERRORS == 0 + means "pass everything up". In python 2.4, however, this job no + longer belongs to the HTTP Handler and is now done by a NEW handler, + HTTPErrorProcessor. Here's the bottom line: + + python version < 2.4 + HANDLE_ERRORS == 1 (default) pass up 200, treat the rest as + errors + HANDLE_ERRORS == 0 pass everything up, error processing is + left to the calling code + python version >= 2.4 + HANDLE_ERRORS == 1 pass up 200, treat the rest as errors + HANDLE_ERRORS == 0 (default) pass everything up, let the + other handlers (specifically, + HTTPErrorProcessor) decide what to do + + In practice, setting the variable either way makes little difference + in python 2.4, so for the most consistent behavior across versions, + you probably just want to use the defaults, which will give you + exceptions on errors. + +""" + +# $Id: keepalive.py,v 1.16 2006/09/22 00:58:05 mstenner Exp $ + +import urllib2 +import httplib +import socket +import thread + +DEBUG = None + +import sslfactory + +import sys +if sys.version_info < (2, 4): HANDLE_ERRORS = 1 +else: HANDLE_ERRORS = 0 + +class ConnectionManager: + """ + The connection manager must be able to: + * keep track of all existing + """ + def __init__(self): + self._lock = thread.allocate_lock() + self._hostmap = {} # map hosts to a list of connections + self._connmap = {} # map connections to host + self._readymap = {} # map connection to ready state + + def add(self, host, connection, ready): + self._lock.acquire() + try: + if not self._hostmap.has_key(host): self._hostmap[host] = [] + self._hostmap[host].append(connection) + self._connmap[connection] = host + self._readymap[connection] = ready + finally: + self._lock.release() + + def remove(self, connection): + self._lock.acquire() + try: + try: + host = self._connmap[connection] + except KeyError: + pass + else: + del self._connmap[connection] + del self._readymap[connection] + self._hostmap[host].remove(connection) + if not self._hostmap[host]: del self._hostmap[host] + finally: + self._lock.release() + + def set_ready(self, connection, ready): + try: self._readymap[connection] = ready + except KeyError: pass + + def get_ready_conn(self, host): + conn = None + self._lock.acquire() + try: + if self._hostmap.has_key(host): + for c in self._hostmap[host]: + if self._readymap[c]: + self._readymap[c] = 0 + conn = c + break + finally: + self._lock.release() + return conn + + def get_all(self, host=None): + if host: + return list(self._hostmap.get(host, [])) + else: + return dict(self._hostmap) + +class KeepAliveHandler: + def __init__(self): + self._cm = ConnectionManager() + + #### Connection Management + def open_connections(self): + """return a list of connected hosts and the number of connections + to each. [('foo.com:80', 2), ('bar.org', 1)]""" + return [(host, len(li)) for (host, li) in self._cm.get_all().items()] + + def close_connection(self, host): + """close connection(s) to <host> + host is the host:port spec, as in 'www.cnn.com:8080' as passed in. + no error occurs if there is no connection to that host.""" + for h in self._cm.get_all(host): + self._cm.remove(h) + h.close() + + def close_all(self): + """close all open connections""" + for host, conns in self._cm.get_all().items(): + for h in conns: + self._cm.remove(h) + h.close() + + def _request_closed(self, request, host, connection): + """tells us that this request is now closed and the the + connection is ready for another request""" + self._cm.set_ready(connection, 1) + + def _remove_connection(self, host, connection, close=0): + if close: connection.close() + self._cm.remove(connection) + + #### Transaction Execution + def do_open(self, req): + host = req.get_host() + if not host: + raise urllib2.URLError('no host given') + + try: + h = self._cm.get_ready_conn(host) + while h: + r = self._reuse_connection(h, req, host) + + # if this response is non-None, then it worked and we're + # done. Break out, skipping the else block. + if r: break + + # connection is bad - possibly closed by server + # discard it and ask for the next free connection + h.close() + self._cm.remove(h) + h = self._cm.get_ready_conn(host) + else: + # no (working) free connections were found. Create a new one. + h = self._get_connection(host) + if DEBUG: DEBUG.info("creating new connection to %s (%d)", + host, id(h)) + self._cm.add(host, h, 0) + self._start_transaction(h, req) + r = h.getresponse() + except (socket.error, httplib.HTTPException), err: + raise urllib2.URLError(err) + + # if not a persistent connection, don't try to reuse it + if r.will_close: self._cm.remove(h) + + if DEBUG: DEBUG.info("STATUS: %s, %s", r.status, r.reason) + r._handler = self + r._host = host + r._url = req.get_full_url() + r._connection = h + r.code = r.status + r.headers = r.msg + r.msg = r.reason + + if r.status == 200 or not HANDLE_ERRORS: + return r + else: + return self.parent.error('http', req, r, + r.status, r.msg, r.headers) + + def _reuse_connection(self, h, req, host): + """start the transaction with a re-used connection + return a response object (r) upon success or None on failure. + This DOES not close or remove bad connections in cases where + it returns. However, if an unexpected exception occurs, it + will close and remove the connection before re-raising. + """ + try: + self._start_transaction(h, req) + r = h.getresponse() + # note: just because we got something back doesn't mean it + # worked. We'll check the version below, too. + except (socket.error, httplib.HTTPException): + r = None + except: + # adding this block just in case we've missed + # something we will still raise the exception, but + # lets try and close the connection and remove it + # first. We previously got into a nasty loop + # where an exception was uncaught, and so the + # connection stayed open. On the next try, the + # same exception was raised, etc. The tradeoff is + # that it's now possible this call will raise + # a DIFFERENT exception + if DEBUG: DEBUG.error("unexpected exception - closing " + \ + "connection to %s (%d)", host, id(h)) + self._cm.remove(h) + h.close() + raise + + if r is None or r.version == 9: + # httplib falls back to assuming HTTP 0.9 if it gets a + # bad header back. This is most likely to happen if + # the socket has been closed by the server since we + # last used the connection. + if DEBUG: DEBUG.info("failed to re-use connection to %s (%d)", + host, id(h)) + r = None + else: + if DEBUG: DEBUG.info("re-using connection to %s (%d)", host, id(h)) + + return r + + def _start_transaction(self, h, req): + try: + if req.has_data(): + data = req.get_data() + h.putrequest('POST', req.get_selector()) + if not req.headers.has_key('Content-type'): + h.putheader('Content-type', + 'application/x-www-form-urlencoded') + if not req.headers.has_key('Content-length'): + h.putheader('Content-length', '%d' % len(data)) + else: + h.putrequest('GET', req.get_selector()) + except (socket.error, httplib.HTTPException), err: + raise urllib2.URLError(err) + + for args in self.parent.addheaders: + h.putheader(*args) + for k, v in req.headers.items(): + h.putheader(k, v) + h.endheaders() + if req.has_data(): + h.send(data) + + def _get_connection(self, host): + return NotImplementedError + +class HTTPHandler(KeepAliveHandler, urllib2.HTTPHandler): + def __init__(self): + KeepAliveHandler.__init__(self) + + def http_open(self, req): + return self.do_open(req) + + def _get_connection(self, host): + return HTTPConnection(host) + +class HTTPSHandler(KeepAliveHandler, urllib2.HTTPSHandler): + def __init__(self, ssl_factory=None): + KeepAliveHandler.__init__(self) + if not ssl_factory: + ssl_factory = sslfactory.get_factory() + self._ssl_factory = ssl_factory + + def https_open(self, req): + return self.do_open(req) + + def _get_connection(self, host): + return self._ssl_factory.get_https_connection(host) + +class HTTPResponse(httplib.HTTPResponse): + # we need to subclass HTTPResponse in order to + # 1) add readline() and readlines() methods + # 2) add close_connection() methods + # 3) add info() and geturl() methods + + # in order to add readline(), read must be modified to deal with a + # buffer. example: readline must read a buffer and then spit back + # one line at a time. The only real alternative is to read one + # BYTE at a time (ick). Once something has been read, it can't be + # put back (ok, maybe it can, but that's even uglier than this), + # so if you THEN do a normal read, you must first take stuff from + # the buffer. + + # the read method wraps the original to accomodate buffering, + # although read() never adds to the buffer. + # Both readline and readlines have been stolen with almost no + # modification from socket.py + + + def __init__(self, sock, debuglevel=0, strict=0, method=None): + if method: # the httplib in python 2.3 uses the method arg + httplib.HTTPResponse.__init__(self, sock, debuglevel, method) + else: # 2.2 doesn't + httplib.HTTPResponse.__init__(self, sock, debuglevel) + self.fileno = sock.fileno + self.code = None + self._rbuf = '' + self._rbufsize = 8096 + self._handler = None # inserted by the handler later + self._host = None # (same) + self._url = None # (same) + self._connection = None # (same) + + _raw_read = httplib.HTTPResponse.read + + def close(self): + if self.fp: + self.fp.close() + self.fp = None + if self._handler: + self._handler._request_closed(self, self._host, + self._connection) + + def close_connection(self): + self._handler._remove_connection(self._host, self._connection, close=1) + self.close() + + def info(self): + return self.headers + + def geturl(self): + return self._url + + def read(self, amt=None): + # the _rbuf test is only in this first if for speed. It's not + # logically necessary + if self._rbuf and not amt is None: + L = len(self._rbuf) + if amt > L: + amt -= L + else: + s = self._rbuf[:amt] + self._rbuf = self._rbuf[amt:] + return s + + s = self._rbuf + self._raw_read(amt) + self._rbuf = '' + return s + + def readline(self, limit=-1): + data = "" + i = self._rbuf.find('\n') + while i < 0 and not (0 < limit <= len(self._rbuf)): + new = self._raw_read(self._rbufsize) + if not new: break + i = new.find('\n') + if i >= 0: i = i + len(self._rbuf) + self._rbuf = self._rbuf + new + if i < 0: i = len(self._rbuf) + else: i = i+1 + if 0 <= limit < len(self._rbuf): i = limit + data, self._rbuf = self._rbuf[:i], self._rbuf[i:] + return data + + def readlines(self, sizehint = 0): + total = 0 + list = [] + while 1: + line = self.readline() + if not line: break + list.append(line) + total += len(line) + if sizehint and total >= sizehint: + break + return list + + +class HTTPConnection(httplib.HTTPConnection): + # use the modified response class + response_class = HTTPResponse + +class HTTPSConnection(httplib.HTTPSConnection): + response_class = HTTPResponse + +######################################################################### +##### TEST FUNCTIONS +######################################################################### + +def error_handler(url): + global HANDLE_ERRORS + orig = HANDLE_ERRORS + keepalive_handler = HTTPHandler() + opener = urllib2.build_opener(keepalive_handler) + urllib2.install_opener(opener) + pos = {0: 'off', 1: 'on'} + for i in (0, 1): + print " fancy error handling %s (HANDLE_ERRORS = %i)" % (pos[i], i) + HANDLE_ERRORS = i + try: + fo = urllib2.urlopen(url) + foo = fo.read() + fo.close() + try: status, reason = fo.status, fo.reason + except AttributeError: status, reason = None, None + except IOError, e: + print " EXCEPTION: %s" % e + raise + else: + print " status = %s, reason = %s" % (status, reason) + HANDLE_ERRORS = orig + hosts = keepalive_handler.open_connections() + print "open connections:", hosts + keepalive_handler.close_all() + +def continuity(url): + import md5 + format = '%25s: %s' + + # first fetch the file with the normal http handler + opener = urllib2.build_opener() + urllib2.install_opener(opener) + fo = urllib2.urlopen(url) + foo = fo.read() + fo.close() + m = md5.new(foo) + print format % ('normal urllib', m.hexdigest()) + + # now install the keepalive handler and try again + opener = urllib2.build_opener(HTTPHandler()) + urllib2.install_opener(opener) + + fo = urllib2.urlopen(url) + foo = fo.read() + fo.close() + m = md5.new(foo) + print format % ('keepalive read', m.hexdigest()) + + fo = urllib2.urlopen(url) + foo = '' + while 1: + f = fo.readline() + if f: foo = foo + f + else: break + fo.close() + m = md5.new(foo) + print format % ('keepalive readline', m.hexdigest()) + +def comp(N, url): + print ' making %i connections to:\n %s' % (N, url) + + sys.stdout.write(' first using the normal urllib handlers') + # first use normal opener + opener = urllib2.build_opener() + urllib2.install_opener(opener) + t1 = fetch(N, url) + print ' TIME: %.3f s' % t1 + + sys.stdout.write(' now using the keepalive handler ') + # now install the keepalive handler and try again + opener = urllib2.build_opener(HTTPHandler()) + urllib2.install_opener(opener) + t2 = fetch(N, url) + print ' TIME: %.3f s' % t2 + print ' improvement factor: %.2f' % (t1/t2, ) + +def fetch(N, url, delay=0): + import time + lens = [] + starttime = time.time() + for i in range(N): + if delay and i > 0: time.sleep(delay) + fo = urllib2.urlopen(url) + foo = fo.read() + fo.close() + lens.append(len(foo)) + diff = time.time() - starttime + + j = 0 + for i in lens[1:]: + j = j + 1 + if not i == lens[0]: + print "WARNING: inconsistent length on read %i: %i" % (j, i) + + return diff + +def test_timeout(url): + global DEBUG + dbbackup = DEBUG + class FakeLogger: + def debug(self, msg, *args): print msg % args + info = warning = error = debug + DEBUG = FakeLogger() + print " fetching the file to establish a connection" + fo = urllib2.urlopen(url) + data1 = fo.read() + fo.close() + + i = 20 + print " waiting %i seconds for the server to close the connection" % i + while i > 0: + sys.stdout.write('\r %2i' % i) + sys.stdout.flush() + time.sleep(1) + i -= 1 + sys.stderr.write('\r') + + print " fetching the file a second time" + fo = urllib2.urlopen(url) + data2 = fo.read() + fo.close() + + if data1 == data2: + print ' data are identical' + else: + print ' ERROR: DATA DIFFER' + + DEBUG = dbbackup + + +def test(url, N=10): + print "checking error hander (do this on a non-200)" + try: error_handler(url) + except IOError, e: + print "exiting - exception will prevent further tests" + sys.exit() + print + print "performing continuity test (making sure stuff isn't corrupted)" + continuity(url) + print + print "performing speed comparison" + comp(N, url) + print + print "performing dropped-connection check" + test_timeout(url) + +if __name__ == '__main__': + import time + import sys + try: + N = int(sys.argv[1]) + url = sys.argv[2] + except: + print "%s <integer> <url>" % sys.argv[0] + else: + test(url, N) diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/mirror.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/mirror.py new file mode 100644 index 0000000000..9664c6b5c5 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/mirror.py @@ -0,0 +1,458 @@ +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the +# Free Software Foundation, Inc., +# 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +# This file is part of urlgrabber, a high-level cross-protocol url-grabber +# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko + +"""Module for downloading files from a pool of mirrors + +DESCRIPTION + + This module provides support for downloading files from a pool of + mirrors with configurable failover policies. To a large extent, the + failover policy is chosen by using different classes derived from + the main class, MirrorGroup. + + Instances of MirrorGroup (and cousins) act very much like URLGrabber + instances in that they have urlread, urlgrab, and urlopen methods. + They can therefore, be used in very similar ways. + + from urlgrabber.grabber import URLGrabber + from urlgrabber.mirror import MirrorGroup + gr = URLGrabber() + mg = MirrorGroup(gr, ['http://foo.com/some/directory/', + 'http://bar.org/maybe/somewhere/else/', + 'ftp://baz.net/some/other/place/entirely/'] + mg.urlgrab('relative/path.zip') + + The assumption is that all mirrors are identical AFTER the base urls + specified, so that any mirror can be used to fetch any file. + +FAILOVER + + The failover mechanism is designed to be customized by subclassing + from MirrorGroup to change the details of the behavior. In general, + the classes maintain a master mirror list and a "current mirror" + index. When a download is initiated, a copy of this list and index + is created for that download only. The specific failover policy + depends on the class used, and so is documented in the class + documentation. Note that ANY behavior of the class can be + overridden, so any failover policy at all is possible (although + you may need to change the interface in extreme cases). + +CUSTOMIZATION + + Most customization of a MirrorGroup object is done at instantiation + time (or via subclassing). There are four major types of + customization: + + 1) Pass in a custom urlgrabber - The passed in urlgrabber will be + used (by default... see #2) for the grabs, so options to it + apply for the url-fetching + + 2) Custom mirror list - Mirror lists can simply be a list of + stings mirrors (as shown in the example above) but each can + also be a dict, allowing for more options. For example, the + first mirror in the list above could also have been: + + {'mirror': 'http://foo.com/some/directory/', + 'grabber': <a custom grabber to be used for this mirror>, + 'kwargs': { <a dict of arguments passed to the grabber> }} + + All mirrors are converted to this format internally. If + 'grabber' is omitted, the default grabber will be used. If + kwargs are omitted, then (duh) they will not be used. + + 3) Pass keyword arguments when instantiating the mirror group. + See, for example, the failure_callback argument. + + 4) Finally, any kwargs passed in for the specific file (to the + urlgrab method, for example) will be folded in. The options + passed into the grabber's urlXXX methods will override any + options specified in a custom mirror dict. + +""" + +# $Id: mirror.py,v 1.14 2006/02/22 18:26:46 mstenner Exp $ + +import random +import thread # needed for locking to make this threadsafe + +from grabber import URLGrabError, CallbackObject, DEBUG + +try: + from i18n import _ +except ImportError, msg: + def _(st): return st + +class GrabRequest: + """This is a dummy class used to hold information about the specific + request. For example, a single file. By maintaining this information + separately, we can accomplish two things: + + 1) make it a little easier to be threadsafe + 2) have request-specific parameters + """ + pass + +class MirrorGroup: + """Base Mirror class + + Instances of this class are built with a grabber object and a list + of mirrors. Then all calls to urlXXX should be passed relative urls. + The requested file will be searched for on the first mirror. If the + grabber raises an exception (possibly after some retries) then that + mirror will be removed from the list, and the next will be attempted. + If all mirrors are exhausted, then an exception will be raised. + + MirrorGroup has the following failover policy: + + * downloads begin with the first mirror + + * by default (see default_action below) a failure (after retries) + causes it to increment the local AND master indices. Also, + the current mirror is removed from the local list (but NOT the + master list - the mirror can potentially be used for other + files) + + * if the local list is ever exhausted, a URLGrabError will be + raised (errno=256, no more mirrors) + + OPTIONS + + In addition to the required arguments "grabber" and "mirrors", + MirrorGroup also takes the following optional arguments: + + default_action + + A dict that describes the actions to be taken upon failure + (after retries). default_action can contain any of the + following keys (shown here with their default values): + + default_action = {'increment': 1, + 'increment_master': 1, + 'remove': 1, + 'remove_master': 0, + 'fail': 0} + + In this context, 'increment' means "use the next mirror" and + 'remove' means "never use this mirror again". The two + 'master' values refer to the instance-level mirror list (used + for all files), whereas the non-master values refer to the + current download only. + + The 'fail' option will cause immediate failure by re-raising + the exception and no further attempts to get the current + download. + + This dict can be set at instantiation time, + mg = MirrorGroup(grabber, mirrors, default_action={'fail':1}) + at method-execution time (only applies to current fetch), + filename = mg.urlgrab(url, default_action={'increment': 0}) + or by returning an action dict from the failure_callback + return {'fail':0} + in increasing precedence. + + If all three of these were done, the net result would be: + {'increment': 0, # set in method + 'increment_master': 1, # class default + 'remove': 1, # class default + 'remove_master': 0, # class default + 'fail': 0} # set at instantiation, reset + # from callback + + failure_callback + + this is a callback that will be called when a mirror "fails", + meaning the grabber raises some URLGrabError. If this is a + tuple, it is interpreted to be of the form (cb, args, kwargs) + where cb is the actual callable object (function, method, + etc). Otherwise, it is assumed to be the callable object + itself. The callback will be passed a grabber.CallbackObject + instance along with args and kwargs (if present). The following + attributes are defined withing the instance: + + obj.exception = < exception that was raised > + obj.mirror = < the mirror that was tried > + obj.relative_url = < url relative to the mirror > + obj.url = < full url that failed > + # .url is just the combination of .mirror + # and .relative_url + + The failure callback can return an action dict, as described + above. + + Like default_action, the failure_callback can be set at + instantiation time or when the urlXXX method is called. In + the latter case, it applies only for that fetch. + + The callback can re-raise the exception quite easily. For + example, this is a perfectly adequate callback function: + + def callback(obj): raise obj.exception + + WARNING: do not save the exception object (or the + CallbackObject instance). As they contain stack frame + references, they can lead to circular references. + + Notes: + * The behavior can be customized by deriving and overriding the + 'CONFIGURATION METHODS' + * The 'grabber' instance is kept as a reference, not copied. + Therefore, the grabber instance can be modified externally + and changes will take effect immediately. + """ + + # notes on thread-safety: + + # A GrabRequest should never be shared by multiple threads because + # it's never saved inside the MG object and never returned outside it. + # therefore, it should be safe to access/modify grabrequest data + # without a lock. However, accessing the mirrors and _next attributes + # of the MG itself must be done when locked to prevent (for example) + # removal of the wrong mirror. + + ############################################################## + # CONFIGURATION METHODS - intended to be overridden to + # customize behavior + def __init__(self, grabber, mirrors, **kwargs): + """Initialize the MirrorGroup object. + + REQUIRED ARGUMENTS + + grabber - URLGrabber instance + mirrors - a list of mirrors + + OPTIONAL ARGUMENTS + + failure_callback - callback to be used when a mirror fails + default_action - dict of failure actions + + See the module-level and class level documentation for more + details. + """ + + # OVERRIDE IDEAS: + # shuffle the list to randomize order + self.grabber = grabber + self.mirrors = self._parse_mirrors(mirrors) + self._next = 0 + self._lock = thread.allocate_lock() + self.default_action = None + self._process_kwargs(kwargs) + + # if these values are found in **kwargs passed to one of the urlXXX + # methods, they will be stripped before getting passed on to the + # grabber + options = ['default_action', 'failure_callback'] + + def _process_kwargs(self, kwargs): + self.failure_callback = kwargs.get('failure_callback') + self.default_action = kwargs.get('default_action') + + def _parse_mirrors(self, mirrors): + parsed_mirrors = [] + for m in mirrors: + if type(m) == type(''): m = {'mirror': m} + parsed_mirrors.append(m) + return parsed_mirrors + + def _load_gr(self, gr): + # OVERRIDE IDEAS: + # shuffle gr list + self._lock.acquire() + gr.mirrors = list(self.mirrors) + gr._next = self._next + self._lock.release() + + def _get_mirror(self, gr): + # OVERRIDE IDEAS: + # return a random mirror so that multiple mirrors get used + # even without failures. + if not gr.mirrors: + raise URLGrabError(256, _('No more mirrors to try.')) + return gr.mirrors[gr._next] + + def _failure(self, gr, cb_obj): + # OVERRIDE IDEAS: + # inspect the error - remove=1 for 404, remove=2 for connection + # refused, etc. (this can also be done via + # the callback) + cb = gr.kw.get('failure_callback') or self.failure_callback + if cb: + if type(cb) == type( () ): + cb, args, kwargs = cb + else: + args, kwargs = (), {} + action = cb(cb_obj, *args, **kwargs) or {} + else: + action = {} + # XXXX - decide - there are two ways to do this + # the first is action-overriding as a whole - use the entire action + # or fall back on module level defaults + #action = action or gr.kw.get('default_action') or self.default_action + # the other is to fall through for each element in the action dict + a = dict(self.default_action or {}) + a.update(gr.kw.get('default_action', {})) + a.update(action) + action = a + self.increment_mirror(gr, action) + if action and action.get('fail', 0): raise + + def increment_mirror(self, gr, action={}): + """Tell the mirror object increment the mirror index + + This increments the mirror index, which amounts to telling the + mirror object to use a different mirror (for this and future + downloads). + + This is a SEMI-public method. It will be called internally, + and you may never need to call it. However, it is provided + (and is made public) so that the calling program can increment + the mirror choice for methods like urlopen. For example, with + urlopen, there's no good way for the mirror group to know that + an error occurs mid-download (it's already returned and given + you the file object). + + remove --- can have several values + 0 do not remove the mirror from the list + 1 remove the mirror for this download only + 2 remove the mirror permanently + + beware of remove=0 as it can lead to infinite loops + """ + badmirror = gr.mirrors[gr._next] + + self._lock.acquire() + try: + ind = self.mirrors.index(badmirror) + except ValueError: + pass + else: + if action.get('remove_master', 0): + del self.mirrors[ind] + elif self._next == ind and action.get('increment_master', 1): + self._next += 1 + if self._next >= len(self.mirrors): self._next = 0 + self._lock.release() + + if action.get('remove', 1): + del gr.mirrors[gr._next] + elif action.get('increment', 1): + gr._next += 1 + if gr._next >= len(gr.mirrors): gr._next = 0 + + if DEBUG: + grm = [m['mirror'] for m in gr.mirrors] + DEBUG.info('GR mirrors: [%s] %i', ' '.join(grm), gr._next) + selfm = [m['mirror'] for m in self.mirrors] + DEBUG.info('MAIN mirrors: [%s] %i', ' '.join(selfm), self._next) + + ##################################################################### + # NON-CONFIGURATION METHODS + # these methods are designed to be largely workhorse methods that + # are not intended to be overridden. That doesn't mean you can't; + # if you want to, feel free, but most things can be done by + # by overriding the configuration methods :) + + def _join_url(self, base_url, rel_url): + if base_url.endswith('/') or rel_url.startswith('/'): + return base_url + rel_url + else: + return base_url + '/' + rel_url + + def _mirror_try(self, func, url, kw): + gr = GrabRequest() + gr.func = func + gr.url = url + gr.kw = dict(kw) + self._load_gr(gr) + + for k in self.options: + try: del kw[k] + except KeyError: pass + + while 1: + mirrorchoice = self._get_mirror(gr) + fullurl = self._join_url(mirrorchoice['mirror'], gr.url) + kwargs = dict(mirrorchoice.get('kwargs', {})) + kwargs.update(kw) + grabber = mirrorchoice.get('grabber') or self.grabber + func_ref = getattr(grabber, func) + if DEBUG: DEBUG.info('MIRROR: trying %s -> %s', url, fullurl) + try: + return func_ref( *(fullurl,), **kwargs ) + except URLGrabError, e: + if DEBUG: DEBUG.info('MIRROR: failed') + obj = CallbackObject() + obj.exception = e + obj.mirror = mirrorchoice['mirror'] + obj.relative_url = gr.url + obj.url = fullurl + self._failure(gr, obj) + + def urlgrab(self, url, filename=None, **kwargs): + kw = dict(kwargs) + kw['filename'] = filename + func = 'urlgrab' + return self._mirror_try(func, url, kw) + + def urlopen(self, url, **kwargs): + kw = dict(kwargs) + func = 'urlopen' + return self._mirror_try(func, url, kw) + + def urlread(self, url, limit=None, **kwargs): + kw = dict(kwargs) + kw['limit'] = limit + func = 'urlread' + return self._mirror_try(func, url, kw) + + +class MGRandomStart(MirrorGroup): + """A mirror group that starts at a random mirror in the list. + + This behavior of this class is identical to MirrorGroup, except that + it starts at a random location in the mirror list. + """ + + def __init__(self, grabber, mirrors, **kwargs): + """Initialize the object + + The arguments for intialization are the same as for MirrorGroup + """ + MirrorGroup.__init__(self, grabber, mirrors, **kwargs) + self._next = random.randrange(len(mirrors)) + +class MGRandomOrder(MirrorGroup): + """A mirror group that uses mirrors in a random order. + + This behavior of this class is identical to MirrorGroup, except that + it uses the mirrors in a random order. Note that the order is set at + initialization time and fixed thereafter. That is, it does not pick a + random mirror after each failure. + """ + + def __init__(self, grabber, mirrors, **kwargs): + """Initialize the object + + The arguments for intialization are the same as for MirrorGroup + """ + MirrorGroup.__init__(self, grabber, mirrors, **kwargs) + random.shuffle(self.mirrors) + +if __name__ == '__main__': + pass diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/progress.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/progress.py new file mode 100644 index 0000000000..02db524e76 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/progress.py @@ -0,0 +1,530 @@ +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the +# Free Software Foundation, Inc., +# 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +# This file is part of urlgrabber, a high-level cross-protocol url-grabber +# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko + +# $Id: progress.py,v 1.7 2005/08/19 21:59:07 mstenner Exp $ + +import sys +import time +import math +import thread + +class BaseMeter: + def __init__(self): + self.update_period = 0.3 # seconds + + self.filename = None + self.url = None + self.basename = None + self.text = None + self.size = None + self.start_time = None + self.last_amount_read = 0 + self.last_update_time = None + self.re = RateEstimator() + + def start(self, filename=None, url=None, basename=None, + size=None, now=None, text=None): + self.filename = filename + self.url = url + self.basename = basename + self.text = text + + #size = None ######### TESTING + self.size = size + if not size is None: self.fsize = format_number(size) + 'B' + + if now is None: now = time.time() + self.start_time = now + self.re.start(size, now) + self.last_amount_read = 0 + self.last_update_time = now + self._do_start(now) + + def _do_start(self, now=None): + pass + + def update(self, amount_read, now=None): + # for a real gui, you probably want to override and put a call + # to your mainloop iteration function here + if now is None: now = time.time() + if (now >= self.last_update_time + self.update_period) or \ + not self.last_update_time: + self.re.update(amount_read, now) + self.last_amount_read = amount_read + self.last_update_time = now + self._do_update(amount_read, now) + + def _do_update(self, amount_read, now=None): + pass + + def end(self, amount_read, now=None): + if now is None: now = time.time() + self.re.update(amount_read, now) + self.last_amount_read = amount_read + self.last_update_time = now + self._do_end(amount_read, now) + + def _do_end(self, amount_read, now=None): + pass + +class TextMeter(BaseMeter): + def __init__(self, fo=sys.stderr): + BaseMeter.__init__(self) + self.fo = fo + + def _do_update(self, amount_read, now=None): + etime = self.re.elapsed_time() + fetime = format_time(etime) + fread = format_number(amount_read) + #self.size = None + if self.text is not None: + text = self.text + else: + text = self.basename + if self.size is None: + out = '\r%-60.60s %5sB %s ' % \ + (text, fread, fetime) + else: + rtime = self.re.remaining_time() + frtime = format_time(rtime) + frac = self.re.fraction_read() + bar = '='*int(25 * frac) + + out = '\r%-25.25s %3i%% |%-25.25s| %5sB %8s ETA ' % \ + (text, frac*100, bar, fread, frtime) + + self.fo.write(out) + self.fo.flush() + + def _do_end(self, amount_read, now=None): + total_time = format_time(self.re.elapsed_time()) + total_size = format_number(amount_read) + if self.text is not None: + text = self.text + else: + text = self.basename + if self.size is None: + out = '\r%-60.60s %5sB %s ' % \ + (text, total_size, total_time) + else: + bar = '='*25 + out = '\r%-25.25s %3i%% |%-25.25s| %5sB %8s ' % \ + (text, 100, bar, total_size, total_time) + self.fo.write(out + '\n') + self.fo.flush() + +text_progress_meter = TextMeter + +class MultiFileHelper(BaseMeter): + def __init__(self, master): + BaseMeter.__init__(self) + self.master = master + + def _do_start(self, now): + self.master.start_meter(self, now) + + def _do_update(self, amount_read, now): + # elapsed time since last update + self.master.update_meter(self, now) + + def _do_end(self, amount_read, now): + self.ftotal_time = format_time(now - self.start_time) + self.ftotal_size = format_number(self.last_amount_read) + self.master.end_meter(self, now) + + def failure(self, message, now=None): + self.master.failure_meter(self, message, now) + + def message(self, message): + self.master.message_meter(self, message) + +class MultiFileMeter: + helperclass = MultiFileHelper + def __init__(self): + self.meters = [] + self.in_progress_meters = [] + self._lock = thread.allocate_lock() + self.update_period = 0.3 # seconds + + self.numfiles = None + self.finished_files = 0 + self.failed_files = 0 + self.open_files = 0 + self.total_size = None + self.failed_size = 0 + self.start_time = None + self.finished_file_size = 0 + self.last_update_time = None + self.re = RateEstimator() + + def start(self, numfiles=None, total_size=None, now=None): + if now is None: now = time.time() + self.numfiles = numfiles + self.finished_files = 0 + self.failed_files = 0 + self.open_files = 0 + self.total_size = total_size + self.failed_size = 0 + self.start_time = now + self.finished_file_size = 0 + self.last_update_time = now + self.re.start(total_size, now) + self._do_start(now) + + def _do_start(self, now): + pass + + def end(self, now=None): + if now is None: now = time.time() + self._do_end(now) + + def _do_end(self, now): + pass + + def lock(self): self._lock.acquire() + def unlock(self): self._lock.release() + + ########################################################### + # child meter creation and destruction + def newMeter(self): + newmeter = self.helperclass(self) + self.meters.append(newmeter) + return newmeter + + def removeMeter(self, meter): + self.meters.remove(meter) + + ########################################################### + # child functions - these should only be called by helpers + def start_meter(self, meter, now): + if not meter in self.meters: + raise ValueError('attempt to use orphaned meter') + self._lock.acquire() + try: + if not meter in self.in_progress_meters: + self.in_progress_meters.append(meter) + self.open_files += 1 + finally: + self._lock.release() + self._do_start_meter(meter, now) + + def _do_start_meter(self, meter, now): + pass + + def update_meter(self, meter, now): + if not meter in self.meters: + raise ValueError('attempt to use orphaned meter') + if (now >= self.last_update_time + self.update_period) or \ + not self.last_update_time: + self.re.update(self._amount_read(), now) + self.last_update_time = now + self._do_update_meter(meter, now) + + def _do_update_meter(self, meter, now): + pass + + def end_meter(self, meter, now): + if not meter in self.meters: + raise ValueError('attempt to use orphaned meter') + self._lock.acquire() + try: + try: self.in_progress_meters.remove(meter) + except ValueError: pass + self.open_files -= 1 + self.finished_files += 1 + self.finished_file_size += meter.last_amount_read + finally: + self._lock.release() + self._do_end_meter(meter, now) + + def _do_end_meter(self, meter, now): + pass + + def failure_meter(self, meter, message, now): + if not meter in self.meters: + raise ValueError('attempt to use orphaned meter') + self._lock.acquire() + try: + try: self.in_progress_meters.remove(meter) + except ValueError: pass + self.open_files -= 1 + self.failed_files += 1 + if meter.size and self.failed_size is not None: + self.failed_size += meter.size + else: + self.failed_size = None + finally: + self._lock.release() + self._do_failure_meter(meter, message, now) + + def _do_failure_meter(self, meter, message, now): + pass + + def message_meter(self, meter, message): + pass + + ######################################################## + # internal functions + def _amount_read(self): + tot = self.finished_file_size + for m in self.in_progress_meters: + tot += m.last_amount_read + return tot + + +class TextMultiFileMeter(MultiFileMeter): + def __init__(self, fo=sys.stderr): + self.fo = fo + MultiFileMeter.__init__(self) + + # files: ###/### ###% data: ######/###### ###% time: ##:##:##/##:##:## + def _do_update_meter(self, meter, now): + self._lock.acquire() + try: + format = "files: %3i/%-3i %3i%% data: %6.6s/%-6.6s %3i%% " \ + "time: %8.8s/%8.8s" + df = self.finished_files + tf = self.numfiles or 1 + pf = 100 * float(df)/tf + 0.49 + dd = self.re.last_amount_read + td = self.total_size + pd = 100 * (self.re.fraction_read() or 0) + 0.49 + dt = self.re.elapsed_time() + rt = self.re.remaining_time() + if rt is None: tt = None + else: tt = dt + rt + + fdd = format_number(dd) + 'B' + ftd = format_number(td) + 'B' + fdt = format_time(dt, 1) + ftt = format_time(tt, 1) + + out = '%-79.79s' % (format % (df, tf, pf, fdd, ftd, pd, fdt, ftt)) + self.fo.write('\r' + out) + self.fo.flush() + finally: + self._lock.release() + + def _do_end_meter(self, meter, now): + self._lock.acquire() + try: + format = "%-30.30s %6.6s %8.8s %9.9s" + fn = meter.basename + size = meter.last_amount_read + fsize = format_number(size) + 'B' + et = meter.re.elapsed_time() + fet = format_time(et, 1) + frate = format_number(size / et) + 'B/s' + + out = '%-79.79s' % (format % (fn, fsize, fet, frate)) + self.fo.write('\r' + out + '\n') + finally: + self._lock.release() + self._do_update_meter(meter, now) + + def _do_failure_meter(self, meter, message, now): + self._lock.acquire() + try: + format = "%-30.30s %6.6s %s" + fn = meter.basename + if type(message) in (type(''), type(u'')): + message = message.splitlines() + if not message: message = [''] + out = '%-79s' % (format % (fn, 'FAILED', message[0] or '')) + self.fo.write('\r' + out + '\n') + for m in message[1:]: self.fo.write(' ' + m + '\n') + self._lock.release() + finally: + self._do_update_meter(meter, now) + + def message_meter(self, meter, message): + self._lock.acquire() + try: + pass + finally: + self._lock.release() + + def _do_end(self, now): + self._do_update_meter(None, now) + self._lock.acquire() + try: + self.fo.write('\n') + self.fo.flush() + finally: + self._lock.release() + +###################################################################### +# support classes and functions + +class RateEstimator: + def __init__(self, timescale=5.0): + self.timescale = timescale + + def start(self, total=None, now=None): + if now is None: now = time.time() + self.total = total + self.start_time = now + self.last_update_time = now + self.last_amount_read = 0 + self.ave_rate = None + + def update(self, amount_read, now=None): + if now is None: now = time.time() + if amount_read == 0: + # if we just started this file, all bets are off + self.last_update_time = now + self.last_amount_read = 0 + self.ave_rate = None + return + + #print 'times', now, self.last_update_time + time_diff = now - self.last_update_time + read_diff = amount_read - self.last_amount_read + self.last_update_time = now + self.last_amount_read = amount_read + self.ave_rate = self._temporal_rolling_ave(\ + time_diff, read_diff, self.ave_rate, self.timescale) + #print 'results', time_diff, read_diff, self.ave_rate + + ##################################################################### + # result methods + def average_rate(self): + "get the average transfer rate (in bytes/second)" + return self.ave_rate + + def elapsed_time(self): + "the time between the start of the transfer and the most recent update" + return self.last_update_time - self.start_time + + def remaining_time(self): + "estimated time remaining" + if not self.ave_rate or not self.total: return None + return (self.total - self.last_amount_read) / self.ave_rate + + def fraction_read(self): + """the fraction of the data that has been read + (can be None for unknown transfer size)""" + if self.total is None: return None + elif self.total == 0: return 1.0 + else: return float(self.last_amount_read)/self.total + + ######################################################################### + # support methods + def _temporal_rolling_ave(self, time_diff, read_diff, last_ave, timescale): + """a temporal rolling average performs smooth averaging even when + updates come at irregular intervals. This is performed by scaling + the "epsilon" according to the time since the last update. + Specifically, epsilon = time_diff / timescale + + As a general rule, the average will take on a completely new value + after 'timescale' seconds.""" + epsilon = time_diff / timescale + if epsilon > 1: epsilon = 1.0 + return self._rolling_ave(time_diff, read_diff, last_ave, epsilon) + + def _rolling_ave(self, time_diff, read_diff, last_ave, epsilon): + """perform a "rolling average" iteration + a rolling average "folds" new data into an existing average with + some weight, epsilon. epsilon must be between 0.0 and 1.0 (inclusive) + a value of 0.0 means only the old value (initial value) counts, + and a value of 1.0 means only the newest value is considered.""" + + try: + recent_rate = read_diff / time_diff + except ZeroDivisionError: + recent_rate = None + if last_ave is None: return recent_rate + elif recent_rate is None: return last_ave + + # at this point, both last_ave and recent_rate are numbers + return epsilon * recent_rate + (1 - epsilon) * last_ave + + def _round_remaining_time(self, rt, start_time=15.0): + """round the remaining time, depending on its size + If rt is between n*start_time and (n+1)*start_time round downward + to the nearest multiple of n (for any counting number n). + If rt < start_time, round down to the nearest 1. + For example (for start_time = 15.0): + 2.7 -> 2.0 + 25.2 -> 25.0 + 26.4 -> 26.0 + 35.3 -> 34.0 + 63.6 -> 60.0 + """ + + if rt < 0: return 0.0 + shift = int(math.log(rt/start_time)/math.log(2)) + rt = int(rt) + if shift <= 0: return rt + return float(int(rt) >> shift << shift) + + +def format_time(seconds, use_hours=0): + if seconds is None or seconds < 0: + if use_hours: return '--:--:--' + else: return '--:--' + else: + seconds = int(seconds) + minutes = seconds / 60 + seconds = seconds % 60 + if use_hours: + hours = minutes / 60 + minutes = minutes % 60 + return '%02i:%02i:%02i' % (hours, minutes, seconds) + else: + return '%02i:%02i' % (minutes, seconds) + +def format_number(number, SI=0, space=' '): + """Turn numbers into human-readable metric-like numbers""" + symbols = ['', # (none) + 'k', # kilo + 'M', # mega + 'G', # giga + 'T', # tera + 'P', # peta + 'E', # exa + 'Z', # zetta + 'Y'] # yotta + + if SI: step = 1000.0 + else: step = 1024.0 + + thresh = 999 + depth = 0 + max_depth = len(symbols) - 1 + + # we want numbers between 0 and thresh, but don't exceed the length + # of our list. In that event, the formatting will be screwed up, + # but it'll still show the right number. + while number > thresh and depth < max_depth: + depth = depth + 1 + number = number / step + + if type(number) == type(1) or type(number) == type(1L): + # it's an int or a long, which means it didn't get divided, + # which means it's already short enough + format = '%i%s%s' + elif number < 9.95: + # must use 9.95 for proper sizing. For example, 9.99 will be + # rounded to 10.0 with the .1f format string (which is too long) + format = '%.1f%s%s' + else: + format = '%.0f%s%s' + + return(format % (float(number or 0), space, symbols[depth])) diff --git a/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/sslfactory.py b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/sslfactory.py new file mode 100644 index 0000000000..07848dac7c --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/urlgrabber/sslfactory.py @@ -0,0 +1,90 @@ +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the +# Free Software Foundation, Inc., +# 59 Temple Place, Suite 330, +# Boston, MA 02111-1307 USA + +# This file is part of urlgrabber, a high-level cross-protocol url-grabber + +import httplib +import urllib2 + +try: + from M2Crypto import SSL + from M2Crypto import httpslib + from M2Crypto import m2urllib2 + + SSL.Connection.clientPostConnectionCheck = None + have_m2crypto = True +except ImportError: + have_m2crypto = False + +DEBUG = None + +if have_m2crypto: + + class M2SSLFactory: + + def __init__(self, ssl_ca_cert, ssl_context): + self.ssl_context = self._get_ssl_context(ssl_ca_cert, ssl_context) + + def _get_ssl_context(self, ssl_ca_cert, ssl_context): + """ + Create an ssl context using the CA cert file or ssl context. + + The CA cert is used first if it was passed as an option. If not, + then the supplied ssl context is used. If no ssl context was supplied, + None is returned. + """ + if ssl_ca_cert: + context = SSL.Context() + context.load_verify_locations(ssl_ca_cert) + context.set_verify(SSL.verify_none, -1) + return context + else: + return ssl_context + + def create_https_connection(self, host, response_class = None): + connection = httplib.HTTPSConnection(host, self.ssl_context) + if response_class: + connection.response_class = response_class + return connection + + def create_opener(self, *handlers): + return m2urllib2.build_opener(self.ssl_context, *handlers) + + +class SSLFactory: + + def create_https_connection(self, host, response_class = None): + connection = httplib.HTTPSConnection(host) + if response_class: + connection.response_class = response_class + return connection + + def create_opener(self, *handlers): + return urllib2.build_opener(*handlers) + + + +def get_factory(ssl_ca_cert = None, ssl_context = None): + """ Return an SSLFactory, based on if M2Crypto is available. """ + if have_m2crypto: + return M2SSLFactory(ssl_ca_cert, ssl_context) + else: + # Log here if someone provides the args but we don't use them. + if ssl_ca_cert or ssl_context: + if DEBUG: + DEBUG.warning("SSL arguments supplied, but M2Crypto is not available. " + "Using Python SSL.") + return SSLFactory() diff --git a/scripts/lib/mic/3rdparty/pykickstart/version.py b/scripts/lib/mic/3rdparty/pykickstart/version.py new file mode 100644 index 0000000000..102cc37d80 --- /dev/null +++ b/scripts/lib/mic/3rdparty/pykickstart/version.py @@ -0,0 +1,197 @@ +# +# Chris Lumens <clumens@redhat.com> +# +# Copyright 2006, 2007, 2008, 2009, 2010 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. +# +""" +Methods for working with kickstart versions. + +This module defines several symbolic constants that specify kickstart syntax +versions. Each version corresponds roughly to one release of Red Hat Linux, +Red Hat Enterprise Linux, or Fedora Core as these are where most syntax +changes take place. + +This module also exports several functions: + + makeVersion - Given a version number, return an instance of the + matching handler class. + + returnClassForVersion - Given a version number, return the matching + handler class. This does not return an + instance of that class, however. + + stringToVersion - Convert a string representation of a version number + into the symbolic constant. + + versionToString - Perform the reverse mapping. + + versionFromFile - Read a kickstart file and determine the version of + syntax it uses. This requires the kickstart file to + have a version= comment in it. +""" +import imputil, re, sys +from urlgrabber import urlopen + +import gettext +_ = lambda x: gettext.ldgettext("pykickstart", x) + +from pykickstart.errors import KickstartVersionError + +# Symbolic names for internal version numbers. +RHEL3 = 900 +FC3 = 1000 +RHEL4 = 1100 +FC4 = 2000 +FC5 = 3000 +FC6 = 4000 +RHEL5 = 4100 +F7 = 5000 +F8 = 6000 +F9 = 7000 +F10 = 8000 +F11 = 9000 +F12 = 10000 +F13 = 11000 +RHEL6 = 11100 +F14 = 12000 +F15 = 13000 +F16 = 14000 + +# This always points at the latest version and is the default. +DEVEL = F16 + +# A one-to-one mapping from string representations to version numbers. +versionMap = { + "DEVEL": DEVEL, + "FC3": FC3, "FC4": FC4, "FC5": FC5, "FC6": FC6, "F7": F7, "F8": F8, + "F9": F9, "F10": F10, "F11": F11, "F12": F12, "F13": F13, + "F14": F14, "F15": F15, "F16": F16, + "RHEL3": RHEL3, "RHEL4": RHEL4, "RHEL5": RHEL5, "RHEL6": RHEL6 +} + +def stringToVersion(s): + """Convert string into one of the provided version constants. Raises + KickstartVersionError if string does not match anything. + """ + # First try these short forms. + try: + return versionMap[s.upper()] + except KeyError: + pass + + # Now try the Fedora versions. + m = re.match("^fedora.* (\d+)$", s, re.I) + + if m and m.group(1): + if versionMap.has_key("FC" + m.group(1)): + return versionMap["FC" + m.group(1)] + elif versionMap.has_key("F" + m.group(1)): + return versionMap["F" + m.group(1)] + else: + raise KickstartVersionError(_("Unsupported version specified: %s") % s) + + # Now try the RHEL versions. + m = re.match("^red hat enterprise linux.* (\d+)([\.\d]*)$", s, re.I) + + if m and m.group(1): + if versionMap.has_key("RHEL" + m.group(1)): + return versionMap["RHEL" + m.group(1)] + else: + raise KickstartVersionError(_("Unsupported version specified: %s") % s) + + # If nothing else worked, we're out of options. + raise KickstartVersionError(_("Unsupported version specified: %s") % s) + +def versionToString(version, skipDevel=False): + """Convert version into a string representation of the version number. + This is the reverse operation of stringToVersion. Raises + KickstartVersionError if version does not match anything. + """ + if not skipDevel and version == versionMap["DEVEL"]: + return "DEVEL" + + for (key, val) in versionMap.iteritems(): + if key == "DEVEL": + continue + elif val == version: + return key + + raise KickstartVersionError(_("Unsupported version specified: %s") % version) + +def versionFromFile(f): + """Given a file or URL, look for a line starting with #version= and + return the version number. If no version is found, return DEVEL. + """ + v = DEVEL + + fh = urlopen(f) + + while True: + try: + l = fh.readline() + except StopIteration: + break + + # At the end of the file? + if l == "": + break + + if l.isspace() or l.strip() == "": + continue + + if l[:9] == "#version=": + v = stringToVersion(l[9:].rstrip()) + break + + fh.close() + return v + +def returnClassForVersion(version=DEVEL): + """Return the class of the syntax handler for version. version can be + either a string or the matching constant. Raises KickstartValueError + if version does not match anything. + """ + try: + version = int(version) + module = "%s" % versionToString(version, skipDevel=True) + except ValueError: + module = "%s" % version + version = stringToVersion(version) + + module = module.lower() + + try: + import pykickstart.handlers + sys.path.extend(pykickstart.handlers.__path__) + found = imputil.imp.find_module(module) + loaded = imputil.imp.load_module(module, found[0], found[1], found[2]) + + for (k, v) in loaded.__dict__.iteritems(): + if k.lower().endswith("%shandler" % module): + return v + except: + raise KickstartVersionError(_("Unsupported version specified: %s") % version) + +def makeVersion(version=DEVEL): + """Return a new instance of the syntax handler for version. version can be + either a string or the matching constant. This function is useful for + standalone programs which just need to handle a specific version of + kickstart syntax (as provided by a command line argument, for example) + and need to instantiate the correct object. + """ + cl = returnClassForVersion(version) + return cl() |