**cts_keytab**

      (*str*) -- Path to Kerberos keytab which will be used for Compose

      Kerberos principal is used.

  **compose_type**

      (*str*) -- Path to a file with password that will be formatted

      into **signing_command** string via ``%(signing_key_password)s``

      string format syntax (if used).

      logs we don't want password to be included directly in the config.

      Note: If ``-`` string is used instead of a filename, then you will be asked

      for the password interactivelly right after pungi starts.

      ``productid`` file in the ``repodata`` directories. The purpose of these

      ``productid`` files is to expose the product data to `subscription-manager

      <https://github.com/candlepin/subscription-manager>`_.

      ``productid`` certificate files from each Yum repository.

  **product_id_allow_missing** = False

      (*str|[str]*) -- RPM scratch build task(s) to include in a package set,

      defined as task IDs. This option can be used only when ``compose_type``

      is set to ``test``. The RPM still needs to have higher NVR than any

      appear in the resulting compose.

  **pkgset_koji_module_tag**

      * ``{runroot_key}`` - Replaced with the string returned by

        ``runroot_ssh_init_template`` if used. This can be used to keep the track

      * ``{packages}`` - White-list separated list of packages to install.

      Example (The ``{runroot_key}`` is expected to be set to mock config file

      * ``{runroot_key}`` - Replaced with the string returned by

        ``runroot_ssh_init_template`` if used. This can be used to keep the track

      * ``{command}`` - Command to run.

      Example (The ``{runroot_key}`` is expected to be set to mock config file

  ====================

  Actual Pungi configuration files can get very large. This pages brings two

  Fedora Rawhide compose

  ----------------------

              ],

          '^Spins': [

              # There are multiple media for Spins variant. They use subvariant

              {

                  'name': 'Fedora-KDE-Live',

                  'kickstart': 'fedora-live-kde.ks',

  **release_type**

     Type of the product for the final compose.

  **extra_args**

  **koji_profile**

     If specified, a current event will be retrieved from the Koji instance and

     used for all parts.

                  compose.paths.compose.topdir().rstrip("/") + "/",

              ).rstrip("/")

              """

              debug_iso_dir = (

                  compose.paths.compose.debug_iso_dir(arch=arch, variant=variant) or ""

              )

              compose.log_info(log_msg % "pungi_buildinstall plugin is not used.")

              return

          # The "sources" are not important, because we check the buildinstall

          # input on RPM level.

          cmd_copy = copy(cmd)

  def _get_old_package_dirs(compose, repo_dir):

      repo in an older compose and return a list of paths to directories with

      packages in it.

      """

                  rpm_obj.name,

              )

              # there are multiple RPMs with the same arch, sourcerpm and name.

              if key in key_to_old_rpm_obj:

                  compose.log_info(

                  compose.log_info(log_msg % "some RPMs have been added.")

                  return

              old_rpm_obj, old_result_key, old_result_record = key_to_old_rpm_obj[key]

              if (

                  old_rpm_obj.requires != rpm_obj.requires

              logfile = self.compose.paths.log.log_file(

                  arch, "hybrid-depsolver-%s-iter-%d" % (variant, step)

              )

              # any log messages with the PID of the fus process (which is quite

              # useless for us anyway).

              env = os.environ.copy()

              koji_task_id, signing_key_id

          )

          if wait_paths(rpm_paths, 60 * 15):

              # Files are ready

              return rpm_paths

      def get_package_path(self, queue_item):

          rpm_info, build_info = queue_item

          # know the path.

          if "path_from_task" in rpm_info:

              return rpm_info["path_from_task"]

              executed.

          :param str output_dir: Directory where the `command` stores its output.

              The permissions of this output_dir might be changed by `runroot_method`

              See `KojiWrapper.get_runroot_cmd()` for more information.

          """

          if self.runroot_method == "local":

      """Ensure that a directory exists, if it already exists, only continue

      if force is set."""

      # itself cause an issue.

      def whoops(func, path, exc_info):

          message = "Could not remove %s" % path

      return DEBUG_PATTERN_RE.match(name)

  def get_arch_variant_data(conf, var_name, arch, variant, keys=None):

      result = []

      for conf_variant, conf_data in conf.get(var_name, []):

          return self.cache[key]

  def get_arch_data(conf, var_name, arch):

      result = []

      for conf_arch, conf_data in conf.get(var_name, {}).items():

      """Attempt to run the command to unmount an image.

      If the command fails and stderr complains about device being busy, try

      If both path and logger are specified, more debugging information will be

      printed in case of failure.

          if normpath.startswith(prefix):

              # We can't call os.path.normpath on result since it is not actually

              # a path - http:// would get changed to  http:/ and so on.

              return normpath.replace(prefix, newvalue, 1)

      return normpath

          opts.supported or iso.get_checkisomd5_data(opts.source)["Supported ISO"]

      )

      # implantmd5 + supported bit (use the same as on source iso, unless

      isomd5sum_cmd = iso.get_implantisomd5_cmd(target, supported)

      sh(log, isomd5sum_cmd)