+ """

+ Add reviewed_outdated_chroot table

+ 

+ Revision ID: 9b7211be5017

+ Revises: de903581465c

+ Create Date: 2020-10-08 11:27:27.588111

+ """

+ 

+ import sqlalchemy as sa

+ from alembic import op

+ 

+ 

+ revision = '9b7211be5017'

+ down_revision = '63db6872060f'

+ 

+ def upgrade():

+     op.create_table('reviewed_outdated_chroot',

+     sa.Column('id', sa.Integer(), nullable=False),

+     sa.Column('user_id', sa.Integer(), nullable=False),

+     sa.Column('copr_chroot_id', sa.Integer(), nullable=False),

+     sa.ForeignKeyConstraint(['copr_chroot_id'], ['copr_chroot.id'], ondelete='CASCADE'),

+     sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),

+     sa.PrimaryKeyConstraint('id')

+     )

+     op.create_index(op.f('ix_reviewed_outdated_chroot_user_id'), 'reviewed_outdated_chroot', ['user_id'], unique=False)

+ 

+ 

+ def downgrade():

+     op.drop_index(op.f('ix_reviewed_outdated_chroot_user_id'), table_name='reviewed_outdated_chroot')

+     op.drop_table('reviewed_outdated_chroot')

+     ownername = wtforms.HiddenField("Owner name")

+     projectname = wtforms.HiddenField("Project name")

+                         user.username, include_unlisted_on_hp=False)).all()

+ import flask

+ from datetime import datetime, timedelta

+ from coprs import db

+ from coprs import app

+ from coprs import models

+ from coprs.logic.complex_logic import ComplexLogic

+ from coprs.logic.coprs_logic import CoprChrootsLogic

+ 

+ 

+ class OutdatedChrootsLogic:

+     @classmethod

+     def has_not_reviewed(cls, user):

+         """

+         Does a user have some projects with newly outdated chroots that he

+         hasn't reviewed yet?

+         """

+         projects = ComplexLogic.get_coprs_permissible_by_user(user)

+         projects_ids = [p.id for p in projects]

+         period = app.config["EOL_CHROOTS_NOTIFICATION_PERIOD"]

+         now = datetime.now()

+         soon = now + timedelta(days=period)

+ 

+         reviewed = [x.copr_chroot_id for x in cls.get_all_reviews(user).all()]

+         return bool((models.CoprChroot.query

+                      .filter(models.CoprChroot.copr_id.in_(projects_ids))

+                      .filter(models.CoprChroot.delete_after != None)

+                      .filter(models.CoprChroot.delete_after <= soon)

+                      .filter(models.CoprChroot.delete_after > now)

+                      .filter(models.CoprChroot.id.notin_(reviewed))

+                      .first()))

+ 

+     @classmethod

+     def get_all_reviews(cls, user):

+         """

+         Query all outdated chroots that a user has already seen

+         """

+         return (models.ReviewedOutdatedChroot.query

+                 .filter(models.ReviewedOutdatedChroot.user_id == user.id))

+ 

+     @classmethod

+     def make_review(cls, user):

+         """

+         A `user` declares that he has seen and reviewed all outdated chroots in

+         all of his projects (i.e. this method creates `ReviewedOutdatedChroot`

+         results for all of them)

+         """

+         reviews = {x.copr_chroot_id for x in cls.get_all_reviews(user)}

+         for copr in ComplexLogic.get_coprs_permissible_by_user(user):

+             for chroot in copr.outdated_chroots:

+                 if chroot.id in reviews:

+                     continue

+ 

+                 period = app.config["EOL_CHROOTS_NOTIFICATION_PERIOD"]

+                 if chroot.delete_after_days > period:

+                     continue

+ 

+                 review = models.ReviewedOutdatedChroot(

+                     user_id=user.id,

+                     copr_chroot_id=chroot.id,

+                 )

+                 db.session.add(review)

+ 

+     @classmethod

+     def extend(cls, copr_chroot):

+         """

+         A `user` decided to extend the preservation period for some EOL chroot

+         """

+         delete_after_days = app.config["DELETE_EOL_CHROOTS_AFTER"] + 1

+         cls._update_copr_chroot(copr_chroot, delete_after_days)

+         (models.ReviewedOutdatedChroot.query

+          .filter(models.ReviewedOutdatedChroot.copr_chroot_id

+                  == copr_chroot.id)).delete()

+ 

+     @classmethod

+     def expire(cls, copr_chroot):

+         """

+         A `user` decided to expire some EOL chroot,

+         i.e. its data should be deleted ASAP

+         """

+         delete_after_days = 0

+         cls._update_copr_chroot(copr_chroot, delete_after_days)

+ 

+     @classmethod

+     def _update_copr_chroot(cls, copr_chroot, delete_after_days):

+         delete_after_timestamp = (

+             datetime.now()

+             + timedelta(days=delete_after_days)

+         )

+         CoprChrootsLogic.update_chroot(flask.g.user, copr_chroot,

+                                        delete_after=delete_after_timestamp)

+ class ReviewedOutdatedChroot(db.Model):

+     id = db.Column(db.Integer, primary_key=True)

+ 

+     user_id = db.Column(

+         db.Integer,

+         db.ForeignKey("user.id"),

+         nullable=False,

+         index=True,

+     )

+     copr_chroot_id = db.Column(

+         db.Integer,

+         db.ForeignKey("copr_chroot.id", ondelete="CASCADE"),

+         nullable=False,

+     )

+ 

+     user = db.relationship(

+         "User",

+         backref=db.backref("reviewed_outdated_chroots"),

+     )

+     copr_chroot = db.relationship(

+         "CoprChroot",

+         backref=db.backref("reviewed_outdated_chroots")

+     )

+ 

+ 

+   {{ message |safe }}

+ {% extends "coprs/show.html" %}

+ {% from "_helpers.html" import copr_url, render_form_errors %}

+ {% block title %}Outdated repositories{% endblock %}

+ {% block header %}Outdated repositories{% endblock %}

+ {% block breadcrumbs %}

+ <ol class="breadcrumb">

+     <li>

+         <a href="{{ url_for('coprs_ns.coprs_show') }}">Home</a>

+     </li>

+     <li>

+         {% if owner.at_name is defined %}

+         <a href="{{ url_for('groups_ns.list_projects_by_group', group_name=owner.name) }}">{{ owner.at_name }}</a>

+         {% else %}

+         <a href="{{ url_for('coprs_ns.coprs_by_user', username=owner.name) }}">{{ owner.name }}</a>

+         {% endif %}

+     </li>

+     <li class="active">

+         {{ owner.name }} repositories

+     </li>

+ </ol>

+ {% endblock %}

+ 

+ 

+ {% block content %}

+ <h1 style="margin-bottom:22px;margin-top:22px">Outdated repositories</h1>

+ <p>

+     These projects have available repositories for at least some outdated chroots.

+     Unless you periodically take an action and extend the time for they should be preserved,

+     they are going to be removed in the future. Please see

+     <a href="#">Outdated repos removal policy</a>

+     in the Copr Documentation.

+ </p>

+ 

+ {% if form %}

+ {{ render_form_errors(form=form) }}

+ {% endif %}

+ 

+ {% for project in projects %}

+ {% if project.outdated_chroots %}

+ <form action="" method="POST">

+     <h3><a href="{{ copr_url('coprs_ns.copr_detail', project) }}">{{ project.full_name }}</a></h3>

+     <table class="table table-bordered">

+         <thead>

+             <tr>

+                 <th class="col-md-2">Release</th>

+                 <th class="col-md-2">Architecture</th>

+                 <th>Remaining time</th>

+                 <th class="col-md-3">Action</th>

+             </tr>

+         </thead>

+         <tbody>

+             {% for chroot in project.outdated_chroots %}

+             <tr>

+                 <td>{{ chroot.mock_chroot.os.capitalize() }}</td>

+                 <td>{{ chroot.mock_chroot.arch }}</td>

+                 <td>

+                     {% if not chroot.delete_after_days %}

+                     To be removed in next cleanup

+                     {% else %}

+                     {% set color = 'danger' if chroot.delete_after_days < 20 else 'secondary' %}

+                     <span class="text-{{ color }}">

+                         {{ chroot.delete_after_days }} days

+                     </span>

+                     {% endif %}

+                 </td>

+                 <td>

+                     <button name="extend" class="btn btn-primary" type="submit" value="{{ chroot.mock_chroot.name }}">

+                         Extend

+                     </button>

+                     <button name="expire" class="btn btn-danger" type="submit" value="{{ chroot.mock_chroot.name }}"

+                         {% if not chroot.delete_after_days %} disabled="disabled" {% endif %}>Expire now

+                     </button>

+                 </td>

+             </tr>

+             {% endfor %}

+         </tbody>

+     </table>

+ 

+     <input type="hidden" name="ownername" value="{{ project.owner_name }}">

+     <input type="hidden" name="projectname" value="{{ project.name }}">

+ </form>

+ {% endif %}

+ {% endfor %}

+ 

+ {% endblock %}

+ from coprs.logic.outdated_chroots_logic import OutdatedChrootsLogic

+ 

+ 

+ def flash_outdated_chroots_warning():

+     if not flask.g.user:

+         return

+ 

+     if not OutdatedChrootsLogic.has_not_reviewed(flask.g.user):

+         return

+ 

+     url = flask.url_for("user_ns.repositories", _external=True)

+     flask.flash("Some of the chroots you maintain are <b>newly marked EOL</b>, "

+                 " and will be removed in the future. Please review "

+                 "<a href='{0}'>{0}</a> to hide this warning."

+                 .format(url), "warning")

+ coprs_ns.before_request(flash_outdated_chroots_warning)

+ from coprs.logic.outdated_chroots_logic import OutdatedChrootsLogic

+     return process_copr_repositories(copr, render_copr_repositories)

+ 

+ 

+ def process_copr_repositories(copr, on_success):

+     form = forms.CoprChrootExtend()

+     if not copr and not (form.ownername.data or form.projectname.data):

+         raise ValidationError("Ambiguous to what project the chroot belongs")

+ 

+     if not copr:

+         copr = ComplexLogic.get_copr_by_owner_safe(form.ownername.data,

+                                                    form.projectname.data)

+         update_fun = OutdatedChrootsLogic.extend

+         update_fun = OutdatedChrootsLogic.expire

+     update_fun(copr_chroot)

+     return on_success(copr)

+ from coprs.logic.coprs_logic import PinnedCoprsLogic

+ from coprs.logic.outdated_chroots_logic import OutdatedChrootsLogic

+ from coprs.views.coprs_ns.coprs_general import process_copr_repositories

+ from . import user_ns

+ 

+ 

+ @user_ns.route("/repositories/")

+ @login_required

+ def repositories():

+     return render_repositories()

+ 

+ 

+ def render_repositories(*_args, **_kwargs):

+     owner = flask.g.user

+     projects = ComplexLogic.get_coprs_permissible_by_user(owner)

+     projects = sorted(projects, key=lambda p: p.full_name)

+     OutdatedChrootsLogic.make_review(owner)

+     db.session.commit()

+     return flask.render_template("repositories.html",

+                                  tasks_info=ComplexLogic.get_queue_sizes(),

+                                  graph=BuildsLogic.get_small_graph_data('30min'),

+                                  owner=owner,

+                                  projects=projects)

+ 

+ 

+ @user_ns.route("/repositories/", methods=["POST"])

+ @login_required

+ def repositories_post():

+     return process_copr_repositories(copr=None, on_success=render_repositories)

+ import flask

+ import pytest

+ from datetime import datetime, timedelta

+ from tests.coprs_test_case import CoprsTestCase, new_app_context

+ from coprs.logic.outdated_chroots_logic import OutdatedChrootsLogic

+ from coprs.logic.complex_logic import ComplexLogic

+ 

+ 

+ class TestOutdatedChrootsLogic(CoprsTestCase):

+ 

+     @new_app_context

+     @pytest.mark.usefixtures("f_users", "f_coprs", "f_mock_chroots", "f_db")

+     def test_outdated_chroots_simple(self):

+         # Make sure, that there are no unreviewed outdated chroots yet

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+         # Once a chroot is EOLed, we should see that a user has something unreviewed

+         self.c2.copr_chroots[0].delete_after = datetime.now() + timedelta(days=10)

+         assert OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+         # User just reviewed his outdated chroots

+         # (e.g. by visiting the /repositories page)

+         OutdatedChrootsLogic.make_review(self.u2)

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+     @new_app_context

+     @pytest.mark.usefixtures("f_users", "f_groups", "f_group_copr", "f_db")

+     def test_outdated_chroots_group(self):

+         # Make sure that a user is a part of a group

+         self.u3.openid_groups = {"fas_groups": [self.g1.fas_name]}

+         assert self.u3.can_build_in_group(self.g1)

+ 

+         # Make sure a project is owned by a group but not by our user himself

+         permissible = ComplexLogic.get_coprs_permissible_by_user(self.u3)

+         assert self.gc2 in permissible

+         assert self.gc2.user != self.u3

+ 

+         # Make sure, that there are no unreviewed outdated chroots yet

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u3)

+ 

+         # Once a chroot is EOLed, we should see that a user has something unreviewed

+         self.gc2.copr_chroots[0].delete_after = datetime.now() + timedelta(days=10)

+         assert OutdatedChrootsLogic.has_not_reviewed(self.u3)

+ 

+         # User just reviewed his outdated chroots

+         # (e.g. by visiting the /repositories page)

+         OutdatedChrootsLogic.make_review(self.u3)

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u3)

+ 

+         # Only a `self.u3` did the review, other group members still has

+         # unreviewed chroots

+         self.u2.openid_groups = {"fas_groups": [self.g1.fas_name]}

+         assert OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+     @new_app_context

+     @pytest.mark.usefixtures("f_users", "f_coprs", "f_mock_chroots", "f_db")

+     def test_outdated_chroots_flash_not_immediately(self):

+         # Make sure, that there are no unreviewed outdated chroots yet

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+         # A chroot was just marked as EOL, we don't want to see any warning just yet

+         self.c2.copr_chroots[0].delete_after = datetime.now() + timedelta(days=180)

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+         # Once around half of the preservation period for an EOLed chroot

+         # runned out, we want to start showing some notification

+         self.c2.copr_chroots[0].delete_after = datetime.now() + timedelta(days=80)

+         assert OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+     @new_app_context

+     @pytest.mark.usefixtures("f_users", "f_coprs", "f_mock_chroots", "f_db")

+     def test_outdated_chroots_flash_not_expired(self):

+         # A preservation period is gone and the chroot is scheduled to be

+         # deleted ASAP. At this point, user has no chance to extend it anymore,

+         # so make sure we don't notify him about such chroots

+         self.c2.copr_chroots[0].delete_after = datetime.now() - timedelta(days=1)

+         assert not OutdatedChrootsLogic.has_not_reviewed(self.u2)

+ 

+     @new_app_context

+     @pytest.mark.usefixtures("f_users", "f_coprs", "f_mock_chroots", "f_db")

+     def test_outdated_chroots_review_only_after_some_time(self):

+         # Make sure that `self.u2` hasn't reviewed anything yet

+         assert not OutdatedChrootsLogic.get_all_reviews(self.u2).all()

+ 

+         # Some chroots are going to be deleted, with various times remaining

+         self.c2.copr_chroots[0].delete_after = datetime.now() + timedelta(days=35)

+         self.c2.copr_chroots[1].delete_after = datetime.now() + timedelta(days=160)

+         self.c3.copr_chroots[0].delete_after = datetime.now() + timedelta(days=80)

+         self.c3.copr_chroots[1].delete_after = datetime.now() + timedelta(days=50)

+ 

+         # User just reviewed his outdated chroots

+         # (e.g. by visiting the /repositories page)

+         OutdatedChrootsLogic.make_review(self.u2)

+         reviews = OutdatedChrootsLogic.get_all_reviews(self.u2).all()

+ 

+         # Make sure that not all EOL chroots have been reviewed. We want to

+         # review only those with a significant portion of the preservation

+         # period already run out.

+         assert len(reviews) == 3

+         assert self.c2.copr_chroots[1] not in [x.copr_chroot for x in reviews]

+         assert {x.copr_chroot for x in reviews} == {

+             self.c2.copr_chroots[0],

+             self.c3.copr_chroots[0],

+             self.c3.copr_chroots[1],

+         }

+ 

+     @new_app_context

+     @pytest.mark.usefixtures("f_users", "f_coprs", "f_mock_chroots", "f_db")

+     def test_outdated_chroots_extend_or_expire(self):

+         # Make sure that `self.u2` hasn't reviewed anything yet

+         assert len(OutdatedChrootsLogic.get_all_reviews(self.u2).all()) == 0

+ 

+         # Let's have some outdated chroot

+         self.c2.copr_chroots[0].delete_after = datetime.now() + timedelta(days=35)

+ 

+         # Make sure a user reviewed it

+         OutdatedChrootsLogic.make_review(self.u2)

+         assert len(OutdatedChrootsLogic.get_all_reviews(self.u2).all()) == 1

+ 

+         # Extend should properly extend the preservation period

+         # and drop the review

+         flask.g.user = self.u2

+         OutdatedChrootsLogic.extend(self.c2.copr_chroots[0])

+         assert (self.c2.copr_chroots[0].delete_after

+                 > datetime.now() + timedelta(days=35))

+         assert len(OutdatedChrootsLogic.get_all_reviews(self.u2).all()) == 0

+ 

+         # User changed his mind and expired the chroot instead

+         OutdatedChrootsLogic.expire(self.c2.copr_chroots[0])

+         assert (self.c2.copr_chroots[0].delete_after.date()

+                 == datetime.now().date())