+ # TODO: sync with ActionTypeEnum from common

+ from ..exceptions import MockRemoteError, CoprWorkerError, VmError, CoprBackendSrpmError

+     local_file_logger, run_cmd, pkg_name_evr

+     def get_srpm_build_details(self, job):

+         build_details = {'srpm_url': ''}

+         self.log.info("Retrieving srpm URL from %s", job.results_dir)

+         pattern = os.path.join(job.results_dir, '*.src.rpm')

+         srpm_file = glob.glob(pattern)[0]

+         srpm_name = os.path.basename(srpm_file)

+         srpm_url = os.path.join(job.results_dir_url, srpm_name)

+         build_details['pkg_name'], build_details['pkg_version'] = pkg_name_evr(srpm_file)

+         build_details['srpm_url'] = srpm_url

+         return build_details

+                 build_details = self.get_srpm_build_details(job)

+ class CoprBackendSrpmError(CoprBackendError):

+     pass

+ from backend.exceptions import CoprBackendError, CoprBackendSrpmError

+ 

+ def pkg_name_evr(srpm_path):

+     """

+     Queries a package for its name and evr (epoch:version-release)

+     """

+     cmd = ['rpm', '-qp', '--nosignature', '--qf',

+            '%{NAME} %{EPOCH} %{VERSION} %{RELEASE}', srpm_path]

+ 

+     try:

+         result = run_cmd(cmd)

+     except OSError as e:

+         raise CoprBackendSrpmError(str(e))

+ 

+     if result.returncode != 0:

+         raise CoprBackendSrpmError('Error querying srpm: %s' % error)

+ 

+     try:

+         name, epoch, version, release = result.stdout.split(" ")

+     except ValueError as e:

+         raise CoprBackendSrpmError(str(e))

+ 

+     # Epoch is an integer or '(none)' if not set

+     if epoch.isdigit():

+         evr = "{}:{}-{}".format(epoch, version, release)

+     else:

+         evr = "{}-{}".format(version, release)

+ 

+     return name, evr

+             task.pkg_name = task_dict["pkg_name"]

+                 srpm_path,

+                 task.pkg_name,

+ def import_package(opts, namespace, branches, srpm_path, pkg_name):

+         (branch_commits, reponame, pkg_name)

+             "pkg_name": "pkg",

+             "pkg_name": "pkg_2",

+         srpm_path, package_desc = get_srpm(version)

+         name = package_desc['package_name']

+         import_result = import_package(opts, 'bob/blah', to_branches, srpm_path, name)

+         result = import_package(self.opts, namespace, branches,

+                 'some_srpm_path', 'pkg_name')

+         result = import_package(self.opts, namespace, branches, 'some_srpm_path', 'pkg_name')

+ """

+ package.chroot_blacklist

+ 

+ Revision ID: 51716ab39d37

+ Revises: c28451aaed50

+ Create Date: 2018-10-04 21:24:41.498242

+ """

+ 

+ # revision identifiers, used by Alembic.

+ revision = '51716ab39d37'

+ down_revision = 'c28451aaed50'

+ 

+ from alembic import op

+ import sqlalchemy as sa

+ 

+ 

+ def upgrade():

+     op.add_column('package', sa.Column('chroot_blacklist_raw', sa.Text(), nullable=True))

+ 

+ 

+ def downgrade():

+     op.drop_column('package', 'chroot_blacklist_raw')

+ from .context_processors import include_banner, inject_fedmenu, counter_processor

+ 

+ @app.context_processor

+ def counter_processor():

+     def counter(name):

+         if not 'counters' in flask.g:

+             flask.g.counters = {}

+         if not name in flask.g.counters:

+             flask.g.counters[name] = 0

+ 

+         flask.g.counters[name] += 1

+         return str(flask.g.counters[name])

+ 

+     return dict(counter=counter)

+ from fnmatch import fnmatch

+ from coprs.logic.coprs_logic import CoprsLogic, MockChrootsLogic

+         enabled = set(MockChrootsLogic.active_names())

+         if selected - enabled:

+             raise wtforms.ValidationError("Such chroot is not available: {}".format(", ".join(selected - enabled)))

+         F.chroots_list = MockChrootsLogic.active_names()

+             if mock_chroots and ch in [x.name for x in mock_chroots]:

+ def cleanup_chroot_blacklist(string):

+     if not string:

+         return string

+     fields = [x.lstrip().rstrip() for x in string.split(',')]

+     return ', '.join(fields)

+ 

+ 

+ def validate_chroot_blacklist(form, field):

+     if field.data:

+         string = field.data

+         fields = [x.lstrip().rstrip() for x in string.split(',')]

+         for field in fields:

+             pattern = r'^[a-z0-9-*]+$'

+             if not re.match(pattern, field):

+                 raise wtforms.ValidationError('Pattern "{0}" does not match "{1}"'.format(field, pattern))

+ 

+             matched = set()

+             all_chroots = MockChrootsLogic.active_names()

+             for chroot in all_chroots:

+                 if fnmatch(chroot, field):

+                     matched.add(chroot)

+ 

+             if not matched:

+                 raise wtforms.ValidationError('no chroot matched by pattern "{0}"'.format(field))

+ 

+             if matched == all_chroots:

+                 raise wtforms.ValidationError('patterns are black-listing all chroots')

+ 

+ 

+     chroot_blacklist = wtforms.StringField(

+         "Chroot blacklist",

+         filters=[cleanup_chroot_blacklist],

+         validators=[

+             wtforms.validators.Optional(),

+             validate_chroot_blacklist,

+         ],

+     )

+     def __new__(cls, active_chroots, form, package=None):

+         # fill chroots based on project settings

+         F.chroots_list = [x.name for x in active_chroots]

+ 

+         package_chroots = set(F.chroots_list)

+         if package:

+             package_chroots = set([ch.name for ch in package.chroots])

+ 

+             default = ch in package_chroots

+             setattr(F, ch, wtforms.BooleanField(ch, default=default, false_values=FALSE_VALUES))

+     def __new__(cls, active_chroots, package=None):

+         return BaseBuildFormFactory(active_chroots, PackageFormScm, package)

+     def __new__(cls, active_chroots, package=None):

+         return BaseBuildFormFactory(active_chroots, PackageFormPyPI, package)

+     def __new__(cls, active_chroots, package=None):

+         return BaseBuildFormFactory(active_chroots, PackageFormRubyGems, package)

+     def __new__(cls, active_chroots, package=None):

+         return BaseBuildFormFactory(active_chroots, PackageFormCustom, package)

+ from coprs.logic.packages_logic import PackagesLogic

+         chroots = None

+         if chroot_names:

+             # Chroots were explicitly set per-build.

+         for chroot in package.chroots:

+         # create the package if it doesn't exist

+         pkg_name = upd_dict.get('pkg_name', None)

+         if pkg_name:

+             if not PackagesLogic.get(build.copr_dir.id, pkg_name).first():

+                 try:

+                     package = PackagesLogic.add(

+                         build.copr.user, build.copr_dir,

+                         pkg_name, build.source_type, build.source_json)

+                     db.session.add(package)

+                     db.session.commit()

+                 except (sqlalchemy.exc.IntegrityError, exceptions.DuplicateException) as e:

+                     app.logger.exception(e)

+                     db.session.rollback()

+                     return

+             build.package = PackagesLogic.get(build.copr_dir.id, pkg_name).first()

+ 

+         for attr in ["built_packages", "srpm_url", "pkg_version"]:

+         if str(upd_dict.get("task_id")) == str(build.task_id):

+             new_status = upd_dict.get("status")

+             if new_status == StatusEnum("succeeded"):

+                 chroot_status=StatusEnum("waiting")

+                 if not build.build_chroots:

+                     # create the BuildChroots from Package setting, if not

+                     # already set explicitly for concrete build

+                     for chroot in build.package.chroots:

+                         buildchroot = models.BuildChroot(

+                             build=build,

+                             status=chroot_status,

+                             mock_chroot=chroot,

+                             git_hash=None,

+                         )

+                         db.session.add(buildchroot)

+                 else:

+                     for buildchroot in build.build_chroots:

+                         buildchroot.status = chroot_status

+                         db.session.add(buildchroot)

+     def active_names(cls):

+         return [ch.name for ch in cls.get_multiple(active_only=True).all()]

+ 

+     @classmethod

+ from fnmatch import fnmatch

+     # comma-separated list of wildcards of chroot names that this package should

+     # not be built against, e.g. "fedora-*, epel-*-i386"

+     chroot_blacklist_raw = db.Column(db.Text)

+ 

+     @property

+     def chroot_blacklist(self):

+         if not self.chroot_blacklist_raw:

+             return []

+ 

+         blacklisted = []

+         for pattern in self.chroot_blacklist_raw.split(','):

+             pattern = pattern.strip()

+             if not pattern:

+                 continue

+             blacklisted.append(pattern)

+ 

+         return blacklisted

+ 

+ 

+     @staticmethod

+     def matched_chroot(chroot, patterns):

+         for pattern in patterns:

+             if fnmatch(chroot.name, pattern):

+                 return True

+         return False

+ 

+ 

+     @property

+     def main_pkg(self):

+         if self.copr_dir.main:

+             return self

+ 

+         main_pkg = Package.query.filter_by(

+                 name=self.name,

+                 copr_dir_id=self.copr.main_dir.id

+         ).first()

+         return main_pkg

+ 

+ 

+     @property

+     def chroots(self):

+         chroots = list(self.copr.active_chroots)

+         if not self.chroot_blacklist_raw:

+             # no specific blacklist

+             if self.copr_dir.main:

+                 return chroots

+             return self.main_pkg.chroots

+ 

+         filtered = [c for c in chroots if not self.matched_chroot(c, self.chroot_blacklist)]

+         # We never want to filter everything, this is a misconfiguration.

+         return filtered if filtered else chroots

+ 

+ 

+         use_src_statuses = ["starting", "pending", "running"]

+         if self.source_status in [StatusEnum(s) for s in use_src_statuses]:

+             return self.source_status

+ 

+     {% if build.status is not none %}

+       {% if build.status|state_from_num == "waiting" %}

+         {{ build_state_text(build.source_status|state_from_num) }}

+       {% else %}

+         {{ build_state_text(build.status|state_from_num) }}

+       {% endif %}

+     {% elif build.source_status %}

+       {{ build_state_text(0|state_from_num) }}

+   <!-- This closes "Provide the source" panel, so we can create a new one.

+       <h3 class="panel-title">{{ counter('instructions') }}. How to build SRPM from the source</h3>

+ {% from "_helpers.html" import render_field, render_form_errors, copr_url, render_pypi_python_versions_field, render_additional_build_options, render_srpm_build_method_box with context %}

+         <h3 class="panel-title">{{ counter('instructions') }}. Provide the source</h3>

+ {% macro copr_build_form_end(form, view, copr, hide_panels=False) %}

+         <h3 class="panel-title">{{ counter('instructions') }}. Select chroots and other options</h3>

+   {{ copr_build_form_end(form, view, copr) }}

+ {% from "_helpers.html" import render_field, render_form_errors, copr_url, render_pypi_python_versions_field, render_additional_build_options, render_srpm_build_method_box with context %}

+               <h3 class="panel-title">{{ counter('instructions') }}. Provide the source</h3>

+               <h3 class="panel-title">{{ counter('instructions') }}. Provide the source</h3>

+ {% macro render_generic_pkg_form(form) %}