| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """ Source file for buildbot.status module modifications. """ |
| |
| import urllib |
| |
| import buildbot |
| import buildbot.util |
| import buildbot.status.web.base as base |
| import buildbot.status.web.console as console |
| import buildbot.status.web.waterfall as waterfall |
| import buildbot.status.builder as statusbuilder |
| import buildbot.status.web.changes |
| |
| from twisted.python import log |
| from twisted.python import components |
| from twisted.web import html |
| from zope.interface import declarations |
| |
| # pylint: disable=F0401 |
| import jinja2 |
| import re |
| import urllib |
| |
| from master.third_party import stats_bb8 as stats |
| |
| # A simplified version of the default 'shortrev' macro used in some jinja |
| # templates. This version isn't actually used for template processing; rather, |
| # it's used to shorten revision names in the waterfall view, which doesn't make |
| # much use of jinja templates. |
| def _ShortRev(rev): |
| if rev is not None: |
| return rev[:12] |
| |
| |
| class BuildBox(waterfall.BuildBox): |
| """Build the yellow starting-build box for a waterfall column. |
| |
| This subclass adds the builder's name to the box. It's otherwise identical |
| to the parent class, apart from naming syntax. |
| """ |
| def getBox(self, req): |
| b = self.original |
| number = b.getNumber() |
| url = base.path_to_build(req, b) |
| reason = b.getReason() |
| if reason: |
| text = (('%s<br><a href="%s">Build %d</a><br>%s') |
| % (b.getBuilder().getName(), url, number, html.escape(reason))) |
| else: |
| text = ('%s<br><a href="%s">Build %d</a>' |
| % (b.getBuilder().getName(), url, number)) |
| color = "yellow" |
| class_ = "start" |
| if b.isFinished() and not b.getSteps(): |
| # the steps have been pruned, so there won't be any indication |
| # of whether it succeeded or failed. Color the box red or green |
| # to show its status |
| color = b.getColor() |
| class_ = base.build_get_class(b) |
| return base.Box([text], color=color, class_="BuildStep " + class_) |
| |
| # First unregister ICurrentBox registered by waterfall.py. |
| # We won't be able to unregister it without messing with ALLOW_DUPLICATES |
| # in twisted.python.components. Instead, work directly with adapter to |
| # remove the component: |
| origInterface = statusbuilder.BuildStatus |
| origInterface = declarations.implementedBy(origInterface) |
| registry = components.getRegistry() |
| registry.register([origInterface], base.IBox, '', None) |
| components.registerAdapter(BuildBox, statusbuilder.BuildStatus, base.IBox) |
| |
| |
| class ChromiumStepBox(waterfall.StepBox): |
| """Apply _ShortRev to the revision numbers in 'update' status boxes.""" |
| |
| def getBox(self, req): |
| text = self.original.getText() |
| if len(text) > 1 and (text[0] == 'update' or text[0] == 'updating'): |
| text[1] = _ShortRev(text[1]) |
| return waterfall.StepBox.getBox(self, req) |
| |
| origInterface = statusbuilder.BuildStepStatus |
| origInterface = declarations.implementedBy(origInterface) |
| registry = components.getRegistry() |
| registry.register([origInterface], base.IBox, '', None) |
| components.registerAdapter(ChromiumStepBox, |
| statusbuilder.BuildStepStatus, |
| base.IBox) |
| |
| |
| class ChromiumChangeBox(buildbot.status.web.changes.ChangeBox): |
| """Apply _ShortRev to the change boxes in the left-hand column.""" |
| |
| def getBox(self, req): |
| url = req.childLink("../changes/%d" % self.original.number) |
| template = \ |
| req.site.buildbot_service.templates.get_template("change_macros.html") |
| who = '@'.join(self.original.getShortAuthor().split('@')[0:2]) |
| revision = _ShortRev(self.original.revision) |
| text = template.module.box_contents(url=url, |
| who=who, |
| pageTitle=self.original.comments, |
| revision=revision, |
| project=self.original.project) |
| return base.Box([text], |
| class_=' '.join(filter(None, ["Change", self.original.project]))) |
| |
| origInterface = buildbot.changes.changes.Change |
| origInterface = declarations.implementedBy(origInterface) |
| registry = components.getRegistry() |
| registry.register([origInterface], base.IBox, '', None) |
| components.registerAdapter(ChromiumChangeBox, |
| buildbot.changes.changes.Change, |
| base.IBox) |
| |
| |
| class HorizontalOneBoxPerBuilder(base.HtmlResource): |
| """This shows a table with one cell per build. The color of the cell is |
| the state of the most recently completed build. If there is a build in |
| progress, the ETA is shown in table cell. The table cell links to the page |
| for that builder. They are layed out, you guessed it, horizontally. |
| |
| builder=: show only builds for this builder. Multiple builder= arguments |
| can be used to see builds from any builder in the set. If no |
| builder= is given, shows them all. |
| """ |
| def __init__(self, builder_filter_fn=None, *args, **kwargs): |
| super(HorizontalOneBoxPerBuilder, self).__init__(*args, **kwargs) |
| self.builder_filter_fn = builder_filter_fn or (lambda b: True) |
| |
| |
| # pylint: disable=W0221 |
| def content(self, request, cxt): |
| status = self.getStatus(request) |
| builders = request.args.get("builder", status.getBuilderNames()) |
| cxt_builders = [] |
| categories = set() |
| for builder_name in builders: |
| if not self.builder_filter_fn(builder_name): |
| continue |
| try: |
| builder_status = status.getBuilder(builder_name) |
| except KeyError: |
| log.msg('status.getBuilder(%r) failed' % builder_name) |
| continue |
| classname = base.ITopBox(builder_status).getBox(request).class_ |
| title = builder_name |
| show_name = 'off' not in request.args.get('titles', ['off']) |
| url = (base.path_to_root(request) + "waterfall?builder=" + |
| urllib.quote(builder_name, safe='() ')) |
| category = builder_status.getCategory() |
| if category: |
| category = category.split('|')[0] |
| categories.add(category) |
| cxt_builders.append({'outcome': classname, |
| 'name': title, |
| 'url': url, |
| 'show_name': show_name, |
| 'category': category}) |
| cxt['builders'] = cxt_builders |
| cxt['categories'] = sorted(categories) |
| templates = request.site.buildbot_service.templates |
| template = templates.get_template("horizontal_one_box_per_build.html") |
| data = template.render(cxt) |
| return data |
| |
| |
| class WaterfallStatusResource(waterfall.WaterfallStatusResource): |
| """Don't serve up waterfall pages for builds older than the threshold.""" |
| |
| # pylint: disable=W0221 |
| def content(self, request, cxt): |
| cutoff = buildbot.util.now() - (60 * 60 * 24 * 2) |
| last_time = int(request.args.get('last_time', [0])[0]) |
| if (last_time and |
| last_time < cutoff and |
| not request.args.get('force', [False])[0]): |
| return """ |
| <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> |
| <html xmlns="http://www.w3.org/1999/xhtml"> |
| <head><title>Buildbot Waterfall Error</title></head> |
| <body><p>To prevent DOS of the waterfall, heavy requests like this |
| are blocked. If you know what you are doing, ask a Chromium trooper |
| how to bypass the protection.</p></body></html> |
| """ |
| # pylint: disable=E1121 |
| return waterfall.WaterfallStatusResource.content(self, request, cxt) |
| |
| |
| class ConsoleStatusResource(console.ConsoleStatusResource): |
| """Class that overrides default behavior of console.ConsoleStatusResource.""" |
| |
| def __init__(self, tagComparator=None, **kwargs): |
| """buildbot's TimeRevisionComparator doesn't work exactly right for git. |
| Allow it to be overridden with the tagComparator parameter.""" |
| super(ConsoleStatusResource, self).__init__(**kwargs) |
| if tagComparator: |
| self.comparator = tagComparator |
| |
| def displayPage(self, *args, **kwargs): |
| """Strip the 'who' parameter down to a valid e-mail address.""" |
| result = console.ConsoleStatusResource.displayPage(self, *args, **kwargs) |
| for revision in result['revisions']: |
| if 'who' not in revision: |
| continue |
| revision['who'] = '@'.join(revision['who'].split('@')[0:2]) |
| return result |
| |
| def BestRevisionJson(self, request, cxt): |
| data_fmt = '<html><head></head><body>\n%s</body></html>\n' |
| revision_fmt = '{\'revision\': \'%s\',\'results\' : [%s]}' |
| build_fmt = '{\'url\':\'color\': \'%s\', \'name\': \'%s\'}' |
| status = self.getStatus(request) |
| debugInfo = {} |
| d = self.getAllChanges(request, status, debugInfo) |
| def got_changes(allChanges): |
| debugInfo["from_cache"] = 0 |
| debugInfo["added_blocks"] = 0 |
| debugInfo["source_all"] = len(allChanges) |
| revisions = list(self.filterRevisions(allChanges, max_revs=40, |
| filter={})) |
| debugInfo["revision_final"] = len(revisions) |
| |
| # Fetch all the builds for all builders until we get the next build |
| # after lastRevision. |
| revision_text = [] |
| if revisions: |
| lastRevision = revisions[-1].revision |
| debugInfo["last_revision"] = lastRevision |
| |
| (builderList, allBuilds) = self.getAllBuildsForRevision( |
| status, request, lastRevision, 40, [], [], debugInfo, revisions) |
| |
| for revision in revisions: |
| builds = self.displayStatusLine(builderList, |
| allBuilds, |
| revision, |
| debugInfo)[0] |
| build_text = [] |
| for builder_builds in builds.values(): |
| for build in builder_builds: |
| build_text.append(build_fmt % ( |
| build['color'], urllib.quote(build['builderName']))) |
| revision_text.append(revision_fmt % ( |
| revision.revision, ''.join(build_text))) |
| |
| return data_fmt % ''.join(revision_text) |
| d.addCallback(got_changes) |
| return d |
| |
| def content(self, request, cxt): # pylint: disable=W0221 |
| """Override default reload setting""" |
| if 'json' in request.args and '213' in request.args['json']: |
| return self.BestRevisionJson(request, cxt) |
| if 'reload' not in request.args: |
| request.args['reload'] = ['9999999999'] |
| if not getattr(self.comparator, 'initialized', True): |
| return """ |
| <html><head></head><body> |
| <h2>console unavailable</h2> |
| <p>while buildbot master is starting up. Please try again in a few seconds.</p> |
| </body></html> |
| """ |
| # pylint: disable=E1121 |
| return console.ConsoleStatusResource.content(self, request, cxt) |
| |
| |
| def SetupChromiumPages(webstatus, tagComparator=None, customEndpoints=None, |
| console_repo_filter=None, console_builder_filter=None): |
| """Add customizations to default web reporting.""" |
| |
| def _tick_filter(n, stride): |
| n = ((n / stride) + 1) * stride |
| return [x for x in range(n+1) if x % (n/stride) == 0] |
| |
| if not customEndpoints: |
| customEndpoints = {} |
| orig_shortrev = webstatus.templates.filters['shortrev'] |
| |
| webstatus.templates.filters.update( |
| {'shortrev': lambda rev, repo: orig_shortrev(rev, repo).rstrip('.'), |
| 'longrev': lambda x, y: jinja2.escape(unicode(x)), |
| 'numstrip': lambda x: jinja2.escape(unicode(x.lstrip('0123456789'))), |
| 'quote': urllib.quote, |
| 'max': lambda x: reduce(max, x, 0), |
| 'average': lambda x: float(sum(x)) / float(max(len(x), 1)), |
| 'ticks': lambda x: ["{v:%d}" % y for y in _tick_filter(x, 12)], |
| 'addlinks': lambda x: re.sub( |
| r'(http://[^\s@]+)', r'<a href="\1">\1</a>', x), |
| 'fixname': lambda x: x.translate(None, ' -():'), |
| 'extract_index': lambda x, i: [y[i] for y in x], |
| }) |
| |
| kwargs = {} |
| if console_repo_filter: |
| kwargs['repository'] = console_repo_filter |
| if console_builder_filter: |
| kwargs['builder_filter_fn'] = console_builder_filter |
| console_ = ConsoleStatusResource( |
| orderByTime=webstatus.orderConsoleByTime, |
| tagComparator=tagComparator, |
| **kwargs) |
| |
| webstatus.putChild("stats", stats.StatsStatusResource()) |
| webstatus.putChild("waterfall", WaterfallStatusResource()) |
| webstatus.putChild("console", console_) |
| webstatus.putChild("grid", console_) |
| webstatus.putChild("tgrid", console_) |
| webstatus.putChild("horizontal_one_box_per_builder", |
| HorizontalOneBoxPerBuilder( |
| builder_filter_fn=console_builder_filter)) |
| for url, resource in customEndpoints.items(): |
| webstatus.putChild(url, resource) |
| return webstatus |
