'--lookaside-repo', default=[], action='append',

      metavar="lookaside_repos",

      help="Koji tag with module builds.")

  wait_parser = subparsers.add_parser(

      'wait', help='wait for a compose to finish')

              module_defaults_url=args.module_defaults_url,

              module_defaults_commit=args.module_defaults_commit,

              lookaside_repos=args.lookaside_repo,

          )

      elif args.command == "wait":

          result = {"id": int(args.compose_id)}

                      sigkeys=None, koji_event=None, results=None,

                      arches=None, builds=None, modular_koji_tags=None,

                      module_defaults_url=None, module_defaults_commit=None,

          """Request a new compose

          :param str source: from where to grab and make new compose, different

              request_data['source']['module_defaults_commit'] = module_defaults_commit

          if lookaside_repos:

              request_data['lookaside_repos'] = lookaside_repos

          if seconds_to_live is not None:

              request_data['seconds-to-live'] = seconds_to_live

          if flags:

  *arches* - ``(white-space separated list of strings)``

      List of architectures the compose is generated for. The strings to express particular architecture are the same as the ones used by Koji build systemd.

  .. _builds:

  *builds* - ``(white-space separated list of strings or null)``

  *koji_event* - ``(number or null)``

      The Koji event defining the point in Koji history when the compose was generated. It can be ``null`` if source type does not relate to Koji tag.

  .. _lookaside_repos:

  *lookaside_repos* - ``(white-space separated list of strings or null)``

      """

      search_query = dict()

          if flask_request.args.get(key, None):

              search_query[key] = flask_request.args[key]

      multilib_method = db.Column(db.Integer)

      # White-space separated lookaside repository URLs.

      lookaside_repos = db.Column(db.String, nullable=True)

      @classmethod

      def create(cls, session, owner, source_type, source, results,

                 seconds_to_live, packages=None, flags=0, sigkeys=None,

                 koji_event=None, arches=None, multilib_arches=None,

                 multilib_method=None, builds=None, lookaside_repos=None,

          now = datetime.utcnow()

          compose = cls(

              owner=owner,

              lookaside_repos=lookaside_repos,

              modular_koji_tags=modular_koji_tags,

              module_defaults_url=module_defaults_url,

          )

          session.add(compose)

          return compose

              lookaside_repos=compose.lookaside_repos,

              modular_koji_tags=compose.modular_koji_tags,

              module_defaults_url=compose.module_defaults_url,

          )

          session.add(compose)

          return compose

              'lookaside_repos': self.lookaside_repos,

              'modular_koji_tags': self.modular_koji_tags,

              'module_defaults_url': self.module_defaults_url,

          }

      @staticmethod

  import jinja2

  import time

  from productmd.composeinfo import ComposeInfo

  import odcs.server.utils

  from odcs.server import comps

  from odcs.common.types import (

      PungiSourceType, COMPOSE_RESULTS, MULTILIB_METHODS,

      INVERSE_PUNGI_SOURCE_TYPE_NAMES, COMPOSE_FLAGS)

              pungi_cmd += ["--old-composes", self.old_compose]

          return pungi_cmd

          """

          Creates the compose directory and returns the full path to it.

          """

          compose_dir = os.path.join(targetdir, compose_id)

          makedirs(compose_dir)

          ci = ComposeInfo()

          ci.compose.date = compose_date

          ci.compose.respin = 0

          # Dump the compose info to work/global/composeinfo-base.json.

          work_dir = os.path.join(compose_dir, "work", "global")

          makedirs(work_dir)

          ci.dump(os.path.join(work_dir, "composeinfo-base.json"))

          return compose_dir

          """

          Runs local Pungi compose.

          """

          try:

              td = tempfile.mkdtemp()

              self._write_cfgs(td)

              pungi_cmd = self.get_pungi_cmd(td, conf.target_dir, compose_dir)

              log_out_path = os.path.join(compose_dir, "pungi-stdout.log")

              log_err_path = os.path.join(compose_dir, "pungi-stderr.log")

          :param models.Compose compose: Compose this Pungi process is running

              for.

          """

  class PungiLogs(object):

          :jsonparam list multilib_arches: List of :ref:`multilib arches<multilib_arches>`.

          :jsonparam string multilib_method: List defining the :ref:`multilib method<multilib_method>`.

          :jsonparam list lookaside_repos: List of :ref:`lookaside_repos<lookaside_repos>`.

          :jsonparam object source: The JSON object defining the source of compose.

          :jsonparam string source["type"]: String defining the :ref:`source type<source_type>`.

          :jsonparam string source["source"]: String defining the :ref:`source<source>`.

          elif module_defaults_url and module_defaults_commit:

              module_defaults = "%s %s" % (module_defaults_url, module_defaults_commit)

          raise_if_input_not_allowed(

              source_types=source_type, sources=source, results=results,

              flags=flags, arches=arches)

              builds=builds,

              lookaside_repos=lookaside_repos,

              modular_koji_tags=modular_koji_tags,

          db.session.add(compose)

          # Flush is needed, because we use `before_commit` SQLAlchemy event to

          # send message and before_commit can be called before flush and

                           'multilib_method': 0,

                           'lookaside_repos': None,

                           'modular_koji_tags': None,

          self.assertEqual(c.json(), expected_json)

      def test_create_copy(self):

              if c.name in ["id", "state", "state_reason", "time_to_expire",

                            "time_done", "time_submitted", "time_removed",

                            "removed_by", "reused_id", "koji_task_id",

                  assertMethod = self.assertNotEqual

              else:

                  assertMethod = self.assertEqual

  import shutil

  import tempfile

  import unittest

  from mock import patch, MagicMock, mock_open

  from kobo.conf import PyConfigParser

              self.assertEqual(pungi_cfg.source, "foo:1:1:1 bar-devel:1:1:1")

      def setUp(self):

          super(TestPungi, self).setUp()

              makedirs(dest)

              makedirs(os.path.join(dest, "another"))

              with open(os.path.join(dest, "pungi.conf"), "w") as fd:

              with open(os.path.join(dest, "another", "pungi.conf"), "w") as fd:

          self.patch_clone_repo = patch("odcs.server.pungi.clone_repo")

          self.clone_repo = self.patch_clone_repo.start()

          self.ci_dump = self.patch_ci_dump.start()

          self.compose = MagicMock()

      def tearDown(self):

          super(TestPungi, self).tearDown()

          self.clone_repo.assert_called_once_with(

              'http://localhost/test.git', AnyStringWith("/raw_config_repo"),

              commit='hash')

      @patch("odcs.server.utils.execute_cmd")

      def test_pungi_run_raw_config_subpath(self, execute_cmd):

                           'multilib_method': 0,

                           'lookaside_repos': '',

                           'modular_koji_tags': None,

          self.assertEqual(data, expected_json)

          db.session.expire_all()

                           'multilib_method': 0,

                           'lookaside_repos': '',

                           'modular_koji_tags': None,

          self.assertEqual(data, expected_json)

          db.session.expire_all()

              self.client.post('/api/1/composes/', data=json.dumps(

                  {'source': {'type': 'raw_config',

          db.session.expire_all()

          c = db.session.query(Compose).filter(Compose.id == 1).one()

          self.assertEqual(c.state, COMPOSE_STATES["wait"])

          self.assertEqual(c.source_type, PungiSourceType.RAW_CONFIG)

          self.assertEqual(c.source, 'pungi_cfg#hash')