Spaces:
Runtime error
Runtime error
| #!/usr/bin/env python3 | |
| # | |
| # Copyright 2001 Google Inc. All Rights Reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """Simple web server for browsing dependency graph data. | |
| This script is inlined into the final executable and spawned by | |
| it when needed. | |
| """ | |
| try: | |
| import http.server as httpserver | |
| import socketserver | |
| except ImportError: | |
| import BaseHTTPServer as httpserver | |
| import SocketServer as socketserver | |
| import argparse | |
| import os | |
| import socket | |
| import subprocess | |
| import sys | |
| import webbrowser | |
| if sys.version_info >= (3, 2): | |
| from html import escape | |
| else: | |
| from cgi import escape | |
| try: | |
| from urllib.request import unquote | |
| except ImportError: | |
| from urllib2 import unquote | |
| from collections import namedtuple | |
| Node = namedtuple("Node", ["inputs", "rule", "target", "outputs"]) | |
| # Ideally we'd allow you to navigate to a build edge or a build node, | |
| # with appropriate views for each. But there's no way to *name* a build | |
| # edge so we can only display nodes. | |
| # | |
| # For a given node, it has at most one input edge, which has n | |
| # different inputs. This becomes node.inputs. (We leave out the | |
| # outputs of the input edge due to what follows.) The node can have | |
| # multiple dependent output edges. Rather than attempting to display | |
| # those, they are summarized by taking the union of all their outputs. | |
| # | |
| # This means there's no single view that shows you all inputs and outputs | |
| # of an edge. But I think it's less confusing than alternatives. | |
| def match_strip(line, prefix): | |
| if not line.startswith(prefix): | |
| return (False, line) | |
| return (True, line[len(prefix) :]) | |
| def html_escape(text): | |
| return escape(text, quote=True) | |
| def parse(text): | |
| lines = iter(text.split("\n")) | |
| target = None | |
| rule = None | |
| inputs = [] | |
| outputs = [] | |
| try: | |
| target = next(lines)[:-1] # strip trailing colon | |
| line = next(lines) | |
| (match, rule) = match_strip(line, " input: ") | |
| if match: | |
| (match, line) = match_strip(next(lines), " ") | |
| while match: | |
| type = None | |
| (match, line) = match_strip(line, "| ") | |
| if match: | |
| type = "implicit" | |
| (match, line) = match_strip(line, "|| ") | |
| if match: | |
| type = "order-only" | |
| inputs.append((line, type)) | |
| (match, line) = match_strip(next(lines), " ") | |
| match, _ = match_strip(line, " outputs:") | |
| if match: | |
| (match, line) = match_strip(next(lines), " ") | |
| while match: | |
| outputs.append(line) | |
| (match, line) = match_strip(next(lines), " ") | |
| except StopIteration: | |
| pass | |
| return Node(inputs, rule, target, outputs) | |
| def create_page(body): | |
| return ( | |
| """<!DOCTYPE html> | |
| <style> | |
| body { | |
| font-family: sans; | |
| font-size: 0.8em; | |
| margin: 4ex; | |
| } | |
| h1 { | |
| font-weight: normal; | |
| font-size: 140%; | |
| text-align: center; | |
| margin: 0; | |
| } | |
| h2 { | |
| font-weight: normal; | |
| font-size: 120%; | |
| } | |
| tt { | |
| font-family: WebKitHack, monospace; | |
| white-space: nowrap; | |
| } | |
| .filelist { | |
| -webkit-columns: auto 2; | |
| } | |
| </style> | |
| """ | |
| + body | |
| ) | |
| def generate_html(node): | |
| document = ["<h1><tt>%s</tt></h1>" % html_escape(node.target)] | |
| if node.inputs: | |
| document.append("<h2>target is built using rule <tt>%s</tt> of</h2>" % html_escape(node.rule)) | |
| if len(node.inputs) > 0: | |
| document.append("<div class=filelist>") | |
| for input, type in sorted(node.inputs): | |
| extra = "" | |
| if type: | |
| extra = " (%s)" % html_escape(type) | |
| document.append( | |
| '<tt><a href="?%s">%s</a>%s</tt><br>' % (html_escape(input), html_escape(input), extra) | |
| ) | |
| document.append("</div>") | |
| if node.outputs: | |
| document.append("<h2>dependent edges build:</h2>") | |
| document.append("<div class=filelist>") | |
| for output in sorted(node.outputs): | |
| document.append('<tt><a href="?%s">%s</a></tt><br>' % (html_escape(output), html_escape(output))) | |
| document.append("</div>") | |
| return "\n".join(document) | |
| def ninja_dump(target): | |
| cmd = [args.ninja_command, "-f", args.f, "-t", "query", target] | |
| proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) | |
| return proc.communicate() + (proc.returncode,) | |
| class RequestHandler(httpserver.BaseHTTPRequestHandler): | |
| def do_GET(self): | |
| assert self.path[0] == "/" | |
| target = unquote(self.path[1:]) | |
| if target == "": | |
| self.send_response(302) | |
| self.send_header("Location", "?" + args.initial_target) | |
| self.end_headers() | |
| return | |
| if not target.startswith("?"): | |
| self.send_response(404) | |
| self.end_headers() | |
| return | |
| target = target[1:] | |
| ninja_output, ninja_error, exit_code = ninja_dump(target) | |
| if exit_code == 0: | |
| page_body = generate_html(parse(ninja_output.strip())) | |
| else: | |
| # Relay ninja's error message. | |
| page_body = "<h1><tt>%s</tt></h1>" % html_escape(ninja_error) | |
| self.send_response(200) | |
| self.end_headers() | |
| self.wfile.write(create_page(page_body).encode("utf-8")) | |
| def log_message(self, format, *args): | |
| pass # Swallow console spam. | |
| parser = argparse.ArgumentParser(prog="ninja -t browse") | |
| parser.add_argument("--port", "-p", default=8000, type=int, help="Port number to use (default %(default)d)") | |
| parser.add_argument( | |
| "--hostname", "-a", default="localhost", type=str, help="Hostname to bind to (default %(default)s)" | |
| ) | |
| parser.add_argument("--no-browser", action="store_true", help="Do not open a webbrowser on startup.") | |
| parser.add_argument("--ninja-command", default="ninja", help="Path to ninja binary (default %(default)s)") | |
| parser.add_argument("-f", default="build.ninja", help="Path to build.ninja file (default %(default)s)") | |
| parser.add_argument("initial_target", default="all", nargs="?", help="Initial target to show (default %(default)s)") | |
| class HTTPServer(socketserver.ThreadingMixIn, httpserver.HTTPServer): | |
| # terminate server immediately when Python exits. | |
| daemon_threads = True | |
| args = parser.parse_args() | |
| port = args.port | |
| hostname = args.hostname | |
| httpd = HTTPServer((hostname, port), RequestHandler) | |
| try: | |
| if hostname == "": | |
| hostname = socket.gethostname() | |
| print("Web server running on %s:%d, ctl-C to abort..." % (hostname, port)) | |
| print("Web server pid %d" % os.getpid(), file=sys.stderr) | |
| if not args.no_browser: | |
| webbrowser.open_new("http://%s:%s" % (hostname, port)) | |
| httpd.serve_forever() | |
| except KeyboardInterrupt: | |
| print() | |
| pass # Swallow console spam. | |