def add_distro():
form = anitya.forms.DistroForm()
if form.validate_on_submit():
name = form.name.data
distro = models.Distro(name)
utilities.publish_message(
distro=distro.__json__(),
topic="distro.add",
message=dict(agent=flask.g.user.username, distro=distro.name),
)
try:
Session.add(distro)
Session.commit()
flask.flash("Distribution added")
except SQLAlchemyError:
Session.rollback()
flask.flash("Could not add this distro, already exists?", "error")
return flask.redirect(flask.url_for("anitya_ui.distros"))
return flask.render_template("distro_add_edit.html",
context="Add",
current="distros",
form=form)
def delete_distro(distro_name):
""" Delete a distro """
distro = models.Distro.by_name(Session, distro_name)
if not distro:
flask.abort(404)
if not is_admin():
flask.abort(401)
form = anitya.forms.ConfirmationForm()
if form.validate_on_submit():
utilities.publish_message(
distro=distro.__json__(),
topic="distro.remove",
message=dict(agent=flask.g.user.username, distro=distro.name),
)
Session.delete(distro)
Session.commit()
flask.flash("Distro %s has been removed" % distro_name)
return flask.redirect(flask.url_for("anitya_ui.distros"))
return flask.render_template("distro_delete.html",
current="distros",
distro=distro,
form=form)
def delete_project_version(project_id, version):
project = models.Project.get(Session, project_id)
if not project:
flask.abort(404)
version_obj = None
for vers in project.versions_obj:
if version == vers.version:
version_obj = vers
break
if version_obj is None:
flask.abort(
404,
"Version %s not found for project %s" % (version, project.name))
if not is_admin():
flask.abort(401)
form = anitya.forms.ConfirmationForm()
confirm = flask.request.form.get("confirm", False)
if form.validate_on_submit():
if confirm:
utilities.publish_message(
project=project.__json__(),
topic="project.version.remove",
message=dict(agent=flask.g.user.username,
project=project.name,
version=version),
)
# Delete the record of the version for this project
Session.delete(version_obj)
# Adjust the latest_version if needed
sorted_versions = project.get_sorted_version_objects()
if len(sorted_versions
) > 1 and sorted_versions[0].version == version:
project.latest_version = sorted_versions[1].parse()
Session.add(project)
elif len(sorted_versions) == 1:
project.latest_version = None
Session.add(project)
Session.commit()
flask.flash("Version for %s has been removed" % version)
return flask.redirect(
flask.url_for("anitya_ui.project", project_id=project.id))
return flask.render_template(
"version_delete.html",
current="projects",
project=project,
version=version,
form=form,
)
def delete_project_mapping(project_id, distro_name, pkg_name):
project = models.Project.get(Session, project_id)
if not project:
flask.abort(404)
distro = models.Distro.get(Session, distro_name)
if not distro:
flask.abort(404)
package = models.Packages.get(Session, project.id, distro.name, pkg_name)
if not package:
flask.abort(404)
if not is_admin():
flask.abort(401)
form = anitya.forms.ConfirmationForm()
confirm = flask.request.form.get("confirm", False)
if form.validate_on_submit():
if confirm:
utilities.publish_message(
project=project.__json__(),
topic="project.map.remove",
message=dict(
agent=flask.g.user.username,
project=project.name,
distro=distro.name,
),
)
Session.delete(package)
Session.commit()
flask.flash("Mapping for %s has been removed" % project.name)
return flask.redirect(
flask.url_for("anitya_ui.project", project_id=project.id))
return flask.render_template(
"regex_delete.html",
current="projects",
project=project,
package=package,
form=form,
)
def delete_project_versions(project_id):
"""
Delete all versions on the project.
"""
project = models.Project.get(Session, project_id)
if not project:
flask.abort(404)
if not is_admin():
flask.abort(401)
form = anitya.forms.ConfirmationForm()
confirm = flask.request.form.get("confirm", False)
if form.validate_on_submit():
if confirm:
for version in project.versions_obj:
# Delete the record of the version for this project
Session.delete(version)
utilities.publish_message(
project=project.__json__(),
topic="project.version.remove",
message=dict(
agent=flask.g.user.username,
project=project.name,
version=str(version),
),
)
project.latest_version = None
Session.add(project)
Session.commit()
flask.flash("All versions were removed")
return flask.redirect(
flask.url_for("anitya_ui.project", project_id=project.id))
return flask.render_template(
"project_versions_delete.html",
current="projects",
project=project,
form=form,
)
def update_project(self, project_id: int) -> None:
"""
Check for updates on the specified project.
Args:
project_id: Id of project to check
"""
session = db.Session()
project = db.Project.query.filter(db.Project.id == project_id).one()
if project.backend in self.blacklist_dict:
self.blacklist_project(project,
self.blacklist_dict[project.backend])
_log.info("{}: Backend is blacklisted. Rescheduling to {}".format(
project.name, self.blacklist_dict[project.backend]))
project.next_check = self.blacklist_dict[project.backend]
session.add(project)
session.commit()
return
try:
_log.debug(f"Checking project {project.name}")
utilities.check_project_release(project, session)
except RateLimitException as err:
self.blacklist_project(project, err.reset_time)
return
except AnityaException as err:
_log.info(f"{project.name} : {str(err)}")
with self.error_counter_lock:
self.error_counter += 1
if self.is_delete_candidate(project):
session.delete(project)
utilities.publish_message(
project=project.__json__(),
topic="project.remove",
message=dict(agent="anitya", project=project.name),
)
session.commit()
return
with self.success_counter_lock:
self.success_counter += 1
def edit_distro(distro_name):
distro = models.Distro.by_name(Session, distro_name)
if not distro:
flask.abort(404)
if not is_admin():
flask.abort(401)
form = anitya.forms.DistroForm(obj=distro)
if form.validate_on_submit():
name = form.name.data
if name != distro.name:
utilities.publish_message(
distro=distro.__json__(),
topic="distro.edit",
message=dict(agent=flask.g.user.username,
old=distro.name,
new=name),
)
distro.name = name
Session.add(distro)
Session.commit()
message = "Distribution edited"
flask.flash(message)
return flask.redirect(flask.url_for("anitya_ui.distros"))
return flask.render_template(
"distro_add_edit.html",
context="Edit",
current="distros",
distro=distro,
form=form,
)
def delete_project(project_id):
project = models.Project.get(Session, project_id)
if not project:
flask.abort(404)
if not is_admin():
flask.abort(401)
project_name = project.name
form = anitya.forms.ConfirmationForm()
confirm = flask.request.form.get("confirm", False)
if form.validate_on_submit():
if confirm:
utilities.publish_message(
project=project.__json__(),
topic="project.remove",
message=dict(agent=flask.g.user.username,
project=project.name),
)
for version in project.versions_obj:
Session.delete(version)
Session.delete(project)
Session.commit()
flask.flash("Project %s has been removed" % project_name)
return flask.redirect(flask.url_for("anitya_ui.projects"))
else:
return flask.redirect(
flask.url_for("anitya_ui.project", project_id=project.id))
return flask.render_template("project_delete.html",
current="projects",
project=project,
form=form)
def post(self):
"""
Create a new package associated with an existing project and distribution.
**Example request**:
.. sourcecode:: http
POST /api/v2/packages/ HTTP/1.1
Accept: application/json
Accept-Encoding: gzip, deflate
Authorization: Token gAOFi2wQPzUJFIfDkscAKjbJfXELCz0r44m57Ur2
Connection: keep-alive
Content-Length: 120
Content-Type: application/json
Host: localhost:5000
User-Agent: HTTPie/0.9.4
{
"distribution": "Fedora",
"package_name": "python-requests",
"project_ecosystem": "pypi",
"project_name": "requests"
}
.. sourcecode:: http
HTTP/1.0 201 CREATED
Content-Length: 69
Content-Type: application/json
Date: Mon, 15 Jan 2018 21:49:01 GMT
Server: Werkzeug/0.14.1 Python/2.7.14
{
"distribution": "Fedora",
"name": "python-requests"
}
:reqheader Authorization: API token to use for authentication
:reqjson string distribution: The name of the distribution that contains this
package.
:reqjson string package_name: The name of the package in the distribution repository.
:reqjson string project_name: The project name in Anitya.
:reqjson string project_ecosystem: The ecosystem the project is a part of.
If it's not part of an ecosystem, use the homepage used in the Anitya project.
:statuscode 201: When the package was successfully created.
:statuscode 400: When required arguments are missing or malformed.
:statuscode 401: When your access token is missing or invalid
:statuscode 409: When the package already exists.
"""
distribution_help = _(
"The name of the distribution that contains this package.")
package_name_help = _(
"The name of the package in the distribution repository.")
project_name_help = _("The project name in Anitya.")
project_ecosystem_help = _(
"The ecosystem the project is a part of. If it's not part of an ecosystem,"
" use the homepage used in the Anitya project.")
parser = _BASE_ARG_PARSER.copy()
parser.add_argument("distribution",
type=str,
help=distribution_help,
required=True)
parser.add_argument("package_name",
type=str,
help=package_name_help,
required=True)
parser.add_argument("project_name",
type=str,
help=project_name_help,
required=True)
parser.add_argument("project_ecosystem",
type=str,
help=project_ecosystem_help,
required=True)
args = parser.parse_args(strict=True)
try:
project = models.Project.query.filter(
func.lower(models.Project.name) == func.lower(
args.project_name),
func.lower(models.Project.ecosystem_name) == func.lower(
args.project_ecosystem),
).one()
except NoResultFound:
return (
{
"error":
'Project "{}" in ecosystem "{}" not found'.format(
args.project_name, args.project_ecosystem)
},
400,
)
try:
distro = models.Distro.query.filter(
func.lower(models.Distro.name) == func.lower(
args.distribution)).one()
except NoResultFound:
return (
{
"error":
'Distribution "{}" not found'.format(args.distribution)
},
400,
)
try:
package = models.Packages(distro_name=distro.name,
project=project,
package_name=args.package_name)
Session.add(package)
Session.commit()
message = dict(
agent=flask_login.current_user.email,
project=project.name,
distro=distro.name,
new=package.package_name,
)
utilities.publish_message(
project=project.__json__(),
distro=distro.__json__(),
topic="project.map.new",
message=message,
)
return {
"distribution": distro.name,
"name": package.package_name
}, 201
except IntegrityError:
Session.rollback()
return {"error": "package already exists in distribution"}, 409
