245 lines
9.0 KiB
Python
245 lines
9.0 KiB
Python
#
|
|
# 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
|