# test use_bootstrap_container setting

          rlRun "copr-cli create ${NAME_PREFIX}BootstrapProject --use-bootstrap on --chroot $CHROOT"

          rlRun -s "copr-cli build ${NAME_PREFIX}BootstrapProject $HELLO --nowait"

          rlRun "parse_build_id"

          rlRun "copr watch-build $BUILD_ID"

          rlRun "curl $BACKEND_URL/results/${NAME_PREFIX}BootstrapProject/$CHROOT/`printf %08d $BUILD_ID`-hello/configs.tar.gz | tar xz -O '*configs/child.cfg' | grep \"config_opts\['use_bootstrap'\] = True\""

          rlRun "copr-cli modify ${NAME_PREFIX}BootstrapProject --use-bootstrap off"

          ## test building in copr dirs

          rlRun "copr-cli create --chroot $CHROOT ${NAME_PREFIX}CoprDirTest"

      None: None,

  }

  no_config_warning = """

  ================= WARNING: =======================

  File '{0}' is missing or incorrect.

              enable_net=ON_OFF_MAP[args.enable_net],

              persistent=args.persistent,

              auto_prune=ON_OFF_MAP[args.auto_prune],

              delete_after_days=args.delete_after_days,

              multilib=ON_OFF_MAP[args.multilib],

              module_hotfixes=ON_OFF_MAP[args.module_hotfixes],

              unlisted_on_hp=ON_OFF_MAP[args.unlisted_on_hp],

              enable_net=ON_OFF_MAP[args.enable_net],

              auto_prune=ON_OFF_MAP[args.auto_prune],

              chroots=args.chroots,

              delete_after_days=args.delete_after_days,

              multilib=ON_OFF_MAP[args.multilib],

      parser_create.add_argument("--auto-prune", choices=["on", "off"], default="on",

                                 help="If auto-deletion of project's obsoleted builds should be enabled (default is on).\

                                 This option can only be specified by a COPR admin.")

                                 help="If mock bootstrap container is used to initialize the buildroot.")

      parser_create.add_argument("--delete-after-days", default=None, metavar='DAYS',

                                 help="Delete the project after the specfied period of time")

      parser_create.add_argument("--module-hotfixes", choices=["on", "off"], default="off",

      parser_modify.add_argument("--auto-prune", choices=["on", "off"],

                                 help="If auto-deletion of project's obsoleted builds should be enabled.\

                                 This option can only be specified by a COPR admin.")

                                 help="If mock bootstrap container is used to initialize the buildroot.")

      parser_modify.add_argument("--delete-after-days", default=None, metavar='DAYS',

                                 help=("Delete the project after the specfied "

                                       "period of time, empty or -1 disables, "

                                           help="Build packages to a specified copr")

      parser_build.add_argument("pkgs", nargs="+",

                                help="filename of SRPM or URL of packages to build")

      parser_build.set_defaults(func="action_build")

      # create the parser for the "buildpypi" command

                                        help="space separated string of package names to be added to buildroot")

      parser_edit_chroot.add_argument("--repos",

                                        help="space separated string of additional repo urls for chroot")

      parser_edit_chroot.set_defaults(func="action_edit_chroot")

      parser_get_chroot = subparsers.add_parser("get-chroot", help="Get chroot of a project")

          raise exceptions.UnknownSourceTypeException("Invalid source type")

  class MultiCheckboxField(wtforms.SelectMultipleField):

      widget = wtforms.widgets.ListWidget(prefix_label=False)

      option_widget = wtforms.widgets.CheckboxInput()

                      newer build (with respect to package version) and it is

                      older than 14 days""")

              follow_fedora_branching = wtforms.BooleanField(

                      "Follow Fedora branching",

                  UrlListValidator(),

                  UrlSrpmListValidator()],

              filters=[StringListFilter()])

          return form

      with_opts = wtforms.StringField("With options")

      without_opts = wtforms.StringField("Without options")

  class CoprChrootExtend(FlaskForm):

      extend = wtforms.StringField("Chroot name")

      disable_createrepo = wtforms.BooleanField(validators=[wtforms.validators.Optional()], false_values=FALSE_VALUES)

      unlisted_on_hp = wtforms.BooleanField(validators=[wtforms.validators.Optional()], false_values=FALSE_VALUES)

      auto_prune = wtforms.BooleanField(validators=[wtforms.validators.Optional()], false_values=FALSE_VALUES)

      follow_fedora_branching = wtforms.BooleanField(validators=[wtforms.validators.Optional()], false_values=FALSE_VALUES)

      follow_fedora_branching = wtforms.BooleanField(default=True, false_values=FALSE_VALUES)

      delete_after_days = wtforms.IntegerField(

              'additional_packages': packages.split(),

              'repos': repos,

              'chroot': chroot_id,

              'with_opts': chroot.with_opts.split(),

              'without_opts': chroot.without_opts.split(),

          }

      @classmethod

      def add(cls, user, name, selected_chroots, repos=None, description=None,

              instructions=None, check_for_duplicates=False, group=None, persistent=False,

          if not flask.g.user.admin and flask.g.user != user:

              msg = ("You were authorized as '{0}' user without permissions to access "

                             created_on=int(time.time()),

                             persistent=persistent,

                             auto_prune=auto_prune,

                             follow_fedora_branching=follow_fedora_branching,

                             **kwargs)

      @classmethod

      def update_chroot(cls, user, copr_chroot, buildroot_pkgs=None, repos=None, comps=None, comps_name=None,

          """

          :type user: models.User

          :type copr_chroot: models.CoprChroot

              "Only owners and admins may update their projects.")

          cls._update_chroot(buildroot_pkgs, repos, comps, comps_name,

          return copr_chroot

      @classmethod

      def _update_chroot(cls, buildroot_pkgs, repos, comps, comps_name,

          if buildroot_pkgs is not None:

              copr_chroot.buildroot_pkgs = buildroot_pkgs

          if module_toggle is not None:

              copr_chroot.module_toggle = module_toggle

          db.session.add(copr_chroot)

      @classmethod

      # if backend deletion script should be run for the project's builds

      auto_prune = db.Column(db.Boolean, default=True, nullable=False, server_default="1")

      # if chroots for the new branch should be auto-enabled and populated from rawhide ones

      follow_fedora_branching = db.Column(db.Boolean, default=True, nullable=False, server_default="1")

      source_status = db.Column(db.Integer, default=StatusEnum("waiting"))

      srpm_url = db.Column(db.Text)

      # relations

      user_id = db.Column(db.Integer, db.ForeignKey("user.id"), index=True)

      user = db.relationship("User", backref=db.backref("builds"))

      delete_after = db.Column(db.DateTime, index=True)

      delete_notify = db.Column(db.DateTime, index=True)

      def update_comps(self, comps_xml):

          if isinstance(comps_xml, str):

              data = comps_xml.encode("utf-8")

    {% endif %}

  {% endmacro %}

  {% macro render_checkbox_field(title, items) %}

  <div class="form-group">

    <label class="col-sm-2 control-label" for="textInput-markup">

      {{ render_field(form.memory_reqs, hidden = True) }}

      {{ render_field(form.timeout, hidden = True) }}

    {% endif %}

    <div class="form-group">

      <label class="col-sm-2 control-label" for="textInput-markup" style="text-align: left">

      Other Options

        </div>

      </div>

    </div>

  {% endmacro %}

  {% macro copr_form(form, view, copr = None, username = None, group = None, comments = None) %}

    {# if using for updating, we need to pass name to url_for, but otherwise we need to pass nothing #}

          [form.auto_prune, g.user.admin],

          [form.unlisted_on_hp],

          [form.persistent, g.user.admin],

          [form.follow_fedora_branching],

          [form.multilib],

          [form.module_hotfixes],

              placeholder='Optional',

              info='Delete the project after the specfied period of time (empty = disabled)') }}

      {{ render_field(form.runtime_dependencies, rows=5, cols=50, placeholder='Optional - URL to additional yum repos, which can be used as runtime dependencies. Space separated. This should be baseurl from .repo file. E.g.: http://copr-be.cloud.fedoraproject.org/results/rhughes/f20-gnome-3-12/fedora-$releasever-$basearch/') }}

      </div>

    </div>

      <input class="btn btn-primary" type="submit" value="{% if copr %}Update{% else %}Create{% endif %}">

    </form>

  {% endmacro %}

  {% macro copr_delete_form(form, copr) %}

         )

      }}

      <div class="form-group">

        <label class="col-sm-2 control-label" for="textInput-markup">

          comps.xml

      <input class="btn btn-primary" type="submit" name="submit" value="update">

      <a class="btn btn-default" href="{{ copr_url('coprs_ns.copr_edit', copr) }}">Cancel</a>

    </form>

  {% endblock %}

          if "auto_prune" in flask.request.form:

              auto_prune = form.auto_prune.data

          try:

              copr = CoprsLogic.add(

                  group=group,

                  persistent=form.persistent.data,

                  auto_prune=auto_prune,

              )

              infos.append("New project was successfully created.")

          "persistent": copr.persistent,

          "unlisted_on_hp": copr.unlisted_on_hp,

          "auto_prune": copr.auto_prune,

      }

      return flask.jsonify(output)

          copr.build_enable_net = form.build_enable_net.data

      if "auto_prune" in flask.request.form:

          copr.auto_prune = form.auto_prune.data

      if "chroots" in  flask.request.form:

          coprs_logic.CoprChrootsLogic.update_from_names(

              flask.g.user, copr, form.chroots.data)

          "repos": config.get("repos"),

          "additional_repos": BuildConfigLogic.generate_additional_repos(copr_chroot),

          "additional_packages": config.get("additional_packages"),

          "with_opts": config.get("with_opts"),

          "without_opts": config.get("without_opts"),

          "memory_limit": build_chroot.build.memory_reqs,

          "repos": config["repos"],

          "additional_repos": BuildConfigLogic.generate_additional_repos(project_chroot),

          "additional_packages": (project_chroot.buildroot_pkgs or "").split(),

          "enable_net": project_chroot.copr.enable_net,

          "with_opts":  str_to_list(project_chroot.with_opts),

          "without_opts": str_to_list(project_chroot.without_opts),

          "chroot_repos": CoprsLogic.get_yum_repos(copr, empty=True),

          "additional_repos": copr.repos_list,

          "enable_net": copr.build_enable_net,

          "module_hotfixes": copr.module_hotfixes,

      }

              group=group,

              persistent=form.persistent.data,

              auto_prune=form.auto_prune.data,

              homepage=form.homepage.data,

              contact=form.contact.data,

              disable_createrepo=form.disable_createrepo.data,

  @apiv3_ns.route("/project/edit/<ownername>/<projectname>", methods=PUT)

  @api_login_required

  def edit_project(ownername, projectname):

      copr = get_copr(ownername, projectname)

      data = rename_fields(get_form_compatible_data())

      form = forms.CoprModifyForm(data, meta={'csrf': False})

              continue

          setattr(copr, field.name, field.data)

      if form.chroots.data:

          CoprChrootsLogic.update_from_names(

              flask.g.user, copr, form.chroots.data)

          build_config = BuildConfigLogic.generate_build_config(task.build.copr, task.mock_chroot.name)

          build_record["repos"] = build_config.get("repos")

          build_record["buildroot_pkgs"] = build_config.get("additional_packages")

          build_record["with_opts"] = build_config.get("with_opts")

          build_record["without_opts"] = build_config.get("without_opts")

      form = forms.ChrootForm(buildroot_pkgs=chroot.buildroot_pkgs, repos=chroot.repos,

                              module_toggle=chroot.module_toggle, with_opts=chroot.with_opts,

      # FIXME - test if chroot belongs to copr

      if flask.g.user.can_build_in(copr):

          return render_template("coprs/detail/edit_chroot.html",

                      form.repos.data,

                      comps=comps_xml, comps_name=comps_name,

                      with_opts=form.with_opts.data, without_opts=form.without_opts.data,

                  )

              elif action == "delete_comps":

                  group=group,

                  persistent=form.persistent.data,

                  auto_prune=(form.auto_prune.data if flask.g.user.admin else True),

                  follow_fedora_branching=form.follow_fedora_branching.data,

                  delete_after_days=form.delete_after_days.data,

                  multilib=form.multilib.data,

                  runtime_dependencies=form.runtime_dependencies.data.replace("\n", " "),

              )

              db.session.commit()

      copr.disable_createrepo = form.disable_createrepo.data

      copr.build_enable_net = form.build_enable_net.data

      copr.unlisted_on_hp = form.unlisted_on_hp.data

      copr.follow_fedora_branching = form.follow_fedora_branching.data

      copr.delete_after_days = form.delete_after_days.data

      copr.multilib = form.multilib.data

      copr.module_hotfixes = form.module_hotfixes.data

      copr.runtime_dependencies = form.runtime_dependencies.data.replace("\n", " ")

      if flask.g.user.admin:

          copr.auto_prune = form.auto_prune.data

      else:

      def add(self, ownername, projectname, chroots, description=None, instructions=None, homepage=None,

              contact=None, additional_repos=None, unlisted_on_hp=False, enable_net=True, persistent=False,

          """

          Create a project

          :param bool enable_net: if builder can access net for builds in this project

          :param bool persistent: if builds and the project are undeletable

          :param bool auto_prune: if backend auto-deletion script should be run for the project

          :param bool devel_mode: if createrepo should run automatically

          :param int delete_after_days: delete the project after the specfied period of time

          :param bool module_hotfixes: make packages from this project available

                                       on along with packages from the active module streams.

          :return: Munch

          """

          endpoint = "/project/add/{ownername}"

          params = {

              "ownername": ownername,

              "enable_net": enable_net,

              "persistent": persistent,

              "auto_prune": auto_prune,

              "devel_mode": devel_mode,

              "delete_after_days": delete_after_days,

              "multilib": multilib,

      def edit(self, ownername, projectname, chroots=None, description=None, instructions=None, homepage=None,

               contact=None, additional_repos=None, unlisted_on_hp=None, enable_net=None,

          """

          Edit a project

          :param bool unlisted_on_hp: project will not be shown on Copr homepage

          :param bool enable_net: if builder can access net for builds in this project

          :param bool auto_prune: if backend auto-deletion script should be run for the project

          :param bool devel_mode: if createrepo should run automatically

          :param int delete_after_days: delete the project after the specfied period of time

          :param bool module_hotfixes: make packages from this project available

                                       on along with packages from the active module streams.

          :return: Munch

          """

          endpoint = "/project/edit/{ownername}/{projectname}"

          params = {

              "ownername": ownername,

              "unlisted_on_hp": unlisted_on_hp,

              "enable_net": enable_net,

              "auto_prune": auto_prune,

              "devel_mode": devel_mode,

              "delete_after_days": delete_after_days,

              "multilib": multilib,

          self.enable_net = task.get("enable_net")

          self.repos = task.get("repos")

          self.use_bootstrap_container = task.get("use_bootstrap_container")

          self.timeout = task.get("timeout", 3600)

          self.with_opts = task.get("with_opts", [])

          self.without_opts = task.get("without_opts", [])

          template = jinja_env.get_template("mock.cfg.j2")

          return template.render(chroot=self.chroot, task_id=self.task_id, buildroot_pkgs=self.buildroot_pkgs,

                                 enable_net=self.enable_net, use_bootstrap_container=self.use_bootstrap_container,

                                 repos=self.repos,

                                 copr_username=self.copr_username, copr_projectname=self.copr_projectname,

                                 modules=self.enable_modules,

  config_opts['macros']['%buildtag'] = '.copr{{ copr_build_id }}'

  config_opts['use_bootstrap'] = {{ 'True' if use_bootstrap_container else 'False' }}

  {% if use_bootstrap_container %}

  config_opts['bootstrap_chroot_additional_packages'] = []