"[build] Build one or more packages from source"

      usage = _("usage: %prog chain-build [options] <target> <URL> [<URL> [:] <URL> [:] <URL> ...]")

      parser = OptionParser(usage=get_usage_str(usage))

      parser.add_option("--quiet", action="store_true",

                        help=_("Do not print the task information"), default=options.quiet)

      parser.add_option("--background", action="store_true",

      if not build_opts.quiet:

          print("Created task: %d" % task_id)

          print("Task info: %s/taskinfo?taskID=%s" % (options.weburl, task_id))

          session.logout()

          return watch_tasks(session, [task_id], quiet=build_opts.quiet,

                             poll_interval=options.poll_interval, topurl=options.topurl)

                        help=_("Do not attempt to tag package"))

      parser.add_option("--scratch", action="store_true",

                        help=_("Perform a scratch build"))

      parser.add_option("--quiet", action="store_true",

                        help=_("Do not print the task information"), default=options.quiet)

      parser.add_option("--background", action="store_true",

      if not build_opts.quiet:

          print("Created task: %d" % task_id)

          print("Task info: %s/taskinfo?taskID=%s" % (options.weburl, task_id))

          session.logout()

          return watch_tasks(session, [task_id], quiet=build_opts.quiet,

                             poll_interval=options.poll_interval, topurl=options.topurl)

      parser.add_option("--skip-tag", action="store_true",

                        help=_("If creating a new build, don't tag it"))

      parser.add_option("--scratch", action="store_true", help=_("Perform a scratch build"))

      parser.add_option("--background", action="store_true",

                        help=_("Run the build at a lower priority"))

      task_id = session.wrapperRPM(build_id, url, target, priority, opts=opts)

      print("Created task: %d" % task_id)

      print("Task info: %s/taskinfo?taskID=%s" % (options.weburl, task_id))

          session.logout()

          return watch_tasks(session, [task_id], quiet=options.quiet,

                             poll_interval=options.poll_interval, topurl=options.topurl)

                        help=_("Run Maven build in debug mode"))

      parser.add_option("--force", action="store_true",

                        help=_("Force rebuilds of all packages"))

      parser.add_option("--background", action="store_true",

                        help=_("Run the build at a lower priority"))

      (build_opts, args) = parser.parse_args(args)

      task_id = session.chainMaven(builds, target, opts, priority=priority)

      print("Created task: %d" % task_id)

      print("Task info: %s/taskinfo?taskID=%s" % (options.weburl, task_id))

          session.logout()

          return watch_tasks(session, [task_id], quiet=options.quiet,

                             poll_interval=options.poll_interval, topurl=options.topurl)

      """[build] Retry a canceled or failed task, using the same parameter as the original task."""

      usage = _("usage: %prog resubmit [options] <task_id>")

      parser = OptionParser(usage=get_usage_str(usage))

      parser.add_option("--nowatch", action="store_true", dest="nowait",

                        help=_("An alias for --nowait"))

      parser.add_option("--quiet", action="store_true", default=goptions.quiet,

      newID = session.resubmitTask(taskID)

      if not options.quiet:

          print("Resubmitted task %s as new task %s" % (taskID, newID))

          session.logout()

          return watch_tasks(session, [newID], quiet=options.quiet,

                             poll_interval=goptions.poll_interval, topurl=goptions.topurl)

                        help=_("Create a scratch image"))

      parser.add_option("--wait", action="store_true",

                        help=_("Wait on the image creation, even if running in the background"))

      parser.add_option("--noprogress", action="store_true",

                        help=_("Do not display progress of the upload"))

      usage = _("usage: %prog tag-build [options] <tag> <pkg> [<pkg> ...]")

      parser = OptionParser(usage=get_usage_str(usage))

      parser.add_option("--force", action="store_true", help=_("force operation"))

      (options, args) = parser.parse_args(args)

      if len(args) < 2:

          parser.error(

          # XXX - wait on task

          tasks.append(task_id)

          print("Created task %d" % task_id)

          session.logout()

          return watch_tasks(session, tasks, quiet=opts.quiet,

                             poll_interval=opts.poll_interval, topurl=opts.topurl)

      usage = _("usage: %prog move-build [options] <tag1> <tag2> <pkg> [<pkg> ...]")

      parser = OptionParser(usage=get_usage_str(usage))

      parser.add_option("--force", action="store_true", help=_("force operation"))

      parser.add_option("--all", action="store_true",

                        help=_("move all instances of a package, <pkg>'s are package names"))

      (options, args) = parser.parse_args(args)

              task_id = session.moveBuild(args[0], args[1], build['id'], options.force)

              tasks.append(task_id)

              print("Created task %d, moving %s" % (task_id, koji.buildLabel(build)))

          session.logout()

          return watch_tasks(session, tasks, quiet=opts.quiet,

                             poll_interval=opts.poll_interval, topurl=opts.topurl)

      parser.add_option("--noprogress", action="store_true",

                        help=_("Do not display progress meter"))

      parser.add_option("--wait", action="store_true",

      parser.add_option("-q", "--quiet", action="store_true",

                        help=_("Suppress output"), default=options.quiet)

      if not base_task:

          error(_('No such task: %d') % base_task_id)

              koji.TASK_STATES['CLOSED'],

              koji.TASK_STATES['CANCELED'],

              koji.TASK_STATES['FAILED']):

      parser = OptionParser(usage=get_usage_str(usage))

      parser.add_option("--target", action="store_true",

                        help=_("Interpret the argument as a build target name"))

      parser.add_option("--debuginfo", action="store_true", help=_("Include debuginfo rpms in repo"))

      parser.add_option("--source", "--src", action="store_true",

                        help=_("Include source rpms in each of repos"))

      print("Regenerating repo for tag: %s" % tag)

      print("Created task: %d" % task_id)

      print("Task info: %s/taskinfo?taskID=%s" % (options.weburl, task_id))

          session.logout()

          return watch_tasks(session, [task_id], quiet=options.quiet,

                             poll_interval=options.poll_interval, topurl=options.topurl)

                               'config file'))

      parser.add_option("--noinherit", action='store_true', default=False,

                        help=_('Do not consider tag inheritance'))

      parser.add_option('--skip-missing-signatures', action='store_true', default=False,

                        help=_('Skip RPMs not signed with the desired key(s)'))

      parser.add_option('--zck', action='store_true', default=False,

      }

      task_id = session.distRepo(tag, keys, **opts)

      print("Creating dist repo for tag " + tag)

          session.logout()

          return watch_tasks(session, [task_id], quiet=options.quiet,

                             poll_interval=options.poll_interval, topurl=options.topurl)

  from koji_cli.commands import handle_chain_build

  from . import utils

  class TestChainBuild(utils.CliTestCase):

      # Show long diffs in error output...

      maxDiff = None

  Options:

    -h, --help    show this help message and exit

    --nowait      Don't wait on build

    --quiet       Do not print the task information

    --background  Run the build at a lower priority

      @mock.patch('sys.stdout', new_callable=six.StringIO)

      @mock.patch('koji_cli.commands.activate_session')

      @mock.patch('koji_cli.commands.watch_tasks', return_value=0)

      def test_handle_chain_build_nowait(

              self,

              watch_tasks_mock,

              activate_session_mock,

              stdout):

          target = 'target'

          self.session.getFullInheritance.assert_called_once_with(build_tag_id)

          self.session.chainBuild.assert_called_once_with(

              sources, target, priority=priority)

          self.session.logout.assert_not_called()

          watch_tasks_mock.assert_not_called()

          self.assertIsNone(rv)

    --multilib=CONFIG     Include multilib packages in the repository using the

                          given config file

    --noinherit           Do not consider tag inheritance

    --nowait              Do not wait for the task to complete

    --skip-missing-signatures

                          Skip RPMs not signed with the desired key(s)

    --logs        Also download build logs

    --topurl=URL  URL under which Koji files are accessible

    --noprogress  Do not display progress meter

    -q, --quiet   Suppress output

  """ % progname

          self.assertMultiLineEqual(actual, expected)

              expected = "Missing the following required options: "

              expected += "--" + r.replace('_', '-') + "\n"

              with self.assertRaises(koji.GenericError) as cm:

                      _build_image_indirection(

                          self.options, self.task_opts, self.session, [])

              self.assert_console_message(stdout, expected)

    --scratch             Create a scratch image

    --wait                Wait on the image creation, even if running in the

                          background

    --noprogress          Do not display progress of the upload

  """ % (self.progname, self.progname))

  EMPTY_BUILD_OPTS = {

      'specfile': None,

      'patches': None,

      'envs': [],

      'scratch': None,

                          wrapper RPMs

    --skip-tag            Do not attempt to tag package

    --scratch             Perform a scratch build

    --nowait              Don't wait on build

    --quiet               Do not print the task information

    --background          Run the build at a lower priority

      @mock.patch('koji_cli.commands.activate_session')

      @mock.patch('koji.util.parse_maven_param')

      @mock.patch('koji.util.maven_opts', return_value={})

      @mock.patch('koji_cli.commands.watch_tasks', return_value=0)

      def test_handle_maven_build_nowait(

              self,

              watch_tasks_mock,

              maven_opts_mock,

              parse_maven_param_mock,

              activate_session_mock,

          task_id = 1

          args = ['--nowait', target, source]

          build_opts = EMPTY_BUILD_OPTS.copy()

          opts = {}

          priority = None

          scratch = None

          maven_opts_mock.assert_called_once_with(build_opts, scratch=scratch)

          self.session.mavenBuild.assert_called_once_with(

              source, target, opts, priority=priority)

          self.session.logout.assert_not_called()

          watch_tasks_mock.assert_not_called()

          self.assertIsNone(rv)

    --scratch     Perform scratch builds

    --debug       Run Maven build in debug mode

    --force       Force rebuilds of all packages

    --nowait      Don't wait on build

    --background  Run the build at a lower priority

  """ % (self.progname))

  Options:

    -h, --help  show this help message and exit

    --force     force operation

    --all       move all instances of a package, <pkg>'s are package names

  """ % self.progname)

  Options:

    -h, --help            show this help message and exit

    --target              Interpret the argument as a build target name

    --nowait              Don't wait on for regen to finish

    --debuginfo           Include debuginfo rpms in repo

    --source, --src       Include source rpms in each of repos

  Options:

    -h, --help  show this help message and exit

    --nowait    Don't wait on task

    --nowatch   An alias for --nowait

    --quiet     Do not print the task information

  """ % self.progname)

  if __name__ == '__main__':

      unittest.main()

      def test_handle_tag_build_argument_error(self):

          """Test handle_tag_build function with error argument"""

          expected = self.format_error_message(

          for arg in [[], ['tag']]:

              self.assert_system_exit(

                  handle_tag_build,

  Options:

    -h, --help  show this help message and exit

    --force     force operation

    --nowait    Do not wait on task

  """ % self.progname)

          # Run it and check immediate output

          expected = self.format_error_message(

          self.assert_system_exit(

              handle_wrapper_rpm,

              options,

                          Get build parameters from this section of the .ini

    --skip-tag            If creating a new build, don't tag it

    --scratch             Perform a scratch build

    --nowait              Don't wait on build

    --background          Run the build at a lower priority

  """ % self.progname)