def content(self, request, cxt):
status = self.getStatus(request)
d = self.getAuthz(request).actionAllowed("cleanShutdown", request)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if request.path == '/shutdown':
if res:
eventually(status.cleanShutdown)
yield redirectTo("/", request)
return
else:
yield redirectTo(path_to_authzfail(request), request)
return
elif request.path == '/cancel_shutdown':
if res:
eventually(status.cancelCleanShutdown)
yield redirectTo("/", request)
return
else:
yield redirectTo(path_to_authzfail(request), request)
return
cxt.update(
shutting_down=status.shuttingDown,
shutdown_url=request.childLink("shutdown"),
cancel_shutdown_url=request.childLink("cancel_shutdown"),
)
template = request.site.buildbot_service.templates.get_template(
"root.html")
yield template.render(**cxt)
return
def content(self, request, cxt):
status = self.getStatus(request)
res = yield self.getAuthz(request).actionAllowed("cleanShutdown",
request)
if request.path == '/shutdown':
if res:
eventually(status.cleanShutdown)
yield defer.returnValue(redirectTo("/", request))
return
else:
yield defer.returnValue(
redirectTo(path_to_authzfail(request), request))
return
elif request.path == '/cancel_shutdown':
if res:
eventually(status.cancelCleanShutdown)
yield defer.returnValue(redirectTo("/", request))
return
else:
yield defer.returnValue(
redirectTo(path_to_authzfail(request), request))
return
cxt.update(
shutting_down = status.shuttingDown,
shutdown_url = request.childLink("shutdown"),
cancel_shutdown_url = request.childLink("cancel_shutdown"),
)
template = request.site.buildbot_service.templates.get_template("root.html")
yield defer.returnValue(template.render(**cxt))
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
authz = self.getAuthz(req)
res = yield authz.actionAllowed('stopChange', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
for bname in self.status.getBuilderNames():
builder_status = self.status.getBuilder(bname)
res = yield self.stopChangeForBuilder(req, builder_status, auth_ok=True)
if not res:
defer.returnValue(path_to_authzfail(req))
return
defer.returnValue(path_to_root(req))
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('cancelAllPendingBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
builders = None
if self.selectedOrAll == 'all':
builders = self.status.getBuilderNames()
elif self.selectedOrAll == 'selected':
builders = [b for b in req.args.get("selected", []) if b]
c = interfaces.IControl(self.getBuildmaster(req))
for bname in builders:
authz = self.getAuthz(req)
builder_control = c.getBuilder(bname)
brcontrols = yield builder_control.getPendingBuildRequestControls()
for build_req in brcontrols:
log.msg("Cancelling %s" % build_req)
build_req.cancel()
# go back to the welcome page
defer.returnValue(path_to_root(req))
def performAction(self, req):
res = yield self.getAuthz(req).actionAllowed('showUsersPage', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
# show the table
defer.returnValue(path_to_root(req) + "users")
def performAction(self, req):
authz = self.getAuthz(req)
d = authz.actionAllowed(self.action, req, self.build_status)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
yield path_to_authzfail(req)
return
b = self.build_status
log.msg("web stopBuild of build %s:%s" % \
(b.getBuilder().getName(), b.getNumber()))
name = authz.getUsernameFull(req)
comments = req.args.get("comments", ["<no reason specified>"])[0]
# html-quote both the username and comments, just to be safe
reason = ("The web-page 'stop build' button was pressed by "
"'%s': %s\n" % (html.escape(name), html.escape(comments)))
c = interfaces.IControl(self.getBuildmaster(req))
bldrc = c.getBuilder(self.build_status.getBuilder().getName())
if bldrc:
bldc = bldrc.getBuild(self.build_status.getNumber())
if bldc:
bldc.stopBuild(reason)
yield path_to_builder(req, self.build_status.getBuilder())
return
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('stopAllBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
builders = None
if self.selectedOrAll == 'all':
builders = self.status.getBuilderNames()
elif self.selectedOrAll == 'selected':
builders = [b for b in req.args.get("selected", []) if b]
for bname in builders:
builder_status = self.status.getBuilder(bname)
(state, current_builds) = builder_status.getState()
if state != "building":
continue
for b in current_builds:
build_status = builder_status.getBuild(b.number)
if not build_status:
continue
build = StatusResourceBuild(build_status)
build.stop(req, auth_ok=True)
# go back to the welcome page
defer.returnValue(path_to_root(req))
def performAction(self, req):
# check if this is allowed
res = yield self.getAuthz(req).actionAllowed(self.action, req,
self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
master = self.getBuildmaster(req)
owner = self.getAuthz(req).getUsernameFull(req)
schedulername = req.args.get("forcescheduler", ["<unknown>"])[0]
if schedulername == "<unknown>":
defer.returnValue((path_to_builder(req, self.builder_status),
"forcescheduler arg not found"))
return
args = {}
# damn html's ungeneric checkbox implementation...
for cb in req.args.get("checkbox", []):
args[cb] = True
args.update(req.args)
builder_name = self.builder_status.getName()
for sch in master.allSchedulers():
if schedulername == sch.name:
try:
yield sch.force(owner, builder_name, **args)
msg = ""
except ValidationError, e:
msg = html.escape(e.message.encode('ascii','ignore'))
break
def performAction(self, req):
# check if this is allowed
res = yield self.getAuthz(req).actionAllowed(self.action, req,
self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
master = self.getBuildmaster(req)
owner = self.getAuthz(req).getUsernameFull(req)
schedulername = req.args.get("forcescheduler", ["<unknown>"])[0]
if schedulername == "<unknown>":
defer.returnValue((path_to_builder(req, self.builder_status),
"forcescheduler arg not found"))
return
args = {}
# damn html's ungeneric checkbox implementation...
for cb in req.args.get("checkbox", []):
args[cb] = True
args.update(req.args)
builder_name = self.builder_status.getName()
for sch in master.allSchedulers():
if schedulername == sch.name:
try:
yield sch.force(owner, builder_name, **args)
msg = ""
except ValidationError, e:
msg = html.escape(e.message.encode('ascii', 'ignore'))
break
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed(self.action, req, self.build_status)
if not res:
defer.returnValue(path_to_authzfail(req))
return
b = self.build_status
log.msg("web stopEntireBuildChain of build %s:%s" % \
(b.getBuilder().getName(), b.getNumber()))
name = authz.getUsernameFull(req)
reason = (
"The web-page 'Stop Entire Build Chain' button was pressed by '%s'\n"
% html.escape(name))
master = interfaces.IControl(self.getBuildmaster(req))
buildername = self.build_status.getBuilder().getName()
number = self.build_status.getNumber()
builderc = master.getBuilder(buildername)
if builderc:
build = builderc.getBuild(number)
if build:
yield self.stopEntireBuildChain(master, build, buildername,
reason)
build.stopBuild(reason)
defer.returnValue(path_to_build(req, self.build_status))
def performAction(self, req):
try:
request_id = req.args.get("id", [None])[0]
if request_id == "all":
cancel_all = True
else:
cancel_all = False
request_id = int(request_id)
except:
request_id = None
authz = self.getAuthz(req)
if request_id:
c = interfaces.IControl(self.getBuildmaster(req))
builder_control = c.getBuilder(self.builder_status.getName())
brcontrols = yield builder_control.getPendingBuildRequestControls()
for build_req in brcontrols:
if cancel_all or (build_req.brid == request_id):
log.msg("Cancelling %s" % build_req)
res = yield authz.actionAllowed('cancelPendingBuild', req,
build_req)
if res:
build_req.cancel()
else:
defer.returnValue(path_to_authzfail(req))
return
if not cancel_all:
break
defer.returnValue(path_to_builder(req, self.builder_status))
def performAction(self, req):
res = yield self.getAuthz(req).actionAllowed('showUsersPage', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
# show the table
defer.returnValue(path_to_root(req) + "users")
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
authz = self.getAuthz(req)
res = yield authz.actionAllowed('stopChange', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
for bname in self.status.getBuilderNames():
builder_status = self.status.getBuilder(bname)
res = yield self.stopChangeForBuilder(req, builder_status, auth_ok=True)
if not res:
defer.returnValue(path_to_authzfail(req))
return
defer.returnValue(path_to_root(req))
def performAction(self, req):
try:
request_id = req.args.get("id", [None])[0]
if request_id == "all":
cancel_all = True
else:
cancel_all = False
request_id = int(request_id)
except:
request_id = None
authz = self.getAuthz(req)
if request_id:
c = interfaces.IControl(self.getBuildmaster(req))
builder_control = c.getBuilder(self.builder_status.getName())
brcontrols = yield builder_control.getPendingBuildRequestControls()
for build_req in brcontrols:
if cancel_all or (build_req.brid == request_id):
log.msg("Cancelling %s" % build_req)
res = yield authz.actionAllowed('cancelPendingBuild', req,
build_req)
if res:
build_req.cancel()
else:
defer.returnValue(path_to_authzfail(req))
return
if not cancel_all:
break
defer.returnValue(path_to_builder(req, self.builder_status))
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed(self.action, req, self.build_status)
if not res:
defer.returnValue(path_to_authzfail(req))
return
b = self.build_status
log.msg("web stopBuild of build %s:%s" % \
(b.getBuilder().getName(), b.getNumber()))
name = authz.getUsernameFull(req)
comments = req.args.get("comments", ["<no reason specified>"])[0]
comments.decode(getRequestCharset(req))
# html-quote both the username and comments, just to be safe
reason = ("The web-page 'stop build' button was pressed by "
"'%s': %s\n" % (html.escape(name), html.escape(comments)))
c = interfaces.IControl(self.getBuildmaster(req))
bldrc = c.getBuilder(self.build_status.getBuilder().getName())
if bldrc:
bldc = bldrc.getBuild(self.build_status.getNumber())
if bldc:
bldc.stopBuild(reason)
defer.returnValue(path_to_builder(req, self.build_status.getBuilder()))
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('stopAllBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
builders = None
if self.selectedOrAll == 'all':
builders = self.status.getBuilderNames()
elif self.selectedOrAll == 'selected':
builders = [b for b in req.args.get("selected", []) if b]
for bname in builders:
builder_status = self.status.getBuilder(bname)
(state, current_builds) = builder_status.getState()
if state != "building":
continue
for b in current_builds:
build_status = builder_status.getBuild(b.number)
if not build_status:
continue
build = StatusResourceBuild(build_status)
build.stop(req, auth_ok=True)
# go back to the welcome page
defer.returnValue(path_to_root(req))
def performAction(self, req):
# check if this is allowed
d = self.getAuthz(req).actionAllowed(self.action, req,
self.builder_status)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
log.msg("..but not authorized")
yield path_to_authzfail(req)
return
master = self.getBuildmaster(req)
owner = self.getAuthz(req).getUsernameFull(req)
schedulername = req.args.get("forcescheduler", ["<unknown>"])[0]
if schedulername == "<unknown>":
yield path_to_builder(req, self.builder_status), "forcescheduler arg not found"
return
for sch in master.allSchedulers():
if schedulername == sch.name:
try:
d = sch.forceWithWebRequest(owner,self.builder_status.getName(),req)
msg = ""
except Exception, e:
msg = html.escape(e.message.encode('ascii','ignore'))
break
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('cancelAllPendingBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
builders = None
if self.selectedOrAll == 'all':
builders = self.status.getBuilderNames()
elif self.selectedOrAll == 'selected':
builders = [b for b in req.args.get("selected", []) if b]
c = interfaces.IControl(self.getBuildmaster(req))
for bname in builders:
authz = self.getAuthz(req)
builder_control = c.getBuilder(bname)
brcontrols = yield builder_control.getPendingBuildRequestControls()
for build_req in brcontrols:
log.msg("Cancelling %s" % build_req)
build_req.cancel()
# go back to the welcome page
defer.returnValue(path_to_root(req))
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed(self.action, req, self.build_status)
if not res:
defer.returnValue(path_to_authzfail(req))
return
b = self.build_status
log.msg("web stopBuild of build %s:%s" %
(b.getBuilder().getName(), b.getNumber()))
name = authz.getUsernameFull(req)
comments = _get_comments_from_request(req)
# html-quote both the username and comments, just to be safe
reason = ("The web-page 'stop build' button was pressed by "
"'%s': %s\n" % (html.escape(name), html.escape(comments)))
c = interfaces.IControl(self.getBuildmaster(req))
bldrc = c.getBuilder(self.build_status.getBuilder().getName())
if bldrc:
bldc = bldrc.getBuild(self.build_status.getNumber())
if bldc:
bldc.stopBuild(reason)
defer.returnValue(path_to_builder(req, self.build_status.getBuilder()))
def performAction(self, req):
url = None
authz = self.getAuthz(req)
res = yield authz.actionAllowed(self.action, req, self.builder)
if not res:
url = path_to_authzfail(req)
else:
# get a control object
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder.getName())
b = self.build_status
builder_name = self.builder.getName()
log.msg("web rebuild of build %s:%s" % (builder_name, b.getNumber()))
name = authz.getUsernameFull(req)
comments = _get_comments_from_request(req)
reason = self.rebuildString % {
'build_number': b.getNumber(),
'owner': b.getInterestedUsers(),
'rebuild_owner': name,
'rebuild_comments': comments
}
useSourcestamp = req.args.get("useSourcestamp", None)
if useSourcestamp and useSourcestamp == ['updated']:
absolute = False
else:
absolute = True
msg = ""
extraProperties = getAndCheckProperties(req)
if not bc or not b.isFinished() or extraProperties is None:
msg = "could not rebuild: "
if b.isFinished():
msg += "build still not finished "
if bc:
msg += "could not get builder control"
else:
tup = yield bc.rebuildBuild(b,
reason=reason,
extraProperties=extraProperties,
absolute=absolute)
# rebuildBuild returns None on error (?!)
if not tup:
msg = "rebuilding a build failed " + str(tup)
# we're at
# http://localhost:8080/builders/NAME/builds/5/rebuild?[args]
# Where should we send them?
#
# Ideally it would be to the per-build page that they just started,
# but we don't know the build number for it yet (besides, it might
# have to wait for a current build to finish). The next-most
# preferred place is somewhere that the user can see tangible
# evidence of their build starting (or to see the reason that it
# didn't start). This should be the Builder page.
url = path_to_builder(req, self.builder), msg
defer.returnValue(url)
def performAction(self, req):
url = None
authz = self.getAuthz(req)
res = yield authz.actionAllowed(self.action, req, self.builder)
if not res:
url = path_to_authzfail(req)
else:
# get a control object
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder.getName())
b = self.build_status
builder_name = self.builder.getName()
log.msg("web rebuild of build %s:%s" % (builder_name, b.getNumber()))
name = authz.getUsernameFull(req)
comments = _get_comments_from_request(req)
reason = self.rebuildString % {
'build_number': b.getNumber(),
'owner': b.getInterestedUsers(),
'rebuild_owner': name,
'rebuild_comments': comments
}
useSourcestamp = req.args.get("useSourcestamp", None)
if useSourcestamp and useSourcestamp == ['updated']:
absolute = False
else:
absolute = True
msg = ""
extraProperties = getAndCheckProperties(req)
if not bc or not b.isFinished() or extraProperties is None:
msg = "could not rebuild: "
if not b.isFinished():
msg += "build still not finished "
if not bc:
msg += "could not get builder control"
else:
tup = yield bc.rebuildBuild(b,
reason=reason,
extraProperties=extraProperties,
absolute=absolute)
# rebuildBuild returns None on error (?!)
if not tup:
msg = "rebuilding a build failed " + str(tup)
# we're at
# http://localhost:8080/builders/NAME/builds/5/rebuild?[args]
# Where should we send them?
#
# Ideally it would be to the per-build page that they just started,
# but we don't know the build number for it yet (besides, it might
# have to wait for a current build to finish). The next-most
# preferred place is somewhere that the user can see tangible
# evidence of their build starting (or to see the reason that it
# didn't start). This should be the Builder page.
url = path_to_builder(req, self.builder), msg
defer.returnValue(url)
def performAction(self, req):
# check if this is allowed
res = yield self.getAuthz(req).actionAllowed(self.action, req,
self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
master = self.getBuildmaster(req)
owner = self.getAuthz(req).getUsernameFull(req)
schedulername = req.args.get("forcescheduler", ["<unknown>"])[0]
if schedulername == "<unknown>":
defer.returnValue((path_to_builder(req, self.builder_status),
"forcescheduler arg not found"))
return
for sch in master.allSchedulers():
if schedulername == sch.name:
try:
yield sch.forceWithWebRequest(
owner, self.builder_status.getName(), req)
msg = ""
except Exception, e:
msg = html.escape(e.message.encode('ascii', 'ignore'))
break
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
success = yield self.stopChangeForBuilder(req, self.builder_status)
if not success:
defer.returnValue(path_to_authzfail(req))
else:
defer.returnValue(path_to_builder(req, self.builder_status))
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
success = yield self.stopChangeForBuilder(req, self.builder_status)
if not success:
defer.returnValue(path_to_authzfail(req))
else:
defer.returnValue(path_to_builder(req, self.builder_status))
def performAction(self, req):
d = self.getAuthz(req).actionAllowed('showUsersPage', req)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
yield path_to_authzfail(req)
return
# show the table
yield path_to_root(req) + "users/table"
def performAction(self, req):
d = self.getAuthz(req).actionAllowed('showUsersPage', req)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
yield path_to_authzfail(req)
return
# show the table
yield path_to_root(req) + "users"
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
wfd = defer.waitForDeferred(
self.stopChangeForBuilder(req, self.builder_status))
yield wfd
success = wfd.getResult()
if not success:
yield path_to_authzfail(req)
else:
yield path_to_builder(req, self.builder_status)
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
wfd = defer.waitForDeferred(
self.stopChangeForBuilder(req, self.builder_status))
yield wfd
success = wfd.getResult()
if not success:
yield path_to_authzfail(req)
else:
yield path_to_builder(req, self.builder_status)
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
authz = self.getAuthz(req)
wfd = defer.waitForDeferred(authz.actionAllowed('stopChange', req))
yield wfd
res = wfd.getResult()
if not res:
yield path_to_authzfail(req)
return
for bname in self.status.getBuilderNames():
builder_status = self.status.getBuilder(bname)
wfd = defer.waitForDeferred(
self.stopChangeForBuilder(req, builder_status, auth_ok=True))
yield wfd
if not wfd.getResult():
yield path_to_authzfail(req)
return
yield path_to_root(req)
def performAction(self, request):
res = yield self.getAuthz(request).actionAllowed(
self.action, request, self.slave)
url = None
if res:
self.slave.setPaused(self.state)
url = path_to_slave(request, self.slave)
else:
url = path_to_authzfail(request)
defer.returnValue(url)
def performAction(self, req):
"""Cancel all pending builds that include a given numbered change."""
authz = self.getAuthz(req)
wfd = defer.waitForDeferred(authz.actionAllowed('stopChange', req))
yield wfd
res = wfd.getResult()
if not res:
yield path_to_authzfail(req)
return
for bname in self.status.getBuilderNames():
builder_status = self.status.getBuilder(bname)
wfd = defer.waitForDeferred(
self.stopChangeForBuilder(req, builder_status, auth_ok=True))
yield wfd
if not wfd.getResult():
yield path_to_authzfail(req)
return
yield path_to_root(req)
def performAction(self, request):
res = yield self.getAuthz(request).actionAllowed(self.action,
request,
self.slave)
url = None
if res:
self.slave.setGraceful(True)
url = path_to_slave(request, self.slave)
else:
url = path_to_authzfail(request)
defer.returnValue(url)
def performAction(self, req):
url = None
authz = self.getAuthz(req)
d = authz.actionAllowed(self.action, req, self.builder)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
url = path_to_authzfail(req)
else:
# get a control object
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder.getName())
b = self.build_status
builder_name = self.builder.getName()
log.msg("web rebuild of build %s:%s" %
(builder_name, b.getNumber()))
name = authz.getUsernameFull(req)
comments = req.args.get("comments", ["<no reason specified>"])[0]
reason = ("The web-page 'rebuild' button was pressed by "
"'%s': %s\n" % (name, comments))
msg = ""
extraProperties = getAndCheckProperties(req)
if not bc or not b.isFinished() or extraProperties is None:
msg = "could not rebuild: "
if b.isFinished():
msg += "build still not finished "
if bc:
msg += "could not get builder control"
else:
d = bc.rebuildBuild(b, reason, extraProperties)
wfd = defer.waitForDeferred(d)
yield wfd
tup = wfd.getResult()
# check that (bsid, brids) were properly stored
if not (isinstance(tup, tuple) and isinstance(tup[0], int)
and isinstance(tup[1], dict)):
msg = "rebuilding a build failed " + str(tup)
# we're at
# http://localhost:8080/builders/NAME/builds/5/rebuild?[args]
# Where should we send them?
#
# Ideally it would be to the per-build page that they just started,
# but we don't know the build number for it yet (besides, it might
# have to wait for a current build to finish). The next-most
# preferred place is somewhere that the user can see tangible
# evidence of their build starting (or to see the reason that it
# didn't start). This should be the Builder page.
url = path_to_builder(req, self.builder), msg
yield url
def performAction(self, req):
url = None
authz = self.getAuthz(req)
d = authz.actionAllowed(self.action, req, self.builder)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
url = path_to_authzfail(req)
else:
# get a control object
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder.getName())
b = self.build_status
builder_name = self.builder.getName()
log.msg("web rebuild of build %s:%s" % (builder_name, b.getNumber()))
name =authz.getUsernameFull(req)
comments = req.args.get("comments", ["<no reason specified>"])[0]
reason = ("The web-page 'rebuild' button was pressed by "
"'%s': %s\n" % (name, comments))
msg = ""
extraProperties = getAndCheckProperties(req)
if not bc or not b.isFinished() or extraProperties is None:
msg = "could not rebuild: "
if b.isFinished():
msg += "build still not finished "
if bc:
msg += "could not get builder control"
else:
d = bc.rebuildBuild(b, reason, extraProperties)
wfd = defer.waitForDeferred(d)
yield wfd
tup = wfd.getResult()
# check that (bsid, brids) were properly stored
if not (isinstance(tup, tuple) and
isinstance(tup[0], int) and
isinstance(tup[1], dict)):
msg = "rebuilding a build failed "+ str(tup)
# we're at
# http://localhost:8080/builders/NAME/builds/5/rebuild?[args]
# Where should we send them?
#
# Ideally it would be to the per-build page that they just started,
# but we don't know the build number for it yet (besides, it might
# have to wait for a current build to finish). The next-most
# preferred place is somewhere that the user can see tangible
# evidence of their build starting (or to see the reason that it
# didn't start). This should be the Builder page.
url = path_to_builder(req, self.builder), msg
yield url
def performAction(self, req):
log.msg("web ping of builder '%s'" % self.builder_status.getName())
res = yield self.getAuthz(req).actionAllowed("pingBuilder", req, self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder_status.getName())
bc.ping()
# send the user back to the builder page
defer.returnValue(path_to_builder(req, self.builder_status))
def performAction(self, req):
# check if this is allowed
res = yield self.getAuthz(req).actionAllowed(self.action, req,
self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
builderName = self.builder_status.getName()
path_to_return = yield self.force(req, [builderName])
# send the user back to the builder page
defer.returnValue(path_to_return)
def performAction(self, request):
d = self.getAuthz(request).actionAllowed(self.action, request,
self.slave)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
url = None
if res:
self.slave.setGraceful(True)
url = path_to_slave(request, self.slave)
else:
url = path_to_authzfail(request)
yield url
def performAction(self, req):
log.msg("web ping of builder '%s'" % self.builder_status.getName())
res = yield self.getAuthz(req).actionAllowed('pingBuilder', req,
self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder_status.getName())
bc.ping()
# send the user back to the builder page
defer.returnValue(path_to_builder(req, self.builder_status))
def performAction(self, req):
# check if this is allowed
res = yield self.getAuthz(req).actionAllowed(self.action, req, self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
builderName = self.builder_status.getName()
msg = yield self.force(req, [builderName])
# send the user back to the builder page
defer.returnValue((path_to_builder(req, self.builder_status), msg))
def performAction(self, req):
authz = self.getAuthz(req)
res = authz.authenticated(req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
# save the settings
for name, val in req.args.iteritems():
if "_setting" in name:
if not isinstance(val, basestring):
val = val[0]
authz.setUserAttr(req, name.replace("_setting", ""), val)
return path_to_root(req) + "users/settings"
def content(self, req, ctx):
# check for False or True on showUsersPage, redirect immediately
authz = self.getAuthz(req)
if not authz.needAuthForm(self.action):
if authz.advertiseAction(self.action):
yield redirectTo("users/table", req)
return
else:
yield redirectTo(path_to_authzfail(req), req)
return
ctx['authz'] = self.getAuthz(req)
ctx['table_link'] = req.childLink("table")
template = req.site.buildbot_service.templates.get_template("users.html")
yield template.render(**ctx)
def performAction(self, request):
d = self.getAuthz(request).actionAllowed(self.action,
request,
self.slave)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
url = None
if res:
self.slave.setGraceful(True)
url = path_to_slave(request, self.slave)
else:
url = path_to_authzfail(request)
yield url
def performAction(self, request):
authz = self.getAuthz(request)
res = yield authz.actionAllowed(self.action, request, self.slave)
url = None
if res:
username = authz.getUsernameFull(request)
slave_url = absolute_path_to_slave(self.slave.master.status, self.slave)
log.msg("Shutdown %s gracefully requested by %s" % (self.slave.name, username))
self.slave.master.status.slaveShutdownGraceFully(self.slave.name, slave_url, username)
self.slave.setGraceful(True)
url = path_to_slave(request, self.slave)
else:
url = path_to_authzfail(request)
defer.returnValue(url)
def performAction(self, req):
log.msg("web ping of builder '%s'" % self.builder_status.getName())
d = self.getAuthz(req).actionAllowed('pingBuilder', req, self.builder_status)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
log.msg("..but not authorized")
yield path_to_authzfail(req)
return
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder_status.getName())
bc.ping()
# send the user back to the builder page
yield path_to_builder(req, self.builder_status)
def content(self, req, ctx):
# check for False or True on showUsersPage, redirect immediately
authz = self.getAuthz(req)
if not authz.needAuthForm(self.action):
if authz.advertiseAction(self.action):
yield redirectTo("users/table", req)
return
else:
yield redirectTo(path_to_authzfail(req), req)
return
ctx['authz'] = self.getAuthz(req)
ctx['table_link'] = req.childLink("table")
template = req.site.buildbot_service.templates.get_template(
"users.html")
yield template.render(**ctx)
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('forceAllBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
if self.selectedOrAll == 'all':
builderNames = None
elif self.selectedOrAll == 'selected':
builderNames = [b for b in req.args.get("selected", []) if b]
path_to_return = yield self.force(req, builderNames)
# send the user back to the builder page
defer.returnValue(path_to_return)
def content(self, req, ctx):
res = yield self.getAuthz(req).actionAllowed('showUsersPage', req)
if not res:
defer.returnValue(redirectTo(path_to_authzfail(req), req))
return
s = self.getStatus(req)
usdicts = yield s.master.db.users.getUsers()
users = ctx['users'] = usdicts
for user in users:
user['user_link'] = req.childLink(urllib.quote(str(user['uid']), ''))
template = req.site.buildbot_service.templates.get_template(
"users.html")
defer.returnValue(template.render(**ctx))
def content(self, req, ctx):
res = yield self.getAuthz(req).actionAllowed('showUsersPage', req)
if not res:
defer.returnValue(redirectTo(path_to_authzfail(req), req))
return
s = self.getStatus(req)
usdicts = yield s.master.db.users.getUsers()
users = ctx['users'] = usdicts
for user in users:
user['user_link'] = req.childLink(urllib.quote(str(user['uid']), ''))
template = req.site.buildbot_service.templates.get_template(
"users.html")
defer.returnValue(template.render(**ctx))
def performAction(self, req):
log.msg("web ping of builder '%s'" % self.builder_status.getName())
d = self.getAuthz(req).actionAllowed('pingBuilder', req,
self.builder_status)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
log.msg("..but not authorized")
yield path_to_authzfail(req)
return
c = interfaces.IControl(self.getBuildmaster(req))
bc = c.getBuilder(self.builder_status.getName())
bc.ping()
# send the user back to the builder page
yield path_to_builder(req, self.builder_status)
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('forceAllBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
if self.selectedOrAll == 'all':
builderNames = None
elif self.selectedOrAll == 'selected':
builderNames = [b for b in req.args.get("selected", []) if b]
msg = yield self.force(req, builderNames)
# back to the welcome page
defer.returnValue((path_to_root(req) + "builders", msg))
def performAction(self, req):
try:
request_id = req.args.get("id", [None])[0]
if request_id == "all":
cancel_all = True
else:
cancel_all = False
request_id = int(request_id)
except:
request_id = None
authz = self.getAuthz(req)
if request_id:
c = interfaces.IControl(self.getBuildmaster(req))
builder_control = c.getBuilder(self.builder_status.getName())
brcontrols = yield builder_control.getPendingBuildRequestControls()
for build_req in brcontrols:
if cancel_all or (build_req.brid == request_id):
log.msg("Cancelling %s" % build_req)
res = yield authz.actionAllowed('cancelPendingBuild', req,
build_req)
if res:
yield build_req.cancel()
else:
defer.returnValue(path_to_authzfail(req))
return
if not cancel_all:
break
args = req.args.copy()
returnpage = args.get("returnpage", None)
if returnpage is None:
defer.returnValue((path_to_builder(req, self.builder_status)))
elif "builders" in returnpage:
defer.returnValue(
(path_to_builders(req, self.builder_status.getProject())))
elif "buildqueue" in returnpage:
defer.returnValue(path_to_buildqueue(req))
elif "builders_json":
s = self.getStatus(req)
defer.returnValue(
(s.getBuildbotURL() +
path_to_json_builders(req, self.builder_status.getProject())))
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('forceAllBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
if self.selectedOrAll == 'all':
builderNames = None
elif self.selectedOrAll == 'selected':
builderNames = [b for b in req.args.get("selected", []) if b]
msg = yield self.force(req, builderNames)
# back to the welcome page
defer.returnValue((path_to_root(req) + "builders", msg))
def performAction(self, request):
authz = self.getAuthz(request)
res = yield authz.actionAllowed(self.action, request, self.slave)
url = None
if res:
username = authz.getUsernameFull(request)
slave_url = absolute_path_to_slave(self.slave.master.status, self.slave)
if self.slave.isPaused():
self.slave.master.status.slaveUnpaused(self.slave.name, slave_url, username)
action = "Unpause"
else:
self.slave.master.status.slavePaused(self.slave.name, slave_url, username)
action = "Pause"
log.msg("%s %s requested by %s" % (action, self.slave.name, username))
self.slave.setPaused(self.state)
url = path_to_slave(request, self.slave)
else:
url = path_to_authzfail(request)
defer.returnValue(url)
def performAction(self, req):
authz = self.getAuthz(req)
print authz.getUsername(req), authz.authenticated(req)
res = yield authz.actionAllowed('forceBuild', req)
if not res:
defer.returnValue(Redirect(path_to_authzfail(req)))
return
projects = json.load(open('projects.json'))
log.msg('loaded projects.json')
log.msg(str(req.args.items()))
projectname = req.args.get('projectname', [])[0]
projectrepo = req.args.get('projectrepo', [])[0]
paths = req.args.get('path', [])
boardaddr = req.args.get('boardaddr', [])[0]
log.msg(str(req.args.get('arches', [])))
arches = req.args.get('arches', ['bluesim'])
revisions = req.args.get('revision', [])
branches = req.args.get('branch', [])
m = re.match('git://github.com/(.*)/(.*).git', projectrepo)
if projectname in projects:
msg = 'project ' + projectname + ' already exists'
elif not m:
msg = 'repo "' + projectrepo + ' must be of the form git://github.com/username/project.git'
else:
p = {"repo": projectrepo}
if arches:
p['arches'] = arches
if paths and paths[0] != '':
p['path'] = paths[0]
if revisions and revisions[0] != '':
p['revision'] = revisions[0]
if branches and branches[0] != '':
p['branch'] = branches[0]
p['owner'] = authz.getUsername(req)
projects[projectname] = p
json.dump(projects, open('projects.json', 'w'), indent=4)
subprocess.call(["/usr/bin/buildbot", "reconfig", "/scratch/buildbot/master"])
msg = 'added project: ' + ' '.join(req.args.get('projectname', '')) + ' url: ' + ' '.join(req.args.get('projectrepo', ''))
defer.returnValue((path_to_root(req), msg))
def performAction(self, req):
authz = self.getAuthz(req)
res = yield authz.actionAllowed('forceAllBuilds', req)
if not res:
defer.returnValue(path_to_authzfail(req))
return
builders = None
if self.selectedOrAll == 'all':
builders = self.status.getBuilderNames()
elif self.selectedOrAll == 'selected':
builders = [b for b in req.args.get("selected", []) if b]
for bname in builders:
builder_status = self.status.getBuilder(bname)
ar = ForceBuildActionResource(builder_status)
d = ar.performAction(req)
d.addErrback(log.err, "(ignored) while trying to force build")
# back to the welcome page
defer.returnValue(path_to_root(req))
def content(self, req, ctx):
d = self.getAuthz(req).actionAllowed('showUsersPage', req)
wfd = defer.waitForDeferred(d)
yield wfd
res = wfd.getResult()
if not res:
yield redirectTo(path_to_authzfail(req), req)
return
s = self.getStatus(req)
d = s.master.db.users.getUsers()
wfd = defer.waitForDeferred(d)
yield wfd
usdicts = wfd.getResult()
users = ctx['users'] = usdicts
for user in users:
user['user_link'] = req.childLink(urllib.quote(str(user['uid']), ''))
template = req.site.buildbot_service.templates.get_template(
"users.html")
yield template.render(**ctx)
def performAction(self, req):
# check if this is allowed
res = yield self.getAuthz(req).actionAllowed(self.action, req, self.builder_status)
if not res:
log.msg("..but not authorized")
defer.returnValue(path_to_authzfail(req))
return
master = self.getBuildmaster(req)
owner = self.getAuthz(req).getUsernameFull(req)
schedulername = req.args.get("forcescheduler", ["<unknown>"])[0]
if schedulername == "<unknown>":
defer.returnValue((path_to_builder(req, self.builder_status), "forcescheduler arg not found"))
return
args = req.args.copy()
# decode all of the args
encoding = getRequestCharset(req)
for name, argl in args.iteritems():
args[name] = [arg.decode(encoding) for arg in argl]
# damn html's ungeneric checkbox implementation...
for cb in args.get("checkbox", []):
args[cb] = True
builder_name = self.builder_status.getName()
for sch in master.allSchedulers():
if schedulername == sch.name:
try:
yield sch.force(owner, builder_name, **args)
msg = ""
except ValidationError, e:
msg = html.escape(e.message.encode("ascii", "ignore"))
break
