Chapter 5. Developing installer add-ons

• pykickstart - parses and validates the Kickstart files. Also, provides data structure that stores values that drive the installation.
• dnf - the package manager that installs packages and resolves dependencies
• blivet - handles all activities related to storage management
• pyanaconda - contains the user interface and modules for Anaconda, such as keyboard and timezone selection, network configuration, and user creation. Also provides various utilities to perform system-oriented functions
• python-meh - contains an exception handler that gathers and stores additional system information in case of a crash and passes this information to the libreport library, which itself is a part of the ABRT Project
• dasbus - enables communication between the D-Bus library with modules of anaconda and with external components
• python-simpleline - text UI framework library to manage user interaction in the Anaconda text mode
• gtk - the Gnome toolkit library for creating and managing GUI

• Boss - manages the internal module discovery, lifecycle, and coordination
• Localization - manages locales
• Network - handles network
• Payloads - handles data for installation in different formats, such as rpm, ostree, tar and other installation formats. Payloads manage the sources of data for installation; sources can vary in format such as CD-ROM, HDD, NFS, URLs, and other sources
• Security - manages security related aspects
• Services - handles services
• Storage - manages storage by using blivet
• Subscription - handles the subscription-manager tool and Insights.
• Timezone - deals with time, date, zones, and time synchronization.
• Users - creates users and groups.

• Flexibility to follow the installer screens.
• Flexibility to retain the default settings.
• Provides an overview of the configured values.
• Supports extensibility. You can add hubs without the need to reorder anything and can resolve some complex ordering dependencies.
• Supports installation in graphical and text mode.

• ready - states whether or not you can visit a spoke. For example, when the installer is configuring a package source, the spoke is colored in gray, and you cannot access it until the configuration is complete.
• completed - marks whether or not the spoke is complete (all required values are set).
• mandatory - determines whether you must visit the spoke before continuing the installation; for example, you must visit the Installation Destination spoke, even if you want to use automatic disk partitioning
• status - provides a short summary of values configured within the spoke (displayed under the spoke name in the hub)

• program with asynchronous calls and return handlers
• A program with synchronous calls that makes the caller wait until the call is complete.

• Support for each interface (graphical interface and text interface) is available in a separate subpackage and these subpackages are named gui for the graphical interface and tui for the text-based interface.
• The gui and tui packages contain a spokes subpackage. ^[1]
• Modules contained in the packages have an arbitrary name.
• The gui/ and tui/ directories contain Python modules with any name.
• There is a service that performs the actual work of the addon. This service can be written in Python or any other language.
• The service implements support for D-Bus and Kickstart.
• The addon contains files that enable automatic startup of the service.

• builderObjects - lists all top-level objects from the spoke’s .glade file that should be exposed to the spoke with their children objects (recursively). In case everything should be exposed to the spoke, the list should be empty.
• mainWidgetName - contains the id of the main window widget (Add Link) as defined in the .glade file.
• uiFile - contains the name of the .glade file.
• category - contains the class of the category the spoke belongs to.
• icon - contains the identifier of the icon that will be used for the spoke on the hub.
• title - defines the title that will be used for the spoke on the hub.

Prerequisites

• Your add-on includes support for Kickstart. See Anaconda add-on structure.
• Install the anaconda-widgets and anaconda-widgets-devel packages, which contain Gtk widgets specific for Anaconda, such as SpokeWindow.

Procedure

• Create the following modules with all required definitions to add support for the Add-on graphical user interface (GUI), according to the following examples.

  # will never be translated
  _ = lambda x: x
  N_ = lambda x: x
  
  # the path to addons is in sys.path so we can import things from org_fedora_hello_world
  from org_fedora_hello_world.gui.categories.hello_world import HelloWorldCategory
  from pyanaconda.ui.gui.spokes import NormalSpoke
  
  # export only the spoke, no helper functions, classes or constants
  all = ["HelloWorldSpoke"]
  
  class HelloWorldSpoke(FirstbootSpokeMixIn, NormalSpoke):
      """
      Class for the Hello world spoke. This spoke will be in the Hello world
      category and thus on the Summary hub. It is a very simple example of a unit
      for the Anaconda's graphical user interface. Since it is also inherited form
      the FirstbootSpokeMixIn, it will also appear in the Initial Setup (successor
      of the Firstboot tool).
  
      :see: pyanaconda.ui.common.UIObject
      :see: pyanaconda.ui.common.Spoke
      :see: pyanaconda.ui.gui.GUIObject
      :see: pyanaconda.ui.common.FirstbootSpokeMixIn
      :see: pyanaconda.ui.gui.spokes.NormalSpoke
  
      """
  
      # class attributes defined by API #
  
      # list all top-level objects from the .glade file that should be exposed
      # to the spoke or leave empty to extract everything
      builderObjects = ["helloWorldSpokeWindow", "buttonImage"]
  
      # the name of the main window widget
      mainWidgetName = "helloWorldSpokeWindow"
  
      # name of the .glade file in the same directory as this source
      uiFile = "hello_world.glade"
  
      # category this spoke belongs to
      category = HelloWorldCategory
  
      # spoke icon (will be displayed on the hub)
      # preferred are the -symbolic icons as these are used in Anaconda's spokes
      icon = "face-cool-symbolic"
  
      # title of the spoke (will be displayed on the hub)
      title = N_("_HELLO WORLD")

  Copy to Clipboard Toggle word wrap

  The __all__ attribute exports the spoke class, followed by the first lines of its definition including definitions of attributes previously mentioned in GUI Add-on basic features. These attribute values are referencing widgets defined in the com_example_hello_world/gui/spokes/hello.glade file. Two other notable attributes are present:

• category, which has its value imported from the HelloWorldCategory class from the com_example_hello_world.gui.categories module. The HelloWorldCategory that the path to add-ons is in sys.path so that values can be imported from the com_example_hello_world package. The category attribute is part of the N_ function name, which marks the string for translation; but returns the non-translated version of the string, as the translation happens in a later stage.

• title, which contains one underscore in its definition. The title attribute underscore marks the beginning of the title itself and makes the spoke reachable by using the Alt+H keyboard shortcut.

  What usually follows the header of the class definition and the class attributes definitions is the constructor that initializes an instance of the class. In case of the Anaconda graphical interface objects, there are two methods initializing a new instance: the __init__ method and the initialize method.

  The reason behind two such functions is that the GUI objects may be created in memory at one time and fully initialized at a different time, as the spoke initialization could be time consuming. Therefore, the __init__ method should only call the parent’s __init__ method and, for example, initialize non-GUI attributes. On the other hand, the initialize method that is called when the installer’s graphical user interface initializes should finish the full initialization of the spoke.

  In the Hello World add-on example, define these two methods as follows. Note the number and description of the arguments passed to the __init__ method. For example:

  def __init__(self, data, storage, payload):
      """
      :see: pyanaconda.ui.common.Spoke.init
      :param data: data object passed to every spoke to load/store data
      from/to it
      :type data: pykickstart.base.BaseHandler
      :param storage: object storing storage-related information
      (disks, partitioning, boot loader, etc.)
      :type storage: blivet.Blivet
      :param payload: object storing packaging-related information
      :type payload: pyanaconda.packaging.Payload
  
      """
  
      NormalSpoke.init(self, data, storage, payload)
      self._hello_world_module = HELLO_WORLD.get_proxy()
  
  def initialize(self):
      """
      The initialize method that is called after the instance is created.
      The difference between init and this method is that this may take
      a long time and thus could be called in a separate thread.
      :see: pyanaconda.ui.common.UIObject.initialize
      """
      NormalSpoke.initialize(self)
      self._entry = self.builder.get_object("textLines")
      self._reverse = self.builder.get_object("reverseCheckButton")

  Copy to Clipboard Toggle word wrap

  The data parameter passed to the __init__ method is the in-memory tree-like representation of the Kickstart file where all data is stored. In one of the ancestors' __init__ methods it is stored in the self.data attribute, which allows all other methods in the class to read and modify the structure.

  Note

  The storage object is no longer usable as of RHEL10. If your add-on needs to interact with storage configuration, use the Storage DBus module.

  Because the HelloWorldData class has already been defined in The Hello World addon example, there already is a subtree in self.data for this add-on. Its root, an instance of the class, is available as self.data.addons.com_example_hello_world.

  Another action that an ancestor’s __init__ does is initializing an instance of the GtkBuilder with the spoke’s .glade file and storing it as self.builder. The initialize method uses this to get the GtkTextEntry used to show and modify the text from the kickstart file’s %addon section.

  The __init__ and initialize methods are both important when the spoke is created. However, the main role of the spoke is to be visited by a user who wants to change or review the spoke’s values shows and sets. To enable this, three other methods are available:

• refresh - called when the spoke is about to be visited; this method refreshes the state of the spoke, mainly its UI elements, to ensure that the displayed data matches internal data structures and, with that, to ensure that current values stored in the self.data structure are displayed.
• apply - called when the spoke is left and used to store values from UI elements back into the self.data structure.

• execute - called when users leave the spoke and used to perform any runtime changes based on the new state of the spoke.

  These functions are implemented in the sample Hello World add-on in the following way:

  def refresh(self):
      """
      The refresh method that is called every time the spoke is displayed.
      It should update the UI elements according to the contents of
      internal data structures.
      :see: pyanaconda.ui.common.UIObject.refresh
      """
      lines = self._hello_world_module.Lines
      self._entry.get_buffer().set_text("".join(lines))
      reverse = self._hello_world_module.Reverse
      self._reverse.set_active(reverse)
  
  def apply(self):
      """
      The apply method that is called when user leaves the spoke. It should
      update the D-Bus service with values set in the GUI elements.
      """
      buf = self._entry.get_buffer()
      text = buf.get_text(buf.get_start_iter(),
                          buf.get_end_iter(),
                          True)
      lines = text.splitlines(True)
      self._hello_world_module.SetLines(lines)
  
      self._hello_world_module.SetReverse(self._reverse.get_active())
  
  def execute(self):
    """
    The execute method that is called when the spoke is exited. It is
    supposed to do all changes to the runtime environment according to
    the values set in the GUI elements.
  
    """
  
    # nothing to do here
    pass

  Copy to Clipboard Toggle word wrap

  You can use several additional methods to control the spoke’s state:

• ready - determines whether the spoke is ready to be visited; if the value is "False", the spoke is not accessible, for example, the Package Selection spoke before a package source is configured.
• completed - determines if the spoke has been completed.

• mandatory - determines if the spoke is mandatory or not, for example, the Installation Destination spoke, which must always be visited, even if you want to use automatic partitioning.

  All of these attributes need to be dynamically determined based on the current state of the installation process. Below is a sample implementation of these methods in the Hello World add-on, which requires a certain value to be set in the text attribute of the HelloWorldData class:

  @property
  def ready(self):
      """
      The ready property reports whether the spoke is ready, that is, can be visited
      or not. The spoke is made (in)sensitive based on the returned value of the ready
      property.
  
      :rtype: bool
  
      """
  
      # this spoke is always ready
      return True
  
  
  @property
  def mandatory(self):
      """
      The mandatory property that tells whether the spoke is mandatory to be
      completed to continue in the installation process.
  
      :rtype: bool
  
      """
  
      # this is an optional spoke that is not mandatory to be completed
      return False

  Copy to Clipboard Toggle word wrap

  After these properties are defined, the spoke can control its accessibility and completeness, but it cannot provide a summary of the values configured within - you must visit the spoke to see how it is configured, which may not be desired. For this reason, an additional property called status exists. This property contains a single line of text with a short summary of configured values, which can then be displayed in the hub under the spoke title.

  The status property is defined in the Hello World example add-on as follows:

  @property
  def status(self):
      """
      The status property that is a brief string describing the state of the
      spoke. It should describe whether all values are set and if possible
      also the values themselves. The returned value will appear on the hub
      below the spoke's title.
      :rtype: str
      """
      lines = self._hello_world_module.Lines
      if not lines:
          return _("No text added")
      elif self._hello_world_module.Reverse:
          return _("Text set with {} lines to reverse").format(len(lines))
      else:
          return _("Text set with {} lines").format(len(lines))

  Copy to Clipboard Toggle word wrap

  After defining all properties described in the examples, the add-on has full support for showing a graphical user interface (GUI) as well as Kickstart.

  Note

  The example demonstrated here is very simple and does not contain any controls; knowledge of Python Gtk programming is required to develop a functional, interactive spoke in the GUI.

  One notable restriction is that each spoke must have its own main window - an instance of the SpokeWindow widget. This widget, along with other widgets specific to Anaconda, is found in the anaconda-widgets package. You can find other files required for development of add-ons with GUI support, such as Glade definitions, in the anaconda-widgets-devel package.

  Once your graphical interface support module contains all necessary methods you can continue with the following section to add support for the text-based user interface.

• Does not support cursor movement - instead, it acts like a line printer.
• Does not support any visual enhancements, such as using different colors or fonts, for example.

• title - determines the title of the spoke, similar to the title argument in the GUI.
• category - determines the category of the spoke as a string; the category name is not displayed anywhere, it is only used for grouping.

Prerequisites

• You have created a new set of subpackages under the tui directory as described in Anaconda add-on structure.

Procedure

• Create modules with all required definitions to add support for the add-on text user interface (TUI), according to the following examples:

• The setup method sets up a default value for the internal attribute of the spoke on every entry, which is then displayed by the refresh method, updated by the input method and used by the apply method to update internal data structures.
• The execute method has the same purpose as the equivalent method in the GUI; in this case, the method has no effect.
• The input method is specific to the text interface; there are no equivalents in Kickstart or GUI. The input methods are responsible for user interaction.
• The input method processes the entered string and takes action depending on its type and value. The above example asks for any value and then stores it as an internal attribute (key). In more complex add-ons, you typically need to perform some non-trivial actions, such as parse letters as actions, convert numbers into integers, show additional screens or toggle boolean values.
• The return value of the input class must be either the InputState enum or the input string itself, in case this input should be processed by a different screen. In contrast to the graphical mode, the apply and execute methods are not called automatically when leaving the spoke; they must be called explicitly from the input method. The same applies to closing (hiding) the spoke’s screen: it must be called explicitly from the close method.

Prerequisites

• You have added a new set of subpackages under the TUI directory, as described in Anaconda add-on structure.

Procedure

• Create modules with all required definitions to add support for the Add-on text user interface (TUI), according to the following examples.

Prerequisites

• You created an Add-on.
• You have access to your D-Bus files.
• You have installed the lorax package.