| from __future__ import print_function |
| |
| try: |
| from http.server import HTTPServer, SimpleHTTPRequestHandler |
| except ImportError: |
| from BaseHTTPServer import HTTPServer |
| from SimpleHTTPServer import SimpleHTTPRequestHandler |
| import os |
| import sys |
| |
| try: |
| from urlparse import urlparse |
| from urllib import unquote |
| except ImportError: |
| from urllib.parse import urlparse, unquote |
| |
| import posixpath |
| |
| if sys.version_info.major >= 3: |
| from io import StringIO, BytesIO |
| else: |
| from io import BytesIO, BytesIO as StringIO |
| |
| import re |
| import shutil |
| import threading |
| import time |
| import socket |
| import itertools |
| |
| import Reporter |
| |
| try: |
| import configparser |
| except ImportError: |
| import ConfigParser as configparser |
| |
| ### |
| # Various patterns matched or replaced by server. |
| |
| kReportFileRE = re.compile("(.*/)?report-(.*)\\.html") |
| |
| kBugKeyValueRE = re.compile("<!-- BUG([^ ]*) (.*) -->") |
| |
| # <!-- REPORTPROBLEM file="crashes/clang_crash_ndSGF9.mi" stderr="crashes/clang_crash_ndSGF9.mi.stderr.txt" info="crashes/clang_crash_ndSGF9.mi.info" --> |
| |
| kReportCrashEntryRE = re.compile("<!-- REPORTPROBLEM (.*?)-->") |
| kReportCrashEntryKeyValueRE = re.compile(' ?([^=]+)="(.*?)"') |
| |
| kReportReplacements = [] |
| |
| # Add custom javascript. |
| kReportReplacements.append( |
| ( |
| re.compile("<!-- SUMMARYENDHEAD -->"), |
| """\ |
| <script language="javascript" type="text/javascript"> |
| function load(url) { |
| if (window.XMLHttpRequest) { |
| req = new XMLHttpRequest(); |
| } else if (window.ActiveXObject) { |
| req = new ActiveXObject("Microsoft.XMLHTTP"); |
| } |
| if (req != undefined) { |
| req.open("GET", url, true); |
| req.send(""); |
| } |
| } |
| </script>""", |
| ) |
| ) |
| |
| # Insert additional columns. |
| kReportReplacements.append((re.compile("<!-- REPORTBUGCOL -->"), "<td></td><td></td>")) |
| |
| # Insert report bug and open file links. |
| kReportReplacements.append( |
| ( |
| re.compile('<!-- REPORTBUG id="report-(.*)\\.html" -->'), |
| ( |
| '<td class="Button"><a href="report/\\1">Report Bug</a></td>' |
| + '<td class="Button"><a href="javascript:load(\'open/\\1\')">Open File</a></td>' |
| ), |
| ) |
| ) |
| |
| kReportReplacements.append( |
| ( |
| re.compile("<!-- REPORTHEADER -->"), |
| '<h3><a href="/">Summary</a> > Report %(report)s</h3>', |
| ) |
| ) |
| |
| kReportReplacements.append( |
| ( |
| re.compile("<!-- REPORTSUMMARYEXTRA -->"), |
| '<td class="Button"><a href="report/%(report)s">Report Bug</a></td>', |
| ) |
| ) |
| |
| # Insert report crashes link. |
| |
| # Disabled for the time being until we decide exactly when this should |
| # be enabled. Also the radar reporter needs to be fixed to report |
| # multiple files. |
| |
| # kReportReplacements.append((re.compile('<!-- REPORTCRASHES -->'), |
| # '<br>These files will automatically be attached to ' + |
| # 'reports filed here: <a href="report_crashes">Report Crashes</a>.')) |
| |
| ### |
| # Other simple parameters |
| |
| kShare = posixpath.join(posixpath.dirname(__file__), "../share/scan-view") |
| kConfigPath = os.path.expanduser("~/.scanview.cfg") |
| |
| ### |
| |
| __version__ = "0.1" |
| |
| __all__ = ["create_server"] |
| |
| |
| class ReporterThread(threading.Thread): |
| def __init__(self, report, reporter, parameters, server): |
| threading.Thread.__init__(self) |
| self.report = report |
| self.server = server |
| self.reporter = reporter |
| self.parameters = parameters |
| self.success = False |
| self.status = None |
| |
| def run(self): |
| result = None |
| try: |
| if self.server.options.debug: |
| print("%s: SERVER: submitting bug." % (sys.argv[0],), file=sys.stderr) |
| self.status = self.reporter.fileReport(self.report, self.parameters) |
| self.success = True |
| time.sleep(3) |
| if self.server.options.debug: |
| print( |
| "%s: SERVER: submission complete." % (sys.argv[0],), file=sys.stderr |
| ) |
| except Reporter.ReportFailure as e: |
| self.status = e.value |
| except Exception as e: |
| s = StringIO() |
| import traceback |
| |
| print("<b>Unhandled Exception</b><br><pre>", file=s) |
| traceback.print_exc(file=s) |
| print("</pre>", file=s) |
| self.status = s.getvalue() |
| |
| |
| class ScanViewServer(HTTPServer): |
| def __init__(self, address, handler, root, reporters, options): |
| HTTPServer.__init__(self, address, handler) |
| self.root = root |
| self.reporters = reporters |
| self.options = options |
| self.halted = False |
| self.config = None |
| self.load_config() |
| |
| def load_config(self): |
| self.config = configparser.RawConfigParser() |
| |
| # Add defaults |
| self.config.add_section("ScanView") |
| for r in self.reporters: |
| self.config.add_section(r.getName()) |
| for p in r.getParameters(): |
| if p.saveConfigValue(): |
| self.config.set(r.getName(), p.getName(), "") |
| |
| # Ignore parse errors |
| try: |
| self.config.read([kConfigPath]) |
| except: |
| pass |
| |
| # Save on exit |
| import atexit |
| |
| atexit.register(lambda: self.save_config()) |
| |
| def save_config(self): |
| # Ignore errors (only called on exit). |
| try: |
| f = open(kConfigPath, "w") |
| self.config.write(f) |
| f.close() |
| except: |
| pass |
| |
| def halt(self): |
| self.halted = True |
| if self.options.debug: |
| print("%s: SERVER: halting." % (sys.argv[0],), file=sys.stderr) |
| |
| def serve_forever(self): |
| while not self.halted: |
| if self.options.debug > 1: |
| print("%s: SERVER: waiting..." % (sys.argv[0],), file=sys.stderr) |
| try: |
| self.handle_request() |
| except OSError as e: |
| print("OSError", e.errno) |
| |
| def finish_request(self, request, client_address): |
| if self.options.autoReload: |
| import ScanView |
| |
| self.RequestHandlerClass = reload(ScanView).ScanViewRequestHandler |
| HTTPServer.finish_request(self, request, client_address) |
| |
| def handle_error(self, request, client_address): |
| # Ignore socket errors |
| info = sys.exc_info() |
| if info and isinstance(info[1], socket.error): |
| if self.options.debug > 1: |
| print( |
| "%s: SERVER: ignored socket error." % (sys.argv[0],), |
| file=sys.stderr, |
| ) |
| return |
| HTTPServer.handle_error(self, request, client_address) |
| |
| |
| # Borrowed from Quixote, with simplifications. |
| def parse_query(qs, fields=None): |
| if fields is None: |
| fields = {} |
| for chunk in (_f for _f in qs.split("&") if _f): |
| if "=" not in chunk: |
| name = chunk |
| value = "" |
| else: |
| name, value = chunk.split("=", 1) |
| name = unquote(name.replace("+", " ")) |
| value = unquote(value.replace("+", " ")) |
| item = fields.get(name) |
| if item is None: |
| fields[name] = [value] |
| else: |
| item.append(value) |
| return fields |
| |
| |
| class ScanViewRequestHandler(SimpleHTTPRequestHandler): |
| server_version = "ScanViewServer/" + __version__ |
| dynamic_mtime = time.time() |
| |
| def do_HEAD(self): |
| try: |
| SimpleHTTPRequestHandler.do_HEAD(self) |
| except Exception as e: |
| self.handle_exception(e) |
| |
| def do_GET(self): |
| try: |
| SimpleHTTPRequestHandler.do_GET(self) |
| except Exception as e: |
| self.handle_exception(e) |
| |
| def do_POST(self): |
| """Serve a POST request.""" |
| try: |
| length = self.headers.getheader("content-length") or "0" |
| try: |
| length = int(length) |
| except: |
| length = 0 |
| content = self.rfile.read(length) |
| fields = parse_query(content) |
| f = self.send_head(fields) |
| if f: |
| self.copyfile(f, self.wfile) |
| f.close() |
| except Exception as e: |
| self.handle_exception(e) |
| |
| def log_message(self, format, *args): |
| if self.server.options.debug: |
| sys.stderr.write( |
| "%s: SERVER: %s - - [%s] %s\n" |
| % ( |
| sys.argv[0], |
| self.address_string(), |
| self.log_date_time_string(), |
| format % args, |
| ) |
| ) |
| |
| def load_report(self, report): |
| path = os.path.join(self.server.root, "report-%s.html" % report) |
| data = open(path).read() |
| keys = {} |
| for item in kBugKeyValueRE.finditer(data): |
| k, v = item.groups() |
| keys[k] = v |
| return keys |
| |
| def load_crashes(self): |
| path = posixpath.join(self.server.root, "index.html") |
| data = open(path).read() |
| problems = [] |
| for item in kReportCrashEntryRE.finditer(data): |
| fieldData = item.group(1) |
| fields = dict( |
| [i.groups() for i in kReportCrashEntryKeyValueRE.finditer(fieldData)] |
| ) |
| problems.append(fields) |
| return problems |
| |
| def handle_exception(self, exc): |
| import traceback |
| |
| s = StringIO() |
| print("INTERNAL ERROR\n", file=s) |
| traceback.print_exc(file=s) |
| f = self.send_string(s.getvalue(), "text/plain") |
| if f: |
| self.copyfile(f, self.wfile) |
| f.close() |
| |
| def get_scalar_field(self, name): |
| if name in self.fields: |
| return self.fields[name][0] |
| else: |
| return None |
| |
| def submit_bug(self, c): |
| title = self.get_scalar_field("title") |
| description = self.get_scalar_field("description") |
| report = self.get_scalar_field("report") |
| reporterIndex = self.get_scalar_field("reporter") |
| files = [] |
| for fileID in self.fields.get("files", []): |
| try: |
| i = int(fileID) |
| except: |
| i = None |
| if i is None or i < 0 or i >= len(c.files): |
| return (False, "Invalid file ID") |
| files.append(c.files[i]) |
| |
| if not title: |
| return (False, "Missing title.") |
| if not description: |
| return (False, "Missing description.") |
| try: |
| reporterIndex = int(reporterIndex) |
| except: |
| return (False, "Invalid report method.") |
| |
| # Get the reporter and parameters. |
| reporter = self.server.reporters[reporterIndex] |
| parameters = {} |
| for o in reporter.getParameters(): |
| name = "%s_%s" % (reporter.getName(), o.getName()) |
| if name not in self.fields: |
| return ( |
| False, |
| 'Missing field "%s" for %s report method.' |
| % (name, reporter.getName()), |
| ) |
| parameters[o.getName()] = self.get_scalar_field(name) |
| |
| # Update config defaults. |
| if report != "None": |
| self.server.config.set("ScanView", "reporter", reporterIndex) |
| for o in reporter.getParameters(): |
| if o.saveConfigValue(): |
| name = o.getName() |
| self.server.config.set(reporter.getName(), name, parameters[name]) |
| |
| # Create the report. |
| bug = Reporter.BugReport(title, description, files) |
| |
| # Kick off a reporting thread. |
| t = ReporterThread(bug, reporter, parameters, self.server) |
| t.start() |
| |
| # Wait for thread to die... |
| while t.isAlive(): |
| time.sleep(0.25) |
| submitStatus = t.status |
| |
| return (t.success, t.status) |
| |
| def send_report_submit(self): |
| report = self.get_scalar_field("report") |
| c = self.get_report_context(report) |
| if c.reportSource is None: |
| reportingFor = "Report Crashes > " |
| fileBug = ( |
| """\ |
| <a href="/report_crashes">File Bug</a> > """ |
| % locals() |
| ) |
| else: |
| reportingFor = '<a href="/%s">Report %s</a> > ' % (c.reportSource, report) |
| fileBug = '<a href="/report/%s">File Bug</a> > ' % report |
| title = self.get_scalar_field("title") |
| description = self.get_scalar_field("description") |
| |
| res, message = self.submit_bug(c) |
| |
| if res: |
| statusClass = "SubmitOk" |
| statusName = "Succeeded" |
| else: |
| statusClass = "SubmitFail" |
| statusName = "Failed" |
| |
| result = ( |
| """ |
| <head> |
| <title>Bug Submission</title> |
| <link rel="stylesheet" type="text/css" href="/scanview.css" /> |
| </head> |
| <body> |
| <h3> |
| <a href="/">Summary</a> > |
| %(reportingFor)s |
| %(fileBug)s |
| Submit</h3> |
| <form name="form" action=""> |
| <table class="form"> |
| <tr><td> |
| <table class="form_group"> |
| <tr> |
| <td class="form_clabel">Title:</td> |
| <td class="form_value"> |
| <input type="text" name="title" size="50" value="%(title)s" disabled> |
| </td> |
| </tr> |
| <tr> |
| <td class="form_label">Description:</td> |
| <td class="form_value"> |
| <textarea rows="10" cols="80" name="description" disabled> |
| %(description)s |
| </textarea> |
| </td> |
| </table> |
| </td></tr> |
| </table> |
| </form> |
| <h1 class="%(statusClass)s">Submission %(statusName)s</h1> |
| %(message)s |
| <p> |
| <hr> |
| <a href="/">Return to Summary</a> |
| </body> |
| </html>""" |
| % locals() |
| ) |
| return self.send_string(result) |
| |
| def send_open_report(self, report): |
| try: |
| keys = self.load_report(report) |
| except IOError: |
| return self.send_error(400, "Invalid report.") |
| |
| file = keys.get("FILE") |
| if not file or not posixpath.exists(file): |
| return self.send_error(400, 'File does not exist: "%s"' % file) |
| |
| import startfile |
| |
| if self.server.options.debug: |
| print('%s: SERVER: opening "%s"' % (sys.argv[0], file), file=sys.stderr) |
| |
| status = startfile.open(file) |
| if status: |
| res = 'Opened: "%s"' % file |
| else: |
| res = 'Open failed: "%s"' % file |
| |
| return self.send_string(res, "text/plain") |
| |
| def get_report_context(self, report): |
| class Context(object): |
| pass |
| |
| if report is None or report == "None": |
| data = self.load_crashes() |
| # Don't allow empty reports. |
| if not data: |
| raise ValueError("No crashes detected!") |
| c = Context() |
| c.title = "clang static analyzer failures" |
| |
| stderrSummary = "" |
| for item in data: |
| if "stderr" in item: |
| path = posixpath.join(self.server.root, item["stderr"]) |
| if os.path.exists(path): |
| lns = itertools.islice(open(path), 0, 10) |
| stderrSummary += "%s\n--\n%s" % ( |
| item.get("src", "<unknown>"), |
| "".join(lns), |
| ) |
| |
| c.description = """\ |
| The clang static analyzer failed on these inputs: |
| %s |
| |
| STDERR Summary |
| -------------- |
| %s |
| """ % ( |
| "\n".join([item.get("src", "<unknown>") for item in data]), |
| stderrSummary, |
| ) |
| c.reportSource = None |
| c.navMarkup = "Report Crashes > " |
| c.files = [] |
| for item in data: |
| c.files.append(item.get("src", "")) |
| c.files.append(posixpath.join(self.server.root, item.get("file", ""))) |
| c.files.append( |
| posixpath.join(self.server.root, item.get("clangfile", "")) |
| ) |
| c.files.append(posixpath.join(self.server.root, item.get("stderr", ""))) |
| c.files.append(posixpath.join(self.server.root, item.get("info", ""))) |
| # Just in case something failed, ignore files which don't |
| # exist. |
| c.files = [f for f in c.files if os.path.exists(f) and os.path.isfile(f)] |
| else: |
| # Check that this is a valid report. |
| path = posixpath.join(self.server.root, "report-%s.html" % report) |
| if not posixpath.exists(path): |
| raise ValueError("Invalid report ID") |
| keys = self.load_report(report) |
| c = Context() |
| c.title = keys.get("DESC", "clang error (unrecognized") |
| c.description = """\ |
| Bug reported by the clang static analyzer. |
| |
| Description: %s |
| File: %s |
| Line: %s |
| """ % ( |
| c.title, |
| keys.get("FILE", "<unknown>"), |
| keys.get("LINE", "<unknown>"), |
| ) |
| c.reportSource = "report-%s.html" % report |
| c.navMarkup = """<a href="/%s">Report %s</a> > """ % ( |
| c.reportSource, |
| report, |
| ) |
| |
| c.files = [path] |
| return c |
| |
| def send_report(self, report, configOverrides=None): |
| def getConfigOption(section, field): |
| if ( |
| configOverrides is not None |
| and section in configOverrides |
| and field in configOverrides[section] |
| ): |
| return configOverrides[section][field] |
| return self.server.config.get(section, field) |
| |
| # report is None is used for crashes |
| try: |
| c = self.get_report_context(report) |
| except ValueError as e: |
| return self.send_error(400, e.message) |
| |
| title = c.title |
| description = c.description |
| reportingFor = c.navMarkup |
| if c.reportSource is None: |
| extraIFrame = "" |
| else: |
| extraIFrame = """\ |
| <iframe src="/%s" width="100%%" height="40%%" |
| scrolling="auto" frameborder="1"> |
| <a href="/%s">View Bug Report</a> |
| </iframe>""" % ( |
| c.reportSource, |
| c.reportSource, |
| ) |
| |
| reporterSelections = [] |
| reporterOptions = [] |
| |
| try: |
| active = int(getConfigOption("ScanView", "reporter")) |
| except: |
| active = 0 |
| for i, r in enumerate(self.server.reporters): |
| selected = i == active |
| if selected: |
| selectedStr = " selected" |
| else: |
| selectedStr = "" |
| reporterSelections.append( |
| '<option value="%d"%s>%s</option>' % (i, selectedStr, r.getName()) |
| ) |
| options = "\n".join( |
| [o.getHTML(r, title, getConfigOption) for o in r.getParameters()] |
| ) |
| display = ("none", "")[selected] |
| reporterOptions.append( |
| """\ |
| <tr id="%sReporterOptions" style="display:%s"> |
| <td class="form_label">%s Options</td> |
| <td class="form_value"> |
| <table class="form_inner_group"> |
| %s |
| </table> |
| </td> |
| </tr> |
| """ |
| % (r.getName(), display, r.getName(), options) |
| ) |
| reporterSelections = "\n".join(reporterSelections) |
| reporterOptionsDivs = "\n".join(reporterOptions) |
| reportersArray = "[%s]" % ( |
| ",".join([repr(r.getName()) for r in self.server.reporters]) |
| ) |
| |
| if c.files: |
| fieldSize = min(5, len(c.files)) |
| attachFileOptions = "\n".join( |
| [ |
| """\ |
| <option value="%d" selected>%s</option>""" |
| % (i, v) |
| for i, v in enumerate(c.files) |
| ] |
| ) |
| attachFileRow = """\ |
| <tr> |
| <td class="form_label">Attach:</td> |
| <td class="form_value"> |
| <select style="width:100%%" name="files" multiple size=%d> |
| %s |
| </select> |
| </td> |
| </tr> |
| """ % ( |
| min(5, len(c.files)), |
| attachFileOptions, |
| ) |
| else: |
| attachFileRow = "" |
| |
| result = ( |
| """<html> |
| <head> |
| <title>File Bug</title> |
| <link rel="stylesheet" type="text/css" href="/scanview.css" /> |
| </head> |
| <script language="javascript" type="text/javascript"> |
| var reporters = %(reportersArray)s; |
| function updateReporterOptions() { |
| index = document.getElementById('reporter').selectedIndex; |
| for (var i=0; i < reporters.length; ++i) { |
| o = document.getElementById(reporters[i] + "ReporterOptions"); |
| if (i == index) { |
| o.style.display = ""; |
| } else { |
| o.style.display = "none"; |
| } |
| } |
| } |
| </script> |
| <body onLoad="updateReporterOptions()"> |
| <h3> |
| <a href="/">Summary</a> > |
| %(reportingFor)s |
| File Bug</h3> |
| <form name="form" action="/report_submit" method="post"> |
| <input type="hidden" name="report" value="%(report)s"> |
| |
| <table class="form"> |
| <tr><td> |
| <table class="form_group"> |
| <tr> |
| <td class="form_clabel">Title:</td> |
| <td class="form_value"> |
| <input type="text" name="title" size="50" value="%(title)s"> |
| </td> |
| </tr> |
| <tr> |
| <td class="form_label">Description:</td> |
| <td class="form_value"> |
| <textarea rows="10" cols="80" name="description"> |
| %(description)s |
| </textarea> |
| </td> |
| </tr> |
| |
| %(attachFileRow)s |
| |
| </table> |
| <br> |
| <table class="form_group"> |
| <tr> |
| <td class="form_clabel">Method:</td> |
| <td class="form_value"> |
| <select id="reporter" name="reporter" onChange="updateReporterOptions()"> |
| %(reporterSelections)s |
| </select> |
| </td> |
| </tr> |
| %(reporterOptionsDivs)s |
| </table> |
| <br> |
| </td></tr> |
| <tr><td class="form_submit"> |
| <input align="right" type="submit" name="Submit" value="Submit"> |
| </td></tr> |
| </table> |
| </form> |
| |
| %(extraIFrame)s |
| |
| </body> |
| </html>""" |
| % locals() |
| ) |
| |
| return self.send_string(result) |
| |
| def send_head(self, fields=None): |
| if self.server.options.onlyServeLocal and self.client_address[0] != "127.0.0.1": |
| return self.send_error(401, "Unauthorized host.") |
| |
| if fields is None: |
| fields = {} |
| self.fields = fields |
| |
| o = urlparse(self.path) |
| self.fields = parse_query(o.query, fields) |
| path = posixpath.normpath(unquote(o.path)) |
| |
| # Split the components and strip the root prefix. |
| components = path.split("/")[1:] |
| |
| # Special case some top-level entries. |
| if components: |
| name = components[0] |
| if len(components) == 2: |
| if name == "report": |
| return self.send_report(components[1]) |
| elif name == "open": |
| return self.send_open_report(components[1]) |
| elif len(components) == 1: |
| if name == "quit": |
| self.server.halt() |
| return self.send_string("Goodbye.", "text/plain") |
| elif name == "report_submit": |
| return self.send_report_submit() |
| elif name == "report_crashes": |
| overrides = {"ScanView": {}, "Radar": {}, "Email": {}} |
| for i, r in enumerate(self.server.reporters): |
| if r.getName() == "Radar": |
| overrides["ScanView"]["reporter"] = i |
| break |
| overrides["Radar"]["Component"] = "llvm - checker" |
| overrides["Radar"]["Component Version"] = "X" |
| return self.send_report(None, overrides) |
| elif name == "favicon.ico": |
| return self.send_path(posixpath.join(kShare, "bugcatcher.ico")) |
| |
| # Match directory entries. |
| if components[-1] == "": |
| components[-1] = "index.html" |
| |
| relpath = "/".join(components) |
| path = posixpath.join(self.server.root, relpath) |
| |
| if self.server.options.debug > 1: |
| print( |
| '%s: SERVER: sending path "%s"' % (sys.argv[0], path), file=sys.stderr |
| ) |
| return self.send_path(path) |
| |
| def send_404(self): |
| self.send_error(404, "File not found") |
| return None |
| |
| def send_path(self, path): |
| # If the requested path is outside the root directory, do not open it |
| rel = os.path.abspath(path) |
| if not rel.startswith(os.path.abspath(self.server.root)): |
| return self.send_404() |
| |
| ctype = self.guess_type(path) |
| if ctype.startswith("text/"): |
| # Patch file instead |
| return self.send_patched_file(path, ctype) |
| else: |
| mode = "rb" |
| try: |
| f = open(path, mode) |
| except IOError: |
| return self.send_404() |
| return self.send_file(f, ctype) |
| |
| def send_file(self, f, ctype): |
| # Patch files to add links, but skip binary files. |
| self.send_response(200) |
| self.send_header("Content-type", ctype) |
| fs = os.fstat(f.fileno()) |
| self.send_header("Content-Length", str(fs[6])) |
| self.send_header("Last-Modified", self.date_time_string(fs.st_mtime)) |
| self.end_headers() |
| return f |
| |
| def send_string(self, s, ctype="text/html", headers=True, mtime=None): |
| encoded_s = s.encode("utf-8") |
| if headers: |
| self.send_response(200) |
| self.send_header("Content-type", ctype) |
| self.send_header("Content-Length", str(len(encoded_s))) |
| if mtime is None: |
| mtime = self.dynamic_mtime |
| self.send_header("Last-Modified", self.date_time_string(mtime)) |
| self.end_headers() |
| return BytesIO(encoded_s) |
| |
| def send_patched_file(self, path, ctype): |
| # Allow a very limited set of variables. This is pretty gross. |
| variables = {} |
| variables["report"] = "" |
| m = kReportFileRE.match(path) |
| if m: |
| variables["report"] = m.group(2) |
| |
| try: |
| f = open(path, "rb") |
| except IOError: |
| return self.send_404() |
| fs = os.fstat(f.fileno()) |
| data = f.read().decode("utf-8") |
| for a, b in kReportReplacements: |
| data = a.sub(b % variables, data) |
| return self.send_string(data, ctype, mtime=fs.st_mtime) |
| |
| |
| def create_server(address, options, root): |
| import Reporter |
| |
| reporters = Reporter.getReporters() |
| |
| return ScanViewServer(address, ScanViewRequestHandler, root, reporters, options) |
