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

Switch from jenkinsapi to python-jenkins

Dockerfile

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

cabot/cabotapp/jenkins.py

@@ -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,
+                                 password=jenkins_config.jenkins_pass)
-                                 lazy=True)
     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)
+        job = client.get_job_info(jobname)
-        last_build = job.get_last_completed_build()
+        last_build = client.get_build_info(jobname, job['lastCompletedBuild']['number'])
 
         ret['status_code'] = 200
-        ret['job_number'] = last_build.get_number()
+        ret['job_number'] = last_build['number']
-        ret['active'] = job.is_enabled()
+        ret['active'] = job['color'] != 'disabled'
-        ret['succeeded'] = job.is_enabled() and last_build.is_good()
+        ret['succeeded'] = ret['active'] and last_build['result'] == 'SUCCESS'
 
-        if job.is_queued():
+        if job['inQueue']:
-            in_queued_since = job._data['queueItem']['inQueueSince']  # job.get_queue_item() crashes
+            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

cabot/cabotapp/tests/tests_basic.py

@@ -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()

cabot/cabotapp/tests/tests_jenkins.py

@@ -1,27 +1,40 @@
 # -*- coding: utf-8 -*-
 
 import unittest
-from freezegun import freeze_time
+from datetime import timedelta
-from mock import patch, create_autospec
+
-from cabot.cabotapp import jenkins
+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
+from freezegun import freeze_time
-import jenkinsapi
+from mock import create_autospec, patch
-from jenkinsapi.custom_exceptions import UnknownJob
+
 
 class TestGetStatus(unittest.TestCase):
 
     def setUp(self):
-        self.mock_build = create_autospec(jenkinsapi.build.Build)
+        self.job = {
-        self.mock_build.get_number.return_value = 12
+            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.build = {
-        self.mock_job.is_enabled.return_value = True
+            u'number': 12,
-        self.mock_job.get_last_completed_build.return_value = self.mock_build
+            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
+        status = cabot_jenkins.get_job_status(self.mock_config, 'foo')
-        self.mock_job.is_queued.return_value = False
-
-        status = 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.build[u'result'] = u'FAILURE'
-        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,
@@ -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.job[u'inQueue'] = True
-        self.mock_job.is_queued.return_value = True
+        self.job['queueItem'] = {
-        self.mock_job.get_last_buildnumber.return_value = 13
+            'inQueueSince': float(timezone.now().strftime('%s')) * 1000
-        self.mock_job._data = {
-            '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.job[u'lastBuild'] = {u'number': 13}
-        self.mock_build.is_good.return_value = False
+        self.job[u'inQueue'] = True
-        self.mock_job.is_queued.return_value = True
+        self.job['queueItem'] = {
-        self.mock_job.get_last_buildnumber.return_value = 13
+            'inQueueSince': float(timezone.now().strftime('%s')) * 1000
-        self.mock_job._data = {
-            '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,

requirements.txt

@@ -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