~launchpad-pqm/launchpad/devel

# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

__metaclass__ = type

__all__ = [

    'BuildFarmJob',

    'BuildFarmJobDerived',

    'BuildFarmJobOld',

    'BuildFarmJobOldDerived',

    ]

import hashlib

from lazr.delegates import delegates

import pytz

from storm.expr import (

    And,

    Desc,

    LeftJoin,

    Or,

    Select,

    Union,

    )

from storm.locals import (

    Bool,

    DateTime,

    Int,

    Reference,

    Storm,

    )

from storm.store import Store

from zope.component import (

    ComponentLookupError,

    getUtility,

    )

from zope.interface import (

    classProvides,

    implements,

    )

from zope.proxy import isProxy

from zope.security.proxy import removeSecurityProxy

from canonical.database.constants import UTC_NOW

from canonical.database.enumcol import DBEnum

from canonical.launchpad.interfaces.lpstorm import (

    IMasterStore,

    IStore,

    )

from canonical.launchpad.webapp.interfaces import (

    DEFAULT_FLAVOR,

    IStoreSelector,

    MAIN_STORE,

    )

from lp.app.errors import NotFoundError

from lp.app.interfaces.launchpad import ILaunchpadCelebrities

from lp.buildmaster.enums import (

    BuildFarmJobType,

    BuildStatus,

    )

from lp.buildmaster.interfaces.buildfarmjob import (

    IBuildFarmJob,

    IBuildFarmJobOld,

    IBuildFarmJobSet,

    IBuildFarmJobSource,

    InconsistentBuildFarmJobError,

    ISpecificBuildFarmJobSource,

    )

from lp.buildmaster.interfaces.buildqueue import IBuildQueueSet

from lp.registry.model.teammembership import TeamParticipation

class BuildFarmJobOld:

    """See `IBuildFarmJobOld`."""

    implements(IBuildFarmJobOld)

    processor = None

    virtualized = None

    def score(self):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def getLogFileName(self):

        """See `IBuildFarmJobOld`."""

        return 'buildlog.txt'

    def getName(self):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def getTitle(self):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def makeJob(self):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def getByJob(self, job):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def jobStarted(self):

        """See `IBuildFarmJobOld`."""

        pass

    def jobReset(self):

        """See `IBuildFarmJobOld`."""

        pass

    def jobAborted(self):

        """See `IBuildFarmJobOld`."""

        pass

    def jobCancel(self):

        """See `IBuildFarmJobOld`."""

        pass

    @staticmethod

    def addCandidateSelectionCriteria(processor, virtualized):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    @staticmethod

    def postprocessCandidate(job, logger):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def cleanUp(self):

        """See `IBuildFarmJob`."""

        pass

    def generateSlaveBuildCookie(self):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

class BuildFarmJobOldDerived:

    """Setup the delegation and provide some common implementation."""

    delegates(IBuildFarmJobOld, context='build_farm_job')

    def __init__(self, *args, **kwargs):

        """Ensure the instance to which we delegate is set on creation."""

        self._set_build_farm_job()

        super(BuildFarmJobOldDerived, self).__init__(*args, **kwargs)

    def __storm_loaded__(self):

        """Set the attribute for our IBuildFarmJob delegation.

        This is needed here as __init__() is not called when a storm object

        is loaded from the database.

        """

        self._set_build_farm_job()

    def _set_build_farm_job(self):

        """Set the build farm job to which we will delegate.

        Deriving classes must set the build_farm_job attribute for the

        delegation.

        """

        raise NotImplementedError

    @classmethod

    def getByJob(cls, job):

        """See `IBuildFarmJobOld`."""

        store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)

        return store.find(cls, cls.job == job).one()

    def generateSlaveBuildCookie(self):

        """See `IBuildFarmJobOld`."""

        buildqueue = getUtility(IBuildQueueSet).getByJob(self.job)

        if buildqueue.processor is None:

            processor = '*'

        else:

            processor = repr(buildqueue.processor.id)

        contents = ';'.join([

            repr(removeSecurityProxy(self.job).id),

            self.job.date_created.isoformat(),

            repr(buildqueue.id),

            buildqueue.job_type.name,

            processor,

            self.getName(),

            ])

        return hashlib.sha1(contents).hexdigest()

    def cleanUp(self):

        """See `IBuildFarmJob`.

        Classes that derive from BuildFarmJobOld need to clean up

        after themselves correctly.

        """

        Store.of(self).remove(self)

    @staticmethod

    def addCandidateSelectionCriteria(processor, virtualized):

        """See `IBuildFarmJobOld`."""

        return ('')

    @staticmethod

    def postprocessCandidate(job, logger):

        """See `IBuildFarmJobOld`."""

        return True

class BuildFarmJob(BuildFarmJobOld, Storm):

    """A base implementation for `IBuildFarmJob` classes."""

    __storm_table__ = 'BuildFarmJob'

    implements(IBuildFarmJob)

    classProvides(IBuildFarmJobSource)

    id = Int(primary=True)

    processor_id = Int(name='processor', allow_none=True)

    processor = Reference(processor_id, 'Processor.id')

    virtualized = Bool()

    date_created = DateTime(

        name='date_created', allow_none=False, tzinfo=pytz.UTC)

    date_started = DateTime(

        name='date_started', allow_none=True, tzinfo=pytz.UTC)

    date_finished = DateTime(

        name='date_finished', allow_none=True, tzinfo=pytz.UTC)

    date_first_dispatched = DateTime(

        name='date_first_dispatched', allow_none=True, tzinfo=pytz.UTC)

    builder_id = Int(name='builder', allow_none=True)

    builder = Reference(builder_id, 'Builder.id')

    status = DBEnum(name='status', allow_none=False, enum=BuildStatus)

    log_id = Int(name='log', allow_none=True)

    log = Reference(log_id, 'LibraryFileAlias.id')

    job_type = DBEnum(

        name='job_type', allow_none=False, enum=BuildFarmJobType)

    failure_count = Int(name='failure_count', allow_none=False)

    dependencies = None

    def __init__(self, job_type, status=BuildStatus.NEEDSBUILD,

                 processor=None, virtualized=None, date_created=None):

        super(BuildFarmJob, self).__init__()

        self.job_type, self.status, self.processor, self.virtualized = (

            job_type,

            status,

            processor,

            virtualized,

            )

        if date_created is not None:

            self.date_created = date_created

    @classmethod

    def new(cls, job_type, status=BuildStatus.NEEDSBUILD, processor=None,

            virtualized=None, date_created=None):

        """See `IBuildFarmJobSource`."""

        build_farm_job = BuildFarmJob(

            job_type, status, processor, virtualized, date_created)

        store = IMasterStore(BuildFarmJob)

        store.add(build_farm_job)

        return build_farm_job

    @property

    def title(self):

        """See `IBuildFarmJob`."""

        return self.job_type.title

    @property

    def duration(self):

        """See `IBuildFarmJob`."""

        if self.date_started is None or self.date_finished is None:

            return None

        return self.date_finished - self.date_started

    def makeJob(self):

        """See `IBuildFarmJobOld`."""

        raise NotImplementedError

    def jobStarted(self):

        """See `IBuildFarmJob`."""

        self.status = BuildStatus.BUILDING

        # The build started, set the start time if not set already.

        self.date_started = UTC_NOW

        if self.date_first_dispatched is None:

            self.date_first_dispatched = UTC_NOW

    def jobReset(self):

        """See `IBuildFarmJob`."""

        self.status = BuildStatus.NEEDSBUILD

        self.date_started = None

    # The implementation of aborting a job is the same as resetting

    # a job.

    jobAborted = jobReset

    def jobCancel(self):

        """See `IBuildFarmJob`."""

        self.status = BuildStatus.CANCELLED

    @staticmethod

    def addCandidateSelectionCriteria(processor, virtualized):

        """See `IBuildFarmJob`."""

        return ('')

    @staticmethod

    def postprocessCandidate(job, logger):

        """See `IBuildFarmJob`."""

        return True

    @property

    def buildqueue_record(self):

        """See `IBuildFarmJob`."""

        return None

    @property

    def is_private(self):

        """See `IBuildFarmJob`.

        This base implementation assumes build farm jobs are public, but

        derived implementations can override as required.

        """

        return False

    @property

    def log_url(self):

        """See `IBuildFarmJob`.

        This base implementation of the property always returns None. Derived

        implementations need to override for their specific context.

        """

        return None

    def cleanUp(self):

        """See `IBuildFarmJobOld`.

        XXX 2010-05-04 michael.nelson bug=570939

        This can be removed once IBuildFarmJobOld is no longer used

        and services jobs are linked directly to IBuildFarmJob.

        """

        pass

    @property

    def was_built(self):

        """See `IBuild`"""

        return self.status not in [BuildStatus.NEEDSBUILD,

                                   BuildStatus.BUILDING,

                                   BuildStatus.CANCELLED,

                                   BuildStatus.CANCELLING,

                                   BuildStatus.UPLOADING,

                                   BuildStatus.SUPERSEDED]

    def getSpecificJob(self):

        """See `IBuild`"""

        # Adapt ourselves based on our job type.

        try:

            source = getUtility(

                ISpecificBuildFarmJobSource, self.job_type.name)

        except ComponentLookupError:

            raise InconsistentBuildFarmJobError(

                "No source was found for the build farm job type %s." % (

                    self.job_type.name))

        build = source.getByBuildFarmJob(self)

        if build is None:

            raise InconsistentBuildFarmJobError(

                "There is no related specific job for the build farm "

                "job with id %d." % self.id)

        # Just to be on the safe side, make sure the build is still

        # proxied before returning it.

        assert isProxy(build), (

            "Unproxied result returned from ISpecificBuildFarmJobSource.")

        return build

    def gotFailure(self):

        """See `IBuildFarmJob`."""

        self.failure_count += 1

class BuildFarmJobDerived:

    implements(IBuildFarmJob)

    delegates(IBuildFarmJob, context='build_farm_job')

class BuildFarmJobSet:

    implements(IBuildFarmJobSet)

    def getBuildsForBuilder(self, builder_id, status=None, user=None):

        """See `IBuildFarmJobSet`."""

        # Imported here to avoid circular imports.

        from lp.buildmaster.model.packagebuild import PackageBuild

        from lp.soyuz.model.archive import Archive

        extra_clauses = [BuildFarmJob.builder == builder_id]

        if status is not None:

            extra_clauses.append(BuildFarmJob.status == status)

        # We need to ensure that we don't include any private builds.

        # Currently only package builds can be private (via their

        # related archive), but not all build farm jobs will have a

        # related package build - hence the left join.

        origin = [

            BuildFarmJob,

            LeftJoin(

                PackageBuild,

                PackageBuild.build_farm_job == BuildFarmJob.id),

            ]

        # STORM syntax has totally obfuscated this query and wasted

        # THREE hours of my time converting perfectly good SQL syntax.  I'm

        # really sorry if you're the poor sap who has to maintain this.

        inner_privacy_query = (

            Union(

                Select(

                    Archive.id,

                    tables=(Archive,),

                    where=(Archive._private == False)

                    ),

                Select(

                    Archive.id,

                    tables=(Archive,),

                    where=And(

                        Archive._private == True,

                        Archive.ownerID.is_in(

                            Select(

                                TeamParticipation.teamID,

                                where=(TeamParticipation.person == user),

                                distinct=True

                            )

                        )

                    )

                )

            )

        )

        if user is None:

            # Anonymous requests don't get to see private builds at all.

            extra_clauses.append(

                Or(

                    PackageBuild.id == None,

                    PackageBuild.archive_id.is_in(

                        Select(

                            Archive.id,

                            tables=(Archive,),

                            where=(Archive._private == False)

                            )

                        )

                    )

                )

        elif user.inTeam(getUtility(ILaunchpadCelebrities).admin):

            # Admins get to see everything.

            pass

        else:

            # Everyone else sees all public builds and the

            # specific private builds to which they have access.

            extra_clauses.append(

                Or(

                    PackageBuild.id == None,

                    PackageBuild.archive_id.is_in(inner_privacy_query)

                    )

                )

        filtered_builds = IStore(BuildFarmJob).using(*origin).find(

            BuildFarmJob, *extra_clauses)

        filtered_builds.order_by(

            Desc(BuildFarmJob.date_finished), BuildFarmJob.id)

        filtered_builds.config(distinct=True)

        return filtered_builds

    def getByID(self, job_id):

        """See `IBuildfarmJobSet`."""

        job = IStore(BuildFarmJob).find(BuildFarmJob,

                BuildFarmJob.id == job_id).one()

        if job is None:

            raise NotFoundError(job_id)

        return job