def handle_header(self, lineno, args):
"""
The handle_header method is called to parse additional arguments in the
%addon section line.
args is a list of all the arguments following the addon ID. For
example, for the line:
%addon org_fedora_hello_world --reverse --arg2="example"
handle_header will be called with args=['--reverse', '--arg2="example"']
:param lineno: the current line number in the kickstart file
:type lineno: int
:param args: the list of arguments from the %addon line
:type args: list
"""
op = KSOptionParser(prog="addon org_fedora_hello_world",
version=F30,
description="Configure the Hello World Addon.")
op.add_argument("--reverse",
action="store_true",
default=False,
version=F30,
dest="reverse",
help="Reverse the display of the addon text.")
# Parse the arguments.
ns = op.parse_args(args=args, lineno=lineno)
# Store the result of the parsing.
self.reverse = ns.reverse
def _getParser(self):
op = KSOptionParser(prog="ostreesetup",
description="""
Used for OSTree installations. See
https://wiki.gnome.org/action/show/Projects/OSTree
for more information about OSTree.
""",
version=F21)
op.add_argument("--osname",
required=True,
version=F21,
help="""
Management root for OS installation.""")
op.add_argument("--remote",
version=F21,
help="""
Management root for OS installation.""")
op.add_argument("--url",
required=True,
version=F21,
help="""
Repository URL.""")
op.add_argument("--ref",
required=True,
version=F21,
help="""
Name of branch inside the repository.""")
op.add_argument("--nogpg",
action="store_true",
version=F21,
help="""
Disable GPG key verification.""")
return op
def _getParser(self):
op = KSOptionParser(prog="rootpw",
description="""
This required command sets the system's root
password.""",
version=FC3)
op.add_argument('password',
metavar='<password>',
nargs='?',
version=FC3,
help="The desired root password.")
op.add_argument("--iscrypted",
dest="isCrypted",
action="store_true",
default=False,
version=FC3,
help="""
If this is present, the password argument is assumed to
already be encrypted. To create an encrypted password
you can use python::
``python -c 'import crypt; print(crypt.crypt("My Password", "$6$My Salt"))'``
This will generate sha512 crypt of your password using
your provided salt.""")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--iscrypted",
dest="isCrypted",
action="store_true",
default=False)
return op
def _getParser(self):
op = KSOptionParser(prog="timezone",
description="""
This required command sets the system time zone to
which may be any of the time zones listed by
timeconfig.""",
version=FC3)
op.add_argument("--utc",
dest="isUtc",
action="store_true",
default=False,
version=FC3,
help="""
If present, the system assumes the hardware clock is set
to UTC (Greenwich Mean) time.
*To get the list of supported timezones, you can either
run this script:
http://vpodzime.fedorapeople.org/timezones_list.py or
look at this list:
http://vpodzime.fedorapeople.org/timezones_list.txt*
""")
op.add_argument("timezone",
metavar="<timezone>",
nargs=1,
version=FC3,
help="""
Timezone name, e.g. Europe/Sofia.""")
return op
def _getParser(self):
op = KSOptionParser(prog="device",
description="""
On most PCI systems, the installation program will autoprobe for
Ethernet and SCSI cards properly. On older systems and some PCI
systems, however, kickstart needs a hint to find the proper
devices. The device command, which tells the installation program
to install extra modules, is in this format:
``device <moduleName> --opts=<options>``
``<moduleName>``
Replace with the name of the kernel module which should be
installed.""",
version=FC3)
op.add_argument("--opts",
dest="moduleOpts",
default="",
version=FC3,
help="""
Options to pass to the kernel module. For example:
``--opts="aic152x=0x340 io=11"``
""")
return op
def _processGroup(self, line):
op = KSOptionParser(prog="", description="", version=version.DEVEL)
op.add_argument("--nodefaults", action="store_true", default=False,
help="", version=version.DEVEL)
op.add_argument("--optional", action="store_true", default=False,
help="", version=version.DEVEL)
(ns, extra) = op.parse_known_args(args=line.split())
if ns.nodefaults and ns.optional:
raise KickstartParseError(_("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 grp in [g.name for g in self.groupList]:
return
if ns.nodefaults:
self.groupList.append(Group(name=grp, include=constants.GROUP_REQUIRED))
elif ns.optional:
self.groupList.append(Group(name=grp, include=constants.GROUP_ALL))
else:
self.groupList.append(Group(name=grp, include=constants.GROUP_DEFAULT))
def _getParser(self):
op = KSOptionParser(prog="sshpw",
description="""
The installer can start up ssh to provide for
interactivity and inspection, just like it can with
telnet. The "inst.sshd" option must be specified on
the kernel command-line for Anaconda to start an ssh
daemon. The sshpw command is used to control the
accounts created in the installation environment that
may be remotely logged into. For each instance of
this command given, a user will be created. These
users will not be created on the final system -
they only exist for use while the installer is
running.
Note that by default, root has a blank password. If
you don't want any user to be able to ssh in and
have full access to your hardware, you must specify
sshpw for username root. Also note that if Anaconda
fails to parse the kickstart file, it will allow
anyone to login as root and have full access to
your hardware.""",
version=F13)
op.add_argument("--username",
required=True,
metavar="<name>",
version=F13,
help="""
Provides the name of the user. This option is required.
""")
op.add_argument("--iscrypted",
dest="isCrypted",
action="store_true",
default=False,
version=F13,
help="""
If this is present, the password argument is assumed to
already be encrypted.""")
op.add_argument("--plaintext",
dest="isCrypted",
action="store_false",
version=F13,
help="""
If this is present, the password argument is assumed to
not be encrypted. This is the default.""")
op.add_argument("--lock",
action="store_true",
default=False,
version=F13,
help="""
If this is present, the new user account is locked by
default. That is, the user will not be able to login
from the console.""")
op.add_argument("password",
metavar="<password>",
nargs="*",
version=F13,
help="""
The password string to use.""")
return op
def _getParser(self):
op = KSOptionParser(prog="module", description="""
The module command makes it possible to manipulate
modules.
(In this case we mean modules as introduced by the
Fedora modularity initiative.)
A module is defined by a unique name and a stream id,
where single module can (and usually has) multiple
available streams.
Streams will in most cases corresponds to stable
releases of the given software components
(such as Node.js, Django, etc.) but there could be
also other use cases, such as a raw upstream master
branch stream or streams corresponding to an upcoming
stable release.
For more information see the Fedora modularity
initiative documentation:
https://docs.pagure.org/modularity/""", version=F29)
op.add_argument("--name", metavar="<module_name>", version=F29, required=True,
help="""
Name of the module to enable.""")
op.add_argument("--stream", metavar="<module_stream_name>", version=F29, required=False,
help="""
Name of the module stream to enable.""")
return op
def _getParser(self):
op = KSOptionParser(prog="snapshot",
version=F26,
description="""
Create an LVM snapshot for devices on an LVM thin pool."""
)
op.add_argument("--name",
metavar="<snapshot_name>",
version=F26,
required=True,
help="""
Name of the newly created snapshot.""")
# Show all possible options in meta message
meta_msg = "<%s>" % ("|".join(self.whenMap.keys()))
op.add_argument("--when",
metavar=meta_msg,
type=self._when_cb,
version=F26,
required=True,
help="""
You can specify two possible values: ``pre-install`` and ``post-install``.
When the ``pre-install`` value is used the snapshot is created before
the installation but after the ``%%pre`` section is run.
When the ``post-install`` value is used the snapshot is created after
the installation is done and after the ``%%post`` section is run."""
)
return op
def _getParser(self):
op = KSOptionParser(prog="nfs",
description="""
Install from the NFS server specified. This can
either be an exploded installation tree or a
directory of ISO images. In the latter case, the
install.img must also be provided subject to the
same rules as with the harddrive installation
method described above.""",
version=FC3)
op.add_argument("--server",
metavar="<hostname>",
required=True,
version=FC3,
help="""
Server from which to install (hostname or IP).""")
op.add_argument("--dir",
metavar="<directory>",
required=True,
version=FC3,
help="""
Directory containing the ``Packages/`` directory of the
installation tree. If doing an ISO install, this
directory must also contain images/install.img.""")
return op
def _getParser(self):
op = KSOptionParser(prog="sshkey",
description="""
This installs a ssh key to the authorized_keys file
of the specified user on the installed system.""",
epilog="""
Note that the key should be quoted, if it contains
spaces and the user should exist (or be root)
either via creation by a package install or the
kickstart ``user`` command.""",
version=F22)
op.add_argument("--username",
required=True,
metavar="<user>",
version=F22,
help="""
User for which to install the specified key. This option is required."""
)
op.add_argument('sshkey',
metavar='"ssh key"',
nargs=1,
version=F22,
help="""
The content of the ssh key to install.""")
return op
def _processGroup(self, line):
op = KSOptionParser(prog="", description="", version=version.DEVEL)
op.add_argument("--nodefaults",
action="store_true",
default=False,
help="",
version=version.DEVEL)
op.add_argument("--optional",
action="store_true",
default=False,
help="",
version=version.DEVEL)
(ns, extra) = op.parse_known_args(args=line.split())
if ns.nodefaults and ns.optional:
raise KickstartParseError(
_("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 grp in [g.name for g in self.groupList]:
return
if ns.nodefaults:
self.groupList.append(
Group(name=grp, include=constants.GROUP_REQUIRED))
elif ns.optional:
self.groupList.append(Group(name=grp, include=constants.GROUP_ALL))
else:
self.groupList.append(
Group(name=grp, include=constants.GROUP_DEFAULT))
def _getParser(self):
op = KSOptionParser(prog="nvdimm", version=F28, description="""
Perform an action on an nvdimm device.""")
op.add_argument("action", choices=self.validActions, nargs=1, default=NVDIMM_ACTION_RECONFIGURE,
version=F28, help="""
The action to be performed on the device specified by further options.
The device can be specified by ``--namespace`` or ``--blockdevs`` options,
depending on the action.
Valid actions:
- ``reconfigure``: Reconfigures the device specified by ``--namespace``
into the mode specified by ``--mode`` and (depending on the mode)
``--sectorsize`` options. The device reconfigured into sector mode
will be allowed to be used for storage configuration.
- ``use``: Allow the device to be used for storage configuration. By default nvdimm
devices are ignored. Only devices in sector mode can be used.
""")
op.add_argument("--namespace", metavar="<namespace>", version=F28,
help="""The device specification by namespace.""")
op.add_argument("--blockdevs", metavar="<devspec1>,<devspec2>,...,<devspecN>", type=commaSplit, version=F28,
help="""Specification of devices by comma separated list of block device names.""")
op.add_argument("--mode", choices=self.validModes, default=NVDIMM_MODE_SECTOR,
version=F28, help="""The mode specification.""")
op.add_argument("--sectorsize", type=int, version=F28,
help="""Size of a sector for sector mode.""")
return op
def _getParser(self):
op = KSOptionParser(prog="lang",
description="""
This required command sets the language to use during installation
and the default language to use on the installed system to ``<id>``.
This can be the same as any recognized setting for the ``$LANG``
environment variable, though not all languages are supported during
installation.
Certain languages (mainly Chinese, Japanese, Korean, and Indic
languages) are not supported during text mode installation. If one
of these languages is specified using the lang command, installation
will continue in English though the running system will have the
specified langauge by default.
The file ``/usr/share/system-config-language/locale-list`` provides a
list the valid language codes in the first column of each line and
is part of the system-config-languages package.""",
version=FC3)
op.add_argument("lang",
metavar="<lang>",
nargs=1,
version=FC3,
help="Language ID.")
return op
def _getParser(self):
op = KSOptionParser(prog="keyboard",
description="""
This required command sets system keyboard type.""",
version=FC3)
op.add_argument("kbd", nargs='*', help="Keyboard type", version=FC3)
return op
def handle_header(self, args, line_number=None):
# Create the argument parser.
op = KSOptionParser(prog="%addon my_test_1",
version=F30,
description="My addon test 1.")
op.add_argument("--foo",
type=int,
default=None,
version=F30,
help="Specify foo.")
op.add_argument("--bar",
action="store_true",
default=False,
version=F30,
help="Specify bar.")
# Parse the arguments.
ns = op.parse_args(args=args, lineno=line_number)
# Store the result of the parsing.
self.seen = True
self.foo = ns.foo
self.bar = ns.bar
def _getParser(self):
op = KSOptionParser(prog="services",
description="""
Modifies the default set of services that will run
under the default runlevel. The services listed in
the disabled list will be disabled before the
services listed in the enabled list are enabled.
""",
epilog="""
One of ``--disabled`` or ``--enabled`` must be provided.
""",
version=FC6)
op.add_argument("--disabled",
type=commaSplit,
version=FC6,
metavar="<list>",
help="""
Disable the services given in the comma separated list.
""")
op.add_argument("--enabled",
type=commaSplit,
version=FC6,
metavar="<list>",
help="""
Enable the services given in the comma separated list.
""")
return op
def _getParser(self):
op = KSOptionParser(prog="clearpart", description="""
Removes partitions from the system, prior to creation
of new partitions. By default, no partitions are
removed.
If the clearpart command is used, then the ``--onpart``
command cannot be used on a logical partition.""",
version=FC3)
op.add_argument("--all", dest="type", action="store_const",
const=CLEARPART_TYPE_ALL, version=FC3,
help="Erases all partitions from the system.")
op.add_argument("--drives", type=commaSplit, help="""
Specifies which drives to clear partitions from. For
example, the following clears the partitions on the
first two drives on the primary IDE controller::
``clearpart --all --drives=sda,sdb``""",
version=FC3)
op.add_argument("--initlabel", dest="initAll", action="store_true",
default=False, version=FC3, help="""
Initializes the disk label to the default for your
architecture (for example msdos for x86 and gpt for
Itanium). This is only meaningful in combination with
the '--all' option.""")
op.add_argument("--linux", dest="type", action="store_const",
const=CLEARPART_TYPE_LINUX, version=FC3,
help="Erases all Linux partitions.")
op.add_argument("--none", dest="type", action="store_const",
const=CLEARPART_TYPE_NONE, version=FC3, help="""
Do not remove any partitions. This is the default""")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--drives",
dest="ignoredisk",
type=commaSplit,
required=True)
return op
def _getParser(self):
op = KSOptionParser(prog="reqpart",
description="""
Automatically create partitions required by your
hardware platform. These include a ``/boot/efi``
for x86_64 and Aarch64 systems with UEFI firmware,
``biosboot`` for x86_64 systems with BIOS firmware
and GPT, and ``PRePBoot`` for IBM Power Systems.
Note: This command can not be used together with
``autopart``, because ``autopart`` does the same
and creates other partitions or logical volumes
such as ``/`` and ``swap`` on top. In contrast with
``autopart``, this command only creates
platform-specific partitions and leaves the rest of
the drive empty, allowing you to create a custom
layout.""",
version=F23)
op.add_argument("--add-boot",
action="store_true",
version=F23,
dest="addBoot",
default=False,
help="""
Create a separate ``/boot`` partition in addition to the
platform-specific partition created by the base command.
""")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--add-boot",
action="store_true",
dest="addBoot",
default=False)
return op
def _getParser(self):
op = KSOptionParser(prog="volgroup", description="""
Creates a Logical Volume Management (LVM) group.
""", epilog="""
Create the partition first, create the logical
volume group, and then create the logical volume.
For example::
part pv.01 --size 3000
volgroup myvg pv.01
logvol / --vgname=myvg --size=2000 --name=rootvol
""", version=FC3)
op.add_argument("name", metavar="<name>", nargs="*", version=FC3, help="""
Name given to the volume group. The (which denotes that
multiple partitions can be listed) lists the identifiers
to add to the volume group.""")
op.add_argument("partitions", metavar="<partitions*>", nargs="*", help="""
Physical Volume partitions to be included in this
Volume Group""", version=FC3)
op.add_argument("--noformat", dest="format", action="store_false",
default=True, version=FC3, help="""
Use an existing volume group. Do not specify partitions
when using this option.""")
op.add_argument("--pesize", type=int, default=32768, version=FC3,
help="""
Set the size of the physical extents in KiB.""")
op.add_argument("--useexisting", dest="preexist", action="store_true",
default=False, version=FC3, help="""
Use an existing volume group. Do not specify partitions
when using this option.""")
return op
def _getParser(self):
op = KSOptionParser(prog="zfcp", description="define a zFCP storage device (IBM System z only)", version=FC3)
op.add_argument("--devnum", required=True, version=FC3, help="zFCP device number")
op.add_argument("--fcplun", required=True, version=FC3, help="zFCP LUN")
op.add_argument("--scsiid", required=True, version=FC3, help="SCSI ID")
op.add_argument("--scsilun", required=True, version=FC3, help="SCSI LUN")
op.add_argument("--wwpn", required=True, version=FC3, help="World Wide Port Name")
return op
def _getParser(self):
op = KSOptionParser(prog="fcoe", description="""
Discover and attach FCoE storage devices accessible via
specified network interface
""", version=F12)
op.add_argument("--nic", required=True, version=F12, help="""
Name of the network device connected to the FCoE switch""")
return op
def _getParser(self):
op = KSOptionParser(prog="key", description="", version=RHEL5)
op.add_argument("--skip",
action="store_true",
default=False,
version=RHEL5,
help="")
return op
def _getParser(self):
op = KSOptionParser(prog="fcoe", description="""
Discover and attach FCoE storage devices accessible via
specified network interface
""", version=F12)
op.add_argument("--nic", required=True, version=F12, help="""
Name of the network device connected to the FCoE switch""")
return op
def _getParser(self):
op = KSOptionParser(prog="url", description="""
Install from an installation tree on a remote server
via FTP or HTTP.""", version=FC3)
op.add_argument("--url", required=True, version=FC3, help="""
The URL to install from. Variable substitution is done
for $releasever and $basearch in the url.""")
return op
def _getParser(self):
op = KSOptionParser(prog="eula", version=F20, description="""
Automatically accept Red Hat's EULA""")
# people would struggle remembering the exact word
op.add_argument("--agreed", "--agree", "--accepted", "--accept",
dest="agreed", action="store_true", default=False,
version=F20, help="Accept the EULA. This is mandatory option!")
return op
def _getParser(self):
op = KSOptionParser(prog="mouse", description="""
Configure the system mouse""", version=RHEL3)
op.add_argument("--device", default="", version=RHEL3,
help="Which device node to use for mouse")
op.add_argument("--emulthree", default=False, action="store_true",
version=RHEL3, help="If set emulate 3 mouse buttons")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--all", dest="type", action="store_const", const=CLEARPART_TYPE_ALL)
op.add_argument("--drives", type=commaSplit)
op.add_argument("--initlabel", dest="initAll", action="store_true", default=False)
op.add_argument("--linux", dest="type", action="store_const", const=CLEARPART_TYPE_LINUX)
op.add_argument("--none", dest="type", action="store_const", const=CLEARPART_TYPE_NONE)
return op
def _getParser(self):
op = KSOptionParser(prog="url", description="""
Install from an installation tree on a remote server
via FTP or HTTP.""", version=FC3)
op.add_argument("--url", required=True, version=FC3, help="""
The URL to install from. Variable substitution is done
for $releasever and $basearch in the url.""")
return op
def _getParser(self):
op = KSOptionParser(prog="iscsiname", description="""
Assigns an initiator name to the computer. If you use the iscsi
parameter in your kickstart file, this parameter is mandatory, and
you must specify iscsiname in the kickstart file before you specify
iscsi.""", version=FC6)
op.add_argument("iqn", metavar="<iqn>", nargs=1, version=FC6, help="""
IQN name""")
return op
def _getParser(self):
op = KSOptionParser(prog="iscsiname", description="""
Assigns an initiator name to the computer. If you use the iscsi
parameter in your kickstart file, this parameter is mandatory, and
you must specify iscsiname in the kickstart file before you specify
iscsi.""", version=FC6)
op.add_argument("iqn", metavar="<iqn>", nargs=1, version=FC6, help="""
IQN name""")
return op
def _getParser(self):
op = KSOptionParser(prog="ignoredisk", description="""
Controls anaconda's access to disks attached to the system. By
default, all disks will be available for partitioning. Only one of
the following three options may be used.""", version=FC3)
op.add_argument("--drives", dest="ignoredisk", type=commaSplit,
required=True, version=FC3, help="""
Specifies those disks that anaconda should not touch
when partitioning, formatting, and clearing.""")
return op
def _getParser(self):
op = KSOptionParser(prog="ignoredisk", description="""
Controls anaconda's access to disks attached to the system. By
default, all disks will be available for partitioning. Only one of
the following three options may be used.""", version=FC3)
op.add_argument("--drives", dest="ignoredisk", type=commaSplit,
required=True, version=FC3, help="""
Specifies those disks that anaconda should not touch
when partitioning, formatting, and clearing.""")
return op
def _getParser(self):
op = KSOptionParser(prog="langsupport",
description="""
Install the support packages for the given locales.""",
version=FC3)
op.add_argument("--default",
dest="deflang",
default="en_US.UTF-8",
version=FC3,
help="Default locale")
return op
def _getParser(self):
op = KSOptionParser(
prog="key",
description="set or skip the software installation key",
version=RHEL5)
op.add_argument("--skip",
action="store_true",
default=False,
version=RHEL5,
help="Skip the software installation key")
return op
def _getParser(self):
op = KSOptionParser(prog="authselect", description="""
This command sets up the authentication options
for the system. This is just a wrapper around the
authselect program, so all options recognized by
that program are valid for this command. See the
manual page for authselect for a complete list.""",
version=F28)
op.add_argument("options", metavar="[options]", help="""
See ``man authselect``.""", version=F28)
return op
def _getParser(self):
op = KSOptionParser(prog="group", description="""
Creates a new user group on the system. If a group with the given
name or GID already exists, this command will fail. In addition,
the ``user`` command can be used to create a new group for the
newly created user.""", version=F12)
op.add_argument("--name", required=True, version=F12,
help="Provides the name of the new group.")
op.add_argument("--gid", type=int, version=F12, help="""
The group's GID. If not provided, this defaults to the
next available non-system GID.""")
return op
def _getParser(self):
op = KSOptionParser(prog="updates", description="""
Specify the location of an updates.img for use in
installation. See anaconda-release-notes.txt for a
description of how to make an updates.img.""",
version=F7)
op.add_argument("updates", metavar="[URL]", nargs="*", version=F7,
help="""
If present, the URL for an updates image.
If not present, anaconda will attempt to load from a
floppy disk.""")
return op
def _getParser(self):
op = KSOptionParser(prog="updates", description="""
Specify the location of an updates.img for use in
installation. See anaconda-release-notes.txt for a
description of how to make an updates.img.""",
version=F7)
op.add_argument("updates", metavar="[URL]", nargs="*", version=F7,
help="""
If present, the URL for an updates image.
If not present, anaconda will attempt to load from a
floppy disk.""")
return op
def _getParser(self):
op = KSOptionParser(prog="mount", description="""
Assigns a mount point to a block device and
optionally reformats it to a given format. It at
least requires a device and a mount point where the
mount point can be ``none`` in case the format on
the device is not mountable or in case the device
should just be reformatted.
The difference between this command and the other
commands for storage configuration (``part``,
``logvol``,...) is that it doesn't require the whole
storage stack to be described in the kickstart
file. The user just needs to make sure that the
specified block device exists in the system. The
installer doesn't necessarily have to know all the
details about of the given device. If, on the other
hand, the installer is supposed to **create** the
storage stack with all the devices mounted at
various places, the ``part``, ``logvol``, ``raid``,
etc. commands have to be used.
""", version=F27)
op.add_argument("device", metavar="<device>", nargs=1, version=F27,
help="""The block device to mount""")
op.add_argument("mntpoint", metavar="<mntpoint>", type=mountpoint, nargs=1,
version=F27, help="""
The ``<mntpoint>`` is where the <device> will be
mounted. Must be a valid mount point, for example
``/``, ``/usr``, ``/home``, or ``none`` if the device
cannot (e.g. swap) or should not be mounted.""")
op.add_argument("--reformat", dest="reformat", nargs="?", version=F27, const=True, default=False,
help="Specifies the new format (e.g. a file system) for the device.")
op.add_argument("--mkfsoptions", dest="mkfs_opts", action="store", version=F27,
help="""
Specifies additional parameters to be passed to the
program that makes a filesystem on this partition. No
processing is done on the list of arguments, so they
must be supplied in a format that can be passed directly
to the mkfs program. This means multiple options should
be comma-separated or surrounded by double quotes,
depending on the filesystem.""")
op.add_argument("--mountoptions", dest="mount_opts", action="store", version=F27,
help="""
Specifies a free form string of options to be used when
mounting the filesystem. This string will be copied into
the /etc/fstab file of the installed system and should
be enclosed in quotes.""")
return op
def _getParser(self):
op = KSOptionParser(prog="auth|authconfig", description="""
This required command sets up the authentication
options for the system. This is just a wrapper
around the authconfig program, so all options
recognized by that program are valid for this
command. See the manual page for authconfig for a
complete list.
By default, passwords are normally encrypted and
are not shadowed.""", version=FC3)
op.add_argument("options", metavar="[options]", help="""
See ``man authconfig``.""", version=FC3)
return op
def _getParser(self):
op = KSOptionParser(prog="liveimg", description="""
Install a disk image instead of packages. The image can be the
squashfs.img from a Live iso, or any filesystem mountable by the
install media (eg. ext4). Anaconda expects the image to contain
utilities it needs to complete the system install so the best way to
create one is to use livemedia-creator to make the disk image. If
the image contains /LiveOS/*.img (this is how squashfs.img is
structured) the first *img file inside LiveOS will be mounted and
used to install the target system. The URL may also point to a
tarfile of the root filesystem. The file must end in .tar, .tbz,
.tgz, .txz, .tar.bz2, tar.gz, tar.xz""",
version=F19)
op.add_argument("--url", metavar="<url>", required=True, version=F19,
help="""
The URL to install from. http, https, ftp and file are
supported.""")
op.add_argument("--proxy", metavar="<proxyurl>", version=F19, help="""
Specify an HTTP/HTTPS/FTP proxy to use while performing
the install. The various parts of the argument act like
you would expect. Syntax is::
``--proxy=[protocol://][username[:password]@]host[:port]``
""")
op.add_argument("--noverifyssl", action="store_true", version=F19,
default=False, help="""
For a tree on a HTTPS server do not check the server's
certificate with what well-known CA validate and do not
check the server's hostname matches the certificate's
domain name.""")
op.add_argument("--checksum", metavar="<sha256>", version=F19,
help="Optional sha256 checksum of the image file")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--username", required=True)
op.add_argument("--iscrypted", dest="isCrypted", action="store_true", default=False)
op.add_argument("--plaintext", dest="isCrypted", action="store_false")
op.add_argument("--lock", action="store_true", default=False)
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--url", required=True)
op.add_argument("--proxy")
op.add_argument("--noverifyssl", action="store_true", default=False)
op.add_argument("--checksum")
return op
def _getParser(self):
op = KSOptionParser(prog="auth|authconfig", description="""
This required command sets up the authentication
options for the system. This is just a wrapper
around the authconfig program, so all options
recognized by that program are valid for this
command. See the manual page for authconfig for a
complete list.
By default, passwords are normally encrypted and
are not shadowed.""", version=FC3)
op.add_argument("options", metavar="[options]", help="""
See ``man authconfig``.""", version=FC3)
return op
def _getParser(self):
op = KSOptionParser(prog="autostep", description="""
Kickstart installs normally skip unnecessary screens.
This makes the installer step through every screen,
displaying each briefly.
This is mostly used for debugging.""",
version=FC3)
op.add_argument("--autoscreenshot", action="store_true", default=False,
version=FC3, help="""
Take a screenshot at every step during installation and
copy the images over to /root/anaconda-screenshots after
installation is complete. This is most useful for
documentation.""")
return op
def _getParser(self):
op = KSOptionParser(prog="zfcp", description="", version=FC3)
op.add_argument("--devnum", required=True, version=FC3, help="")
op.add_argument("--fcplun", required=True, version=FC3, help="")
op.add_argument("--scsiid", required=True, version=FC3, help="")
op.add_argument("--scsilun", required=True, version=FC3, help="")
op.add_argument("--wwpn", required=True, version=FC3, help="")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--osname", required=True)
op.add_argument("--remote")
op.add_argument("--url", required=True)
op.add_argument("--ref", required=True)
op.add_argument("--nogpg", action="store_true")
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--devnum", required=True)
op.add_argument("--fcplun", required=True)
op.add_argument("--scsiid", required=True)
op.add_argument("--scsilun", required=True)
op.add_argument("--wwpn", required=True)
return op
def _getParser(self):
op = KSOptionParser()
op.add_argument("--target")
op.add_argument("--ipaddr", required=True)
op.add_argument("--port")
op.add_argument("--user")
op.add_argument("--password")
return op
def _getParser(self):
op = KSOptionParser(prog="snapshot", version=F26, description="""
Create an LVM snapshot for devices on an LVM thin pool.""")
op.add_argument("--name", metavar="<snapshot_name>", version=F26, required=True,
help="""
Name of the newly created snapshot.""")
# Show all possible options in meta message
meta_msg = "<%s>" % ("|".join(self.whenMap.keys()))
op.add_argument("--when", metavar=meta_msg, type=self._when_cb, version=F26,
required=True, help="""
You can specify two possible values: ``pre-install`` and ``post-install``.
When the ``pre-install`` value is used the snapshot is created before
the installation but after the ``%%pre`` section is run.
When the ``post-install`` value is used the snapshot is created after
the installation is done and after the ``%%post`` section is run.""")
return op
def _getParser(self):
op = KSOptionParser(prog="sshkey", description="""
This installs a ssh key to the authorized_keys file
of the specified user on the installed system.""",
epilog="""
Note that the key should be quoted, if it contains
spaces and the user should exist (or be root)
either via creation by a package install or the
kickstart ``user`` command.""", version=F22)
op.add_argument("--username", required=True, metavar="<user>",
version=F22, help="""
User for which to install the specified key. This option is required.""")
op.add_argument('sshkey', metavar='"ssh key"', nargs=1,
version=F22, help="""
The content of the ssh key to install.""")
return op
def _getParser(self):
op = KSOptionParser(prog="nfs", description="""
Install from the NFS server specified. This can
either be an exploded installation tree or a
directory of ISO images. In the latter case, the
install.img must also be provided subject to the
same rules as with the harddrive installation
method described above.""", version=FC3)
op.add_argument("--server", metavar="<hostname>", required=True,
version=FC3, help="""
Server from which to install (hostname or IP).""")
op.add_argument("--dir", metavar="<directory>", required=True,
version=FC3, help="""
Directory containing the Packages/ directory of the
installation tree. If doing an ISO install, this
directory must also contain images/install.img.""")
return op
def _getParser(self):
op = KSOptionParser(prog="rootpw", description="""
This required command sets the system's root
password.""", version=FC3)
op.add_argument('password', metavar='<password>', nargs='?', version=FC3,
help="The desired root password.")
op.add_argument("--iscrypted", dest="isCrypted", action="store_true",
default=False, version=FC3, help="""
If this is present, the password argument is assumed to
already be encrypted. To create an encrypted password
you can use python::
``python -c 'import crypt; print(crypt.crypt("My Password", "$6$My Salt"))'``
This will generate sha512 crypt of your password using
your provided salt.""")
return op
