status-im/cabot
2
0
Fork 0
mirror of https://github.com/status-im/cabot.git synced 2025-02-24 10:28:06 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #553 from arachnys/switch-jenkins-api

Browse Source 
Switch from jenkinsapi to python-jenkins
This commit is contained in:
Frank Hamand 2017-09-07 16:02:55 +01:00 committed by GitHub
commit 13cb71213e
5 changed files with 59 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Dockerfile
View File

@ -14,6 +14,7 @@ RUN apk add --no-cache \
musl-dev \
libffi-dev \
openldap-dev \
ca-certificates \
bash
RUN npm install -g \

28
cabot/cabotapp/jenkins.py
View File

@ -1,10 +1,11 @@
from __future__ import absolute_import
from datetime import datetime
import jenkins
from celery.utils.log import get_task_logger
from django.conf import settings
from django.utils import timezone
from jenkinsapi.custom_exceptions import UnknownJob
from jenkinsapi.jenkins import Jenkins
logger = get_task_logger(__name__)
@ -14,10 +15,9 @@ JENKINS_CLIENT = None
def _get_jenkins_client(jenkins_config):
global JENKINS_CLIENT
if JENKINS_CLIENT is None:
JENKINS_CLIENT = Jenkins(jenkins_config.jenkins_api,
JENKINS_CLIENT = jenkins.Jenkins(jenkins_config.jenkins_api,
username=jenkins_config.jenkins_user,
password=jenkins_config.jenkins_pass,
lazy=True)
password=jenkins_config.jenkins_pass)
return JENKINS_CLIENT
def get_job_status(jenkins_config, jobname):
@ -29,21 +29,21 @@ def get_job_status(jenkins_config, jobname):
}
client = _get_jenkins_client(jenkins_config)
try:
job = client.get_job(jobname)
last_build = job.get_last_completed_build()
job = client.get_job_info(jobname)
last_build = client.get_build_info(jobname, job['lastCompletedBuild']['number'])
ret['status_code'] = 200
ret['job_number'] = last_build.get_number()
ret['active'] = job.is_enabled()
ret['succeeded'] = job.is_enabled() and last_build.is_good()
ret['job_number'] = last_build['number']
ret['active'] = job['color'] != 'disabled'
ret['succeeded'] = ret['active'] and last_build['result'] == 'SUCCESS'
if job.is_queued():
in_queued_since = job._data['queueItem']['inQueueSince'] # job.get_queue_item() crashes
if job['inQueue']:
in_queued_since = job['queueItem']['inQueueSince']
time_blocked_since = datetime.utcfromtimestamp(
float(in_queued_since) / 1000).replace(tzinfo=timezone.utc)
ret['blocked_build_time'] = (timezone.now() - time_blocked_since).total_seconds()
ret['queued_job_number'] = job.get_last_buildnumber()
ret['queued_job_number'] = job['lastBuild']['number']
return ret
except UnknownJob:
except jenkins.NotFoundException:
ret['status_code'] = 404
return ret

2
cabot/cabotapp/tests/tests_basic.py
View File

@ -420,7 +420,7 @@ class TestCheckRun(LocalTestCase):
self.assertEqual(len(checkresults), 1)
self.assertFalse(self.jenkins_check.last_result().succeeded)
@patch('cabot.cabotapp.models.requests.get', throws_timeout)
@patch('cabot.cabotapp.models.jenkins_check_plugin.get_job_status', throws_timeout)
def test_timeout_handling_in_jenkins(self):
"""This works because we are effectively patching requests.get globally, including in jenkinsapi."""
checkresults = self.jenkins_check.statuscheckresult_set.all()

77
cabot/cabotapp/tests/tests_jenkins.py
View File

@ -1,27 +1,40 @@
# -*- coding: utf-8 -*-
import unittest
from freezegun import freeze_time
from mock import patch, create_autospec
from cabot.cabotapp import jenkins
from datetime import timedelta
import jenkins
from cabot.cabotapp import jenkins as cabot_jenkins
from cabot.cabotapp.models import JenkinsConfig
from django.utils import timezone
from datetime import timedelta
import jenkinsapi
from jenkinsapi.custom_exceptions import UnknownJob
from freezegun import freeze_time
from mock import create_autospec, patch
class TestGetStatus(unittest.TestCase):
def setUp(self):
self.mock_build = create_autospec(jenkinsapi.build.Build)
self.mock_build.get_number.return_value = 12
self.job = {
u'inQueue': False,
u'queueItem': None,
u'lastCompletedBuild': {
u'number': 12,
},
u'lastBuild': {
u'number': 12,
},
u'color': 'blue'
}
self.mock_job = create_autospec(jenkinsapi.job.Job)
self.mock_job.is_enabled.return_value = True
self.mock_job.get_last_completed_build.return_value = self.mock_build
self.build = {
u'number': 12,
u'result': u'SUCCESS'
self.mock_client = create_autospec(jenkinsapi.jenkins.Jenkins)
self.mock_client.get_job.return_value = self.mock_job
}
self.mock_client = create_autospec(jenkins.Jenkins)
self.mock_client.get_job_info.return_value = self.job
self.mock_client.get_build_info.return_value = self.build
self.mock_config = create_autospec(JenkinsConfig)
@ -29,10 +42,7 @@ class TestGetStatus(unittest.TestCase):
def test_job_passing(self, mock_jenkins):
mock_jenkins.return_value = self.mock_client
self.mock_build.is_good.return_value = True
self.mock_job.is_queued.return_value = False
status = jenkins.get_job_status(self.mock_config, 'foo')
status = cabot_jenkins.get_job_status(self.mock_config, 'foo')
expected = {
'active': True,
@ -47,10 +57,9 @@ class TestGetStatus(unittest.TestCase):
def test_job_failing(self, mock_jenkins):
mock_jenkins.return_value = self.mock_client
self.mock_build.is_good.return_value = False
self.mock_job.is_queued.return_value = False
self.build[u'result'] = u'FAILURE'
status = jenkins.get_job_status(self.mock_config, 'foo')
status = cabot_jenkins.get_job_status(self.mock_config, 'foo')
expected = {
'active': True,
@ -65,18 +74,15 @@ class TestGetStatus(unittest.TestCase):
@patch("cabot.cabotapp.jenkins._get_jenkins_client")
def test_job_queued_last_succeeded(self, mock_jenkins):
mock_jenkins.return_value = self.mock_client
self.job[u'lastBuild'] = {u'number': 13}
self.mock_build.is_good.return_value = True
self.mock_job.is_queued.return_value = True
self.mock_job.get_last_buildnumber.return_value = 13
self.mock_job._data = {
'queueItem': {
self.job[u'inQueue'] = True
self.job['queueItem'] = {
'inQueueSince': float(timezone.now().strftime('%s')) * 1000
}
}
with freeze_time(timezone.now() + timedelta(minutes=10)):
status = jenkins.get_job_status(self.mock_config, 'foo')
status = cabot_jenkins.get_job_status(self.mock_config, 'foo')
expected = {
'active': True,
@ -92,18 +98,15 @@ class TestGetStatus(unittest.TestCase):
@patch("cabot.cabotapp.jenkins._get_jenkins_client")
def test_job_queued_last_failed(self, mock_jenkins):
mock_jenkins.return_value = self.mock_client
self.mock_build.is_good.return_value = False
self.mock_job.is_queued.return_value = True
self.mock_job.get_last_buildnumber.return_value = 13
self.mock_job._data = {
'queueItem': {
self.job[u'lastBuild'] = {u'number': 13}
self.job[u'inQueue'] = True
self.job['queueItem'] = {
'inQueueSince': float(timezone.now().strftime('%s')) * 1000
}
}
self.build[u'result'] = u'FAILURE'
with freeze_time(timezone.now() + timedelta(minutes=10)):
status = jenkins.get_job_status(self.mock_config, 'foo')
status = cabot_jenkins.get_job_status(self.mock_config, 'foo')
expected = {
'active': True,
@ -117,10 +120,10 @@ class TestGetStatus(unittest.TestCase):
@patch("cabot.cabotapp.jenkins._get_jenkins_client")
def test_job_unknown(self, mock_jenkins):
self.mock_client.get_job.side_effect = UnknownJob()
self.mock_client.get_job_info.side_effect = jenkins.NotFoundException()
mock_jenkins.return_value = self.mock_client
status = jenkins.get_job_status(self.mock_config, 'unknown-job')
status = cabot_jenkins.get_job_status(self.mock_config, 'unknown-job')
expected = {
'active': None,

2
requirements.txt
View File

@ -20,7 +20,7 @@ gunicorn==19.7.1
httplib2==0.10.3
icalendar==3.11.3
itypes==1.1.0
jenkinsapi==0.3.4
python-jenkins==0.4.15
Jinja2==2.9.6
kombu==4.0.2
Markdown==2.6.8