def content(self, req, cxt): status = self.getStatus(req) cxt['path_to_codebases'] = path_to_codebases(req, self.project.name) cxt['selectedproject'] = self.project.name codebases = {} getCodebasesArg(req, codebases) project_json = SingleProjectJsonResource(status, self.project) project_dict = yield project_json.asDict(req) url = status.getBuildbotURL() + path_to_json_builders(req, self.project.name) filters = { "project": self.project.name, "sources": codebases } cxt['instant_json']['builders'] = {"url": url, "data": json.dumps(project_dict, separators=(',', ':')), "waitForPush": status.master.config.autobahn_push, "pushFilters": { "buildStarted": filters, "buildFinished": filters, "requestSubmitted": filters, "requestCancelled": filters, "stepStarted": filters, "stepFinished": filters, }} template = req.site.buildbot_service.templates.get_template("builders.html") defer.returnValue(template.render(**cxt))
def asDict(self, request): result = {'builders': []} #Get codebases codebases = {} getCodebasesArg(request=request, codebases=codebases) result['latestRevisions'] = yield self.getLatestRevision(codebases) encoding = getRequestCharset(request) branches = [ branch.decode(encoding) for branch in request.args.get("branch", []) if branch ] result['comparisonURL'] = path_to_comparison(request, self.project_status.name, codebases) defers = [] for name in self.children: child = self.getChildWithDefault(name, request) d = child.asDict(request, codebases, branches, True) defers.append(d) for d in defers: r = yield d result['builders'].append(r) defer.returnValue(result)
def asDict(self, request): #Get codebases codebases = {} getCodebasesArg(request=request, codebases=codebases) # Get pending request filtered + sorted pendingBuilds = yield self.builder.getPendingBuildRequestStatusesDicts( codebases=codebases) defer.returnValue(pendingBuilds)
def asDict(self, request, params=None): include_steps = True include_props = True # We pass params only if we are doing this directly and not from a user args = request.args if params is not None: args = params if "steps" in args: include_steps = True if "1" in args["steps"] else False if "props" in args: include_props = True if "1" in args["props"] else False results = getResultsArg(request) if self.builder_status is not None: codebases = {} getCodebasesArg(request=request, codebases=codebases) encoding = getRequestCharset(request) branches = [ b.decode(encoding) for b in request.args.get("branch", []) if b ] builds = yield self.builder_status.generateFinishedBuildsAsync( branches=map_branches(branches), codebases=codebases, results=results, num_builds=self.number) defer.returnValue([ b.asDict(request, include_artifacts=True, include_failure_url=True, include_steps=include_steps, include_properties=include_props) for b in builds ]) return if self.slave_status is not None: slavename = self.slave_status.getName() builds = yield self.status.generateFinishedBuildsAsync( num_builds=self.number, results=results, slavename=slavename) defer.returnValue([ rb.asDict(request=request, include_steps=False) for rb in builds ]) return
def asDict(self, request=None): from buildbot.status.web.base import getCodebasesArg result = {} # Constant result['name'] = self.getName() # Transient result['text'] = self.getText() result['results'] = self.getResults() result['isStarted'] = self.isStarted() result['isFinished'] = self.isFinished() result['statistics'] = self.statistics result['times'] = self.getTimes() result['expectations'] = self.getExpectations() result['eta'] = self.getETA() result['step_number'] = self.step_number result['hidden'] = self.hidden args = getCodebasesArg(request) result['logs'] = [[ l.getName(), self.build.builder.status.getURLForThing(l) + args ] for l in self.getLogs()] result["urls"] = self.getURLs() if request is not None: from buildbot.status.web.base import path_to_step result['url'] = path_to_step(request, self) return result
def asDict(self, request=None, include_artifacts=False, include_failure_url=False, include_steps=True, include_properties=True): from buildbot.status.web.base import getCodebasesArg result = self.asBaseDict(request, include_artifacts=include_artifacts, include_failure_url=include_failure_url) # TODO(maruel): Add. #result['test_results'] = self.getTestResults() args = getCodebasesArg(request) result['logs'] = [[ l.getName(), self.master.status.getURLForThing(l) + args ] for l in self.getLogs()] result['isWaiting'] = False if include_steps: result['steps'] = [bss.asDict(request) for bss in self.steps] result = self.currentStepDict(result) # Transient if include_properties: result['properties'] = self.getProperties().asList() return result
def getURLForBuild(self, builder_name, build_number, friendly_name=None, sourcestamps=None): if friendly_name is None: friendly_name = builder_name url = {} prefix = self.getBuildbotURL() url['path'] = prefix + self.getBuildersPath(builder_name, build_number) \ + getCodebasesArg(sourcestamps=sourcestamps) url['text'] = self.getURLText(friendly_name, build_number) return url
def asDict(self, request): results = {} #Get codebases codebases = {} getCodebasesArg(request=request, codebases=codebases) # If max > buildCacheSize, it'll trash the cache... cache_size = self.builder_status.master.config.caches['Builds'] max = int(RequestArg(request, 'max', cache_size)) for i in range(0, max): child = self.getChildWithDefault(-i, request) if not isinstance(child, BuildJsonResource): continue if len(codebases ) == 0 or child.build_status.builder.foundCodebasesInBuild( child.build_status, codebases): results[child.build_status.getNumber()] = child.asDict(request) return results
def getMasterURL(bmdict, builder_name, build_number): url = {} buildbotURL = bmdict['buildbotURL'] if bmdict and 'buildbotURL' in bmdict else '' if not buildbotURL: log.msg("Did not find buildbotURL for buildrequest self.master.db.mastersconfig.getMasterURL(%d)" % brid) url['path'] = buildbotURL + self.getBuildersPath(builder_name, build_number) \ + getCodebasesArg(sourcestamps=sourcestamps) url['text'] = self.getURLText(name, build_number) return url
def asDict(self, request, codebases=None, branches=None, base_build_dict=False, params=None): # We pass params only if we are doing this directly and not from a user args = request.args if params is not None: args = params include_build_steps = self.getRequestArgumentValue( args=args, parameter="build_steps", defaultValue=True) include_build_props = self.getRequestArgumentValue( args=args, parameter="build_props", defaultValue=True) include_pending_builds = self.getRequestArgumentValue( args=args, parameter="pending_builds", defaultValue=False) if codebases is None or branches is None: #Get codebases codebases = {} getCodebasesArg(request=request, codebases=codebases) encoding = getRequestCharset(request) branches = [ branch.decode(encoding) for branch in request.args.get("branch", []) if branch ] builder_dict = yield self.builder_dict( self.builder, codebases, request, branches, base_build_dict, include_build_steps, include_build_props, include_pending_builds) if self.latest_rev: builder_dict['latestRevisions'] = yield self.getLatestRevision( codebases) defer.returnValue(builder_dict)
def asDict(self, request, params=None): include_steps = True include_props = True # We pass params only if we are doing this directly and not from a user args = request.args if params is not None: args = params if "steps" in args: include_steps = True if "1" in args["steps"] else False if "props" in args: include_props = True if "1" in args["props"] else False #Get codebases codebases = {} getCodebasesArg(request=request, codebases=codebases) builds = self.builder_status.getCachedBuilds(codebases=codebases) return [ b.asDict(include_steps=include_steps, include_properties=include_props) for b in builds ]
def render_GET(self, req): self._setContentType(req) self.req = req if self.original.isFinished(): req.setHeader("Cache-Control", "max-age=604800") else: req.setHeader("Cache-Control", "no-cache") # If plaintext is requested just return the content of the logfile if self.asDownload: with_headers = "_with_headers" if self.withHeaders else "" base_name = self.original.step.getName( ) + "_" + self.original.getName() + with_headers base_name = re.sub(r'[\W]', '_', base_name) + ".log" req.setHeader("Content-Disposition", "attachment; filename =\"" + base_name + "\"") return self.original.getTextWithHeaders( ) if self.withHeaders else self.original.getText() # Or open in new window if self.newWindow: req.setHeader("Content-Disposition", "inline") return self.original.getTextWithHeaders( ) if self.withHeaders else self.original.getText() # Else render the logs template self.template = req.site.buildbot_service.templates.get_template( "logs.html") self.chunk_template = req.site.buildbot_service.templates.get_template( "log_chunk.html") builder = self.original.step.build.builder build_id = self.original.step.build.number url_dict = self.original.master.status.getURLForBuild( builder.getName(), build_id) if self.iFrame: data = self.chunk_template.module.page_header(version) data = data.encode('utf-8') req.write(data) self.original.subscribeConsumer(ChunkConsumer(req, self)) return server.NOT_DONE_YET cxt = self.getContext(req) build = self.original.step.build builder_status = build.builder project = builder_status.getProject() cxt["pageTitle"] = "Log File Contents" cxt["new_window_url"] = req.path + "/plaintext" cxt["new_window_with_headers_url"] = req.path + "/plaintext_with_headers" cxt["download_url"] = req.path + "/download" cxt["download_with_headers_url"] = req.path + "/download_with_headers" cxt["iframe_url"] = req.path + "/iframe" cxt["builder_name"] = builder.getFriendlyName() cxt['path_to_builder'] = path_to_builder(req, builder_status) cxt['path_to_builders'] = path_to_builders(req, project) cxt["builder_url"] = url_dict['path'] + getCodebasesArg(request=req) cxt['path_to_codebases'] = path_to_codebases(req, project) cxt['path_to_build'] = path_to_build(req, build) cxt['build_number'] = build.getNumber() cxt['selectedproject'] = project data = self.template.render(**cxt) data = data.encode('utf-8') req.write(data) return ""
def content(self, req, cxt): b = self.builder_status master = self.getBuildmaster(req) # Grab all the parameters which are prefixed with 'property.'. # We'll use these to filter the builds and build requests we # show below. props = {} prop_prefix = 'property.' for arg, val in req.args.iteritems(): if arg.startswith(prop_prefix): props[arg[len(prop_prefix):]] = val[0] def prop_match(oprops): for key, val in props.iteritems(): if key not in oprops or val != str(oprops[key]): return False return True project = cxt['selectedproject'] = b.getProject() cxt['name'] = b.getName() cxt['friendly_name'] = b.getFriendlyName() cxt['description'] = b.getDescription() req.setHeader('Cache-Control', 'no-cache') codebases = {} getCodebasesArg(request=req, codebases=codebases) num_builds = int(req.args.get('numbuilds', [self.numbuilds])[0]) cxt['builder_url'] = path_to_builder(req, b, codebases=True) cxt['path_to_codebases'] = path_to_codebases(req, project) cxt['path_to_builders'] = path_to_builders(req, project) cxt['builder_name'] = b.getName() cxt['rt_update'] = req.args filters = { "project": self.builder_status.project, "builderName": b.getName(), "sources": codebases } project_params = { "build_steps": ["0"], "build_props": ["0"] } project_json = SingleProjectBuilderJsonResource(self.status, self.builder_status, latest_rev=True) project_dict = yield project_json.asDict(req, params=project_params) url = self.status.getBuildbotURL() + path_to_json_project_builder(req, project, self.builder_status.name) filtered_tags = filter_tags_by_codebases(project_dict['tags'], codebases, master.config.tag_as_branch_regex, master.config.regex_branches) cxt['instant_json']['project'] = {"url": url, "data": json.dumps(project_dict, separators=(',', ':')), "tags": filtered_tags, "waitForPush": self.status.master.config.autobahn_push, "pushFilters": { "buildStarted": filters, "buildFinished": filters, "stepStarted": filters, "stepFinished": filters, }} pending_json = SinglePendingBuildsJsonResource(self.status, self.builder_status) pending_dict = yield pending_json.asDict(req) pending_url = self.status.getBuildbotURL() + path_to_json_pending(req, self.builder_status.name) cxt['instant_json']['pending_builds'] = {"url": pending_url, "data": json.dumps(pending_dict, separators=(',', ':')), "waitForPush": self.status.master.config.autobahn_push, "pushFilters": { "buildStarted": filters, "requestSubmitted": filters, "requestCancelled": filters, }} builds_params = { "steps": ["0"], } builds_json = PastBuildsJsonResource(self.status, num_builds, builder_status=self.builder_status) builds_dict = yield builds_json.asDict(req, params=builds_params) builds_url = self.status.getBuildbotURL() + path_to_json_past_builds(req, self.builder_status.name, num_builds, filter_data=True) cxt['instant_json']['builds'] = {"url": builds_url, "data": json.dumps(builds_dict, separators=(',', ':')), "waitForPush": self.status.master.config.autobahn_push, "pushFilters": { "buildFinished": filters }} slave_params = { "build_steps": ["0"], "build_props": ["0"], "builders": ["0"] } slaves = b.getSlaves() slaves_array = [SlaveJsonResource(self.status, ss).asDict(req, params=slave_params) for ss in slaves] slaves_dict = FilterOut(slaves_array) url = self.status.getBuildbotURL() + path_to_json_builder_slaves(self.builder_status.getName()) cxt['instant_json']["slaves"] = self.getSlavesJsonResource(filters, url, slaves_dict) startslaves = BuilderStartSlavesJsonResources(self.status, self.builder_status) startslaves_dict = yield startslaves.asDict(req) url = self.status.getBuildbotURL() + \ path_to_json_builder_startslaves(self.builder_status.getName()) + "?filter=1" cxt['instant_json']["start_slaves"] = self.getSlavesJsonResource(filters, url, startslaves_dict) cxt['numbuilds'] = int(req.args.get('numbuilds', [self.numbuilds])[0]) buildForceContext(cxt, req, self.getBuildmaster(req), b.getName()) template = req.site.buildbot_service.templates.get_template("builder.html") defer.returnValue(template.render(**cxt))
def asBaseDict(self, request=None, include_current_step=False, include_artifacts=False, include_failure_url=False): from buildbot.status.web.base import getCodebasesArg result = {} sourcestamps = self.getSourceStamps() status = self.master.status args = getCodebasesArg(request, sourcestamps=sourcestamps) # Constant result['builderName'] = self.builder.name result['builderFriendlyName'] = self.builder.getFriendlyName() result['number'] = self.getNumber() result['reason'] = self.getReason() result['submittedTime'] = self.submitted result['owners'] = self.owners result['brids'] = self.brids result['buildChainID'] = self.buildChainID result['blame'] = self.getResponsibleUsers() result['url'] = status.getURLForThing(self) result['url']['path'] += args result['builder_url'] = status.getURLForThing(self.builder) + args result['builder_tags'] = self.builder.tags result['build_tags'] = self.getBuildTags() if self.resume: result['resume'] = self.resume if self.resumeSlavepool: result['resumeSlavepool'] = self.resumeSlavepool if include_failure_url: result['failure_url'] = self.get_failure_of_interest() if result['failure_url'] is not None: result['failure_url'] += args if include_artifacts: result['artifacts'] = self.get_artifacts() # Transient result['times'] = self.getTimes() result['text'] = self.getText() result['results'] = self.getResults() result['slave'] = self.getSlavename() slave = status.getSlave(self.getSlavename()) if slave is not None: result['slave_friendly_name'] = slave.getFriendlyName() result['slave_url'] = status.getURLForThing(slave) result['eta'] = self.getETA() #Lazy importing here to avoid python import errors from buildbot.status.web.base import css_classes result['results_text'] = css_classes.get(result['results'], "") if include_current_step: result = self.currentStepDict(result) # Constant project = None for p, obj in status.getProjects().iteritems(): if p == self.builder.project: project = obj break def getCodebaseObj(repo): for c in project.codebases: if c.values()[0]['repository'] == repo: return c.values()[0] stamp_array = [] for ss in sourcestamps: d = ss.asDict(status) c = getCodebaseObj(d['repository']) if c is not None and c.has_key("display_repository"): d['display_repository'] = c['display_repository'] else: d['display_repository'] = d['repository'] stamp_array.append(d) result['sourceStamps'] = stamp_array return result
def __prepare_context(self, request, cxt=None): """ This method prepares context for templates :param request: http request object :param cxt: default context variable :type cxt: dictionary :return: dictionary with variables for template """ if not cxt: context = {} else: context = cxt.copy() builder = self.build_status.getBuilder() context['builder_name'] = builder.name context['builder_friendly_name'] = builder.getFriendlyName() context['selected_project'] = builder.getProject() context['build_number'] = self.build_status.getNumber() context['custom_build_urls'] = self.build_status.getCustomUrls() context['source_stamps'] = self.build_status.getSourceStamps() context['got_revisions'] = self.build_status.getAllGotRevisions() context['slave_friendly_name'] = self.build_status.getSlavename() context['build_reason'] = self.build_status.getReason() context['build_is_resuming'] = self.build_status.isResuming() context['build_is_finished'] = self.build_status.isFinished() context['path_to_builder'] = path_to_builder( request, self.build_status.getBuilder()) context['path_to_builders'] = path_to_builders(request, builder.getProject()) context['path_to_codebases'] = path_to_codebases( request, builder.getProject()) context['build_url'] = path_to_build(request, self.build_status, False) context['slave_debug_url'] = self.getBuildmaster( request).config.slave_debug_url context['codebases_arg'] = getCodebasesArg(request=request) context['parent_build_url'] = None context['top_build_url'] = None start, end = self.build_status.getTimes() context['start'] = time.ctime(start) context['end'] = time.ctime(end) if end else None context['elapsed'] = None if not end: end = util.now() if start: context['elapsed'] = util.formatInterval(end - start) context['authz'] = self.getAuthz(request) context['has_changes'] = False context['tests_link'] = None context['resume'] = None context['top_build_name'] = None context['parent_build_name'] = None context['result_css'] = "" context['slave_url'] = "" context['steps'] = [] context['properties'] = [] return context
def content(self, req, cxt): status = self.getStatus(req) cxt = self.__prepare_context(req, cxt) slave_obj = None is_finished_build = self.build_status.isFinished() if is_finished_build: cxt['result_css'] = css_classes[self.build_status.getResults()] if is_finished_build and self.build_status.getTestResults(): cxt['tests_link'] = req.childLink("tests") try: slave_obj = status.getSlave(self.build_status.getSlavename()) except KeyError: pass if slave_obj: cxt['slave_friendly_name'] = slave_obj.getFriendlyName() cxt['slave_url'] = path_to_slave(req, slave_obj) if self.build_status.resume: cxt['resume'] = self.build_status.resume cxt['steps'] = yield get_steps( self.build_status.getSteps(), getCodebasesArg(req), req, ) parameters = self.__get_force_scheduler_parameters(req) cxt['properties'] = self.__get_properties(parameters) cxt['has_changes'] = any( map(lambda ss: ss.changes, self.build_status.getSourceStamps())) cxt['instant_json']['build'] = yield self.__prepare_instant_json( status, req) cxt['chained_build'] = yield req.site.buildbot_service.master.db.buildrequests.getBuildChain( self.build_status.buildChainID, ) current_build = next( ifilter(lambda x: x['id'] in self.build_status.brids, cxt['chained_build']), None, ) builder_project = self.build_status.getBuilder().getProject() if current_build: cxt['top_build_url'], cxt[ 'top_build_name'] = get_url_and_name_build_in_chain( current_build['startbrid'], cxt['chained_build'], builder_project, req, ) cxt['parent_build_url'], cxt[ 'parent_build_name'] = get_url_and_name_build_in_chain( current_build['triggeredbybrid'], cxt['chained_build'], builder_project, req, ) template = req.site.buildbot_service.templates.get_template( "build.html") defer.returnValue(template.render(**cxt))
def content(self, req, cxt): b = self.build_status status = self.getStatus(req) req.setHeader('Cache-Control', 'no-cache') builder = self.build_status.getBuilder() cxt['builder'] = builder cxt['builder_name'] = builder.getFriendlyName() cxt['build_number'] = b.getNumber() cxt['builder_name_link'] = urllib.quote( self.build_status.getBuilder().getName(), safe='') cxt['b'] = b project = cxt['selectedproject'] = builder.getProject() cxt['path_to_builder'] = path_to_builder(req, b.getBuilder()) cxt['path_to_builders'] = path_to_builders(req, project) cxt['path_to_codebases'] = path_to_codebases(req, project) cxt['build_url'] = path_to_build(req, b, False) cxt['slave_debug_url'] = self.getBuildmaster( req).config.slave_debug_url cxt['customBuildUrls'] = b.getCustomUrls() codebases_arg = cxt['codebases_arg'] = getCodebasesArg(request=req) cxt['build_chain_top_build_url'] = yield b.getTopBuildUrl( codebases_arg) if not b.isFinished(): cxt['stop_build_chain'] = False step = b.getCurrentStep() if not step: cxt['current_step'] = "[waiting for build slave]" else: if step.isWaitingForLocks(): cxt['current_step'] = "%s [waiting for build slave]" % step.getName( ) else: cxt['current_step'] = step.getName() when = b.getETA() if when is not None: cxt['when'] = util.formatInterval(when) cxt['when_time'] = time.strftime( "%H:%M:%S", time.localtime(time.time() + when)) else: cxt['result_css'] = css_classes[b.getResults()] if b.getTestResults(): cxt['tests_link'] = req.childLink("tests") ssList = b.getSourceStamps() sourcestamps = cxt['sourcestamps'] = ssList all_got_revisions = b.getAllGotRevisions() cxt['got_revisions'] = all_got_revisions try: slave_obj = status.getSlave(b.getSlavename()) if slave_obj is not None: cxt['slave_friendly_name'] = slave_obj.getFriendlyName() cxt['slave_url'] = path_to_slave(req, slave_obj) else: cxt['slave_friendly_name'] = b.getSlavename() cxt['slave_url'] = "" except KeyError: pass if b.resume: cxt['resume'] = b.resume cxt['steps'] = [] for s in b.getSteps(): step = {'name': s.getName()} if s.isFinished(): if s.isHidden(): continue step['css_class'] = css_classes[s.getResults()[0]] (start, end) = s.getTimes() step['time_to_run'] = util.formatInterval(end - start) elif s.isStarted(): if s.isWaitingForLocks(): step['css_class'] = "waiting" step['time_to_run'] = "waiting for locks" else: step['css_class'] = "running" step['time_to_run'] = "running" else: step['css_class'] = "not-started" step['time_to_run'] = "" cxt['steps'].append(step) step['link'] = path_to_step(req, s) step['text'] = " ".join(s.getText()) urls = [] getUrls = s.getURLs().items() for k, v in s.getURLs().items(): if isinstance(v, dict): if 'results' in v.keys() and v['results'] in css_classes: url_dict = dict(logname=k, url=v['url'] + codebases_arg, results=css_classes[v['results']]) else: url_dict = dict(logname=k, url=v['url'] + codebases_arg) else: url_dict = dict(logname=k, url=v + codebases_arg) urls.append(url_dict) step['urls'] = urls step['logs'] = [] for l in s.getLogs(): logname = l.getName() step['logs'].append({ 'link': req.childLink( "steps/%s/logs/%s%s" % (urllib.quote(s.getName(), safe=''), urllib.quote(logname, safe=''), codebases_arg)), 'name': logname }) scheduler = b.getProperty("scheduler", None) parameters = {} master = self.getBuildmaster(req) for sch in master.allSchedulers(): if isinstance(sch, ForceScheduler) and scheduler == sch.name: for p in sch.all_fields: parameters[p.name] = p ps = cxt['properties'] = [] for name, value, source in b.getProperties().asList(): if not isinstance(value, dict): cxt_value = unicode(value) else: cxt_value = value if name == 'submittedTime': cxt_value = time.ctime(value) p = {'name': name, 'value': cxt_value, 'source': source} if len(cxt_value) > 500: p['short_value'] = cxt_value[:500] if name in parameters: param = parameters[name] if isinstance(param, TextParameter): p['text'] = param.value_to_text(value) p['cols'] = param.cols p['rows'] = param.rows p['label'] = param.label ps.append(p) (start, end) = b.getTimes() cxt['start'] = time.ctime(start) cxt['elapsed'] = None if end and start: cxt['end'] = time.ctime(end) cxt['elapsed'] = util.formatInterval(end - start) elif start: now = util.now() cxt['elapsed'] = util.formatInterval(now - start) has_changes = False for ss in sourcestamps: has_changes = has_changes or ss.changes cxt['has_changes'] = has_changes cxt['authz'] = self.getAuthz(req) filters = {"number": b.getNumber()} build_json = BuildJsonResource(status, b) build_dict = yield build_json.asDict(req) cxt['instant_json']['build'] = { "url": path_to_json_build(status, req, builder.name, b.getNumber()), "data": json.dumps(build_dict, separators=(',', ':')), "waitForPush": status.master.config.autobahn_push, "pushFilters": { "buildStarted": filters, "buildFinished": filters, "stepStarted": filters, "stepFinished": filters, } } template = req.site.buildbot_service.templates.get_template( "build.html") defer.returnValue(template.render(**cxt))