Import wpt@758b3b4cfa805067f36121333ba031e583d3a62c

third_party/WebKit/LayoutTests/external/wpt/check_stability.py

 from __future__ import print_function
 
 import argparse
 import logging
 import os
 import re
 import stat
 import subprocess
 import sys
 import tarfile
 import zipfile
 from abc import ABCMeta, abstractmethod
-from cStringIO import StringIO
+from cStringIO import StringIO as CStringIO
 from collections import defaultdict
 from ConfigParser import RawConfigParser
-from io import BytesIO
-from tools.manifest import manifest
+from io import BytesIO, StringIO
 
 import requests
 
 BaseHandler = None
 LogActionFilter = None
 LogHandler = None
 LogLevelFilter = None
 StreamHandler = None
 TbplFormatter = None
+manifest = None
 reader = None
 wptcommandline = None
 wptrunner = None
 wpt_root = None
 wptrunner_root = None
 
-logger = logging.getLogger(os.path.splitext(__file__)[0])
-
+logger = None
 
 def do_delayed_imports():
     """Import and set up modules only needed if execution gets to this point."""
     global BaseHandler
     global LogLevelFilter
     global StreamHandler
     global TbplFormatter
+    global manifest
     global reader
     global wptcommandline
     global wptrunner
     from mozlog import reader
     from mozlog.formatters import TbplFormatter
     from mozlog.handlers import BaseHandler, LogLevelFilter, StreamHandler
+    from tools.manifest import manifest
     from wptrunner import wptcommandline, wptrunner
     setup_log_handler()
     setup_action_filter()
 
 
 def setup_logging():
     """Set up basic debug logger."""
     handler = logging.StreamHandler(sys.stdout)
     formatter = logging.Formatter(logging.BASIC_FORMAT, None)
     handler.setFormatter(formatter)
     logger.addHandler(handler)
     logger.setLevel(logging.DEBUG)
 
-setup_logging()
-
 
 def setup_action_filter():
     """Create global LogActionFilter class as part of deferred module load."""
     global LogActionFilter
 
     class LogActionFilter(BaseHandler):
 
         """Handler that filters out messages not of a given set of actions.
 
         Subclasses BaseHandler.
@@ skipping 27 matching lines @@
 
     def __enter__(self):
         """Emit fold start syntax."""
         print("travis_fold:start:%s" % self.name, file=sys.stderr)
 
     def __exit__(self, type, value, traceback):
         """Emit fold end syntax."""
         print("travis_fold:end:%s" % self.name, file=sys.stderr)
 
 
+class FilteredIO(object):
+    """Wrap a file object, invoking the provided callback for every call to
+    `write` and only proceeding with the operation when that callback returns
+    True."""
+    def __init__(self, original, on_write):
+        self.original = original
+        self.on_write = on_write
+
+    def __getattr__(self, name):
+        return getattr(self.original, name)
+
+    def disable(self):
+        self.write = lambda msg: None
+
+    def write(self, msg):
+        encoded = msg.encode("utf8", "backslashreplace").decode("utf8")
+        if self.on_write(self.original, encoded) is True:
+            self.original.write(encoded)
+
+
+def replace_streams(capacity, warning_msg):
+    # Value must be boxed to support modification from inner function scope
+    count = [0]
+    capacity -= 2 + len(warning_msg)
+    stderr = sys.stderr
+
+    def on_write(handle, msg):
+        length = len(msg)
+        count[0] += length
+
+        if count[0] > capacity:
+            sys.stdout.disable()
+            sys.stderr.disable()
+            handle.write(msg[0:capacity - count[0]])
+            handle.flush()
+            stderr.write("\n%s\n" % warning_msg)
+            return False
+
+        return True
+
+    sys.stdout = FilteredIO(sys.stdout, on_write)
+    sys.stderr = FilteredIO(sys.stderr, on_write)
+
+
 class Browser(object):
     __metaclass__ = ABCMeta
 
     @abstractmethod
     def install(self):
         return NotImplemented
 
     @abstractmethod
     def install_webdriver(self):
         return NotImplemented
@@ skipping 148 matching lines @@
             logger.error(e.output)
             sys.exit(1)
     return git
 
 
 def seekable(fileobj):
     """Attempt to use file.seek on given file, with fallbacks."""
     try:
         fileobj.seek(fileobj.tell())
     except Exception:
-        return StringIO(fileobj.read())
+        return CStringIO(fileobj.read())
     else:
         return fileobj
 
 
 def untar(fileobj):
     """Extract tar archive."""
     logger.debug("untar")
     fileobj = seekable(fileobj)
     with tarfile.open(fileobj=fileobj) as tar_data:
         tar_data.extractall()
@@ skipping 226 matching lines @@
                                            else prev[i]
                                            for i in cols],
                         data,
                         [len(item) + 2 for item in headings])
     log("|%s|" % "|".join(item.center(max_widths[i]) for i, item in enumerate(headings)))
     log("|%s|" % "|".join("-" * max_widths[i] for i in cols))
     for row in data:
         log("|%s|" % "|".join(" %s" % row[i].ljust(max_widths[i] - 1) for i in cols))
     log("")
 
-
 def write_inconsistent(inconsistent, iterations):
     """Output inconsistent tests to logger.error."""
     logger.error("## Unstable results ##\n")
     strings = [("`%s`" % markdown_adjust(test), ("`%s`" % markdown_adjust(subtest)) if subtest else "", err_string(results, iterations))
                for test, subtest, results in inconsistent]
     table(["Test", "Subtest", "Results"], strings, logger.error)
 
 
 def write_results(results, iterations, comment_pr):
     """Output all test results to logger.info."""
@@ skipping 39 matching lines @@
     parser.add_argument("--comment-pr",
                         action="store",
                         default=os.environ.get("TRAVIS_PULL_REQUEST"),
                         help="PR to comment on with stability results")
     parser.add_argument("--user",
                         action="store",
                         # Travis docs say do not depend on USER env variable.
                         # This is a workaround to get what should be the same value
                         default=os.environ.get("TRAVIS_REPO_SLUG").split('/')[0],
                         help="Travis user name")
+    parser.add_argument("--output-bytes",
+                        action="store",
+                        type=int,
+                        help="Maximum number of bytes to write to standard output/error")
     parser.add_argument("product",
                         action="store",
                         help="Product to run against (`browser-name` or 'browser-name:channel')")
     return parser
 
 
 def main():
     """Perform check_stability functionality and return exit code."""
     global wpt_root
     global wptrunner_root
+    global logger
 
     retcode = 0
     parser = get_parser()
     args = parser.parse_args()
 
+    if args.output_bytes is not None:
+        replace_streams(args.output_bytes,
+                        "Log reached capacity (%s bytes); output disabled." % args.output_bytes)
+
+    logger = logging.getLogger(os.path.splitext(__file__)[0])
+    setup_logging()
+
     wpt_root = os.path.abspath(os.curdir)
     wptrunner_root = os.path.normpath(os.path.join(wpt_root, "..", "wptrunner"))
 
     if not os.path.exists(args.root):
         logger.critical("Root directory %s does not exist" % args.root)
         return 1
 
     os.chdir(args.root)
 
     browser_name = args.product.split(":")[0]
@@ skipping 83 matching lines @@
     return retcode
 
 
 if __name__ == "__main__":
     try:
         retcode = main()
     except:
         raise
     else:
         sys.exit(retcode)