def cbResponse(self, response):
self.proxy_response = response
if int(response.code) >= 600 and int(response.code) <= 699:
self.setResponseCode(500)
self.var['errorcode'] = int(response.code) - 600
if self.var['errorcode'] in SOCKS_errors:
return flattenString(
self, templates[SOCKS_errors[
self.var['errorcode']]]).addCallback(
self.contentFinish)
else:
return flattenString(
self, templates[SOCKS_errors[0x00]]).addCallback(
self.contentFinish)
self.setResponseCode(response.code)
self.processResponseHeaders(response.headers)
if (response.length is not 0):
finished = defer.Deferred()
if self.obj.html:
response.deliverBody(BodyStreamer(self.handleFixPart,
finished))
finished.addCallback(self.handleFixEnd)
else:
response.deliverBody(
BodyStreamer(self.handleForwardPart, finished))
finished.addCallback(self.handleForwardEnd)
return finished
else:
self.contentFinish('')
return defer.succeed
def handle_windows_windows_pub_clientid_DELETE(request, clientid):
cors(request, methods=["GET", "PUT", "OPTIONS"])
request.setHeader("Allow", "GET, PUT, OPTIONS")
logging.debug(request.requestHeaders)
accept_type = request.requestHeaders.getRawHeaders("Accept")[0].split()[0]
client = SubscriberDB.getClient(clientid)
SubscriberDB.deleteQuery(clientid)
if not None:
if "application/json" in accept_type:
request.setHeader("Content-Type", "application/json; charset=UTF-8")
request.setResponseCode(200)
return str(
'{"id":"%s", "uri":"%s", "method":"%s", "accept":"%s"}' % (client[0], client[1], client[2], client[3])
)
elif "application/xml" in accept_type:
request.setHeader("Content-Type", "application/xml; charset=UTF-8")
request.setResponseCode(200)
return str(
"<client><id>%s</id><uri>%s</uri><method>%s</method><accept>%s</accept></client>"
% (client[0], client[1], client[2], client[3])
)
else:
request.write("<!DOCTYPE html>\n")
flattenString(request, ClientElement(client[0], client[1], client[2], client[3])).addCallback(request.write)
request.finish()
def render_DELETE(self, request):
"""Handles DELETE request"""
# TODO implement this
logging.debug(request.requestHeaders)
accept_type = request.requestHeaders.getRawHeaders("Accept")[0]
client = self.__getClient()
self.__deleteQuery()
logging.debug(request.requestHeaders)
accept_type = request.requestHeaders.getRawHeaders("Accept")[0]
client = self.__getClient()
request.setHeader('Access-Control-Allow-Origin', '*')
request.setHeader('Access-Control-Allow-Methods', 'GET, PUT, DELETE')
request.setHeader('Access-Control-Allow-Headers', 'x-prototype-version,x-requested-with')
request.setHeader('Access-Control-Max-Age', 2520) # 42 hours
if not None:
if accept_type == "application/json":
request.setHeader("Content-Type", "application/json; charset=UTF-8")
request.setResponseCode(200)
return str('{"id":"%s", "uri":"%s", "method":"%s", "accept":"%s"}' % (client[0], client[1], client[2], client[3]))
elif accept_type == "application/xml":
request.setHeader("Content-Type", "application/xml; charset=UTF-8")
request.setResponseCode(200)
return str('<client><id>%s</id><uri>%s</uri><method>%s</method><accept>%s</accept></client>' % (client[0], client[1], client[2], client[3]))
else:
request.write("<!DOCTYPE html>\n")
flattenString(request, ClientElement(client[0], client[1], client[2], client[3], '')).addCallback(
request.write)
request.finish()
return NOT_DONE_YET
def test_templateLoaderWithAttributes(self):
"""
L{StringFormatTemplateLoader.load} will convert a template with
C{%(x)s}-format slots inside attributes into t:attr elements containing
t:slot slots.
"""
class StubElement(Element):
loader = StringFormatTemplateLoader(
lambda: StringIO(
'<test><alpha beta="before %(slot1)s after">inner</alpha>'
'%(other)s</test>'
),
"testRenderHere"
)
@renderer
def testRenderHere(self, request, tag):
return tag.fillSlots(slot1="hello",
other="world")
result = []
flattenString(None, StubElement()).addCallback(result.append)
self.assertEquals(
result,
[
'<test><alpha beta="before hello after">'
'inner</alpha>world</test>'
]
)
def test_stringFormatTemplateLoader(self):
"""
L{StringFormatTemplateLoader.load} will convert a template with
C{%(x)s}-format slots by converting it to a template with C{<t:slot
name="x" />} slots, and a renderer on the document element named
according to the constructor argument.
"""
class StubElement(Element):
loader = StringFormatTemplateLoader(
lambda: StringIO(
"<test><alpha>%(slot1)s</alpha>%(other)s</test>"
),
"testRenderHere"
)
@renderer
def testRenderHere(self, request, tag):
return tag.fillSlots(slot1="hello",
other="world")
result = []
flattenString(None, StubElement()).addCallback(result.append)
self.assertEquals(
list(result),
["<test><alpha>hello</alpha>world</test>"]
)
def handle_windows_windows_pub_GET2(request):
cors(request, methods=["GET", "PUT", "OPTIONS"])
request.setHeader("Allow", "GET, PUT, OPTIONS")
dbclient = SubscriberDB.getAllClients("1")
logging.debug(request.requestHeaders)
accept_type = request.requestHeaders.getRawHeaders("Accept")[0]
clients = ""
if not None:
if accept_type == "application/json":
request.setHeader("Content-Type", "application/json; charset=UTF-8")
request.setResponseCode(200)
for cl in dbclient:
clients += str('{"id":"%s", "uri":"%s", "method":"%s", "accept":"%s"}, ' % (cl[0], cl[1], cl[2], cl[3]))
return str('{"clients": {"client":[%s]}}' % (clients[:-2]))
elif accept_type == "application/xml":
request.setHeader("Content-Type", "application/xml; charset=UTF-8")
request.setResponseCode(200)
for cl in dbclient:
clients += str(
"<client><id>%s</id><uri>%s</uri><method>%s</method><accept>%s</accept></client> "
% (cl[0], cl[1], cl[2], cl[3])
)
return str("<clients>%s</clients>" % (clients))
else:
request.write("<!DOCTYPE html>\n")
flattenString(request, ClientsElement(dbclient)).addCallback(request.write)
request.finish()
def handle_windows_windows_pub_POST2(request):
cors(request, methods=["GET", "PUT", "OPTIONS"])
request.setHeader("Allow", "GET, PUT, OPTIONS")
json_data = json.loads(request.content.getvalue())
logging.debug(json_data)
logging.debug(request.requestHeaders)
accept_type = request.requestHeaders.getRawHeaders("Accept")[0]
lastrowid = SubscriberDB.insertClient(json_data["uri"], json_data["method"], json_data["accept"], "1")
if not None:
if accept_type == "application/json":
request.setHeader("Content-Type", "application/json; charset=UTF-8")
request.setResponseCode(200)
return str(
'{"id":"%s", "uri":"%s", "method":"%s", "accept":"%s"}'
% (lastrowid, json_data["uri"], json_data["method"], json_data["accept"])
)
elif accept_type == "application/xml":
request.setHeader("Content-Type", "application/xml; charset=UTF-8")
request.setResponseCode(200)
return str(
"<client><id>%s</id><uri>%s</uri><method>%s</method><accept>%s</accept></client>"
% (lastrowid, json_data["uri"], json_data["method"], json_data["accept"])
)
else:
request.write("<!DOCTYPE html>\n")
flattenString(
request, ClientElement(lastrowid, json_data["uri"], json_data["method"], json_data["accept"], "")
).addCallback(request.write)
request.finish()
def test_stringFormatTemplateLoader(self):
"""
L{StringFormatTemplateLoader.load} will convert a template with
C{%(x)s}-format slots by converting it to a template with C{<t:slot
name="x" />} slots, and a renderer on the document element named
according to the constructor argument.
"""
class StubElement(Element):
loader = StringFormatTemplateLoader(
lambda: StringIO(
"<test><alpha>%(slot1)s</alpha>%(other)s</test>"
),
"testRenderHere"
)
@renderer
def testRenderHere(self, request, tag):
return tag.fillSlots(slot1="hello",
other="world")
result = []
flattenString(None, StubElement()).addCallback(result.append)
self.assertEquals(
list(result),
["<test><alpha>hello</alpha>world</test>"]
)
def render_GET(self, request):
LOGGER.info('Rendering TimelineView %s' % request.path)
request.setHeader('content-type', 'text/html')
processes = []
# This array will hold all of the data for the timeline view.
data = [['Timestamp']]
# Add the list of processes to the timeline table.
for row in self.db.get_process_cmdlines(name=self.process_name_filter):
processes.append(row[0])
data[0].append(row[1].strip())
LOGGER.debug('got process data: %s' % data)
# Now add the top-level PSS values for the processes to the table.
for row in self.db.get_process_stats(name=self.process_name_filter):
timestamp = row[0]
if timestamp != data[-1][0]:
# Moved onto a new snapshot
data.append([0] * (len(processes) + 1))
data[-1][0] = timestamp
# Add process for this snapshot
pos = 1 + processes.index(row[2])
data[-1][pos] = int(row[4])
flattenString(None,
TimelineElement('static/timeline.html',
data)).addCallback(self.renderOutput)
request.write(self.output)
return ""
def cbResponse(self, response):
self.proxy_response = response
if 600 <= int(response.code) <= 699:
self.setResponseCode(500)
self.var['errorcode'] = int(response.code) - 600
if self.var['errorcode'] in SOCKS_errors:
return flattenString(self, templates[SOCKS_errors[self.var['errorcode']]]).addCallback(self.contentFinish)
else:
return flattenString(self, templates[SOCKS_errors[0x00]]).addCallback(self.contentFinish)
self.setResponseCode(response.code)
self.processResponseHeaders(response.headers)
if response.length is not 0:
finished = defer.Deferred()
if self.obj.html:
response.deliverBody(BodyStreamer(self.handleFixPart, finished))
finished.addCallback(self.handleFixEnd)
else:
response.deliverBody(BodyStreamer(self.handleForwardPart, finished))
finished.addCallback(self.handleForwardEnd)
return finished
else:
self.contentFinish('')
return defer.succeed
def render_GET(self, request):
print "Rendering ProcessView"
if not "snapshot" in request.args:
raise Error("No snapshot id specified")
if not "pid" in request.args:
raise Error("No process id specified")
c = self.conn.cursor()
request.setHeader("content-type", "text/html")
process_id = request.args["pid"][0]
snapshot_id = request.args["snapshot"][0]
data = [['Memory type', "Value (Kb)"]]
stmt = "select Process, %s from %s where pid = '%s' and snap_id = '%s'" % (
self.fields, self.process_detail_table, process_id, snapshot_id)
print "stmt = %s" % stmt
for row in c.execute(stmt):
for (i, field) in enumerate(self.labels):
data.append([self.labels[field], int(row[i + 1])])
flattenString(
None, ProcessElement("static/process-stats.html", data,
self.labels)).addCallback(self.renderOutput)
request.write(self.output)
return ""
def render_GET(self, request):
def _renderDone(html):
request.write(html)
request.finish()
flattenString(None, SearchElement()).addCallback(_renderDone)
return NOT_DONE_YET
def render(self, request):
if request.args:
self.headers = request.getAllHeaders()
img = cgi.FieldStorage(
fp=request.content,
headers=self.headers,
environ={'REQUEST_METHOD': 'POST', 'CONTENT_TYPE': self.headers['content-type'], }
)
out = open(img["upl_file"].filename, 'wb')
out.write(img["upl_file"].value)
out.close()
#print img["upl_file"].name, img["upl_file"].filename, img["upl_file"].type
request.write("<!DOCTYPE html>\n")
request.write("<!DOCTYPE html>\n")
request.write("<html>\n")
request.write("<head>\n")
request.write("<meta charset=\"utf-8\">\n")
request.write("<title></title>\n")
request.write("<meta name=\"description\" content=\"\">\n")
request.write("</head>\n")
request.write("<body>\n")
flattenString(request, element.FileUpload()).addCallback(request.write)
request.write("</body>\n")
request.write("</html>\n")
request.finish()
return NOT_DONE_YET
def test_templateLoaderTagSoup(self):
"""
L{StringFormatTemplateLoader.load} will convert a template with
C{%(x)s}-format slots into t:slot slots, and render a well-formed output
document, even if the input is malformed (i.e. missing necessary closing
tags).
"""
class StubElement(Element):
loader = StringFormatTemplateLoader(
lambda : StringIO(
'<test><alpha beta="before %(slot1)s after">inner</alpha>'
'%(other)s'
),
"testRenderHere"
)
@renderer
def testRenderHere(self, request, tag):
return tag.fillSlots(slot1="hello",
other="world")
result = []
flattenString(None, StubElement()).addCallback(result.append)
self.assertEquals(result,
['<test><alpha beta="before hello after">'
'inner</alpha>world</test>'])
def test_templateLoaderWithAttributes(self):
"""
L{StringFormatTemplateLoader.load} will convert a template with
C{%(x)s}-format slots inside attributes into t:attr elements containing
t:slot slots.
"""
class StubElement(Element):
loader = StringFormatTemplateLoader(
lambda: StringIO(
'<test><alpha beta="before %(slot1)s after">inner</alpha>'
'%(other)s</test>'
),
"testRenderHere"
)
@renderer
def testRenderHere(self, request, tag):
return tag.fillSlots(slot1="hello",
other="world")
result = []
flattenString(None, StubElement()).addCallback(result.append)
self.assertEquals(
result,
[
'<test><alpha beta="before hello after">'
'inner</alpha>world</test>'
]
)
def render_GET(self, request):
def renderDone(output):
request.write(output)
request.finish()
flattenString(None, HomePageTemplate()).addCallback(renderDone)
return server.NOT_DONE_YET
def test_templateLoaderTagSoup(self):
"""
L{StringFormatTemplateLoader.load} will convert a template with
C{%(x)s}-format slots into t:slot slots, and render a well-formed output
document, even if the input is malformed (i.e. missing necessary closing
tags).
"""
class StubElement(Element):
loader = StringFormatTemplateLoader(
lambda: StringIO(
'<test><alpha beta="before %(slot1)s after">inner</alpha>'
'%(other)s'
),
"testRenderHere"
)
@renderer
def testRenderHere(self, request, tag):
return tag.fillSlots(slot1="hello",
other="world")
result = []
flattenString(None, StubElement()).addCallback(result.append)
self.assertEquals(result,
['<test><alpha beta="before hello after">'
'inner</alpha>world</test>'])
def render_GET(self, request):
def renderDone(output):
request.write(output)
request.finish()
flattenString(None, ExampleElement()).addCallback(renderDone)
return server.NOT_DONE_YET
def flattenToFile(fobj, page):
fobj.write(DOCTYPE)
err = []
def e(r):
err.append(r.value)
flattenString(None, page).addCallback(fobj.write).addErrback(e)
if err:
raise err[0]
def flattenToFile(fobj, page):
fobj.write(DOCTYPE)
err = []
def e(r):
err.append(r.value)
flattenString(None, page).addCallback(fobj.write).addErrback(e)
if err:
raise err[0]
def flatten(t):
r = []
def _(result):
r.append(result)
flattenString(None, t).addCallback(_)
return r[0]
def render_GET(self, request):
def _renderDone(html):
request.write(html)
request.finish()
if self.avatar:
request.redirect('/')
flattenString(None, LoginElement()).addCallback(_renderDone)
return NOT_DONE_YET
def handleError(self, failure):
if type(failure.value) is SOCKSError:
self.setResponseCode(404)
self.var['errorcode'] = failure.value.code
if failure.value.code in SOCKS_errors:
return flattenString(self, templates[SOCKS_errors[failure.value.code]]).addCallback(self.contentFinish)
else:
return flattenString(self, templates[SOCKS_errors[0x00]]).addCallback(self.contentFinish)
else:
self.sendError()
def handleError(self, failure):
if type(failure.value) is SOCKSError:
self.setResponseCode(404)
self.var['errorcode'] = failure.value.code
if failure.value.code in SOCKS_errors:
return flattenString(self, templates[SOCKS_errors[failure.value.code]]).addCallback(self.contentFinish)
else:
return flattenString(self, templates[SOCKS_errors[0x00]]).addCallback(self.contentFinish)
else:
self.sendError()
def flatten(stan: Tag) -> str:
"""
Convert a document fragment from a Stan tree to HTML.
@param stan: Document fragment to flatten.
@return: An HTML string representation of the C{stan} tree.
"""
ret: List[bytes] = []
err: List[Failure] = []
flattenString(None, stan).addCallback(ret.append).addErrback(err.append)
if err:
raise err[0].value
else:
return ret[0].decode()
def flatten(stan):
"""
Convert a document fragment from a Stan tree to HTML.
@param stan: Document fragment to flatten.
@return: An HTML string representation of the C{stan} tree.
@rtype: C{str}
"""
ret = []
err = []
flattenString(None, stan).addCallback(ret.append).addErrback(err.append)
if err:
raise err[0].value
else:
return ret[0].decode()
def flattenToFile(fobj: IO[bytes], elem: Element) -> None:
"""
This method writes a page to a HTML file.
@raises Exception: If the L{twisted.web.template.flatten} call fails.
"""
fobj.write(DOCTYPE)
err = None
def e(r: Failure) -> None:
nonlocal err
err = r.value
flattenString(None, elem).addCallback(fobj.write).addErrback(e)
if err:
raise err
def build_page(self):
with open(cosmosConfigFile(self.opts['home'])) as f:
config = f.read()
args = ConfigElement.gatherArgs(self.opts)
html = yield flattenString(None, ConfigElement(*args))
return html
def test_render(self):
'''Rendering IFrameElement produces the HTML SockJS requires.'''
renderDeferred = template.flattenString(
None, R.IFrameElement(SOCKJS_URL_BYTES))
renderDeferred.addCallback(self.assertEqual, STATIC_IFRAME)
return renderDeferred
def render_POST(self, request):
tweet = request.args["tweet"][0]
c.execute("insert into tweets values(?)", (tweet, ))
conn.commit()
print request.args
return flattenString(request, IndexElement()).result
def test_commentEscaping(self):
"""
The data in a L{Comment} is escaped and mangled in the flattened output
so that the result is a legal SGML and XML comment.
SGML comment syntax is complicated and hard to use. This rule is more
restrictive, and more compatible:
Comments start with <!-- and end with --> and never contain -- or >.
Also by XML syntax, a comment may not end with '-'.
@see: U{http://www.w3.org/TR/REC-xml/#sec-comments}
"""
def verifyComment(c):
self.assertTrue(c.startswith("<!--"), "%r does not start with the comment prefix" % (c,))
self.assertTrue(c.endswith("-->"), "%r does not end with the comment suffix" % (c,))
# If it is shorter than 7, then the prefix and suffix overlap
# illegally.
self.assertTrue(len(c) >= 7, "%r is too short to be a legal comment" % (c,))
content = c[4:-3]
self.assertNotIn("--", content)
self.assertNotIn(">", content)
if content:
self.assertNotEqual(content[-1], "-")
results = []
for c in ["", "foo---bar", "foo---bar-", "foo>bar", "foo-->bar", "----------------"]:
d = flattenString(None, Comment(c))
d.addCallback(verifyComment)
results.append(d)
return gatherResults(results)
def test_sourceFragmentElement(self):
"""
L{_SourceFragmentElement} renders source lines at and around the line
number indicated by a frame object.
"""
element = _SourceFragmentElement(
TagLoader(
tags.div(tags.span(render="lineNumber"),
tags.span(render="sourceLine"),
render="sourceLines")), self.frame)
source = [
u' \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}message = '
u'"This is a problem"',
u' \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}raise Exception(message)',
u'# Figure out the line number from which the exception will be '
u'raised.',
]
d = flattenString(None, element)
d.addCallback(
self.assertEqual, ''.join([
'<div class="snippet%sLine"><span>%d</span><span>%s</span>'
'</div>' %
(["", "Highlight"][lineNumber == 1], self.base + lineNumber,
(u" \N{NO-BREAK SPACE}" * 4 + sourceLine).encode('utf-8'))
for (lineNumber, sourceLine) in enumerate(source)
]))
return d
def content(self, request):
points = yield self.highscore.points.getUserPoints(self.userid)
display_name = yield self.highscore.users.getDisplayName(self.userid)
request.write('<!doctype html>\n')
defer.returnValue((yield template.flattenString(
request, UserPointsElement(self.highscore, display_name, points))))
def test_sourceFragmentElement(self):
"""
L{_SourceFragmentElement} renders source lines at and around the line
number indicated by a frame object.
"""
element = _SourceFragmentElement(
TagLoader(tags.div(
tags.span(render="lineNumber"),
tags.span(render="sourceLine"),
render="sourceLines")),
self.frame)
source = [
u' \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}message = '
u'"This is a problem"',
u' \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}raise Exception(message)',
u'# Figure out the line number from which the exception will be '
u'raised.',
]
d = flattenString(None, element)
d.addCallback(
self.assertEqual,
''.join([
'<div class="snippet%sLine"><span>%d</span><span>%s</span>'
'</div>' % (
["", "Highlight"][lineNumber == 1],
self.base + lineNumber,
(u" \N{NO-BREAK SPACE}" * 4 + sourceLine).encode(
'utf-8'))
for (lineNumber, sourceLine)
in enumerate(source)]))
return d
def build_page(self):
f = open(cosmosConfigFile(self.opts['home']))
config = f.read()
args = ConfigElement.gatherArgs(self.opts)
html = yield flattenString(None, ConfigElement(*args))
defer.returnValue(html)
def render_GET(self, request):
try:
(clx,resource) = reservoir.uri_canonical_open(request.uri.decode('utf-8'))
if resource is None:
w = WidgetsElement()
w.widgetData = [ ]
for item in clx.items():
entry = { 'href': '../' + item[1] + '/', 'content': item[0] }
w.widgetData.append(entry)
resources = clx.load_all_resources()
for resource in resources:
result = ""
for cn in resource['cn']:
result += cn
entry = { 'href': resource.resuuid, 'content': result }
w.widgetData.append(entry)
d = flattenString(None, w)
self.request = request
d.addCallback(self.printResult)
return NOT_DONE_YET
else:
fh = resource.open(binary=True)
fileContent = fh.read()
fh.close()
for media_type in resource['mediaType']:
request.setHeader('Content-type', media_type)
return fileContent
except:
(uri,clx,resource) = reservoir.uri_canonical(domain='arpa2.org', apphint='Music', domain_relative=True)
host = request.getHeader('host')
request.redirect(('//' + host + uri).encode('utf-8'))
request.finish()
return NOT_DONE_YET
def new_email(self, incoming_email, email_element, domain):
email_element.raw_email(incoming_email)
email_element.domain = domain
def error(e):
print 'new email error:', e
def add_result_back(html_result):
if email_element.html is not None:
try:
pattern_obj = re.compile(mail_keys.html_placeholder,
re.MULTILINE)
html_result = pattern_obj.sub(email_element.html,
html_result)
except Exception as e:
print 'bind html exception:', e
email_element.summary = html_result
return email_element
email_element
d = flattenString(None, email_element)
d.addCallback(add_result_back)
d.addCallback(self.broadcast)
d.addErrback(error)
return d
def render_GET(self, request):
d = flattenString(request, BravoElement(self.services))
def complete_request(html):
request.write(html)
request.finish()
d.addCallback(complete_request)
return NOT_DONE_YET
def render_GET(self, request):
d = flattenString(request, AutomatonStatsElement())
def complete_request(html):
request.write(html)
request.finish()
d.addCallback(complete_request)
return NOT_DONE_YET
def render_POST(self, request):
tweet = request.args["tweet"][0]
c.execute("insert into tweets values(?)", (tweet,))
conn.commit()
print request.args
return flattenString(request, IndexElement()).result
def content(self, request):
scores = yield self.highscore.points.getHighscores(const.MONTHLY_MODE)
ltscores = yield self.highscore.points.getHighscores(
const.LONGTERM_MODE)
request.write('<!doctype html>\n')
defer.returnValue((yield template.flattenString(
request, HighscoresElement(self.highscore, scores, ltscores))))
def render_GET(self, request):
"""
Renders self.element
"""
request.write('<!DOCTYPE html>\n')
d = flattenString(request, self.element_from_request(request))
d.addCallback(self._finish_request, request)
return NOT_DONE_YET
def content(self, request):
points = yield self.highscore.points.getUserPoints(self.userid)
display_name = yield self.highscore.users.getDisplayName(self.userid)
request.write('<!doctype html>\n')
defer.returnValue((yield template.flattenString(request,
UserPointsElement(self.highscore,
display_name, points))))
def _render_download_status_element(self, status):
"""
:param IDownloadStatus status:
:return: HTML string rendered by DownloadStatusElement
"""
elem = DownloadStatusElement(status)
d = flattenString(None, elem)
return self.successResultOf(d)
def render(self, request):
request.write("<!DOCTYPE html>\n")
request.write("<!DOCTYPE html>\n")
request.write("<html>\n")
request.write("<head>\n")
request.write("<meta charset=\"utf-8\">\n")
request.write("<title></title>\n")
request.write("<meta name=\"description\" content=\"\">\n")
request.write("</head>\n")
request.write("<body>\n")
print request.args
#flattenString(request, ExampleElement()).addCallback(request.write)
flattenString(request, element.FileUpload()).addCallback(request.write)
request.write("</body>\n")
request.write("</html>\n")
request.finish()
return NOT_DONE_YET
def render_GET(self, request):
d = flattenString(request, self.element)
def complete_request(html):
if not request._disconnected:
request.write(html)
request.finish()
d.addCallback(complete_request)
return NOT_DONE_YET
def process(r):
if IResource.providedBy(r):
return request.render(getChildForRequest(r, request))
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
return r
def content(self, request):
scores = yield self.highscore.points.getHighscores(const.MONTHLY_MODE)
ltscores = yield self.highscore.points.getHighscores(const.LONGTERM_MODE)
request.write('<!doctype html>\n')
defer.returnValue((yield template.flattenString(request,
HighscoresElement(self.highscore, scores,
ltscores))))
def test_brand_rendering_for_non_shared_pages(self):
page = DashboardPage(mk_dashboard(), shared=False)
d = flattenString(None, page)
def assert_brand_rendering(response):
self.assertTrue('<a href="/" class="brand">' in response)
d.addCallback(assert_brand_rendering)
return d
def formatFailure(myFailure):
"""
Construct an HTML representation of the given failure.
Consider using L{FailureElement} instead.
@type myFailure: L{Failure<twisted.python.failure.Failure>}
@rtype: C{bytes}
@return: A string containing the HTML representation of the given failure.
"""
result = []
flattenString(None, FailureElement(myFailure)).addBoth(result.append)
if isinstance(result[0], bytes):
# Ensure the result string is all ASCII, for compatibility with the
# default encoding expected by browsers.
return result[0].decode('utf-8').encode('ascii', 'xmlcharrefreplace')
result[0].raiseException()
def handle_windows_windows_pub_clientid_GET6(request, clientid):
logging.debug(request.requestHeaders)
cors(request, methods=['GET', 'PUT', 'OPTIONS'])
accept_type = request.requestHeaders.getRawHeaders('Accept')[0].split(',')[0]
client = SubscriberDB.getClient(clientid)
if not None:
if 'application/json' in accept_type:
request.setHeader('Content-Type', 'application/json; charset=UTF-8')
request.setResponseCode(200)
return str('{"id":"%s", "uri":"%s", "method":"%s", "accept":"%s"}' % (client[0], client[1], client[2], client[3]))
elif accept_type == 'application/xml':
request.setHeader('Content-Type', 'application/xml; charset=UTF-8')
request.setResponseCode(200)
return str('<client><id>%s</id><uri>%s</uri><method>%s</method><accept>%s</accept></client>' % (client[0], client[1], client[2], client[3]))
else:
request.write('<!DOCTYPE html>\n')
flattenString(request, ClientElement(client[0], client[1], client[2], client[3], '')).addCallback(request.write)
request.finish()
def render_GET(self, request):
d = flattenString(request, AutomatonStatsElement(self.factory))
def complete_request(html):
if not request._disconnected:
request.write(html)
request.finish()
d.addCallback(complete_request)
return NOT_DONE_YET
def test_title_rendering(self):
dashboard = mk_dashboard()
d = flattenString(None, dashboard)
def assert_title_rendering(response):
self.assertTrue('<h1>Some Dashboard</h1>' in response)
d.addCallback(assert_title_rendering)
return d
def formatFailure(myFailure):
"""
Construct an HTML representation of the given failure.
Consider using L{FailureElement} instead.
@type myFailure: L{Failure<twisted.python.failure.Failure>}
@rtype: C{str}
@return: A string containing the HTML representation of the given failure.
"""
result = []
flattenString(None, FailureElement(myFailure)).addBoth(result.append)
if isinstance(result[0], str):
# Ensure the result string is all ASCII, for compatibility with the
# default encoding expected by browsers.
return result[0].decode('utf-8').encode('ascii', 'xmlcharrefreplace')
result[0].raiseException()
def process(r):
if IResource.providedBy(r):
request.render(getChildForRequest(r, request))
return _StandInResource
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
return r
def render_GET(self, request):
d = flattenString(request, self.element)
def complete_request(html):
request.write(html)
request.finish()
d.addCallback(complete_request)
return NOT_DONE_YET
def test_failureElementType(self):
"""
The I{type} renderer of L{FailureElement} renders the failure's
exception type.
"""
element = FailureElement(self.failure,
TagLoader(tags.span(render="type")))
d = flattenString(None, element)
d.addCallback(self.assertEqual, "<span>exceptions.Exception</span>")
return d
def test_failureElementValue(self):
"""
The I{value} renderer of L{FailureElement} renders the value's exception
value.
"""
element = FailureElement(self.failure,
TagLoader(tags.span(render="value")))
d = flattenString(None, element)
d.addCallback(self.assertEqual, b"<span>This is a problem</span>")
return d
def body(self, req):
status = self.getStatus(req)
authz = self.getAuthz(req)
builders = req.args.get(
"builder", status.getBuilderNames(categories=self.categories))
branches = [b for b in req.args.get("branch", []) if b]
if not branches:
branches = ["master"]
if branches and "master" not in branches:
defaultCount = "1"
else:
defaultCount = "10"
num_builds = int(req.args.get("num_builds", [defaultCount])[0])
tag = tags.div()
tag(tags.script(src="hlbb.js"))
tag(
tags.h2(style="float:left; margin-top:0")("Latest builds: ",
", ".join(branches)))
form = tags.form(method="get",
action="",
style="float:right",
onsubmit="return checkBranch(branch.value)")
form(
tags.input(type="test",
name="branch",
placeholder=branches[0],
size="40"))
form(tags.input(type="submit", value="View"))
if (yield authz.actionAllowed('forceAllBuilds', req)):
# XXX: Unsafe interpolation
form(
tags.button(type="button",
onclick="forceBranch(branch.value || %r, %r)" % (
branches[0],
self.categories,
))("Force"))
tag(form)
table = tags.table(style="clear:both")
tag(table)
for bn in filter(lambda bn: bn not in self.failing_builders, builders):
table(self.builder_row(bn, req, branches, num_builds))
table(tags.tr()(tags.td(colspan="100")(
tags.h3(style="float:left; margin-top:0")("Expected failures: "))))
for bn in filter(lambda bn: bn in self.failing_builders, builders):
table(self.builder_row(bn, req, branches, num_builds))
defer.returnValue((yield flattenString(req, tag)))
def test_failureElementValue(self):
"""
The I{value} renderer of L{FailureElement} renders the value's exception
value.
"""
element = FailureElement(
self.failure, TagLoader(tags.span(render="value")))
d = flattenString(None, element)
d.addCallback(
self.assertEqual, b'<span>This is a problem</span>')
return d
