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 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 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 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 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