~mrazik/jenkins-launchpad-plugin/rebuild_link

from launchpadlib.launchpad import Launchpad

from launchpadlib.credentials import UnencryptedFileCredentialStore

from credentials import AuthorizeRequestTokenWithConsole

from mergeproposalreview import MergeProposalReview

from settings import (ALLOWED_USERS, LAUNCHPAD_REVIEW_TYPE, JENKINS_URL,

                      JENKINS_PASSWORD, JENKINS_USER, LAUNCHPAD_LOGIN,

                      PUBLIC_JENKINS_URL, URLS_TO_HIDE, CREDENTIAL_STORE_PATH,

                      LP_ENV, LP_APP, logger)

from lazr.restfulclient.errors import Unauthorized

import jenkins

from xml.dom.minidom import parseString

import re

from jsonjenkins import JSONJenkins

from textwrap import dedent

class LaunchpadAgent():

    _launchpad = None

    def __init__(self):

        self._launchpad = self.login()

    def get_launchpad(self):

        return self._launchpad

    def change_mp_status(self, mp, status, message, subject,

                         revision, vote=None):

        mp.setStatus(status=status, revid=revision)

        if vote:

            mp.createComment(review_type=LAUNCHPAD_REVIEW_TYPE,

                             subject=subject, content=message, vote=vote)

            review = MergeProposalReview(mp)

            review.unlock()

        else:

            mp.createComment(review_type=LAUNCHPAD_REVIEW_TYPE,

                             subject=subject, content=message)

    def get_merge_proposal(self, branch_name, merge_proposal_link):

        lp_branch = branch_name.replace('https://code.launchpad.net/', 'lp:')

        lp_branch = lp_branch.replace('https://code.staging.launchpad.net/',

                            'lp://staging/')

        logger.debug('fetching branch: ' + lp_branch)

        branch = self._launchpad.branches.getByUrl(url=lp_branch)

        if not branch:

            logger.debug('branch "' + branch_name + '" doesn\'t exist')

            return None

        logger.debug('mp_link: ' + merge_proposal_link)

        for mp in branch.landing_targets:

            logger.debug('mp.web_link: ' + mp.web_link)

            if mp.web_link == merge_proposal_link:

                return mp

        return None

    def get_launchpad_user(self):

        return self._launchpad.people(LAUNCHPAD_LOGIN)

    @staticmethod

    def get_branch_from_mp(merge_proposal):

        m = re.search('(.*)\+merge/[0-9]+$', merge_proposal)

        if m:

            return m.group(1)

        return None

    @staticmethod

    def is_job_published(job):

        if not job:

            logger.debug('is_job_published: no job specified')

            return False

        jenkins_server = jenkins.Jenkins(JENKINS_URL,

                                         JENKINS_USER, JENKINS_PASSWORD)

        try:

            config = jenkins_server.get_job_config(job)

            dom = parseString(config)

            elements = dom.getElementsByTagName(

                            'hudson.plugins.build__publisher.BuildPublisher')

            # if the above element was found then the job is configured to be

            # published. Return true if the length of the array is > 0 and

            # False otherwise

            return elements.length > 0

        except:

            logger.info('Unable to fetch or parse job configuration for: ' +

                         job)

            return False

    @staticmethod

    def hide_jenkins_url(url):

        job = None

        # Match the jenkins JOB_URL and extract the IP/hostname

        # (^http[s]?://.*) and the name of jenkins job.

        # The following format is expected

        # http://10.0.0.1:8080/job/my-jenkins-job/7/

        m = re.match('^(http[s]?://.*)/job/([^/]*)/.*$', url)

        if m:

            jenkins_ip = m.group(1)

            job = m.group(2)

        # if there was a match in the regexp above then both

        # job and jenkins_ip must be set. It is enough to check just for job

        if job and LaunchpadAgent.is_job_published(job):

            return url.replace(jenkins_ip, PUBLIC_JENKINS_URL)

        for ip, replacement in URLS_TO_HIDE:

            url = url.replace(ip, replacement)

        return url

    @staticmethod

    def login():

        credential_store = UnencryptedFileCredentialStore(

                                                         CREDENTIAL_STORE_PATH)

        authorization_engine = AuthorizeRequestTokenWithConsole(LP_ENV, LP_APP)

        return Launchpad.login_with(LP_APP, LP_ENV,

                                    credential_store=credential_store,

                                    authorization_engine=authorization_engine)

class UpdateMergeProposalException(Exception):

    pass

def build_state(args):

    """Return a tuple containing merge proposal state, message, and

    subject."""

    if 'merge_failed' in args and args['merge_failed']:

        return ('Needs review',

                "FAILED: Autolanding.\n" +

                "Merging failed. More details in the following jenkins job:\n",

                "Re: [Merge] autolanding failed (merge failed)")

    elif 'push_failed' in args and args['push_failed']:

        return ('Needs review',

                "FAILED: Autolanding.\n" +

                "Pushing failed. More details in the following jenkins job:\n",

                "Re: [Merge] autolanding failed (push failed)")

    elif 'landing_failed' in args and args['landing_failed']:

        return ('Needs review',

                "FAILED: Autolanding.\n" +

                "More details in the following jenkins job:\n",

                "Re: [Merge] autolanding failed")

    elif 'merged' in args and args['merged']:

        return ('Merged',

                "PASSED: Autolanding.\nBranch merged.",

                "Re: [Merge] branch merged")

    elif 'commit_message_empty' in args and args['commit_message_empty']:

        return ('Needs review',

                "FAILED: Autolanding.\nNo commit message was specified.\n",

                "Re: [Merge] autolanding failed",)

    elif 'unapproved_changes' in args and args['unapproved_changes']:

        return ('Needs review',

                "FAILED: Autolanding.\n" +

                "Unapproved changes made after approval.\n",

                "Re: [Merge] autolanding failed",)

    elif 'invalid_revid' in args and args['invalid_revid']:

        return ('Needs review',

                "FAILED: Autolanding.\n" +

                "Approved revid is not set in launchpad " +

                "(maybe a permission problem?).\n",

                "Re: [Merge] autolanding failed",)

    else:

        raise UpdateMergeProposalException("unrecognized parameters")

class LaunchpadVote():

    APPROVE = 'Approve'

    DISAPPROVE = 'Disapprove'

    NEEDS_FIXING = 'Needs Fixing'

class LaunchpadTrigger():

    _launchpad = None

    _launchpad_user = None

    _json_jenkins = None

    def __init__(self):

        self._launchpadAgent = LaunchpadAgent()

        self._launchpad = self._launchpadAgent.get_launchpad()

        self._launchpad_user = self._launchpad.people(LAUNCHPAD_LOGIN)

    def get_launchpad_user(self):

        return self._launchpad_user

    def get_branch_from_mp(self, merge_proposal):

        return self._launchpadAgent.get_branch_from_mp(merge_proposal)

    def hide_jenkins_url(self, url):

        return self._launchpadAgent.hide_jenkins_url(url)

    def change_mp_status(self, mp, status, message, subject,

                         revision, vote=None):

        return self._launchpadAgent.change_mp_status(mp, status, message,

                                            subject, revision, vote)

    def get_merge_proposal(self, branch_name, merge_proposal_link):

        return self._launchpadAgent.get_merge_proposal(branch_name,

                                            merge_proposal_link)

    def approve_mp(self, mp, revision, build_url):

        state = 'PASSED: Continuous integration, rev:' + str(revision)

        logger.debug(state)

        content = self.format_message_for_mp_update(build_url,

                                                    state + "\n")

        mp.createComment(review_type=LAUNCHPAD_REVIEW_TYPE,

                         vote=LaunchpadVote.APPROVE, subject=state,

                         content=content)

        review = MergeProposalReview(mp)

        review.unlock()

    def disapprove_mp(self, mp, revision, build_url):

        state = 'FAILED: Continuous integration, rev:' + str(revision)

        logger.debug(state)

        content = self.format_message_for_mp_update(build_url,

                                                    state + "\n")

        mp.createComment(review_type=LAUNCHPAD_REVIEW_TYPE,

                         vote=LaunchpadVote.NEEDS_FIXING, subject=state,

                         content=content)

        review = MergeProposalReview(mp)

        review.unlock()

    def _get_json_jenkins(self, url):

        if not self._json_jenkins:

            self._json_jenkins = JSONJenkins(url, JENKINS_USER,

                                             JENKINS_PASSWORD)

        return self._json_jenkins

    def get_executed_test_runs(self, url):

        jenkins = self._get_json_jenkins(url)

        job = jenkins.get_json_data(url)

        ret = "\nExecuted test runs:"

        for run in job['runs']:

            if run['number'] == job['number']:

                result = jenkins.get_json_data(run['url'])['result']

                ret = (ret + "\n    " + result + ': ' +

                       self.hide_jenkins_url(run['url']) + 'console')

        return ret

    def format_message_for_mp_update(self, build_url, message=None,

                                     include_rebuild_link=True):

        formatted_message = dedent('''\

                {message}{build_url}{executed_test_runs}

                ''')

        if include_rebuild_link:

                formatted_message = formatted_message + dedent('''\

                Click here to trigger a rebuild:

                {build_url}/rebuild/?

                ''')

        if not message:

            message = ''

        if not build_url:

            build_url_message = ''

            executed_test_runs_message = ''

        else:

            build_url_message = self.hide_jenkins_url(build_url)

            executed_test_runs_message = self.get_executed_test_runs(

                                                      build_url)

        formatted_message = formatted_message.format(

                message=message,

                build_url=build_url_message,

                executed_test_runs=executed_test_runs_message)

        return formatted_message

    def get_latest_review(self, mp):

        revision = 0

        launchpad_user = self.get_launchpad_user()

        for comment in mp.all_comments:

            if comment.author.name == launchpad_user.name:

                if comment.vote_tag == LAUNCHPAD_REVIEW_TYPE:

                    m = re.search(

                        '^(PASSED|FAILED): Continuous integration, rev:(\d+)',

                        comment.message_body)

                    if m and (int(m.group(2)) > revision):

                        revision = int(m.group(2))

        return revision

    def latest_candidate_validated(self, mp):

        latest_review = self.get_latest_review(mp)

        logger.debug('Latest_review is revision: ' + str(latest_review))

        if latest_review >= mp.source_branch.revision_count:

            logger.debug('Skipping this MP. Current revision: ' +

                           str(mp.source_branch.revision_count))

            return True

        return False

    def testing_in_progress(self, mp):

        review = MergeProposalReview(mp)

        if review.is_locked():

            logger.debug('Skipping this MP. It is curently being ' +

                  'tested by Jenkins.')

            return True

        return False

    def user_allowed_to_trigger_jobs(self, lp_user):

        allowed_people = ALLOWED_USERS

        if lp_user.name in allowed_people:

            return True

        for membership in lp_user.memberships_details:

            if membership.team.name in allowed_people:

                return True

        logger.debug('User "' + lp_user.name +

                      '" not allowed to trigger jobs')

        return False

    def start_jenkins_job(self, jenkins_url, jenkins_job, mp):

            j = jenkins.Jenkins(jenkins_url, JENKINS_USER, JENKINS_PASSWORD)

            jenkins_params = {

                     'landing_candidate': 'bzr+ssh://' + LAUNCHPAD_LOGIN +

                     '@bazaar.launchpad.net/' + mp.source_branch.unique_name,

                     'merge_proposal': mp.web_link,

                     'candidate_revision': mp.source_branch.revision_count

                             }

            job_info = j.get_job_info(jenkins_job)

            if not job_info['buildable']:

                logger.debug('Job is not buildable (probably disabled)')

                return False

            try:

                mp.nominateReviewer(reviewer=self.get_launchpad_user(),

                                    review_type=LAUNCHPAD_REVIEW_TYPE)

            except Unauthorized:

                logger.info('You are not authorized to review this merge ' +

                            'proposal. CI process will now be stopped.')

                return False

            review = MergeProposalReview(mp)

            review.lock()

            try:

                logger.debug('Starting job: ' + str(jenkins_params))

                j.build_job(jenkins_job, jenkins_params)

            except jenkins.JenkinsException:

                logger.debug('Starting a job failed')

                message = "ERROR: failed to start a jenkins job"

                mp.createComment(review_type=LAUNCHPAD_REVIEW_TYPE,

                                 vote='Disapprove', subject=message,

                                 content=message)

    def trigger_ci_building(self, mps, jenkins_job, jenkins_url):

        result = True

        for mp in mps:

            if not self.user_allowed_to_trigger_jobs(mp.registrant):

                continue

            if self.testing_in_progress(mp):

                continue

            if self.latest_candidate_validated(mp):

                continue

            ret = self.start_jenkins_job(jenkins_url, jenkins_job, mp)

            result = ret and result

        return result

    def unapproved_prerequisite_exists(self, mp):

        prereq = mp.prerequisite_branch

        target_branch = mp.target_branch

        if prereq:

            #x is a merge-proposal object

            merges = [x for x in prereq.landing_targets

                      if x.target_branch.web_link == target_branch.web_link and

                      x.queue_status != u'Superseded']

            if len(merges) == 0:

                logger.debug('No proposals of prerequisite branch exists')

                return True

            elif len(merges) > 1:

                logger.debug('Too many proposals exists for prerequisite')

                return True

            elif len(merges) == 1:

                if merges[0].queue_status != u'Merged':

                    logger.debug('Prerequisite not yet merged')

                    return True

        #TODO

        # skip also branches with changes made after approval

        return False

    def is_commit_message_set(self, mp, jenkins_job, jenkins_url):

        jenkins = self._get_json_jenkins(jenkins_url)

        job_config = jenkins.get_json_data(jenkins_url + '/job/' +

                                           jenkins_job + '/')

        use_description = False

        try:

            for param in job_config['property'][1]['parameterDefinitions']:

                if param['name'] == 'use_description_for_commit' and \

                   param['defaultParameterValue']['value']:

                        use_description = True

                        break

        except:

            logger.debug("Unable to get \"use_description_for_commit\" " +

                    "configuration for %s" % (jenkins_job))

        logger.debug('Job is configured to fallback to description: %s' %

                     (use_description))

        return bool(self.get_commit_message(mp, use_description))

    def trigger_al_building(self, mps, jenkins_job, jenkins_url):

        result = True

        for mp in mps:

            #ignore this merge proposal if both registrant and reviewer

            #are not trusted (aka belong to canonical)

            #check if mp.reviewer actually exists just to be sure (it should

            # as we are autolanding and thus the MP needs to be approved)

            if mp.reviewer is None:

                continue

            if not (self.user_allowed_to_trigger_jobs(mp.registrant) or

                self.user_allowed_to_trigger_jobs(mp.reviewer)):

                logger.debug('Skiping this merge proposal as neither ' +

                             'registrant nor reviewer is allowed to ' +

                             'trigger jenkins jobs')

                continue

            if not self.is_commit_message_set(mp, jenkins_job, jenkins_url):

                logger.debug('No commit message was set. Interrupting ' +

                             'autolanding for "%s".' % (mp.web_link))

                mp_state, message, subject = build_state(

                                               {'commit_message_empty': True})

                self.change_mp_status(mp, mp_state, message, subject,

                        mp.source_branch.revision_count,

                        LaunchpadVote.NEEDS_FIXING)

                continue

            if self.testing_in_progress(mp):

                continue

            if self.unapproved_prerequisite_exists(mp):

                logger.debug('Unapproved prerequisite exists for ' + str(mp))

                continue

            logger.debug('Going to trigger merge: ' + str(mp.source_branch))

            ret = self.start_jenkins_job(jenkins_url, jenkins_job, mp)

            result = ret and result

        return result

    def get_merge_proposals(self, branch_name, state):

        branch = self._launchpad.branches.getByUrl(url=branch_name)

        if not branch:

            logger.debug('Branch "' + branch_name + '" doesn\'t exist')

            return []

        mps = []

        for mp in branch.landing_candidates:

            if mp.queue_status in state:

                mps.append(mp)

        return mps

    def get_reviews(self, mp):

        reviews = []

        for vote in mp.votes:

            if vote.comment:

                reviews.append('%s;%s' % (vote.reviewer.display_name,

                                          vote.comment.vote))

        if len(reviews) == 0:

            return None

        return reviews

    def get_commit_message(self, mp, use_description):

        message = None

        if mp.commit_message:

            message = mp.commit_message

        elif use_description and mp.description:

            message = mp.description

        return message

    def close_bugs(self, mp):

        for b in mp.source_branch.linked_bugs_collection:

            for task in b.bug_tasks_collection:

                if task.target.web_link == mp.target_branch.project.web_link:

                    task.status = 'Fix Committed'

                    task.lp_save()