async def writeReply(self, response: Response, proc: Processor) -> None:
response.write('<?xml version="1.0" encoding="utf-8"?>')
# Note: Using an "xml:base" attribute here and relative URLs in the rest
# of the feed works fine in Akregator (KDE4 version), but fails in
# Outlook 2007. Therefore we should only use absolute URLs.
response.writeXML(
atom.feed(xmlns='http://www.w3.org/2005/Atom', )[self.presentFeed(
proc, rootURL)])
async def writeReply(self, response: Response, proc: Processor) -> None:
matches = proc.matches
subjectIdName = proc.args.subject + 'id'
response.writeXML(
xml.matches[(xml.tag(**{
subjectIdName: recordId,
'key': key,
'value': value,
}) for recordId, key, value in matches)])
async def respond(self, response: Response) -> None:
self.__page.writeHTTPHeaders(response)
# TODO: This is copy-pasted from UIPage.
# I'm not sure yet where the proper location would be;
# if it is copy-pasted a third time it might be clearer.
proc = self.__proc
presentationArgs = dict(
proc=proc,
styleURL=proc.req.relativeRoot + styleRoot.relativeURL,
)
response.writeXML(self.__widget.present(**presentationArgs))
def writeHTML(self, response: Response, proc: ProcT) -> None:
req = proc.req
ccURL = req.relativeRoot
presentationArgs = dict(
proc=proc,
ccURL=ccURL,
styleURL=ccURL + styleRoot.relativeURL,
)
response.write('<!DOCTYPE html>\n')
response.writeXML(
xhtml.html(lang='en')[xhtml.head[self.presentHeadParts(
**presentationArgs)], xhtml.body[self.__presentBodyParts(
req, response, **presentationArgs)], ])
async def writeReply(self, response: Response, proc: Processor) -> None:
response.writeXML(
xml.factory(
name = proc.project.name,
url = rootURL,
version = VERSION,
boottime = formatTimeAttr(getBootTime()),
timezone = proc.project.timezone,
)[
( xml.table(name = db.name, count = len(db))
for db in proc.databases ),
]
)
async def writeReply(self, response: Response, proc: Processor) -> None:
args: GetTaskDefParams_GET.Arguments = proc.args
requestedParams = args.param
def externalizeParams(taskParams: Mapping[str, str]) -> XMLContent:
for param in requestedParams or taskParams:
value = taskParams.get(param)
if value is not None:
yield xml.param(name=param, value=value)
response.writeXML(
xml.taskdefs[(xml.taskdef(name=taskId)[externalizeParams(
taskDef.getParameters())]
for taskId, taskDef in proc.taskDefDB.items())])
async def renderAsync(page: FabResource, request: TwistedRequest) -> None:
req: Request = Request(request)
authenticator = page.authenticator
response = Response(request,
authenticator.project.frameAncestors,
req.userAgent)
try:
try:
user: User = await authenticator.authenticate(req)
except LoginFailed as ex:
if req.getSubPath() is None:
responder = authenticator.askForAuthentication(
req, ex.args[0] if ex.args else None
)
else:
# Widget requests should just fail immediately instead of
# asking for authentication.
responder = _unauthorizedResponder(ex)
except Unauthorized as ex:
responder = _unauthorizedResponder(ex)
else:
responder = await _parseAndProcess(page, req, user)
except Redirect as ex:
responder = Redirector(ex.url)
except InternalError as ex:
logging.error(
'Internal error processing %s: %s', page.name, str(ex)
)
responder = UIResponder(
InternalErrorPage[PageProcessor](str(ex)),
PageProcessor(page, req, FabResource.Arguments(), UnknownUser())
)
await _present(responder, response)
async def respond(self, response: Response) -> None:
page = self.page
proc = self.proc
response.setContentType('text/x-csv; charset=UTF-8')
response.setFileName(page.getFileName(proc))
sepChar = proc.args.sep.value
for row in page.iterRows(proc):
response.write(sepChar.join(row) + '\r\n')
async def _present(responder: Responder, response: Response) -> None:
"""Presentation step: write a response based on the processing results."""
if _timeRender:
start = time()
if _profileRender:
profile = Profile()
# Note: This will only profile the execution until the first
# 'await' in the responder. However, a lot of pages do
# their whole presentation in one go, so in many cases
# this is good enough.
try:
await profile.runcall(responder.respond, response)
except NotModified:
pass
profile.dump_stats('request.prof')
else:
try:
await responder.respond(response)
except NotModified:
pass
if _timeRender:
end = time()
print('Responding took %1.3f seconds' % (end - start))
response.finish()
async def writeReply(self, response: Response, proc: Processor) -> None:
jobs = proc.jobs
response.write('<jobrefs>')
for chunk in chop(jobs, 1000):
# Measurements have shown that a single write with a big XML
# sequence is much faster than many small writes.
response.writeXML(xml.jobref(jobid=job.getId()) for job in chunk)
# Return control to reactor.
await response.returnToReactor()
response.write('</jobrefs>')
async def respond(self, response: Response) -> None:
response.setStatus(500, 'Unexpected exception processing request')
self.proc.processingError = self.__exception
await super().respond(response)
async def writeReply(self, response: Response, proc: Processor) -> None:
response.writeXML(xml.response[proc.createResponse()])
async def respond(self, response: Response) -> None:
page = self.page
proc = self.proc
response.setContentType(page.getContentType(proc))
await page.writeReply(response, proc)
async def respond(self, response: Response) -> None:
response.setStatus(500, 'Unexpected exception processing request')
response.setContentType('text/plain')
response.write('Unexpected exception processing request.\n'
'Details were written to the server log.\n')
async def respond(self, response: Response) -> None:
response.setStatus(401, self.__message)
response.setHeader('WWW-Authenticate', f'Basic realm="{self.__realm}"')
async def writeReply(self, response: Response, proc: Processor) -> None:
response.writeXML(xml.ok)
async def writeReply(self, response: Response, proc: Processor) -> None:
taskprio = proc.project['taskprio']
def taskToXML(task: Task) -> XML:
run = task.getLatestRun()
return xml.task(
name = task.getName(),
priority = task.getPriority() if taskprio else None,
waiting = run.isWaiting(),
running = run.isRunning(),
done = run.isDone(),
cancelled = run.isCancelled(),
result = task.result,
alert = task.getAlert(),
summary = run.getSummary(),
report = task.getURL(),
starttime = formatTimeAttr(task.startTime),
duration = task.getDuration(),
runner = run.getTaskRunnerId(),
)[
( xml.param(name = name, value = value)
for name, value in task.getVisibleParameters().items() )
]
def productToXML(product: Product, listProducers: bool) -> XML:
prodType = product.getType()
return xml.product(
name = product.getName(),
type = prodType,
available = product.isAvailable(),
blocked = product.isBlocked(),
local = product.isLocal(),
combined = product.isCombined(),
localat = product.getLocalAt(),
locator = None if prodType is ProductType.TOKEN
else product.getLocator(),
)[
( xml.producer(
name = name,
locator = None if prodType is ProductType.TOKEN else locator
)
for name, locator in product.getProducers()
) if listProducers else None
]
job = proc.job
job.updateSummaries(list(proc.resourceDB.iterTaskRunners()))
comment = job.comment
tasks = job.getTaskSequence()
response.writeXML(
xml.job(
jobid = job.getId(),
target = job.getTarget(),
createtime = formatTimeAttr(job.getCreateTime()),
configid = job.configId,
owner = job.owner,
scheduledby = job.getScheduledBy(),
)
[
xml.comment[ comment ] if comment else None,
( taskToXML(task) for task in tasks ),
xml.inputs[
( productToXML(prod, False) for prod in job.getInputs() )
],
xml.outputs[
( productToXML(prod, True) for prod in job.getProduced() )
],
])
async def respond(self, response: Response) -> None:
response.sendRedirect(self.__url)
async def respond(self, response: Response) -> None:
export = self.__export
fmt = self.__format
response.setContentType(fmt.mediaType)
if export:
response.setFileName(f'{self.__fileName}.{fmt.ext}')
else:
response.allowEmbedding()
data = self.__builder.build(export).data
response.setETag(createETag(data) + b'-dot')
try:
rendered = await _renderGraph(data, fmt)
except Exception as ex:
response.setStatus(500, 'Graph rendering failed')
response.setContentType('text/plain')
response.write(f'Graph rendering failed: {ex}\n')
else:
response.write(rendered)
async def respond(self, response: Response) -> None:
response.setStatus(500)
self.proc.error = self.error
await super().respond(response)
async def writeReply(self, response: Response, proc: Processor) -> None:
def iterChangedBy(resource: ResourceBase) -> Iterator[XML]:
user = resource.getChangedUser()
if user:
# Currently 'user' is always 'None' for custom resources
yield xml.changedby(
name = user,
time = formatTimeAttr(resource.getChangedTime()),
)
def iterReservedBy(resource: ResourceBase) -> Iterator[XML]:
if isinstance(resource, TaskRunner):
# Resource is a Task Runner.
runner = resource
run = runner.getRun()
if run:
yield xml.reservedby[
xml.taskref(
taskname = run.getName(),
jobid = run.getJob().getId(),
)
]
else:
# Resource is of a custom type.
if resource.isReserved():
yield xml.reservedby[
xml.userref(
userid = cast(str, resource['reserved'])
)
]
def iterResourceContent(resource: ResourceBase) -> Iterator[XML]:
# Resource type independent information
for cap in resource.capabilities:
yield xml.capability(name = cap)
yield from iterChangedBy(resource)
yield from iterReservedBy(resource)
if isinstance(resource, TaskRunner):
# Include Task Runner specific infomation.
yield xml.taskrunner(
connectionstatus = resource.getConnectionStatus(),
version = cast(str, resource['runnerVersion']),
exitonidle = resource.shouldExit(),
lastsync = cast(Optional[int], resource['lastSync']),
)
else:
# Include information on custom resource type.
yield xml.custom(
description = resource.description
)
response.writeXML(xml.resources[(
xml.resource(
# Resource type independent information
type = resource.typeName,
name = resource.getId(),
suspended = resource.isSuspended(),
locator = resource.getParameter('locator')
)[iterResourceContent(resource)]
for resource in proc.resources
)])
async def writeReply(self, response: Response, proc: Processor) -> None:
response.writeXML(xml.abortedtasks[(
xml.taskref(jobid=jobId, taskname=taskName)
for jobId, taskNames in proc.abortedTasks.items()
for taskName in taskNames)])
async def respond(self, response: Response) -> None:
response.setStatus(self.__status, self.__message)
response.setContentType('text/plain')
response.write(self.__message + '\n')
