| 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(.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) |