~launchpad-pqm/launchpad/devel

# Copyright 2010-2012 Canonical Ltd.  This software is licensed under the

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

"""SourcePackageRecipe views."""

__metaclass__ = type

__all__ = [

    'SourcePackageRecipeAddView',

    'SourcePackageRecipeContextMenu',

    'SourcePackageRecipeEditView',

    'SourcePackageRecipeNavigationMenu',

    'SourcePackageRecipeRequestBuildsView',

    'SourcePackageRecipeView',

    ]

import itertools

from bzrlib.plugins.builder.recipe import (

    ForbiddenInstructionError,

    RecipeParseError,

    RecipeParser,

    )

from lazr.lifecycle.event import ObjectModifiedEvent

from lazr.lifecycle.snapshot import Snapshot

from lazr.restful.interface import (

    copy_field,

    use_template,

    )

from lazr.restful.interfaces import (

    IFieldHTMLRenderer,

    IWebServiceClientRequest,

    )

import simplejson

from storm.locals import Store

from z3c.ptcompat import ViewPageTemplateFile

from zope import component

from zope.app.form.browser.widget import Widget

from zope.app.form.interfaces import IView

from zope.component import getUtility

from zope.event import notify

from zope.formlib import form

from zope.interface import (

    implementer,

    implements,

    Interface,

    providedBy,

    )

from zope.schema import (

    Choice,

    Field,

    List,

    Text,

    TextLine,

    )

from zope.schema.interfaces import ICollection

from zope.schema.vocabulary import (

    SimpleTerm,

    SimpleVocabulary,

    )

from zope.security.proxy import isinstance as zope_isinstance

from lp import _

from lp.app.browser.launchpad import Hierarchy

from lp.app.browser.launchpadform import (

    action,

    custom_widget,

    has_structured_doc,

    LaunchpadEditFormView,

    LaunchpadFormView,

    render_radio_widget_part,

    )

from lp.app.browser.lazrjs import (

    BooleanChoiceWidget,

    InlineEditPickerWidget,

    InlinePersonEditPickerWidget,

    TextAreaEditorWidget,

    TextLineEditorWidget,

    )

from lp.app.browser.tales import format_link

from lp.app.validators.name import name_validator

from lp.app.widgets.itemswidgets import (

    LabeledMultiCheckBoxWidget,

    LaunchpadRadioWidget,

    )

from lp.app.widgets.suggestion import RecipeOwnerWidget

from lp.code.errors import (

    BuildAlreadyPending,

    NoSuchBranch,

    PrivateBranchRecipe,

    TooManyBuilds,

    TooNewRecipeFormat,

    )

from lp.code.interfaces.branchtarget import IBranchTarget

from lp.code.interfaces.sourcepackagerecipe import (

    ISourcePackageRecipe,

    ISourcePackageRecipeSource,

    MINIMAL_RECIPE_TEXT,

    )

from lp.code.model.branchtarget import PersonBranchTarget

from lp.code.model.sourcepackagerecipe import get_buildable_distroseries_set

from lp.registry.interfaces.series import SeriesStatus

from lp.services.fields import PersonChoice

from lp.services.propertycache import cachedproperty

from lp.services.webapp import (

    canonical_url,

    ContextMenu,

    enabled_with_permission,

    LaunchpadView,

    Link,

    NavigationMenu,

    structured,

    )

from lp.services.webapp.authorization import check_permission

from lp.services.webapp.breadcrumb import Breadcrumb

from lp.soyuz.interfaces.archive import ArchiveDisabled

from lp.soyuz.model.archive import Archive

class IRecipesForPerson(Interface):

    """A marker interface for source package recipe sets."""

class RecipesForPersonBreadcrumb(Breadcrumb):

    """A Breadcrumb to handle the "Recipes" link for recipe breadcrumbs."""

    rootsite = 'code'

    text = 'Recipes'

    implements(IRecipesForPerson)

    @property

    def url(self):

        return canonical_url(

            self.context, view_name="+recipes", rootsite='code')

class SourcePackageRecipeHierarchy(Hierarchy):

    """Hierarchy for Source Package Recipe."""

    vhost_breadcrumb = False

    @property

    def objects(self):

        """See `Hierarchy`."""

        traversed = list(self.request.traversed_objects)

        # Pop the root object

        yield traversed.pop(0)

        recipe = traversed.pop(0)

        while not ISourcePackageRecipe.providedBy(recipe):

            yield recipe

            recipe = traversed.pop(0)

        # Pop in the "Recipes" link to recipe listings.

        yield RecipesForPersonBreadcrumb(recipe.owner)

        yield recipe

        for item in traversed:

            yield item

class SourcePackageRecipeNavigationMenu(NavigationMenu):

    """Navigation menu for sourcepackage recipes."""

    usedfor = ISourcePackageRecipe

    facet = 'branches'

    links = ('edit', 'delete')

    @enabled_with_permission('launchpad.Edit')

    def edit(self):

        return Link('+edit', 'Edit recipe', icon='edit')

    @enabled_with_permission('launchpad.Edit')

    def delete(self):

        return Link('+delete', 'Delete recipe', icon='trash-icon')

class SourcePackageRecipeContextMenu(ContextMenu):

    """Context menu for sourcepackage recipes."""

    usedfor = ISourcePackageRecipe

    facet = 'branches'

    links = ('request_builds', 'request_daily_build',)

    def request_builds(self):

        """Provide a link for requesting builds of a recipe."""

        return Link('+request-builds', 'Request build(s)', icon='add')

    def request_daily_build(self):

        """Provide a link for requesting a daily build of a recipe."""

        recipe = self.context

        ppa = recipe.daily_build_archive

        if (ppa is None or not ppa.enabled or not recipe.build_daily or not

            recipe.is_stale or not recipe.distroseries):

            show_request_build = False

        else:

            has_upload = ppa.checkArchivePermission(recipe.owner)

            show_request_build = has_upload

        show_request_build = (show_request_build and

            check_permission('launchpad.Edit', recipe))

        return Link(

                '+request-daily-build', 'Build now',

                enabled=show_request_build)

class SourcePackageRecipeView(LaunchpadView):

    """Default view of a SourcePackageRecipe."""

    def initialize(self):

        super(SourcePackageRecipeView, self).initialize()

        recipe = self.context

        if recipe.build_daily and recipe.daily_build_archive is None:

            self.request.response.addWarningNotification(

                structured(

                    "Daily builds for this recipe will <strong>not</strong> "

                    "occur.<br/><br/>There is no PPA."))

        elif self.dailyBuildWithoutUploadPermission():

            self.request.response.addWarningNotification(

                structured(

                    "Daily builds for this recipe will <strong>not</strong> "

                    "occur.<br/><br/>The owner of the recipe (%s) does not "

                    "have permission to upload packages into the daily "

                    "build PPA (%s)" % (

                        format_link(recipe.owner),

                        format_link(recipe.daily_build_archive))))

    @property

    def page_title(self):

        return "%(name)s\'s %(recipe_name)s recipe" % {

            'name': self.context.owner.displayname,

            'recipe_name': self.context.name}

    label = page_title

    @property

    def builds(self):

        return builds_for_recipe(self.context)

    def dailyBuildWithoutUploadPermission(self):

        """Returns true if there are upload permissions to the daily archive.

        If the recipe isn't built daily, we don't consider this a problem.

        """

        recipe = self.context

        ppa = recipe.daily_build_archive

        if recipe.build_daily:

            has_upload = ppa.checkArchivePermission(recipe.owner)

            return not has_upload

        return False

    @property

    def person_picker(self):

        field = copy_field(

            ISourcePackageRecipe['owner'],

            vocabularyName='UserTeamsParticipationPlusSelfSimpleDisplay')

        return InlinePersonEditPickerWidget(

            self.context, field,

            format_link(self.context.owner),

            header='Change owner',

            step_title='Select a new owner')

    @property

    def archive_picker(self):

        field = ISourcePackageEditSchema['daily_build_archive']

        return InlineEditPickerWidget(

            self.context, field,

            format_link(self.context.daily_build_archive),

            header='Change daily build archive',

            step_title='Select a PPA')

    @property

    def recipe_text_widget(self):

        """The recipe text as widget HTML."""

        recipe_text = ISourcePackageRecipe['recipe_text']

        return TextAreaEditorWidget(self.context, recipe_text, title="")

    @property

    def daily_build_widget(self):

        return BooleanChoiceWidget(

            self.context, ISourcePackageRecipe['build_daily'],

            tag='span',

            false_text='Built on request',

            true_text='Built daily',

            header='Change build schedule')

    @property

    def description_widget(self):

        """The description as a widget."""

        description = ISourcePackageRecipe['description']

        return TextAreaEditorWidget(

            self.context, description, title="")

    @property

    def name_widget(self):

        name = ISourcePackageRecipe['name']

        title = "Edit the recipe name"

        return TextLineEditorWidget(self.context, name, title, 'h1')

    @property

    def distroseries_widget(self):

        from lp.app.browser.lazrjs import InlineMultiCheckboxWidget

        field = ISourcePackageEditSchema['distroseries']

        return InlineMultiCheckboxWidget(

            self.context,

            field,

            attribute_type="reference",

            vocabulary='BuildableDistroSeries',

            label="Distribution series:",

            label_tag="dt",

            header="Change default distribution series:",

            empty_display_value="None",

            selected_items=sorted(

                self.context.distroseries, key=lambda ds: ds.displayname),

            items_tag="dd",

            )

@component.adapter(ISourcePackageRecipe, ICollection,

                   IWebServiceClientRequest)

@implementer(IFieldHTMLRenderer)

def distroseries_renderer(context, field, request):

    """Render a distroseries collection as a set of links."""

    def render(value):

        distroseries = sorted(

            context.distroseries, key=lambda ds: ds.displayname)

        if not distroseries:

            return 'None'

        html = "<ul>"

        html += ''.join(

            ["<li>%s</li>" % format_link(series) for series in distroseries])

        html += "</ul>"

        return html

    return render

def builds_for_recipe(recipe):

        """A list of interesting builds.

        All pending builds are shown, as well as 1-5 recent builds.

        Recent builds are ordered by date finished (if completed) or

        date_started (if date finished is not set due to an error building or

        other circumstance which resulted in the build not being completed).

        This allows started but unfinished builds to show up in the view but

        be discarded as more recent builds become available.

        Builds that the user does not have permission to see are excluded.

        """

        builds = [build for build in recipe.pending_builds

            if check_permission('launchpad.View', build)]

        for build in recipe.completed_builds:

            if not check_permission('launchpad.View', build):

                continue

            builds.append(build)

            if len(builds) >= 5:

                break

        return builds

def new_builds_notification_text(builds, already_pending=None):

    nr_builds = len(builds)

    if not nr_builds:

        builds_text = "All requested recipe builds are already queued."

    elif nr_builds == 1:

        builds_text = "1 new recipe build has been queued."

    else:

        builds_text = "%d new recipe builds have been queued." % nr_builds

    if nr_builds > 0 and already_pending:

        builds_text = "<p>%s</p>%s" % (builds_text, already_pending)

    return structured(builds_text)

class SourcePackageRecipeRequestBuildsView(LaunchpadFormView):

    """A view for requesting builds of a SourcePackageRecipe."""

    @property

    def initial_values(self):

        """Set initial values for the widgets.

        The distroseries function as defaults for requesting a build.

        """

        initial_values = {'distroseries': self.context.distroseries}

        build = self.context.last_build

        if build:

            # If the build can't be viewed, the archive can't.

            if check_permission('launchpad.View', build):

                initial_values['archive'] = build.archive

        return initial_values

    class schema(Interface):

        """Schema for requesting a build."""

        archive = Choice(vocabulary='TargetPPAs', title=u'Archive')

        distroseries = List(

            Choice(vocabulary='BuildableDistroSeries'),

            title=u'Distribution series')

    custom_widget('distroseries', LabeledMultiCheckBoxWidget)

    def validate(self, data):

        distros = data.get('distroseries', [])

        if not len(distros):

            self.setFieldError('distroseries',

                "You need to specify at least one distro series for which "

                "to build.")

            return

        over_quota_distroseries = []

        for distroseries in data['distroseries']:

            if self.context.isOverQuota(self.user, distroseries):

                over_quota_distroseries.append(str(distroseries))

        if len(over_quota_distroseries) > 0:

            self.setFieldError(

                'distroseries',

                "You have exceeded today's quota for %s." %

                ', '.join(over_quota_distroseries))

    def requestBuild(self, data):

        """User action for requesting a number of builds.

        We raise exceptions for most errors but if there's already a pending

        build for a particular distroseries, we simply record that so that

        other builds can ne queued and a message be displayed to the caller.

        """

        informational = {}

        builds = []

        for distroseries in data['distroseries']:

            try:

                build = self.context.requestBuild(

                    data['archive'], self.user, distroseries, manual=True)

                builds.append(build)

            except BuildAlreadyPending, e:

                existing_message = informational.get("already_pending")

                if existing_message:

                    new_message = existing_message[:-1] + (

                                    ", and %s." % e.distroseries)

                else:

                    new_message = ("An identical build is "

                                "already pending for %s." % e.distroseries)

                informational["already_pending"] = new_message

        return builds, informational

class SourcePackageRecipeRequestBuildsHtmlView(

        SourcePackageRecipeRequestBuildsView):

    """Supports HTML form recipe build requests."""

    @property

    def title(self):

        return 'Request builds for %s' % self.context.name

    label = title

    @property

    def cancel_url(self):

        return canonical_url(self.context)

    @action('Request builds', name='request')

    def request_action(self, action, data):

        builds, informational = self.requestBuild(data)

        self.next_url = self.cancel_url

        already_pending = informational.get("already_pending")

        notification_text = new_builds_notification_text(

            builds, already_pending)

        self.request.response.addNotification(notification_text)

class SourcePackageRecipeRequestBuildsAjaxView(

        SourcePackageRecipeRequestBuildsView):

    """Supports AJAX form recipe build requests."""

    def _process_error(self, data=None, builds=None, informational=None,

                       errors=None, reason="Validation"):

        """Set up the response and json data to return to the caller."""

        self.request.response.setStatus(200, reason)

        self.request.response.setHeader('Content-type', 'application/json')

        return_data = dict(builds=builds, errors=errors)

        if informational:

            return_data.update(informational)

        return simplejson.dumps(return_data)

    def failure(self, action, data, errors):

        """Called by the form if validate() finds any errors.

           We simply convert the errors to json and return that data to the

           caller for display to the user.

        """

        return self._process_error(data=data, errors=self.widget_errors)

    @action('Request builds', name='request', failure=failure)

    def request_action(self, action, data):

        """User action for requesting a number of builds.

        The failure handler will handle any validation errors. We still need

        to handle errors which may occur when invoking the business logic.

        These "expected" errors are ones which result in a predefined message

        being displayed to the user. If the business method raises an

        unexpected exception, that will be handled using the form's standard

        exception processing mechanism (using response code 500).

        """

        builds, informational = self.requestBuild(data)

        # If there are errors we return a json data snippet containing the

        # errors as well as the form content. These errors are processed

        # by the caller's response handler and displayed to the user. The

        # form content may be rendered as well if required.

        if informational:

            builds_html = None

            if len(builds):

                builds_html = self.render()

            return self._process_error(

                data=data, builds=builds_html, informational=informational,

                reason="Request Build")

    @property

    def builds(self):

        return builds_for_recipe(self.context)

class SourcePackageRecipeRequestDailyBuildView(LaunchpadFormView):

    """Supports requests to perform a daily build for a recipe.

    Renders the recipe builds table so that the recipe index page can be

    updated with the new build records.

    This view works for both ajax and html form requests.

    """

    # Attributes for the html version

    page_title = "Build now"

    class schema(Interface):

        """Schema for requesting a build."""

    @action('Build now', name='build')

    def build_action(self, action, data):

        recipe = self.context

        try:

            builds = recipe.performDailyBuild()

        except (TooManyBuilds, ArchiveDisabled) as e:

            self.request.response.addErrorNotification(str(e))

            self.next_url = canonical_url(recipe)

            return

        if self.request.is_ajax:

            template = ViewPageTemplateFile(

                    "../templates/sourcepackagerecipe-builds.pt")

            return template(self)

        else:

            self.next_url = canonical_url(recipe)

            self.request.response.addNotification(

                    new_builds_notification_text(builds))

    @property

    def builds(self):

        return builds_for_recipe(self.context)

class ISourcePackageEditSchema(Interface):

    """Schema for adding or editing a recipe."""

    use_template(ISourcePackageRecipe, include=[

        'name',

        'description',

        'owner',

        'build_daily',

        'distroseries',

        ])

    daily_build_archive = Choice(vocabulary='TargetPPAs',

        title=u'Daily build archive',

        description=(

            u'If built daily, this is the archive where the package '

            u'will be uploaded.'))

    recipe_text = has_structured_doc(

        Text(

            title=u'Recipe text', required=True,

            description=u"""The text of the recipe.

                <a href="/+help-code/recipe-syntax.html" target="help"

                  >Syntax help 

                  <span class="sprite maybe">

                    <span class="invisible-link">Help</span>

                  </span></a>

               """))

EXISTING_PPA = 'existing-ppa'

CREATE_NEW = 'create-new'

USE_ARCHIVE_VOCABULARY = SimpleVocabulary((

    SimpleTerm(EXISTING_PPA, EXISTING_PPA, _("Use an existing PPA")),

    SimpleTerm(

        CREATE_NEW, CREATE_NEW, _("Create a new PPA for this recipe")),

    ))

class ISourcePackageAddSchema(ISourcePackageEditSchema):

    daily_build_archive = Choice(vocabulary='TargetPPAs',

        title=u'Daily build archive', required=False,

        description=(

            u'If built daily, this is the archive where the package '

            u'will be uploaded.'))

    use_ppa = Choice(

        title=_('Which PPA'),

        vocabulary=USE_ARCHIVE_VOCABULARY,

        description=_("Which PPA to use..."),

        required=True)

    ppa_name = TextLine(

            title=_("New PPA name"), required=False,

            constraint=name_validator,

            description=_("A new PPA with this name will be created for "

                          "the owner of the recipe ."))

class ErrorHandled(Exception):

    """A field error occured and was handled."""

class RecipeTextValidatorMixin:

    """Class to validate that the Source Package Recipe text is valid."""

    def validate(self, data):

        if data['build_daily']:

            if len(data['distroseries']) == 0:

                self.setFieldError(

                    'distroseries',

                    'You must specify at least one series for daily builds.')

        try:

            parser = RecipeParser(data['recipe_text'])

            parser.parse()

        except RecipeParseError, error:

            self.setFieldError('recipe_text', str(error))

    def error_handler(self, callable, *args, **kwargs):

        try:

            return callable(*args)

        except TooNewRecipeFormat:

            self.setFieldError(

                'recipe_text',

                'The recipe format version specified is not available.')

        except ForbiddenInstructionError, e:

            self.setFieldError(

                'recipe_text',

                'The bzr-builder instruction "%s" is not permitted '

                'here.' % e.instruction_name)

        except NoSuchBranch, e:

            self.setFieldError(

                'recipe_text', '%s is not a branch on Launchpad.' % e.name)

        except PrivateBranchRecipe, e:

            self.setFieldError('recipe_text', str(e))

        raise ErrorHandled()

class RelatedBranchesWidget(Widget):

    """A widget to render the related branches for a recipe."""

    implements(IView)

    __call__ = ViewPageTemplateFile(

        '../templates/sourcepackagerecipe-related-branches.pt')

    related_package_branch_info = []

    related_series_branch_info = []

    def hasInput(self):

        return True

    def setRenderedValue(self, value):

        self.related_package_branch_info = (

            value['related_package_branch_info'])

        self.related_series_branch_info = value['related_series_branch_info']