Example #1
0
    def content(self, req, cxt):
        status = self.getStatus(req)
        # building = False
        # online = 0
        req.setHeader('Cache-Control', 'no-cache')
        # base_builders_url = "buildersresource/"
        base_builders_url = "builders/"
        cats = req.args.get('groups', False)
        if cats is not False:
            cats = cats.split(',')
        else:
            cats = None
        builders = req.args.get("builder", status.getBuilderNames(cats))
        branches = [b for b in req.args.get("branch", []) if b]
        num_cols = get_args_int(req.args, 'num', 5)
        
        cxt['num_cols'] = num_cols
        cxt['builders'] = []
        builders_grouped = {}
        groups_seq = {}  # sequence of groups
        for bn in builders:
            base_builder_url = base_builders_url + urllib.quote(bn, safe='')
            builder = status.getBuilder(bn)
            bld_props = status.botmaster.builders[bn].properties # hack into the structure
            categ = builder.category
            bname = bn
            if categ and bn.startswith(categ + '-'):
                bname = bname[len(categ)+1:]
            bname = html.escape(bname.replace('-',' ', 1))
            bldr_cxt = { 'name': bname , 'url': base_builder_url, 
                        'builds': [], 
                        'sequence': bld_props.get('sequence', 10) }
            if categ:
                if bld_props.get('group_public', True):
                    builders_grouped.setdefault(categ, []).append(bldr_cxt)
                    if 'group_seq' in bld_props:
                        groups_seq[categ] = bld_props['group_seq']
            else:
                cxt['builders'].append(bldr_cxt)

            
            # It is difficult to do paging here, because we are already iterating over the
            # builders, so won't have the same build names or rev-ids.
            builds = list(builder.generateFinishedBuilds(map_branches(branches), num_builds=num_cols))
            # builds.reverse()
            
            bldr_cxt['builds'] = []
            for build in builds[:num_cols]:
                url = (base_builder_url + "/builds/%d" % build.getNumber())
                build_cxt = {'url': url}
                bldr_cxt['builds'].append(build_cxt)
                try:
                    ss = build.getSourceStamp()
                    commiter = ""
                    if list(build.getResponsibleUsers()):
                        for who in build.getResponsibleUsers():
                            commiter += "%s" % html.escape(reduce_eml(who))
                    else:
                        commiter += "No Commiter Found !"
                    if ss.revision:
                        revision = ss.revision
                    label = '%s-%s: %s' % (str(revision), commiter, ''.join(build.text))
                except Exception:
                    label = None
                if not label:
                    label = "#%d" % build.getNumber()
                tftime = time.strftime('%a %d, %H:%M:%S', time.localtime(build.getTimes()[1]))
                ttitle = 'Test at: %s\n%s' %(ustr(tftime), html.escape(ustr(build.getReason())))
                class_b = "build%s" % build_get_class(build)
                
                build_cxt.update({ 'label': label, 'commiter': commiter,
                                'tftime': tftime, 'ttitle': ttitle,
                                'last_t': ustr(last_change(ss, True)),
                                'class_b': class_b })

            
            builder_status = builder.getState()[0]
            bldr_cxt['status'] = builder_status
        
        # Now, sort the builders and grouped:
        cxt['builders'].sort(key=lambda bld: bld['sequence'])
        for bldrs in builders_grouped.values():
            bldrs.sort(key=lambda bld: bld['sequence'])

        cxt['builders_grouped'] = [] # will be list of tuples
        for gk, bldrs in builders_grouped.items():
            cxt['builders_grouped'].append((groups_seq.get(gk,10), gk, bldrs))
            
        template = req.site.buildbot_service.templates.get_template(self.tpl_page)
        return template.render(**cxt)
Example #2
0
    def createSummary(self, log):
        """ Try to read the file-lint.sh output and parse results
        """
        severity = SUCCESS
        if self.args['repo_mode'] == 'server':
            repo_expr = r'bin/addons/([^/]+)/.+$'
        else:
            repo_expr = r'([^/]+)/.+$'

        t_results= {}
        
        repo_re = re.compile(repo_expr)
        for line in StringIO(log.getText()).readlines():
            for rem, sev in self.known_res:
                m = rem.match(line)
                if not m:
                    continue
                fname = m.group(1)
                if sev > severity:
                    severity = sev
                mf = repo_re.match(fname)
                if mf:
                    module = (mf.group(1), 'lint')
                else:
                    module = ('lint', 'rest')
                
                if module not in t_results:
                    t_results[module] = TestResult(name=module,
                                        results=SUCCESS,
                                        text='', logs={'stdout': u''})
                if t_results[module].results < sev:
                    t_results[module].results = sev
                if line.endswith('\r\n'):
                    line = line[:-2] + '\n'
                elif not line.endswith('\n'):
                    line += '\n'
                if sev > SUCCESS:
                    t_results[module].text += ustr(line)
                else:
                    t_results[module].logs['stdout'] += ustr(line)
                
                break # don't attempt more matching of the same line

        # use t_results
        for tr in t_results.values():
            if self.build_result < tr.results:
                self.build_result = tr.results
            # and, after it's clean..
            self.build.build_status.addTestResult(tr)

        self.build_result = severity

        build_id = self.build.requests[0].id # FIXME when builds have their class
        # self.descriptionDone = self.descriptionDone[:]
        self.build.builder.db.saveTResults(build_id, self.name,
                                            self.build_result, t_results.values())

        if severity >= FAILURE:
            try:
                orm_id = self.getProperty('orm_id') or '?'
            except KeyError:
                orm_id = '?'
            self.setProperty('failure_tag', 'openerp-buildfail-%s-%s' % \
                                (orm_id, build_id) )
Example #3
0
    def content(self, req, cxt):
        status = self.getStatus(req)
        # building = False
        # online = 0
        req.setHeader("Cache-Control", "no-cache")
        # base_builders_url = "buildersresource/"
        base_builders_url = "builders/"
        cats = req.args.get("groups", False)
        if cats is not False:
            cats = cats.split(",")
        else:
            cats = None
        builders = req.args.get("builder", status.getBuilderNames(cats))
        branches = [b for b in req.args.get("branch", []) if b]
        num_cols = get_args_int(req.args, "num", 5)

        cxt["num_cols"] = num_cols
        cxt["builders"] = []
        builders_grouped = {}
        groups_seq = {}  # sequence of groups
        for bn in builders:
            base_builder_url = base_builders_url + urllib.quote(bn, safe="")
            builder = status.getBuilder(bn)
            bld_props = status.botmaster.builders[bn].properties  # hack into the structure
            categ = builder.category
            bname = bn
            if categ and bn.startswith(categ + "-"):
                bname = bname[len(categ) + 1 :]
            bname = html.escape(bname.replace("-", " ", 1))
            bldr_cxt = {"name": bname, "url": base_builder_url, "builds": [], "sequence": bld_props.get("sequence", 10)}
            if categ:
                if bld_props.get("group_public", True):
                    builders_grouped.setdefault(categ, []).append(bldr_cxt)
                    if "group_seq" in bld_props:
                        groups_seq[categ] = bld_props["group_seq"]
            else:
                cxt["builders"].append(bldr_cxt)

            # It is difficult to do paging here, because we are already iterating over the
            # builders, so won't have the same build names or rev-ids.
            builds = list(builder.generateFinishedBuilds(map_branches(branches), num_builds=num_cols))
            # builds.reverse()

            bldr_cxt["builds"] = []
            for build in builds[:num_cols]:
                url = base_builder_url + "/builds/%d" % build.getNumber()
                build_cxt = {"url": url}
                bldr_cxt["builds"].append(build_cxt)
                try:
                    ss = build.getSourceStamp()
                    commiter = ""
                    if list(build.getResponsibleUsers()):
                        for who in build.getResponsibleUsers():
                            commiter += "%s" % html.escape(reduce_eml(who))
                    else:
                        commiter += "No Commiter Found !"
                    if ss.revision:
                        revision = ss.revision
                    label = "%s-%s: %s" % (str(revision), commiter, "".join(build.text))
                except Exception:
                    label = None
                if not label:
                    label = "#%d" % build.getNumber()
                tftime = time.strftime("%a %d, %H:%M:%S", time.localtime(build.getTimes()[1]))
                ttitle = "Test at: %s\n%s" % (ustr(tftime), html.escape(ustr(build.getReason())))
                class_b = "build%s" % build_get_class(build)

                build_cxt.update(
                    {
                        "label": label,
                        "commiter": commiter,
                        "tftime": tftime,
                        "ttitle": ttitle,
                        "last_t": ustr(last_change(ss, True)),
                        "class_b": class_b,
                    }
                )

            builder_status = builder.getState()[0]
            bldr_cxt["status"] = builder_status

        # Now, sort the builders and grouped:
        cxt["builders"].sort(key=lambda bld: bld["sequence"])
        for bldrs in builders_grouped.values():
            bldrs.sort(key=lambda bld: bld["sequence"])

        cxt["builders_grouped"] = []  # will be list of tuples
        for gk, bldrs in builders_grouped.items():
            cxt["builders_grouped"].append((groups_seq.get(gk, 10), gk, bldrs))

        template = req.site.buildbot_service.templates.get_template(self.tpl_page)
        return template.render(**cxt)