TT#121955 update Django 3.1

* models.JSONField
  https://docs.djangoproject.com/en/3.1/releases/3.1/#jsonfield-for-all-supported-database-backends
  Now returns a str() instead of a dict()

* no need to pin psycop2
  https://docs.djangoproject.com/en/3.1/releases/3.1/#database-backend-api
  "connection.timezone property is now 'UTC' by default, or the
  TIME_ZONE when USE_TZ is True on databases that support time zones.
  Previously, it was None on databases that support time zones."

* rework signal receivers

Change-Id: I4e1c6f780c416c7e2f2e1c7ba6154f25e4bd8c5a
pull/5/head
Victor Seva 3 years ago
parent 8a89cdfc56
commit 29e328b069

@ -1,4 +1,4 @@
# Copyright (C) 2017 The Sipwise Team - http://sipwise.com
# Copyright (C) 2017-2022 The Sipwise Team - http://sipwise.com
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
@ -17,3 +17,7 @@ from django.apps import AppConfig
class ReleaseConfig(AppConfig):
name = "build"
def ready(self):
# Implicitly connect a signal handlers decorated with @receiver.
from . import signals # noqa

@ -1,4 +1,4 @@
# Copyright (C) 2017-2020 The Sipwise Team - http://sipwise.com
# Copyright (C) 2017-2022 The Sipwise Team - http://sipwise.com
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
@ -12,71 +12,5 @@
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
import logging
from datetime import timedelta
from django.db.models import signals
from django.utils import timezone
from ..conf import settings
from .br import BuildRelease
from build.tasks import build_release
from build.tasks import build_resume
from repoapi.models import JenkinsBuildInfo
logger = logging.getLogger(__name__)
def br_manage(sender, **kwargs):
if kwargs["created"]:
instance = kwargs["instance"]
if instance.release.endswith("-update"):
build_resume.delay(instance.pk)
logger.debug("BuildRelease:%s triggered", instance)
elif timezone.now() > instance.start_date + timedelta(minutes=15):
logger.debug(
"BuildRelease:%s not triggered, is from the past:%s",
instance,
instance.start_date,
)
else:
build_release.delay(instance.pk)
logger.debug("BuildRelease:%s triggered", instance)
def jbi_manage(sender, **kwargs):
if not kwargs["created"]:
return
jbi = kwargs["instance"]
if not jbi.is_job_url_allowed():
return
if jbi.param_release_uuid is None:
return
release = jbi.param_release
if jbi.jobname in settings.BUILD_RELEASE_JOBS:
if not release.startswith("release-"):
release = "release-{}".format(jbi.param_release)
if jbi.param_release_uuid in [None, "none", ""]:
logger.debug(
"jbi release:%s release_uuid:%s, no ReleaseBuild link, skip",
jbi.param_release,
jbi.param_release_uuid,
)
return
try:
br = BuildRelease.objects.get(uuid=jbi.param_release_uuid,)
except BuildRelease.DoesNotExist:
logger.error(
"BuildRelease:%s not found", jbi.param_release_uuid,
)
return
if not br.append_built(jbi):
logger.debug("BuildRelease:%s jbi:%s skip", br, jbi)
return
br.remove_triggered(jbi)
build_resume.delay(br.id)
post_save = signals.post_save.connect
post_save(br_manage, sender=BuildRelease)
post_save(jbi_manage, sender=JenkinsBuildInfo)
from .br import BuildRelease # noqa
from repoapi.models import JenkinsBuildInfo # noqa

@ -0,0 +1,79 @@
# Copyright (C) 2022 The Sipwise Team - http://sipwise.com
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
from datetime import timedelta
import structlog
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils import timezone
from .conf import settings
from .models.br import BuildRelease
from build.tasks import build_release
from build.tasks import build_resume
from repoapi.models import JenkinsBuildInfo
logger = structlog.get_logger(__name__)
@receiver(post_save, sender=BuildRelease, dispatch_uid="build_br_manage")
def br_manage(sender, **kwargs):
if kwargs["created"]:
instance = kwargs["instance"]
if instance.release.endswith("-update"):
build_resume.delay(instance.pk)
logger.debug("BuildRelease:%s triggered", instance)
elif timezone.now() > instance.start_date + timedelta(minutes=15):
logger.debug(
"BuildRelease:%s not triggered, is from the past:%s",
instance,
instance.start_date,
)
else:
build_release.delay(instance.pk)
logger.debug("BuildRelease:%s triggered", instance)
@receiver(post_save, sender=JenkinsBuildInfo, dispatch_uid="build_jbi_manage")
def jbi_manage(sender, **kwargs):
if not kwargs["created"]:
return
jbi = kwargs["instance"]
if not jbi.is_job_url_allowed():
return
if jbi.param_release_uuid is None:
return
release = jbi.param_release
log = logger.bind(
release_uuid=jbi.param_release_uuid, release=jbi.param_release
)
if jbi.jobname in settings.BUILD_RELEASE_JOBS:
if not release.startswith("release-"):
release = "release-{}".format(jbi.param_release)
if jbi.param_release_uuid in [None, "none", ""]:
log.debug("no ReleaseBuild link, skip")
return
try:
br = BuildRelease.objects.get(
uuid=jbi.param_release_uuid,
)
except BuildRelease.DoesNotExist:
log.error("BuildRelease not found")
return
if not br.append_built(jbi):
log.debug("BuildRelease:%s jbi:%s skip", br, jbi)
return
br.remove_triggered(jbi)
build_resume.delay(br.id)

@ -391,7 +391,7 @@ class BuildReleaseStepsTest(BaseTest):
@override_settings(JBI_ALLOWED_HOSTS=["fake.local"])
@patch("repoapi.utils.dlfile")
@patch("build.models.build_resume")
@patch("build.signals.build_resume")
class JBIManageTest(BaseTest):
fixtures = ["test_models"]
release = "release-mr8.1"
@ -467,7 +467,7 @@ class BRManageTest(BaseTest):
fixtures = ["test_models"]
@patch("build.tasks.trigger_copy_deps")
@patch("build.models.build_resume")
@patch("build.signals.build_resume")
def test_br_manage(self, build_resume, trigger_copy_deps):
br = BuildRelease.objects.create_build_release("UUID", "mr7.5")
build_resume.delay.assert_not_called()
@ -476,7 +476,7 @@ class BRManageTest(BaseTest):
)
@patch("build.tasks.trigger_copy_deps")
@patch("build.models.build_resume")
@patch("build.signals.build_resume")
def test_br_manage_ko(self, build_resume, trigger_copy_deps):
br = BuildRelease.objects.create_build_release("UUID1", "mr8.1")
build_resume.delay.assert_called_once_with(br.id)

@ -0,0 +1,28 @@
# Generated by Django 3.1.14 on 2022-01-19 08:47
from django.db import migrations
from django.db import models
class Migration(migrations.Migration):
dependencies = [
("release_dashboard", "0003_dockertag_reference"),
]
operations = [
migrations.AlterField(
model_name="dockertag",
name="manifests",
field=models.JSONField(),
),
migrations.AlterField(
model_name="project",
name="json_branches",
field=models.JSONField(null=True),
),
migrations.AlterField(
model_name="project",
name="json_tags",
field=models.JSONField(null=True),
),
]

@ -1,4 +1,4 @@
# Copyright (C) 2016 The Sipwise Team - http://sipwise.com
# Copyright (C) 2016-2022 The Sipwise Team - http://sipwise.com
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
@ -19,7 +19,6 @@ from datetime import datetime
from django.db import models
from django_extensions.db.fields import ModificationDateTimeField
from django_extensions.db.fields.json import JSONField
from .conf import settings
@ -28,12 +27,14 @@ logger = logging.getLogger(__name__)
class Project(models.Model):
name = models.CharField(max_length=50, unique=True, null=False)
json_tags = JSONField(null=True)
json_branches = JSONField(null=True)
json_tags = models.JSONField(null=True)
json_branches = models.JSONField(null=True)
modified = ModificationDateTimeField(null=True)
@classmethod
def _filter_values(cls, values, val_ok_filter, regex=None):
if values is None:
return list()
res = set()
for value in values:
@ -50,7 +51,7 @@ class Project(models.Model):
@classmethod
def _get_filtered_json(cls, text):
"""gerrit responds with malformed json
https://gerrit-review.googlesource.com/Documentation/rest-api.html#output
https://gerrit-review.googlesource.com/Documentation/rest-api.html#output
"""
return json.loads(text[5:])
@ -125,7 +126,7 @@ class DockerImage(models.Model):
class DockerTag(models.Model):
name = models.CharField(max_length=50, null=False)
manifests = JSONField(null=False)
manifests = models.JSONField(null=False)
image = models.ForeignKey(DockerImage, on_delete=models.CASCADE)
reference = models.CharField(max_length=150, unique=True, null=False)
@ -139,10 +140,17 @@ class DockerTag(models.Model):
def date(self):
if self.manifests is None:
return None
if isinstance(self.manifests, dict):
manifests = self.manifests
else:
try:
manifests = json.loads(self.manifests)
except json.JSONDecodeError:
return None
try:
value = self.manifests["history"][0]["v1Compatibility"]
value = manifests["history"][0]["v1Compatibility"]
time = json.loads(value)
created = time["created"].split(".")
return datetime.strptime(created[0], "%Y-%m-%dT%H:%M:%S")
except Exception:
except json.JSONDecodeError:
return None

@ -11,7 +11,7 @@
# more details.
#
# You should have received a copy of the GNU General Public License along
# with this prograproj. If not, see <http://www.gnu.org/licenses/>.
# with this program. If not, see <http://www.gnu.org/licenses/>.
import copy
from django.test import TestCase
@ -82,6 +82,10 @@ class ProjectTestCase(TestCase):
res = Project._get_filtered_json(GERRIT_REST_TAGS)
self.assertEqual(res, FILTERED_TAGS)
def test_filter_values_null(self):
res = Project._filter_values(None, "^refs/tags/(.+)$")
self.assertIsInstance(res, list)
def test_filter_values(self):
values = copy.deepcopy(FILTERED_TAGS)
res = Project._filter_values(FILTERED_TAGS, "^refs/tags/(.+)$")

@ -11,7 +11,7 @@
# more details.
#
# You should have received a copy of the GNU General Public License along
# with this prograproj. If not, see <http://www.gnu.org/licenses/>.
# with this program. If not, see <http://www.gnu.org/licenses/>.
import datetime
from release_dashboard.models import DockerImage

@ -13,10 +13,10 @@
# You should have received a copy of the GNU General Public License along
# with this prograproj. If not, see <http://www.gnu.org/licenses/>.
import uuid
from unittest.mock import call
from unittest.mock import patch
from django.test import override_settings
from mock import call
from mock import patch
from release_dashboard import tasks
from release_dashboard.models import DockerImage
@ -156,7 +156,10 @@ class TasksDockerTestCase(BaseTest):
name="data-hal-jessie", project=proj
)
tag = DockerTag.objects.create(
name="latest", image=image, reference=uuid.uuid4()
name="latest",
image=image,
reference=uuid.uuid4(),
manifests=dict(),
)
result = tasks.docker_remove_tag.delay("data-hal-jessie", "latest")
self.assertTrue(result.successful())

@ -13,7 +13,21 @@
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
from django.apps import AppConfig
from django.db.models.signals import post_save
class RepoAPIConfig(AppConfig):
name = "repoapi"
def ready(self):
from .conf import settings
# Implicitly connect a signal handlers decorated with @receiver.
from . import signals
if settings.WORKFRONT_NOTE:
post_save.connect(
signals.workfront_note_manage,
sender="repoapi.JenkinsBuildInfo",
dispatch_uid="workfront_note_manage",
)

@ -12,18 +12,6 @@
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models import signals
from .gri import gerrit_repo_manage
from .gri import GerritRepoInfo # noqa
from .jbi import jbi_manage
from .jbi import JenkinsBuildInfo
from .wni import workfront_note_manage
from .jbi import JenkinsBuildInfo # noqa
from .wni import WorkfrontNoteInfo # noqa
from repoapi.conf import settings
post_save = signals.post_save.connect
post_save(jbi_manage, sender=JenkinsBuildInfo)
post_save(gerrit_repo_manage, sender=JenkinsBuildInfo)
if settings.WORKFRONT_NOTE:
post_save(workfront_note_manage, sender=JenkinsBuildInfo)

@ -12,14 +12,8 @@
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
import structlog
from django.db import models
from repoapi import utils
from repoapi.tasks import jenkins_remove_project
logger = structlog.get_logger(__name__)
class GerritRepoInfo(models.Model):
param_ppa = models.CharField(max_length=50, null=False)
@ -33,84 +27,3 @@ class GerritRepoInfo(models.Model):
return "{}:{}:{}".format(
self.param_ppa, self.gerrit_change, self.projectname
)
def gerrit_repo_add(instance):
log = logger.bind(
instance=str(instance),
)
if instance.param_ppa == "$ppa":
log.warn("ppa unset, skip removal")
return
gri = GerritRepoInfo.objects
ppa, created = gri.get_or_create(
param_ppa=instance.param_ppa,
gerrit_change=instance.gerrit_change,
defaults={"projectname": instance.projectname},
)
if created:
log.debug("ppa created", ppa=str(ppa))
elif ppa.projectname == "unknown":
ppa.projectname = instance.projectname
ppa.save()
log.info("ppa projectname updated")
def gerrit_repo_del(instance):
log = logger.bind(
instance=str(instance),
)
if instance.param_ppa == "$ppa":
log.warn("ppa unset, skip removal")
return
gri = GerritRepoInfo.objects
try:
ppa = gri.get(
param_ppa=instance.param_ppa, gerrit_change=instance.gerrit_change
)
ppa.delete()
log.debug("removed ppa", ppa=str(ppa))
except GerritRepoInfo.DoesNotExist:
pass
qs = gri.filter(param_ppa=instance.param_ppa)
ppa_count = qs.count()
project_ppa_count = qs.filter(projectname=instance.projectname).count()
if ppa_count == 0:
utils.jenkins_remove_ppa(instance.param_ppa)
elif project_ppa_count == 0:
log.debug("remove source+packages from ppa")
jenkins_remove_project.delay(instance.id)
else:
log.debug(
"nothing to do here",
ppa_count=ppa_count,
project_ppa_count=project_ppa_count,
)
def gerrit_repo_manage(sender, **kwargs):
if kwargs["created"]:
instance = kwargs["instance"]
log = logger.bind(
instance=str(instance),
ppa=instance.param_ppa,
)
if instance.param_ppa == "$ppa":
log.warn("ppa unset, skip")
return
if (
instance.jobname.endswith("-repos")
and instance.result == "SUCCESS"
):
logger.debug("we need to count this")
if instance.gerrit_eventtype == "patchset-created":
gerrit_repo_add(instance)
elif instance.gerrit_eventtype == "change-merged":
gerrit_repo_del(instance)
elif (
instance.jobname.endswith("-cleanup")
and instance.result == "SUCCESS"
and instance.gerrit_eventtype == "change-abandoned"
):
log.debug("we need to count this")
gerrit_repo_del(instance)

@ -28,7 +28,6 @@ from django.forms.models import model_to_dict
from debian import deb822
from repoapi.conf import settings
from repoapi.tasks import get_jbi_files
logger = structlog.get_logger(__name__)
workfront_re = re.compile(r"TT#(\d+)")
@ -288,12 +287,3 @@ class JenkinsBuildInfo(models.Model):
d = deb822.Dsc(f)
self._source = d["Source"]
return self._source
def jbi_manage(sender, **kwargs):
if kwargs["created"]:
instance = kwargs["instance"]
if instance.is_job_url_allowed():
get_jbi_files.delay(
instance.pk, instance.jobname, instance.buildnumber
)

@ -12,16 +12,10 @@
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
import logging
import re
from django.db import models
from release_dashboard.utils.build import is_ngcp_project
from repoapi import utils
from repoapi.conf import settings
logger = logging.getLogger(__name__)
workfront_re = re.compile(r"TT#(\d+)")
workfront_re_branch = re.compile(r"^mr[0-9]+\.[0-9]+\.[0-9]+$")
commit_re = re.compile(r"^(\w{7}) ")
@ -59,67 +53,3 @@ class WorkfrontNoteInfo(models.Model):
def __str__(self):
return "%s:%s" % (self.workfront_id, self.gerrit_change)
def workfront_release_target(instance, wid):
if not is_ngcp_project(instance.projectname):
logger.info(
"%s not a NGCP project, skip release_target", instance.projectname
)
return
branch = instance.param_branch
if workfront_re_branch.search(branch):
release = branch
else:
release = utils.get_next_release(branch)
if release:
utils.workfront_set_release_target(wid, release)
def workfront_note_add(instance, message, release_target=False):
wni = WorkfrontNoteInfo.objects
workfront_ids = WorkfrontNoteInfo.getIds(instance.git_commit_msg)
for wid in workfront_ids:
if not instance.gerrit_eventtype:
change = WorkfrontNoteInfo.getCommit(instance.git_commit_msg)
url = settings.GITWEB_URL.format(instance.projectname, change)
eventtype = "git-commit"
else:
change = instance.gerrit_change
url = settings.GERRIT_URL.format(instance.gerrit_change)
eventtype = instance.gerrit_eventtype
note, created = wni.get_or_create(
workfront_id=wid, gerrit_change=change, eventtype=eventtype
)
if created:
if not utils.workfront_note_send(wid, "%s %s " % (message, url)):
logger.error("remove related WorkfrontNoteInfo")
note.delete()
if release_target:
workfront_release_target(instance, wid)
def workfront_note_manage(sender, **kwargs):
"""
<name>-get-code job is the first in the flow that has the proper
GIT_CHANGE_SUBJECT envVar set, so git_commit_msg is fine
"""
if kwargs["created"]:
instance = kwargs["instance"]
if instance.result != "SUCCESS":
return
if instance.jobname.endswith("-get-code"):
set_release_target = True
if instance.gerrit_eventtype == "change-merged":
msg = "%s.git[%s] review merged"
elif instance.gerrit_eventtype == "patchset-created":
msg = "%s.git[%s] review created"
set_release_target = False
else:
msg = "%s.git[%s] commit created"
workfront_note_add(
instance,
msg % (instance.projectname, instance.param_branch),
set_release_target,
)

@ -0,0 +1,187 @@
# Copyright (C) 2022 The Sipwise Team - http://sipwise.com
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
import structlog
from django.db.models.signals import post_save
from django.dispatch import receiver
from . import utils
from .models import GerritRepoInfo
from .models import JenkinsBuildInfo
from .models import WorkfrontNoteInfo
from .models.wni import workfront_re_branch
from .tasks import get_jbi_files
from .tasks import jenkins_remove_project
from release_dashboard.utils.build import is_ngcp_project
logger = structlog.get_logger(__name__)
@receiver(post_save, sender=JenkinsBuildInfo, dispatch_uid="jbi_manage")
def jbi_manage(sender, **kwargs):
if kwargs["created"]:
instance = kwargs["instance"]
if instance.is_job_url_allowed():
get_jbi_files.delay(
instance.pk, instance.jobname, instance.buildnumber
)
def gerrit_repo_add(instance):
log = logger.bind(
instance=str(instance),
)
if instance.param_ppa == "$ppa":
log.warn("ppa unset, skip removal")
return
gri = GerritRepoInfo.objects
ppa, created = gri.get_or_create(
param_ppa=instance.param_ppa,
gerrit_change=instance.gerrit_change,
defaults={"projectname": instance.projectname},
)
if created:
log.debug("ppa created", ppa=str(ppa))
elif ppa.projectname == "unknown":
ppa.projectname = instance.projectname
ppa.save()
log.info("ppa projectname updated")
def gerrit_repo_del(instance):
log = logger.bind(
instance=str(instance),
)
if instance.param_ppa == "$ppa":
log.warn("ppa unset, skip removal")
return
gri = GerritRepoInfo.objects
try:
ppa = gri.get(
param_ppa=instance.param_ppa, gerrit_change=instance.gerrit_change
)
ppa.delete()
log.debug("removed ppa", ppa=str(ppa))
except GerritRepoInfo.DoesNotExist:
pass
qs = gri.filter(param_ppa=instance.param_ppa)
ppa_count = qs.count()
project_ppa_count = qs.filter(projectname=instance.projectname).count()
if ppa_count == 0:
utils.jenkins_remove_ppa(instance.param_ppa)
elif project_ppa_count == 0:
log.debug("remove source+packages from ppa")
jenkins_remove_project.delay(instance.id)
else:
log.debug(
"nothing to do here",
ppa_count=ppa_count,
project_ppa_count=project_ppa_count,
)
@receiver(
post_save, sender=JenkinsBuildInfo, dispatch_uid="gerrit_repo_manage"
)
def gerrit_repo_manage(sender, **kwargs):
if kwargs["created"]:
instance = kwargs["instance"]
log = logger.bind(
instance=str(instance),
ppa=instance.param_ppa,
)
if instance.param_ppa == "$ppa":
log.warn("ppa unset, skip")
return
if (
instance.jobname.endswith("-repos")
and instance.result == "SUCCESS"
):
logger.debug("we need to count this")
if instance.gerrit_eventtype == "patchset-created":
gerrit_repo_add(instance)
elif instance.gerrit_eventtype == "change-merged":
gerrit_repo_del(instance)
elif (
instance.jobname.endswith("-cleanup")
and instance.result == "SUCCESS"
and instance.gerrit_eventtype == "change-abandoned"
):
log.debug("we need to count this")
gerrit_repo_del(instance)
def workfront_release_target(instance, wid):
if not is_ngcp_project(instance.projectname):
logger.info(
"%s not a NGCP project, skip release_target", instance.projectname
)
return
branch = instance.param_branch
if workfront_re_branch.search(branch):
release = branch
else:
release = utils.get_next_release(branch)
if release:
utils.workfront_set_release_target(wid, release)
def workfront_note_add(instance, message, release_target=False):
wni = WorkfrontNoteInfo.objects
workfront_ids = WorkfrontNoteInfo.getIds(instance.git_commit_msg)
from django.conf import settings
for wid in workfront_ids:
if not instance.gerrit_eventtype:
change = WorkfrontNoteInfo.getCommit(instance.git_commit_msg)
url = settings.GITWEB_URL.format(instance.projectname, change)
eventtype = "git-commit"
else:
change = instance.gerrit_change
url = settings.GERRIT_URL.format(instance.gerrit_change)
eventtype = instance.gerrit_eventtype
note, created = wni.get_or_create(
workfront_id=wid, gerrit_change=change, eventtype=eventtype
)
if created:
if not utils.workfront_note_send(wid, "%s %s " % (message, url)):
logger.error("remove related WorkfrontNoteInfo")
note.delete()
if release_target:
workfront_release_target(instance, wid)
def workfront_note_manage(sender, **kwargs):
"""
<name>-get-code job is the first in the flow that has the proper
GIT_CHANGE_SUBJECT envVar set, so git_commit_msg is fine
"""
if kwargs["created"]:
instance = kwargs["instance"]
if instance.result != "SUCCESS":
return
if instance.jobname.endswith("-get-code"):
set_release_target = True
if instance.gerrit_eventtype == "change-merged":
msg = "%s.git[%s] review merged"
elif instance.gerrit_eventtype == "patchset-created":
msg = "%s.git[%s] review created"
set_release_target = False
else:
msg = "%s.git[%s] commit created"
workfront_note_add(
instance,
msg % (instance.projectname, instance.param_branch),
set_release_target,
)

@ -33,7 +33,7 @@ from .utils import jenkins_remove_project_ppa
logger = structlog.get_logger(__name__)
@app.task(bind=True)
@shared_task(bind=True)
def jenkins_remove_project(self, jbi_id):
JenkinsBuildInfo = apps.get_model("repoapi", "JenkinsBuildInfo")
jbi = JenkinsBuildInfo.objects.get(id=jbi_id)

@ -19,7 +19,7 @@ from repoapi.models import JenkinsBuildInfo
from repoapi.test.base import BaseTest
@patch("repoapi.models.gri.jenkins_remove_project")
@patch("repoapi.signals.jenkins_remove_project")
@patch("repoapi.utils.jenkins_remove_ppa")
class GerritRepoInfoTestCase(BaseTest):
def get_defaults(self):

@ -1,5 +1,5 @@
celery
Django==3.0.14
Django==3.1.14
django-appconf
django-assets
django-celery-beat

@ -1,3 +1,3 @@
-r common.txt
django-auth-ldap
psycopg2>=2.8,<2.9
psycopg2

@ -5,7 +5,7 @@ FROM docker.mgm.sipwise.com/sipwise-bullseye:latest
# is updated with the current date. It will force refresh of all
# of the base images and things like `apt-get update` won't be using
# old cached versions when the Dockerfile is built.
ENV REFRESHED_AT 2022-01-13
ENV REFRESHED_AT 2022-01-19
RUN apt-get update && apt-get install --assume-yes python3 python3-dev \
python3-pytest python3-pytest-django python3-pytest-pep8 \

Loading…
Cancel
Save