mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
d8f9d05bae
As well as any other stray instances of mic in the codebase that can be removed. We don't really need to carry around legacy naming, and the history is in git. (From OE-Core rev: 598b120406dc1d2b7e377bd1ab6f0acbef034b22) Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
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
|