def copr_build_package(copr, package_name):
form = forms.BuildFormRebuildFactory.create_form_cls(
copr.active_chroots)(meta={
'csrf': False
})
try:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
except IndexError:
raise LegacyApiError(
"No package with name {name} in copr {copr}".format(
name=package_name, copr=copr.name))
if form.validate_on_submit():
try:
build = PackagesLogic.build_package(flask.g.user, copr, package,
form.selected_chroots,
**form.data)
db.session.commit()
except (InsufficientRightsException, ActionInProgressException,
NoPackageSourceException) as e:
raise LegacyApiError(str(e))
else:
raise LegacyApiError(form.errors)
return flask.jsonify({
"output": "ok",
"ids": [build.id],
"message": "Build was added to {0}.".format(copr.name)
})
def copr_rebuild_all_packages(copr):
form = forms.RebuildAllPackagesFormFactory(
copr.active_chroots, [package.name for package in copr.packages])()
if flask.request.method == "POST" and form.validate_on_submit():
try:
packages = []
for package_name in form.packages.data:
packages.append(
ComplexLogic.get_package_safe(copr.main_dir, package_name))
PackagesLogic.batch_build(flask.g.user,
copr,
packages,
form.selected_chroots,
enable_net=form.enable_net.data)
except (ObjectNotFound, ActionInProgressException, NoPackageSourceException, \
InsufficientRightsException, MalformedArgumentException) as e:
db.session.rollback()
flask.flash(str(e), "error")
else:
db.session.commit()
flask.flash("Batch build successfully started.", "success")
return flask.redirect(helpers.url_for_copr_builds(copr))
return flask.render_template("coprs/detail/packages_rebuild_all.html",
view="coprs_ns.copr_rebuild_all_packages",
form=form,
copr=copr)
def dist_git_upload_completed():
"""
Mark BuildChroot in a Build as uploaded, which means:
- set it to pending state
- set BuildChroot.git_hash
- if it's the last BuildChroot in a Build:
- delete local srpm
BuildChroot is identified with task_id which is build id + git branch name
- For example: 56-f22 -> build 55, chroots fedora-22-*
"""
result = {"updated": False}
if "task_id" in flask.request.json:
app.logger.debug(flask.request.data)
task_id = flask.request.json["task_id"]
build_chroots = BuildsLogic.get_chroots_from_dist_git_task_id(task_id)
build = build_chroots[0].build
# Is it OK?
if "git_hash" in flask.request.json and "repo_name" in flask.request.json:
git_hash = flask.request.json["git_hash"]
repo_name = flask.request.json["repo_name"]
pkg_name = flask.request.json["pkg_name"]
pkg_version = flask.request.json["pkg_version"]
# Now I need to assign a package to this build
package = PackagesLogic.get(build.copr.id, pkg_name).first()
if not package:
package = PackagesLogic.add(build.copr.owner, build.copr, pkg_name)
db.session.add(package)
db.session.flush()
build.package_id = package.id
build.pkg_version = pkg_version
for ch in build_chroots:
ch.status = helpers.StatusEnum("pending")
ch.git_hash = git_hash
# Failed?
elif "error" in flask.request.json:
error_type = flask.request.json["error"]
try:
build.fail_type = helpers.FailTypeEnum(error_type)
except KeyError:
build.fail_type = helpers.FailTypeEnum("unknown_error")
for ch in build_chroots:
ch.status = helpers.StatusEnum("failed")
# is it the last chroot?
if not build.has_importing_chroot:
BuildsLogic.delete_local_srpm(build)
db.session.commit()
result.update({"updated": True})
return flask.jsonify(result)
def dist_git_upload_completed():
"""
Mark BuildChroot in a Build as uploaded, which means:
- set it to pending state
- set BuildChroot.git_hash
- if it's the last BuildChroot in a Build:
- delete local srpm
BuildChroot is identified with task_id which is build id + git branch name
- For example: 56-f22 -> build 55, chroots fedora-22-*
"""
result = {"updated": False}
if "task_id" in flask.request.json:
app.logger.debug(flask.request.data)
task_id = flask.request.json["task_id"]
build_chroots = BuildsLogic.get_chroots_from_dist_git_task_id(task_id)
build = build_chroots[0].build
# Is it OK?
if "git_hash" in flask.request.json and "repo_name" in flask.request.json:
git_hash = flask.request.json["git_hash"]
pkg_name = flask.request.json["pkg_name"]
pkg_version = flask.request.json["pkg_version"]
# Now I need to assign a package to this build
package = PackagesLogic.get(build.copr.id, pkg_name).first()
if not package:
package = PackagesLogic.add(build.copr.owner, build.copr,
pkg_name)
db.session.add(package)
db.session.flush()
build.package_id = package.id
build.pkg_version = pkg_version
for ch in build_chroots:
ch.status = helpers.StatusEnum("pending")
ch.git_hash = git_hash
# Failed?
elif "error" in flask.request.json:
error_type = flask.request.json["error"]
try:
build.fail_type = helpers.FailTypeEnum(error_type)
except KeyError:
build.fail_type = helpers.FailTypeEnum("unknown_error")
for ch in build_chroots:
ch.status = helpers.StatusEnum("failed")
# is it the last chroot?
if not build.has_importing_chroot:
BuildsLogic.delete_local_srpm(build)
db.session.commit()
result.update({"updated": True})
return flask.jsonify(result)
def process_save_package(copr, source_type_text, package_name, view,
view_method, url_on_success):
form = forms.get_package_form_cls_by_source_type_text(source_type_text)()
if "reset" in flask.request.form:
try:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
except IndexError:
flask.flash(
"Package {package_name} does not exist in copr_dir {copr_dir}."
.format(package_name, copr.main_dir.full_name))
return flask.redirect(url_on_success) # should be url_on_fail
try:
PackagesLogic.reset_package(flask.g.user, package)
db.session.commit()
except InsufficientRightsException as e:
flask.flash(str(e))
return flask.redirect(url_on_success) # should be url_on_fail
flask.flash("Package default source successfully reset.")
return flask.redirect(url_on_success)
if form.validate_on_submit():
try:
if package_name:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
else:
package = PackagesLogic.add(flask.app.g.user, copr.main_dir,
form.package_name.data)
package.source_type = helpers.BuildSourceEnum(source_type_text)
package.webhook_rebuild = form.webhook_rebuild.data
package.source_json = form.source_json
package.chroot_blacklist_raw = form.chroot_blacklist.data
package.max_builds = form.max_builds.data
db.session.add(package)
db.session.commit()
except (InsufficientRightsException, IndexError) as e:
db.session.rollback()
flask.flash(str(e), "error")
else:
flask.flash(
"Package successfully saved" if package_name else
"New package has been created.", "success")
return flask.redirect(url_on_success)
kwargs = {
"coprname": copr.name,
"package_name": package_name,
"source_type_text": source_type_text,
"form": form,
}
kwargs.update({"group_name": copr.group.name} if copr.
is_a_group_project else {"username": copr.user.name})
return view_method(**kwargs)
def test_last_successful_build_chroots(self, f_users, f_fork_prepare,
f_build_few_chroots):
builds_p4 = PackagesLogic.last_successful_build_chroots(self.p4)
builds_p5 = PackagesLogic.last_successful_build_chroots(self.p5)
assert builds_p4 == {self.b6: self.b6_bc}
assert builds_p5 == {
self.b10: [self.b10_bc[0]],
self.b11: [self.b11_bc[1]]
}
def package_reset():
copr = get_copr()
form = forms.BasePackageForm()
try:
package = PackagesLogic.get(copr.main_dir.id, form.package_name.data)[0]
except IndexError:
raise ObjectNotFound("No package with name {name} in copr {copr}"
.format(name=form.package_name.data, copr=copr.name))
PackagesLogic.reset_package(flask.g.user, package)
db.session.commit()
return flask.jsonify(to_dict(package))
def copr_delete_package(copr, package_id):
package = ComplexLogic.get_package_by_id_safe(package_id)
try:
PackagesLogic.delete_package(flask.g.user, package)
except (InsufficientRightsException, ActionInProgressException) as e:
flask.flash(str(e), "error")
else:
db.session.commit()
flask.flash("Package has been deleted successfully.", "success")
return flask.redirect(helpers.copr_url("coprs_ns.copr_packages", copr))
def copr_delete_package(copr, package_id):
package = ComplexLogic.get_package_by_id_safe(package_id)
try:
PackagesLogic.delete_package(flask.g.user, package)
except (InsufficientRightsException, ActionInProgressException) as e:
flask.flash(str(e), "error")
else:
db.session.commit()
flask.flash("Package has been deleted successfully.", "success")
return flask.redirect(helpers.copr_url("coprs_ns.copr_packages", copr))
def process_save_package(copr, source_type_text, package_name, view, view_method, url_on_success):
form = forms.get_package_form_cls_by_source_type_text(source_type_text)()
if "reset" in flask.request.form:
try:
package = PackagesLogic.get(copr.id, package_name)[0]
except IndexError:
flask.flash("Package {package_name} does not exist in copr {copr}.".format(package_name, copr.full_name))
return flask.redirect(url_on_success) # should be url_on_fail
try:
PackagesLogic.reset_package(flask.g.user, package)
db.session.commit()
except InsufficientRightsException as e:
flask.flash(str(e))
return flask.redirect(url_on_success) # should be url_on_fail
flask.flash("Package default source successfully reset.")
return flask.redirect(url_on_success)
if form.validate_on_submit():
try:
if package_name:
package = PackagesLogic.get(copr.id, package_name)[0]
else:
package = PackagesLogic.add(flask.app.g.user, copr, form.package_name.data)
package.source_type = helpers.BuildSourceEnum(source_type_text)
package.webhook_rebuild = form.webhook_rebuild.data
package.source_json = form.source_json
db.session.add(package)
db.session.commit()
except (InsufficientRightsException, IndexError) as e:
db.session.rollback()
flask.flash(str(e), "error")
else:
flask.flash("Package successfully saved" if package_name else "New package has been created.")
return flask.redirect(url_on_success)
kwargs = {
"coprname": copr.name,
"package_name": package_name,
"source_type_text": source_type_text,
"form": form,
}
kwargs.update({"group_name": copr.group.name} if copr.is_a_group_project else {"username": copr.user.name})
return view_method(**kwargs)
def process_save_package(copr, package_name, view, view_method, url_on_success):
if flask.request.form["source_type"] == "git_and_tito":
form = forms.PackageFormTito()
elif flask.request.form["source_type"] == "mock_scm":
form = forms.PackageFormMock()
elif flask.request.form["source_type"] == "pypi":
form = forms.PackageFormPyPI()
else:
raise Exception("Wrong source type")
if form.validate_on_submit():
if package_name:
package = PackagesLogic.get(copr.id, package_name).first()
else:
package = PackagesLogic.add(flask.app.g.user, copr, form.package_name.data)
package.source_type = helpers.BuildSourceEnum(form.source_type.data)
package.webhook_rebuild = form.webhook_rebuild.data
if package.source_type == helpers.BuildSourceEnum("git_and_tito"):
package.source_json = json.dumps({
"git_url": form.git_url.data,
"git_branch": form.git_branch.data,
"git_dir": form.git_directory.data,
"tito_test": form.tito_test.data})
elif package.source_type == helpers.BuildSourceEnum("mock_scm"):
package.source_json = json.dumps({
"scm_type": form.scm_type.data,
"scm_url": form.scm_url.data,
"scm_branch": form.scm_branch.data,
"spec": form.spec.data})
elif package.source_type == helpers.BuildSourceEnum("pypi"):
package.source_json = json.dumps({
"pypi_package_name": form.pypi_package_name.data,
"python_versions": form.python_versions.data})
try:
db.session.add(package)
db.session.commit()
except (ActionInProgressException, InsufficientRightsException) as e:
db.session.rollback()
flask.flash(str(e), "error")
else:
flask.flash("Package successfully saved" if package_name else "New package has been created.")
return flask.redirect(url_on_success)
return view_method(username=copr.owner.name, coprname=copr.name,
package_name=package_name, source_type=form.source_type.data, form=form)
def get_package_safe(copr_dir, package_name):
try:
return PackagesLogic.get(copr_dir.id, package_name).one()
except sqlalchemy.orm.exc.NoResultFound:
raise ObjectNotFound(
message="Package {} in the copr_dir {} does not exist.".format(
package_name, copr_dir))
def process_package_add_or_edit(copr, source_type, package=None):
try:
form = forms.get_package_form_cls_by_source_type(source_type)(csrf_enabled=False)
except UnknownSourceTypeException:
raise LegacyApiError("Unsupported package source type {source_type}".format(source_type=source_type))
if form.validate_on_submit():
if not package:
try:
package = PackagesLogic.add(flask.app.g.user, copr, form.package_name.data)
except InsufficientRightsException:
raise LegacyApiError("Insufficient permissions.")
except DuplicateException:
raise LegacyApiError("Package {0} already exists in copr {1}.".format(form.package_name.data, copr.full_name))
package.source_type = helpers.BuildSourceEnum(form.source_type.data)
package.webhook_rebuild = form.webhook_rebuild.data
package.source_json = form.source_json
db.session.add(package)
db.session.commit()
else:
raise LegacyApiError(form.errors)
return flask.jsonify({
"output": "ok",
"message": "Create or edit operation was successful.",
"package": package.to_dict(),
})
def webhooks_hello(copr_id, uuid):
# For the documentation of the data we receive see:
# https://developer.github.com/v3/activity/events/types/#pushevent
try:
copr = ComplexLogic.get_copr_by_id_safe(copr_id)
except ObjectNotFound:
return page_not_found("Project does not exist")
if copr.webhook_secret != uuid:
return access_restricted("This webhook is not valid")
try:
request_json = flask.request.json
clone_url = request_json["repository"]["clone_url"]
except KeyError:
return "Bad Request", 400
if "commits" in request_json:
commits = request_json["commits"]
else:
commits = []
packages = PackagesLogic.get_for_webhook_rebuild(copr_id, uuid, clone_url, commits)
for package in packages:
BuildsLogic.rebuild_package(package)
db.session.commit()
return "OK", 200
def process_package_edit(copr, package_name, view):
if request.form["source_type"] == "git_and_tito":
form = forms.PackageFormTitoFactory
form_var = "form_tito"
elif request.form["source_type"] == "mock_scm":
form = forms.PackageFormMockFactory
form_var = "form_mock"
else:
raise Exception("Wrong source type")
form = form.create_form_cls()()
if form.validate_on_submit():
package = PackagesLogic.get(copr.id, package_name).first()
package.source_type = helpers.BuildSourceEnum(form.source_type.data)
if package.source_type == helpers.BuildSourceEnum("git_and_tito"):
package.source_json = json.dumps({
"git_url": form.git_url.data,
"git_branch": form.git_branch.data,
"git_dir": form.git_directory.data,
"tito_test": form.tito_test.data
})
elif package.source_type == helpers.BuildSourceEnum("mock_scm"):
package.source_json = json.dumps({
"scm_type": form.scm_type.data,
"scm_url": form.scm_url.data,
"scm_branch": form.scm_branch.data,
"spec": form.spec.data
})
db.session.add(package)
db.session.commit()
return render_package_edit(copr, package_name, view, **{form_var: form})
def process_package_edit(copr, package_name, view):
if request.form["source_type"] == "git_and_tito":
form = forms.PackageFormTitoFactory
form_var = "form_tito"
elif request.form["source_type"] == "mock_scm":
form = forms.PackageFormMockFactory
form_var = "form_mock"
else:
raise Exception("Wrong source type")
form = form.create_form_cls()()
if form.validate_on_submit():
package = PackagesLogic.get(copr.id, package_name).first()
package.source_type = helpers.BuildSourceEnum(form.source_type.data)
if package.source_type == helpers.BuildSourceEnum("git_and_tito"):
package.source_json = json.dumps({
"git_url": form.git_url.data,
"git_branch": form.git_branch.data,
"git_dir": form.git_directory.data,
"tito_test": form.tito_test.data})
elif package.source_type == helpers.BuildSourceEnum("mock_scm"):
package.source_json = json.dumps({
"scm_type": form.scm_type.data,
"scm_url": form.scm_url.data,
"scm_branch": form.scm_branch.data,
"spec": form.spec.data})
db.session.add(package)
db.session.commit()
return render_package_edit(copr, package_name, view, **{form_var: form})
def get_package_safe(copr, package_name):
try:
return PackagesLogic.get(copr.id, package_name).one()
except sqlalchemy.orm.exc.NoResultFound:
raise ObjectNotFound(
message="Package {} in the copr {} does not exist."
.format(package_name, copr))
def fork_package(self, package, fcopr):
fpackage = PackagesLogic.get(fcopr.id, package.name).first()
if not fpackage:
fpackage = self.create_object(models.Package, package, exclude=["id", "copr_id"])
fpackage.copr = fcopr
db.session.add(fpackage)
return fpackage
def process_package_add_or_edit(copr, source_type, package=None):
try:
form = forms.get_package_form_cls_by_source_type(source_type)(
csrf_enabled=False)
except UnknownSourceTypeException:
raise LegacyApiError(
"Unsupported package source type {source_type}".format(
source_type=source_type))
if form.validate_on_submit():
if not package:
try:
package = PackagesLogic.add(flask.app.g.user, copr,
form.package_name.data)
except InsufficientRightsException:
raise LegacyApiError("Insufficient permissions.")
except DuplicateException:
raise LegacyApiError(
"Package {0} already exists in copr {1}.".format(
form.package_name.data, copr.full_name))
package.source_type = helpers.BuildSourceEnum(form.source_type.data)
package.webhook_rebuild = form.webhook_rebuild.data
package.source_json = form.source_json
db.session.add(package)
db.session.commit()
else:
raise LegacyApiError(form.errors)
return flask.jsonify({
"output": "ok",
"message": "Create or edit operation was successful.",
"package": package.to_dict(),
})
def webhooks_hello(copr_id, uuid):
# For the documentation of the data we receive see:
# https://developer.github.com/v3/activity/events/types/#pushevent
try:
copr = ComplexLogic.get_copr_by_id_safe(copr_id)
except ObjectNotFound:
return page_not_found("Project does not exist")
if copr.webhook_secret != uuid:
return access_restricted("This webhook is not valid")
try:
request_json = flask.request.json
clone_url = request_json["repository"]["clone_url"]
except KeyError:
return "Bad Request", 400
if "commits" in request_json:
commits = request_json["commits"]
else:
commits = []
packages = PackagesLogic.get_for_webhook_rebuild(copr_id, uuid, clone_url,
commits)
for package in packages:
BuildsLogic.rebuild_package(package)
db.session.commit()
return "OK", 200
def fork_package(self, package, fcopr):
fpackage = PackagesLogic.get(fcopr.id, package.name).first()
if not fpackage:
fpackage = self.create_object(models.Package, package, exclude=["id", "copr_id"])
fpackage.copr = fcopr
db.session.add(fpackage)
return fpackage
def copr_packages(copr):
packages_query = PackagesLogic.get_copr_packages_list(copr)
return flask.Response(
stream_with_context(
helpers.stream_template("coprs/detail/packages.html",
copr=copr,
packages=list(packages_query))))
def get_package(ownername, projectname, packagename):
copr = get_copr(ownername, projectname)
try:
package = PackagesLogic.get(copr.main_dir.id, packagename)[0]
except IndexError:
raise ObjectNotFound("No package with name {name} in copr {copr}".format(name=packagename, copr=copr.name))
return flask.jsonify(to_dict(package))
def process_package_add_or_edit(copr,
source_type_text,
package=None,
data=None):
if not flask.g.user.can_edit(copr):
raise InsufficientRightsException(
"You are not allowed to add or edit packages in this copr.")
formdata = data or flask.request.form
try:
if package and data:
formdata = data.copy()
for key in package.source_json_dict.keys() - data.keys():
value = package.source_json_dict[key]
add_function = formdata.setlist if type(
value) == list else formdata.add
add_function(key, value)
form = forms.get_package_form_cls_by_source_type_text(
source_type_text)(formdata, meta={
'csrf': False
})
except UnknownSourceTypeException:
raise LegacyApiError(
"Unsupported package source type {source_type_text}".format(
source_type_text=source_type_text))
if form.validate_on_submit():
if not package:
try:
package = PackagesLogic.add(flask.app.g.user, copr.main_dir,
form.package_name.data)
except InsufficientRightsException:
raise LegacyApiError("Insufficient permissions.")
except DuplicateException:
raise LegacyApiError(
"Package {0} already exists in copr {1}.".format(
form.package_name.data, copr.full_name))
try:
source_type = helpers.BuildSourceEnum(source_type_text)
except KeyError:
source_type = helpers.BuildSourceEnum("scm")
package.source_type = source_type
package.source_json = form.source_json
if "webhook_rebuild" in formdata:
package.webhook_rebuild = form.webhook_rebuild.data
if "max_builds" in formdata:
package.max_builds = form.max_builds.data
db.session.add(package)
db.session.commit()
else:
raise LegacyApiError(form.errors)
return flask.jsonify({
"output": "ok",
"message": "Create or edit operation was successful.",
"package": package.to_dict(),
})
def copy_data(cp):
for model in mods:
cp.copy_objects(model)
for copr in all_coprs():
for package in PackagesLogic.get_all(copr.id):
cp.copy_package(package)
cp.copy_build(package.last_build(successful=True))
def package_build():
copr = get_copr()
data = rename_fields(get_form_compatible_data(preserve=["python_versions"]))
form = forms.RebuildPackageFactory.create_form_cls(copr.active_chroots)(data, meta={'csrf': False})
try:
package = PackagesLogic.get(copr.main_dir.id, form.package_name.data)[0]
except IndexError:
raise ObjectNotFound("No package with name {name} in copr {copr}"
.format(name=form.package_name.data, copr=copr.name))
if form.validate_on_submit():
buildopts = {k: v for k, v in form.data.items() if k in data}
build = PackagesLogic.build_package(flask.g.user, copr, package, form.selected_chroots,
copr_dirname=form.project_dirname.data, **buildopts)
db.session.commit()
else:
raise BadRequest(form.errors)
return flask.jsonify(build_to_dict(build))
def copy_data(cp):
for model in mods:
cp.copy_objects(model)
for copr in all_coprs():
for package in PackagesLogic.get_all(copr.id):
cp.copy_package(package)
cp.copy_build(package.last_build(successful=True))
def copr_reset_package(copr, package_name):
try:
package = PackagesLogic.get(copr.id, package_name)[0]
except IndexError:
raise LegacyApiError("No package with name {name} in copr {copr}".format(name=package_name, copr=copr.name))
try:
PackagesLogic.reset_package(flask.g.user, package)
db.session.commit()
except InsufficientRightsException as e:
raise LegacyApiError(str(e))
return flask.jsonify({
"output": "ok",
"message": "Package's default source was successfully reseted.",
'package': package.to_dict(),
})
def copr_edit_package(copr, package_name, source_type_text):
try:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
except IndexError:
raise LegacyApiError(
"Package {name} does not exists in copr_dir {copr_dir}.".format(
name=package_name, copr_dir=copr_dir.name))
return process_package_add_or_edit(copr, source_type_text, package=package)
def copr_get_package(copr, package_name):
try:
package = PackagesLogic.get(copr.id, package_name)[0]
except IndexError:
raise LegacyApiError("No package with name {name} in copr {copr}".format(name=package_name, copr=copr.name))
params = get_package_record_params()
return flask.jsonify({'package': package.to_dict(**params)})
def copr_get_package(copr, package_name):
try:
package = PackagesLogic.get(copr.id, package_name)[0]
except IndexError:
raise LegacyApiError(
"No package with name {name} in copr {copr}".format(
name=package_name, copr=copr.name))
return flask.jsonify({'package': package.to_dict()})
def copr_reset_package(copr, package_name):
try:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
except IndexError:
raise LegacyApiError(
"No package with name {name} in copr {copr}".format(
name=package_name, copr=copr.name))
try:
PackagesLogic.reset_package(flask.g.user, package)
db.session.commit()
except InsufficientRightsException as e:
raise LegacyApiError(str(e))
return flask.jsonify({
"output": "ok",
"message": "Package's default source was successfully reseted.",
'package': package.to_dict(),
})
def copr_get_package(copr, package_name):
try:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
except IndexError:
raise LegacyApiError(
"No package with name {name} in copr_dir {copr_dir}".format(
name=package_name, copr_dir=copr.main_dir.name))
params = get_package_record_params()
return flask.jsonify({'package': package.to_dict(**params)})
def package_edit(ownername, projectname, package_name, source_type_text=None):
copr = get_copr(ownername, projectname)
data = rename_fields(get_form_compatible_data(preserve=["python_versions"]))
try:
package = PackagesLogic.get(copr.main_dir.id, package_name)[0]
source_type_text = source_type_text or package.source_type_text
except IndexError:
raise ObjectNotFound("Package {name} does not exists in copr {copr}."
.format(name=package_name, copr=copr.full_name))
process_package_add_or_edit(copr, source_type_text, package=package, data=data)
return flask.jsonify(to_dict(package))
def copr_build_package(copr, package_name):
form = forms.BuildFormRebuildFactory.create_form_cls(copr.active_chroots)(csrf_enabled=False)
try:
package = PackagesLogic.get(copr.id, package_name)[0]
except IndexError:
raise LegacyApiError("No package with name {name} in copr {copr}".format(name=package_name, copr=copr.name))
if form.validate_on_submit():
try:
build = PackagesLogic.build_package(flask.g.user, copr, package, form.selected_chroots, **form.data)
db.session.commit()
except (InsufficientRightsException, ActionInProgressException, NoPackageSourceException) as e:
raise LegacyApiError(str(e))
else:
raise LegacyApiError(form.errors)
return flask.jsonify({
"output": "ok",
"ids": [build.id],
"message": "Build was added to {0}.".format(copr.name)
})
def copr_packages(copr):
flashes = flask.session.pop('_flashes', [])
packages = PackagesLogic.get_packages_with_latest_builds_for_dir(
copr.main_dir.id)
response = flask.Response(
stream_with_context(helpers.stream_template(
"coprs/detail/packages.html",
copr=copr,
packages=packages,
flashes=flashes,
)))
flask.session.pop('_flashes', [])
return response
def copr_packages(copr):
flashes = flask.session.pop('_flashes', [])
packages_query = PackagesLogic.get_copr_packages_list(copr.main_dir)
response = flask.Response(
stream_with_context(
helpers.stream_template(
"coprs/detail/packages.html",
copr=copr,
packages=list(packages_query),
flashes=flashes,
)))
flask.session.pop('_flashes', [])
return response
def webhooks_gitlab_push(copr_id, uuid):
# For the documentation of the data we receive see:
# https://gitlab.com/help/user/project/integrations/webhooks#events
try:
copr = ComplexLogic.get_copr_by_id_safe(copr_id)
except ObjectNotFound:
return page_not_found("Project does not exist")
if copr.webhook_secret != uuid:
return access_restricted("This webhook is not valid")
try:
payload = flask.request.json
clone_url = payload['project']['git_http_url']
commits = []
payload_commits = payload.get('commits', [])
for payload_commit in payload_commits:
commits.append({
'added': payload_commit['added'],
'modified': payload_commit['modified'],
'removed': payload_commit['removed'],
})
if payload['object_kind'] == 'tag_push':
ref_type = 'tag'
ref = os.path.basename(payload.get('ref', ''))
else:
ref_type = None
ref = payload.get('ref', '')
try:
submitter = 'gitlab.com:{}'.format(str(payload["user_username"]))
except KeyError:
submitter = None
except KeyError:
return "Bad Request", 400
packages = PackagesLogic.get_for_webhook_rebuild(copr_id, uuid, clone_url,
commits, ref_type, ref)
committish = (ref if ref_type == 'tag' else payload.get('after', ''))
for package in packages:
BuildsLogic.rebuild_package(package, {'committish': committish},
submitted_by=submitter)
db.session.commit()
return "OK", 200
def webhooks_git_push(copr_id, uuid):
if flask.request.headers["X-GitHub-Event"] == "ping":
return "OK", 200
# For the documentation of the data we receive see:
# https://developer.github.com/v3/activity/events/types/#pushevent
try:
copr = ComplexLogic.get_copr_by_id_safe(copr_id)
except ObjectNotFound:
return page_not_found("Project does not exist")
if copr.webhook_secret != uuid:
return access_restricted("This webhook is not valid")
try:
payload = flask.request.json
clone_url = payload['repository']['clone_url']
commits = []
payload_commits = payload.get('commits', [])
for payload_commit in payload_commits:
commits.append({
'added': payload_commit['added'],
'modified': payload_commit['modified'],
'removed': payload_commit['removed'],
})
ref_type = payload.get('ref_type', '')
ref = payload.get('ref', '')
try:
sender = payload['sender']['url']
except KeyError:
sender = None
except KeyError:
return "Bad Request", 400
packages = PackagesLogic.get_for_webhook_rebuild(copr_id, uuid, clone_url,
commits, ref_type, ref)
committish = (ref if ref_type == 'tag' else payload.get('after', ''))
for package in packages:
BuildsLogic.rebuild_package(package, {'committish': committish},
submitted_by=sender)
db.session.commit()
return "OK", 200
def build(self, source_dict_update, copr_dir, update_callback,
scm_object_type, scm_object_id, scm_object_url, agent_url):
if self.package.copr_dir.name != copr_dir.name:
package = PackagesLogic.get_or_create(copr_dir, self.package.name,
self.package)
else:
package = self.package
db.session.execute('LOCK TABLE build IN EXCLUSIVE MODE')
return BuildsLogic.rebuild_package(package,
source_dict_update,
copr_dir,
update_callback,
scm_object_type,
scm_object_id,
scm_object_url,
submitted_by=agent_url)
def webhooks_bitbucket_push(copr_id, uuid):
# For the documentation of the data we receive see:
# https://confluence.atlassian.com/bitbucket/event-payloads-740262817.html
try:
copr = ComplexLogic.get_copr_by_id_safe(copr_id)
except ObjectNotFound:
return page_not_found("Project does not exist")
if copr.webhook_secret != uuid:
return access_restricted("This webhook is not valid")
try:
payload = flask.request.json
api_url = payload['repository']['links']['self']['href']
clone_url = payload['repository']['links']['html']['href']
commits = []
ref_type = payload['push']['changes'][0]['new']['type']
ref = payload['push']['changes'][0]['new']['name']
try:
actor = payload['actor']['links']['html']['href']
except KeyError:
actor = None
if ref_type == 'tag':
committish = ref
else:
committish = payload['push']['changes'][0]['new']['target']['hash']
except KeyError:
return "Bad Request", 400
packages = PackagesLogic.get_for_webhook_rebuild(copr_id, uuid, clone_url,
commits, ref_type, ref)
for package in packages:
BuildsLogic.rebuild_package(package, {'committish': committish},
submitted_by=actor)
db.session.commit()
return "OK", 200
def webhooks_hello(copr_id, uuid):
try:
copr = ComplexLogic.get_copr_by_id_safe(copr_id)
except ObjectNotFound:
return page_not_found("Project does not exist")
if copr.webhook_secret != uuid:
return access_restricted("This webhook is not valid")
try:
request_json = flask.request.json
clone_url = request_json["repository"]["clone_url"]
except KeyError:
return "Bad Request", 400
packages = PackagesLogic.get_for_webhook_rebuild(copr_id, uuid, clone_url)
for package in packages:
BuildsLogic.rebuild_package(package)
db.session.commit()
return "OK", 200
def copr_list_packages(copr):
packages = PackagesLogic.get_all(copr.id)
params = get_package_record_params()
return flask.jsonify({"packages": [package.to_dict(**params) for package in packages]})
def copr_edit_package(copr, package_name, source_type):
try:
package = PackagesLogic.get(copr.id, package_name)[0]
except IndexError:
raise LegacyApiError("Package {name} does not exists in copr {copr}.".format(name=package_name, copr=copr.full_name))
return process_package_add_or_edit(copr, source_type, package=package)
def copr_list_packages(copr):
packages = PackagesLogic.get_all(copr.main_dir.id)
params = get_package_record_params()
return flask.Response(generate_package_list(packages, params),
content_type='application/json')
def copr_list_packages(copr):
packages = PackagesLogic.get_all(copr.id)
return flask.jsonify({"packages": [package.to_dict() for package in packages]})
def get_package_by_id_safe(package_id):
try:
return PackagesLogic.get_by_id(package_id).one()
except sqlalchemy.orm.exc.NoResultFound:
raise ObjectNotFound(
message="Package {} does not exist.".format(package_id))
def copr_packages(copr):
packages = PackagesLogic.get_all(copr.id)
return flask.render_template("coprs/detail/packages.html", packages=packages, copr=copr, empty_build=Build())
def copr_packages(copr):
packages_query = PackagesLogic.get_copr_packages_list(copr)
return flask.render_template("coprs/detail/packages.html",
copr=copr,
packages=packages_query)
