python jenkins模块集成jenkins

官方文档http://python-jenkins.readthedocs.io/en/latest/examples.html#example-3-working-with-jenkins-jobs

pip install python-jenkins

import jenkins
from jenkins_ops import logger
import time
class Run_jenkins():
    def __init__(self,url,user,passwd,project,build_target,version_type):
        self.url=url
        self.user=user
        self.passwd=passwd
        self.project=project
        self.build_target=build_target
        self.version_type=version_type
    def __run_status(self,ret):
        build_run = ret.get_running_builds()
        run_job = []
        for item in build_run:
            run_job.append(item['name'])
        return run_job
    def __run_job(self,ret,next_build_number):
        flag = True
        while flag:
            run_job=self.__run_status(ret)
            if run_job==[]:
                logger.log.info("{project} #{number} is not running,keep waiting......".format(project=self.project,
                                                                                     number=next_build_number))
                time.sleep(2)
            else:
                logger.log.info("{project} #{number} is still building......".format(project=self.project,number=next_build_number))
                flag=False
        flag1 = True
        while flag1:
            run_job = self.__run_status(ret)
            if self.project not in run_job:
                # lastnum1 = ret.get_job_info(project)['lastCompletedBuild']['number']
                self.__run_result(ret, next_build_number)
                flag1 = False
            else:
                logger.log.info("{project} #{number} is still building......".format(project=self.project,number=next_build_number))
                time.sleep(2)
    def __run_result(self,req,next_build_number):
        build_info = req.get_build_info(self.project, next_build_number)
        build_result = build_info['result']
        build_ip=build_info['builtOn']
        logger.log.info("{project} #{number} FINISHED".format(project=self.project, number=next_build_number))
        logger.log.info("{project} #{number} build {status}".format(project=self.project, number=next_build_number,
                                                                    status=build_result))
        logger.log.info("{project} #{number} build on {build_ip}".format(project=self.project, number=next_build_number,
                                                                    build_ip=build_ip))
    def run_jenkins(self):
        ret = jenkins.Jenkins(self.url, self.user, self.passwd)
        if  not ret.job_exists(self.project):
            logger.log.error("the {job} not exist,please check".format(job=self.project))
            raise ValueError("the {job} not exist,please check".format(job=self.project))
        run_job = self.__run_status(ret)
        if self.project  not in run_job:
            next_build_number = ret.get_job_info(self.project)['nextBuildNumber']
            ret.build_job(self.project, {'build_target': self.build_target, 'version_type': self.version_type})
            logger.log.warning(
                "{project} #{number} will be build......".format(project=self.project, number=next_build_number))
            time.sleep(2)
            self.__run_job(ret, next_build_number)
        else:
            logger.log.warning("the job was started by others,please waiting!")
if __name__ == '__main__':
    s=Run_jenkins('http://192.168.10.128:8500','admin','admin','test_gateway','master','dev')
    s.run_jenkins()

 

logger.py

import logging.handlers
import logging
import time
from jenkins_ops import config
log = logging.getLogger('log')
time_cut = logging.handlers.TimedRotatingFileHandler(filename=config.log_file, when='D', interval=1, backupCount=config.backup_count)
formatter = logging.Formatter("%(asctime)s %(filename)s %(levelname)s %(message)s", datefmt='%a, %m-%d-%Y %H:%M:%S')
time_cut.setFormatter(formatter)
log.setLevel(config.log_level)
time_cut.suffix = "%Y-%m-%d"  # 如果设定是天，就必须写成"%Y-%m-%d"其他格式不生效
log.addHandler(time_cut)

config.py

#the confifg file
import logging
log_level=logging.INFO
log_file='jenkins_ops.log'
backup_count=2

 

import logging
import traceback
import sys
import re
import requests
import time
import jenkinsapi
from jenkinsapi.jenkins import Jenkins


# set the logger
FORMAT = '[%(asctime)s %(filename)s(line:%(lineno)d) %(levelname)s] %(message)s'
logging.basicConfig(format=FORMAT)
logger = logging.getLogger('log')
logger.setLevel(logging.DEBUG)


# format the url and connect to the jenkins server
def connect_to_jenkins(job_url, user_name=None, password=None):
    # format url
    #match = re.match(r'(http://[^/]+/)(job/)(\w.+$)', job_url)
    #match = re.match(r'(http://\w.+)(job/)(\w.+$)', job_url)
    match = re.match(r'(http://\w.+)(/job/)([^\s]+$)', job_url)
    if match:
        jenkins_server_url = match.group(1)
        job_name = match.group(3).split('/')[0]
    else:
        logger.error("The url of jenkins job is not vaild: " + job_url)
        sys.exit(2)

    # connect to the server and examine the job_name
    try:
        if user_name and password:
            jenkins_server = Jenkins(jenkins_server_url, user_name, password)
        else:
            jenkins_server = Jenkins(jenkins_server_url)

        if job_name not in jenkins_server.keys():
            logger.error("The job is not exist: " + job_name)
            sys.exit(3)

        return jenkins_server, job_name
    except requests.ConnectionError:
        logger.error("Can not connect to the jenkins_server: " + job_url)
        logger.error(traceback.format_exc())
        sys.exit(4)


# build the job and wait for the result
def build_job(job_url, build_params=None, user_name=None, password=None, build_timeout=None):
    print job_url, build_params, user_name, password, build_timeout
    jenkins_server, job_name = connect_to_jenkins(job_url, user_name, password)

    job = jenkins_server.get_job(job_name)
    next_build_number = job.get_next_build_number()

    # trigger the job to build
    jenkins_server.build_job(job_name, params=build_params)

    # wait for the result
    build_name = 'UNKNOWN'
    build_status = 'TIMEOUT'
    build_result = 'UNKNOWN'
    build_cost = 0
    build_on = 'UNKNOWN'
    build_result_page = 'UNKNOWN'
    build_workspace = 'UNKNOWN'
    start_time = time.time()
    while True:
        try:
            build_info = job.get_build(next_build_number)
            build_name = build_info.name
            build_on = build_info.get_slave() or JENKINS_SERVER.split('//')[1].split(":")[0]
            build_result_page = build_info.get_result_url()

            if build_info.is_running():
                build_status = "RUNNING"
                logger.info(build_name + " is still running...")

                # if build_timeout is set, the build_cost should be examined
                end_time = time.time()
                build_cost = end_time - start_time
                if build_timeout:
                    if build_cost > int(build_timeout):
                        message = "The build timeout is {build_timeout}, but this build is " \
                                  "already take {build_cost} seconds".format(build_timeout=build_timeout,
                                                                             build_cost=build_cost)
                        logger.error(message)
                        logger.error("The EasyOps platform can't wait for so much longer")
                        sys.exit(5)

                time.sleep(3)
            else:
                build_status = 'FINISHED'
                logger.info(build_name + " : " + build_status)
                build_cost = build_info.get_duration().total_seconds()
                if build_info.is_good():
                    build_result = 'SUCCESS'
                    logger.info(build_name + " : " + build_result)
                else:
                    build_result = 'FALSE'
                    logger.info(build_name + " : " + build_result)

                console_output = build_info.get_console()
                match = re.search(pattern=r"in workspace (.+)", string=console_output)
                if match:
                    build_workspace = match.group(1)
                    logger.info(build_name + "'s workspace : " + build_workspace)

                logger.info(build_name + " is cost : " + str(build_cost) + " seconds")
                logger.info(build_name + ' is build on : ' + build_on)
                logger.info(build_name + "'s result : " + build_result_page)

                # output
                PutStr("NAME", build_name)
                PutStr("STATUS", build_status)
                PutStr("RESULT", build_result)
                PutStr("COST", build_cost)
                PutStr("SLAVE", build_on)
                PutStr("RESULT_PAGE", build_result_page)
                PutStr("WORKSPACE", build_workspace)
                info = "NAME={0}&STATUS={1}&RESULT={2}&COST={3}&SLAVE={4}&RESULT_PAGE={5}&WORKSPACE={6}".format(build_name, build_status, build_result, build_cost, build_on, build_result_page, build_workspace)
                PutRow("table", info)
                
                if build_result == 'FALSE':
                    sys.exit(1)
                    
                break

        # the build may be delay for some seconds, so, just wait.
        except jenkinsapi.custom_exceptions.NotFound:
            logger.warn('the job is not running, keep waiting...')
            time.sleep(5)
            end_time = time.time()
            build_cost = end_time - start_time
            if build_timeout:
                if build_cost > int(build_timeout):
                    logger.error("The build timeout is " + str(build_timeout))
                    logger.error("But this build is already take " + str(build_cost) + " seconds, and it can't start")
                    logger.error("The EasyOps platform can not wait for so much longer")
                    sys.exit(6)


if __name__ == '__main__':
    if 'JENKINS_USER' not in locals():
        JENKINS_USER = 'admin'

    if 'JENKINS_PASSWORD' not in locals():
        JENKINS_PASSWORD = 'admin'

    if 'TIMEOUT' not in locals():
        TIMEOUT = None

    # execute the build task
    job_url = JENKINS_SERVER + "/job/" + JOB_NAME
    build_job(job_url, {"build_target": BUILD_TARGET, "version_type": VERSION_TYPE}, JENKINS_USER, JENKINS_PASSWORD, TIMEOUT)