~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).

"""Browser code for the launchpad application."""

__metaclass__ = type

__all__ = [

    'AppFrontPageSearchView',

    'DoesNotExistView',

    'Hierarchy',

    'IcingFolder',

    'iter_view_registrations',

    'LaunchpadImageFolder',

    'LaunchpadGraphics',

    'LaunchpadRootNavigation',

    'LinkView',

    'LoginStatus',

    'Macro',

    'MaintenanceMessage',

    'NavigationMenuTabs',

    'SoftTimeoutView',

    'get_launchpad_views',

    ]

import cgi

from datetime import timedelta

import operator

import os

import re

import time

import urllib

from lazr.uri import URI

from zope import i18n

from zope.app import zapi

from zope.component import (

    getGlobalSiteManager,

    getUtility,

    queryAdapter,

    )

from zope.datetime import (

    DateTimeError,

    parseDatetimetz,

    )

from zope.i18nmessageid import Message

from zope.interface import implements

from zope.publisher.interfaces import NotFound

from zope.publisher.interfaces.browser import IBrowserPublisher

from zope.publisher.interfaces.xmlrpc import IXMLRPCRequest

from zope.security.interfaces import Unauthorized

from zope.traversing.interfaces import ITraversable

from canonical.config import config

from canonical.launchpad.helpers import intOrZero

from canonical.launchpad.interfaces.launchpad import (

    IAppFrontPageSearchForm,

    IBazaarApplication,

    IRosettaApplication,

    )

from lp.services.statistics.interfaces.statistic import (

    ILaunchpadStatisticSet,

    )

from lp.services.verification.interfaces.logintoken import ILoginTokenSet

from lp.services.temporaryblobstorage.interfaces import (

    ITemporaryStorageManager,

    )

from canonical.launchpad.layers import WebServiceLayer

from canonical.launchpad.webapp import (

    canonical_name,

    canonical_url,

    LaunchpadView,

    Link,

    Navigation,

    StandardLaunchpadFacets,

    stepto,

    )

from canonical.launchpad.webapp.authorization import check_permission

from canonical.launchpad.webapp.breadcrumb import Breadcrumb

from canonical.launchpad.webapp.interfaces import (

    IBreadcrumb,

    ILaunchBag,

    ILaunchpadRoot,

    INavigationMenu,

    )

from canonical.launchpad.webapp.publisher import RedirectionView

from canonical.launchpad.webapp.url import urlappend

from canonical.launchpad.webapp.vhosts import allvhosts

from canonical.lazr import (

    ExportedFolder,

    ExportedImageFolder,

    )

from lp.answers.interfaces.questioncollection import IQuestionSet

from lp.app.browser.launchpadform import (

    custom_widget,

    LaunchpadFormView,

    )

from lp.app.browser.tales import (

    DurationFormatterAPI,

    MenuAPI,

    )

from lp.app.errors import (

    GoneError,

    NotFoundError,

    POSTToNonCanonicalURL,

    )

from lp.app.interfaces.headings import IMajorHeadingView

from lp.app.interfaces.launchpad import ILaunchpadCelebrities

from lp.app.widgets.project import ProjectScopeWidget

from lp.blueprints.interfaces.specification import ISpecificationSet

from lp.blueprints.interfaces.sprint import ISprintSet

from lp.bugs.interfaces.bug import IBugSet

from lp.bugs.interfaces.malone import IMaloneApplication

from lp.buildmaster.interfaces.builder import IBuilderSet

from lp.code.errors import (

    CannotHaveLinkedBranch,

    InvalidNamespace,

    NoLinkedBranch,

    )

from lp.code.interfaces.branch import IBranchSet

from lp.code.interfaces.branchlookup import IBranchLookup

from lp.code.interfaces.codeimport import ICodeImportSet

from lp.hardwaredb.interfaces.hwdb import IHWDBApplication

from lp.registry.interfaces.announcement import IAnnouncementSet

from lp.registry.interfaces.codeofconduct import ICodeOfConductSet

from lp.registry.interfaces.distribution import IDistributionSet

from lp.registry.interfaces.karma import IKarmaActionSet

from lp.registry.interfaces.nameblacklist import INameBlacklistSet

from lp.registry.interfaces.person import IPersonSet

from lp.registry.interfaces.pillar import IPillarNameSet

from lp.registry.interfaces.product import (

    InvalidProductName,

    IProductSet,

    )

from lp.registry.interfaces.projectgroup import IProjectGroupSet

from lp.registry.interfaces.sourcepackagename import ISourcePackageNameSet

from lp.services.identity.interfaces.account import AccountStatus

from lp.services.propertycache import cachedproperty

from lp.services.utils import utc_now

from lp.services.worlddata.interfaces.country import ICountrySet

from lp.services.worlddata.interfaces.language import ILanguageSet

from lp.soyuz.interfaces.binarypackagename import IBinaryPackageNameSet

from lp.soyuz.interfaces.packageset import IPackagesetSet

from lp.soyuz.interfaces.processor import (

    IProcessorFamilySet,

    IProcessorSet,

    )

from lp.testopenid.interfaces.server import ITestOpenIDApplication

from lp.translations.interfaces.translationgroup import ITranslationGroupSet

from lp.translations.interfaces.translationimportqueue import (

    ITranslationImportQueue,

    )

class NavigationMenuTabs(LaunchpadView):

    """View class that helps its template render the navigation menu tabs.

    Nothing at all is rendered if there are no navigation menu items.

    """

    def initialize(self):

        menuapi = MenuAPI(self.context)

        self.links = sorted([

            link for link in menuapi.navigation.values()

            if (link.enabled or config.devmode)],

            key=operator.attrgetter('sort_key'))

        self.title = None

        if len(self.links) > 0:

            facet = menuapi.selectedfacetname()

            menu = queryAdapter(self.context, INavigationMenu, name=facet)

            if menu is not None:

                self.title = menu.title

        self.enabled_links = [link for link in self.links if link.enabled]

    def render(self):

        if not self.links:

            return ''

        else:

            return self.template()

class LinkView(LaunchpadView):

    """View class that helps its template render a menu link.

    The link is not rendered if it's not enabled and we are not in development

    mode.

    """

    MODIFY_ICONS = ('edit', 'remove', 'trash-icon')

    @property

    def sprite_class(self):

        """Return the class used to display the link's icon."""

        if self.context.icon in self.MODIFY_ICONS:

            # The 3.0 UI design says these are displayed like other icons

            # But they do not have the same use so we want to keep this rule

            # separate.

            return 'sprite modify'

        else:

            return 'sprite'

    def render(self):

        """Render the menu link if it's enabled or we're in dev mode."""

        if self.context.enabled or config.devmode:

            # XXX: Tom Berger 2008-04-16 bug=218706:

            # We strip the result of the template rendering

            # since ZPT seems to always insert a line break

            # at the end of an embedded template.

            return self.template().strip()

        else:

            return ''

    @property

    def css_class(self):

        """Return the CSS class."""

        value = ["menu-link-%s" % self.context.name]

        if not self.context.linked:

            value.append('nolink')

        if self.context.icon:

            value.append(self.sprite_class)

            value.append(self.context.icon)

        if self.context.hidden:

            value.append('invisible-link')

        return " ".join(value)

    @property

    def url(self):

        """Return the url if linked."""

        if self.context.linked:

            return self.context.url

        return ''

    @property

    def summary(self):

        """Return the summary if linked."""

        if self.context.linked:

            return self.context.summary

        return ''

class Hierarchy(LaunchpadView):

    """The hierarchy part of the location bar on each page."""

    vhost_breadcrumb = True

    @property

    def objects(self):

        """The objects for which we want breadcrumbs."""

        return self.request.traversed_objects

    @cachedproperty

    def items(self):

        """Return a list of `IBreadcrumb` objects visible in the hierarchy.

        The list starts with the breadcrumb closest to the hierarchy root.

        """

        breadcrumbs = []

        for obj in self.objects:

            breadcrumb = IBreadcrumb(obj, None)

            if breadcrumb is not None:

                breadcrumbs.append(breadcrumb)

        host = URI(self.request.getURL()).host

        mainhost = allvhosts.configs['mainsite'].hostname

        if (len(breadcrumbs) != 0 and

            host != mainhost and

            self.vhost_breadcrumb):

            # We have breadcrumbs and we're not on the mainsite, so we'll

            # sneak an extra breadcrumb for the vhost we're on.

            vhost = host.split('.')[0]

            # Iterate over the context of our breadcrumbs in reverse order and

            # for the first one we find an adapter named after the vhost we're

            # on, generate an extra breadcrumb and insert it in our list.

            for idx, breadcrumb in reversed(list(enumerate(breadcrumbs))):

                extra_breadcrumb = queryAdapter(

                    breadcrumb.context, IBreadcrumb, name=vhost)

                if extra_breadcrumb is not None:

                    breadcrumbs.insert(idx + 1, extra_breadcrumb)

                    break

        if len(breadcrumbs) > 0:

            page_crumb = self.makeBreadcrumbForRequestedPage()

            if page_crumb:

                breadcrumbs.append(page_crumb)

        return breadcrumbs

    @property

    def _naked_context_view(self):

        """Return the unproxied view for the context of the hierarchy."""

        from zope.security.proxy import removeSecurityProxy

        if len(self.request.traversed_objects) > 0:

            return removeSecurityProxy(self.request.traversed_objects[-1])

        else:

            return None

    def makeBreadcrumbForRequestedPage(self):

        """Return an `IBreadcrumb` for the requested page.

        The `IBreadcrumb` for the requested page is created using the current

        URL and the page's name (i.e. the last path segment of the URL).

        If the requested page (as specified in self.request) is the default

        one for our parent view's context, return None.

        """

        url = self.request.getURL()

        obj = self.request.traversed_objects[-2]

        default_view_name = zapi.getDefaultViewName(obj, self.request)

        view = self._naked_context_view

        if view.__name__ != default_view_name:

            title = getattr(view, 'page_title', None)

            if title is None:

                title = getattr(view, 'label', None)

            if isinstance(title, Message):

                title = i18n.translate(title, context=self.request)

            breadcrumb = Breadcrumb(None)

            breadcrumb._url = url

            breadcrumb.text = title

            return breadcrumb

        else:

            return None

    @property

    def display_breadcrumbs(self):

        """Return whether the breadcrumbs should be displayed."""

        # If there is only one breadcrumb then it does not make sense

        # to display it as it will simply repeat the context.title.

        # If the view is an IMajorHeadingView then we do not want

        # to display breadcrumbs either.

        has_major_heading = IMajorHeadingView.providedBy(

            self._naked_context_view)

        return len(self.items) > 1 and not has_major_heading

class Macro:

    """Keeps templates that are registered as pages from being URL accessable.

    The standard pattern in LP is to register templates that contain macros as

    views on all objects:

    <browser:page

        for="*"

        name="+main-template-macros"

        template="../templates/base-layout-macros.pt"

        permission="zope.Public"

        />

    Without this class, that pattern would make the template URL traversable

    from any object.  Therefore requests like these would all "work":

        http://launchpad.net/+main-template-macros

        http://launchpad.net/ubuntu/+main-template-macros

        http://launchpad.net/ubuntu/+main-template-macros

        https://blueprints.launchpad.dev/ubuntu/hoary/+main-template-macros

    Obviously, those requests wouldn't do anything useful and would instead

    generate an OOPS.

    It would be nice to use a different pattern for macros instead, but we've

    grown dependent on some of the peculiatrities of registering macro

    templates in this way.

    This class was created in order to prevent macro templates from being

    accessable via URL without having to make nontrivial changes to the many,

    many templates that use macros.  To use the class add a "class" parameter

    to macro template registrations:

    <browser:page

        for="*"

        name="+main-template-macros"

        template="../templates/base-layout-macros.pt"

        class="lp.app.browser.launchpad.Macro"

        permission="zope.Public"

        />

    """

    implements(IBrowserPublisher, ITraversable)

    def __init__(self, context, request):

        self.context = context

    def traverse(self, name, furtherPath):

        return self.index.macros[name]

    def browserDefault(self, request):

        return self, ()

    def publishTraverse(self, request, name):

        raise NotFound(self.context, self.__name__)

    def __call__(self):

        raise NotFound(self.context, self.__name__)

class MaintenanceMessage:

    """Display a maintenance message if the control file is present and

    it contains a valid iso format time.

    The maintenance message shows the approximate time before launchpad will

    be taken offline for maintenance.

    The control file is +maintenancetime.txt in the launchpad root.

    If there is no maintenance message, an empty string is returned.

    If the maintenance time is too far in the future, then an empty string

    is returned.

    If the maintenance time is in the past, then the maintenance message says

    that Launchpad will go offline "very very soon".

    If the text in the maintenance message is poorly formatted, then an

    empty string is returned, and a warning should be logged.

    """

    timelefttext = None

    notmuchtime = timedelta(seconds=30)

    toomuchtime = timedelta(seconds=1800)  # 30 minutes

    def __call__(self):

        if os.path.exists('+maintenancetime.txt'):

            message = file('+maintenancetime.txt').read()

            try:

                maintenancetime = parseDatetimetz(message)

            except DateTimeError:

                # XXX SteveAlexander 2005-09-22: log a warning here.

                return ''

            timeleft = maintenancetime - utc_now()

            if timeleft > self.toomuchtime:

                return ''

            elif timeleft < self.notmuchtime:

                self.timelefttext = 'very very soon'

            else:

                self.timelefttext = 'in %s' % (

                    DurationFormatterAPI(timeleft).approximateduration())

            return self.index()

        return ''

class LaunchpadRootFacets(StandardLaunchpadFacets):

    usedfor = ILaunchpadRoot

    enable_only = ['overview', 'bugs', 'answers', 'specifications',

                   'translations', 'branches']

    def overview(self):

        target = ''

        text = 'Launchpad Home'

        return Link(target, text)

    def translations(self):

        target = ''

        text = 'Translations'

        return Link(target, text)

    def bugs(self):

        target = ''

        text = 'Bugs'

        return Link(target, text)

    def answers(self):

        target = ''

        text = 'Answers'

        summary = 'Launchpad Answer Tracker'

        return Link(target, text, summary)

    def specifications(self):

        target = ''

        text = 'Blueprints'

        summary = 'Launchpad feature specification tracker.'

        return Link(target, text, summary)

    def branches(self):

        target = ''

        text = 'Code'

        summary = 'The Code Bazaar'

        return Link(target, text, summary)

class LoginStatus:

    def __init__(self, context, request):

        self.context = context

        self.request = request

        self.user = getUtility(ILaunchBag).user

    @property

    def login_shown(self):

        return (self.user is None and

                '+login' not in self.request['PATH_INFO'])

    @property

    def logged_in(self):

        return self.user is not None

    @property

    def login_url(self):

        query_string = self.request.get('QUERY_STRING', '')

        # If we have a query string, remove some things we don't want, and

        # keep it around.

        if query_string:

            query_dict = cgi.parse_qs(query_string, keep_blank_values=True)

            query_dict.pop('loggingout', None)

            query_string = urllib.urlencode(

                sorted(query_dict.items()), doseq=True)

            # If we still have a query_string after things we don't want

            # have been removed, add it onto the url.

            if query_string:

                query_string = '?' + query_string

        # The approach we're taking is to combine the application url with

        # the path_info, taking out path steps that are to do with virtual

        # hosting.  This is not exactly correct, as the application url

        # can have other path steps in it.  We're not using the feature of

        # having other path steps in the application url, so this will work

        # for us, assuming we don't need that in the future.

        # The application_url is typically like 'http://thing:port'. No

        # trailing slash.

        application_url = self.request.getApplicationURL()

        # We're going to use PATH_INFO to remove any spurious '+index' at the

        # end of the URL.  But, PATH_INFO will contain virtual hosting

        # configuration, if there is any.

        path_info = self.request['PATH_INFO']

        # Remove any virtual hosting segments.

        path_steps = []

        in_virtual_hosting_section = False

        for step in path_info.split('/'):

            if step.startswith('++vh++'):

                in_virtual_hosting_section = True

                continue

            if step == '++':

                in_virtual_hosting_section = False

                continue

            if not in_virtual_hosting_section:

                path_steps.append(step)

        path = '/'.join(path_steps)

        # Make the URL stop at the end of path_info so that we don't get

        # spurious '+index' at the end.

        full_url = '%s%s' % (application_url, path)

        if full_url.endswith('/'):

            full_url = full_url[:-1]

        logout_url_end = '/+logout'

        openid_callback_url_end = '/+openid-callback'

        if full_url.endswith(logout_url_end):

            full_url = full_url[:-len(logout_url_end)]

        elif full_url.endswith(openid_callback_url_end):

            full_url = full_url[:-len(openid_callback_url_end)]

        else:

            # No need to remove anything from full_url.

            pass

        return '%s/+login%s' % (full_url, query_string)

class LaunchpadRootNavigation(Navigation):

    usedfor = ILaunchpadRoot

    @stepto('support')

    def redirect_support(self):

        """Redirect /support to launchpad Answers site."""

        target_url = canonical_url(

            getUtility(ILaunchpadCelebrities).launchpad, rootsite='answers')

        return self.redirectSubTree(target_url, status=301)

    @stepto('legal')

    def redirect_legal(self):

        """Redirect /legal to help.launchpad.net/Legal site."""

        return self.redirectSubTree(

            'https://help.launchpad.net/Legal', status=301)

    @stepto('faq')

    def redirect_faq(self):

        """Redirect /faq to launchpad-project/+faqs."""

        return self.redirectSubTree(

            'https://answers.launchpad.net/launchpad-project/+faqs',

            status=301)

    @stepto('feedback')

    def redirect_feedback(self):

        """Redirect /feedback to help.launchpad.net/Feedback site."""

        return self.redirectSubTree(

            'https://help.launchpad.net/Feedback', status=301)

    @stepto('+branch')

    def redirect_branch(self):

        """Redirect /+branch/<foo> to the branch named 'foo'.

        'foo' can be the unique name of the branch, or any of the aliases for

        the branch.

        If 'foo' resolves to an ICanHasLinkedBranch instance but the linked

        branch is not yet set, redirect back to the referring page with a

        suitable notification message.

        If 'foo' is completely invalid, redirect back to the referring page

        with a suitable error message.

        """

        # The default target url to go to will be back to the referring page

        # (in the case that there is an error resolving the branch url).

        # Note: the http referer may be None if someone has hacked a url

        # directly rather than following a /+branch/<foo> link.

        target_url = self.request.getHeader('referer')

        path = '/'.join(self.request.stepstogo)

        try:

            branch_data = getUtility(IBranchLookup).getByLPPath(path)

            branch, trailing = branch_data

            target_url = canonical_url(branch)

            if trailing is not None:

                target_url = urlappend(target_url, trailing)

        except (NoLinkedBranch), e:

            # A valid ICanHasLinkedBranch target exists but there's no

            # branch or it's not visible.

            # If are aren't arriving at this invalid branch URL from

            # another page then we just raise a NotFoundError to generate

            # a 404, otherwise we end up in a bad recursion loop. The

            # target url will be None in that case.

            if target_url is None:

                raise NotFoundError

            self.request.response.addNotification(

                "The target %s does not have a linked branch." % path)

        except (CannotHaveLinkedBranch, InvalidNamespace,

                InvalidProductName, NotFoundError), e:

            # If are aren't arriving at this invalid branch URL from another

            # page then we just raise a NotFoundError to generate a 404,

            # otherwise we end up in a bad recursion loop. The target url will

            # be None in that case.

            if target_url is None:

                raise NotFoundError

            error_msg = str(e)

            if error_msg == '':

                error_msg = "Invalid branch lp:%s." % path

            self.request.response.addErrorNotification(error_msg)

        return self.redirectSubTree(target_url)

    @stepto('+builds')

    def redirect_buildfarm(self):

        """Redirect old /+builds requests to new URL, /builders."""

        new_url = '/builders'

        return self.redirectSubTree(

            urlappend(new_url, '/'.join(self.request.stepstogo)))

    # XXX cprov 2009-03-19 bug=345877: path segments starting with '+'

    # should never correspond to a valid traversal, they confuse the

    # hierarchical navigation model.

    stepto_utilities = {

        '+announcements': IAnnouncementSet,

        'binarypackagenames': IBinaryPackageNameSet,

        'branches': IBranchSet,

        'bugs': IMaloneApplication,

        'builders': IBuilderSet,

        '+code': IBazaarApplication,

        '+code-imports': ICodeImportSet,

        'codeofconduct': ICodeOfConductSet,

        '+countries': ICountrySet,

        'distros': IDistributionSet,

        '+hwdb': IHWDBApplication,

        'karmaaction': IKarmaActionSet,

        '+imports': ITranslationImportQueue,

        '+languages': ILanguageSet,

        '+nameblacklist': INameBlacklistSet,

        'package-sets': IPackagesetSet,

        'people': IPersonSet,

        'pillars': IPillarNameSet,

        '+processor-families': IProcessorFamilySet,

        '+processors': IProcessorSet,

        'projects': IProductSet,

        'projectgroups': IProjectGroupSet,

        'sourcepackagenames': ISourcePackageNameSet,

        'specs': ISpecificationSet,

        'sprints': ISprintSet,

        '+statistics': ILaunchpadStatisticSet,

        'token': ILoginTokenSet,

        '+groups': ITranslationGroupSet,

        'translations': IRosettaApplication,

        'testopenid': ITestOpenIDApplication,

        'questions': IQuestionSet,

        'temporary-blobs': ITemporaryStorageManager,

        # These three have been renamed, and no redirects done, as the old

        # urls now point to the product pages.

        #'bazaar': IBazaarApplication,

        #'malone': IMaloneApplication,

        #'rosetta': IRosettaApplication,

        }

    @stepto('products')

    def products(self):

        return self.redirectSubTree(

            canonical_url(getUtility(IProductSet)), status=301)