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 getBox(self, req):
urlbase = path_to_step(req, self.original)
text = self.original.getText()
if text is None:
log.msg("getText() gave None", urlbase)
text = []
text = text[:]
logs = self.original.getLogs()
cxt = dict(text=text, logs=[], urls=[])
for num in range(len(logs)):
name = logs[num].getName()
if logs[num].hasContents():
url = urlbase + "/logs/%s" % urllib.quote(name)
else:
url = None
cxt['logs'].append(dict(name=name, url=url))
for name, target in self.original.getURLs().items():
cxt['urls'].append(dict(link=target,name=name))
template = req.site.buildbot_service.templates.get_template("box_macros.html")
text = template.module.step_box(**cxt)
class_ = "BuildStep " + build_get_class(self.original)
return Box(text, class_=class_)
def getBox(self, req):
urlbase = path_to_step(req, self.original)
text = self.original.getText()
if text is None:
log.msg("getText() gave None", urlbase)
text = []
text = text[:]
logs = self.original.getLogs()
cxt = dict(text=text, logs=[], urls=[])
for num in range(len(logs)):
name = logs[num].getName()
if logs[num].hasContents():
url = urlbase + "/logs/%s" % urllib.quote(name)
else:
url = None
cxt['logs'].append(dict(name=name, url=url))
for name, target in self.original.getURLs().items():
cxt['urls'].append(dict(link=target,name=name))
template = req.site.buildbot_service.templates.get_template("box_macros.html")
text = template.module.step_box(**cxt)
class_ = "BuildStep " + build_get_class(self.original)
return Box(text, class_=class_)
def getBox(self, req):
urlbase = path_to_step(req, self.original)
text = self.original.getText()
if text is None:
log.msg("getText() gave None", urlbase)
text = []
text = text[:]
def native_link_fn(l):
if l.hasContents():
url = urlbase + "/logs/%s" % urllib.quote(l.getName())
else:
url = None
return url
logs, urls, _ = getStepLogsURLsAndAliases(
self.original,
False,
native_link_fn,
)
cxt = dict(text=text, logs=logs, urls=urls)
template = req.site.buildbot_service.templates.get_template(
"box_macros.html")
text = template.module.step_box(**unicodify(cxt))
class_ = "BuildStep " + build_get_class(self.original)
return Box(text,
class_=class_,
buildNumber=self.original.build_number,
builder=self.original.builder.getName(),
stepName=self.original.getName())
def get_steps(steps_list, codebases_arg, request):
""" This function return steps list with full description
:param steps_list: list of steps in build (object must implement IBuildStepStatus)
:param codebases_arg: additional parameters for url
:param request: http request object
:return:
"""
steps = []
for step in steps_list:
step_obj = {
'name': step.getName(),
'css_class': 'not-started',
'time_to_run': '',
'link': path_to_step(request, step),
'text': ' '.join(step.getText()),
'urls': [],
'logs': [],
}
if step.isFinished() and step.isHidden():
continue
if step.isFinished():
start, end = step.getTimes()
step_obj['css_class'] = css_classes[step.getResults()[0]]
step_obj['time_to_run'] = formatInterval(end - start)
elif step.isStarted():
is_waiting = step.isWaitingForLocks()
step_obj['css_class'] = 'waiting' if is_waiting else 'running'
step_obj[
'time_to_run'] = 'waiting for locks' if is_waiting else 'running'
trigger_links = yield step.prepare_trigger_links(codebases_arg)
for link_data in trigger_links:
step.addURL(*link_data)
step_obj['urls'] = __prepare_url_object(step, codebases_arg)
step_obj['logs'] = __get_logs_for_step(step, codebases_arg, request)
steps.append(step_obj)
defer.returnValue(steps)
def getBox(self, req):
urlbase = path_to_step(req, self.original)
text = self.original.getText()
if text is None:
log.msg("getText() gave None", urlbase)
text = []
text = text[:]
logs = self.original.getLogs()
for num in range(len(logs)):
name = logs[num].getName()
if logs[num].hasContents():
url = urlbase + "/logs/%s" % urllib.quote(name)
text.append("<a href=\"%s\">%s</a>" % (url, html.escape(name)))
else:
text.append(html.escape(name))
urls = self.original.getURLs()
ex_url_class = "BuildStep external"
for name, target in urls.items():
text.append('[<a href="%s" class="%s">%s</a>]' %
(target, ex_url_class, html.escape(name)))
class_ = "BuildStep " + build_get_class(self.original)
return Box(text, class_=class_)
def getBox(self, req):
urlbase = path_to_step(req, self.original)
text = self.original.getText()
if text is None:
log.msg("getText() gave None", urlbase)
text = []
text = text[:]
logs = self.original.getLogs()
for num in range(len(logs)):
name = logs[num].getName()
if logs[num].hasContents():
url = urlbase + "/logs/%s" % urllib.quote(name)
text.append("<a href=\"%s\">%s</a>" % (url, html.escape(name)))
else:
text.append(html.escape(name))
urls = self.original.getURLs()
ex_url_class = "BuildStep external"
for name, target in urls.items():
text.append('[<a href="%s" class="%s">%s</a>]' %
(target, ex_url_class, html.escape(name)))
class_ = "BuildStep " + build_get_class(self.original)
return Box(text, class_=class_)
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))
