| # -*- coding: utf-8 -*- |
| # Copyright 2010-2015, Google Inc. |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| """A utility tool to run NaCl Pepper HTTPClient test. |
| |
| Example usage: |
| The following command starts HTTP server and launch Chrome with the extension |
| and open test.html. When '/TEST_FIN?result=success' is accessed from the page |
| or the extension, this command successfully exit. |
| When '/TEST_FIN?result=SOME_ERROR' is accessed, it exit showing SOME_ERROR. |
| When the timeout specified has expired, it exit showing timeout error. |
| |
| python nacl_net_test_server.py --browser_path=/usr/bin/google-chrome \ |
| --serving_dir=/PATH/TO/FILE_DIR \ |
| --serving_dir=/PATH/TO/ADDITIONAL_FILE_DIR \ |
| --load_extension=/PATH/TO/EXTENSION_DIR \ |
| --url=test.html \ |
| --timeout=20 |
| """ |
| |
| import BaseHTTPServer |
| import optparse |
| import os |
| import os.path |
| import shutil |
| import SocketServer |
| import subprocess |
| import sys |
| import tempfile |
| import thread |
| import time |
| import urlparse |
| |
| |
| class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): |
| """Handle the HTTP requests that arrive at the server.""" |
| |
| def do_GET(self): |
| # pylint: disable=g-bad-name |
| """Handles GET request.""" |
| parsed_path = urlparse.urlparse(self.path) |
| options = {'response': 200, |
| 'result': '', |
| 'before_response_sleep': 0.0, |
| 'before_head_sleep': 0.0, |
| 'after_head_sleep': 0.0, |
| 'before_data_sleep': 0.0, |
| 'after_data_sleep': 0.0, |
| 'content_length': '', |
| 'data': 'DEFAULT_DATA', |
| 'times': 1, |
| 'redirect_location': ''} |
| query = urlparse.parse_qsl(parsed_path.query) |
| for params in query: |
| options[params[0]] = params[1] |
| |
| if parsed_path.path.startswith('/TEST_FIN'): |
| if 'result' in options: |
| if options['result'] == 'success': |
| self.server.result = 0 |
| else: |
| self.server.result = options['result'] |
| self.server.finished = True |
| return |
| |
| # For retry test. |
| if parsed_path.path.startswith('/RETRY_TEST'): |
| if 'action' in options: |
| self.send_response(200) |
| self.end_headers() |
| if options['action'] == 'set_counter': |
| self.wfile.write('OK') |
| self.server.retry_test_counter = int(options['value']) |
| elif options['action'] == 'get_counter': |
| self.wfile.write(str(self.server.retry_test_counter)) |
| return |
| else: |
| self.server.retry_test_counter += 1 |
| if self.server.retry_test_counter <= 0: |
| self.send_response(404) |
| self.end_headers() |
| self.wfile.write('NG') |
| return |
| |
| for extra_dir in self.server.serving_dirs: |
| full_path = os.path.join(extra_dir, os.path.basename(parsed_path.path)) |
| if os.path.isfile(full_path): |
| try: |
| data = open(full_path).read() |
| self.send_response(200) |
| self.send_header('Content-Length', len(data)) |
| self.end_headers() |
| self.wfile.write(data) |
| except IOError, (errno, strerror): |
| print 'I/O error(%s): %s' % (errno, strerror) |
| return |
| |
| try: |
| time.sleep(float(options['before_response_sleep'])) |
| self.send_response(int(options['response'])) |
| time.sleep(float(options['before_head_sleep'])) |
| self.send_header('command', '%s' % self.command) |
| self.send_header('path', '%s' % self.path) |
| self.send_header('parsed_path', '%s' % parsed_path.path) |
| for name, value in sorted(self.headers.items()): |
| self.send_header('CLIENT_HEADER_%s' % name, '%s' % value) |
| if options['content_length']: |
| self.send_header('Content-Length', |
| options['content_length']) |
| if options['redirect_location']: |
| self.send_header('Location', |
| options['redirect_location']) |
| self.end_headers() |
| time.sleep(float(options['after_head_sleep'])) |
| for _ in range(int(options['times'])): |
| time.sleep(float(options['before_data_sleep'])) |
| self.wfile.write(options['data']) |
| time.sleep(float(options['after_data_sleep'])) |
| except IOError, (errno, strerror): |
| print 'I/O error(%s): %s' % (errno, strerror) |
| return |
| |
| def do_POST(self): |
| # pylint: disable=g-bad-name |
| """Handles POST request.""" |
| parsed_path = urlparse.urlparse(self.path) |
| options = {'response': 200, |
| 'result': '', |
| 'before_response_sleep': 0.0, |
| 'before_head_sleep': 0.0, |
| 'after_head_sleep': 0.0, |
| 'after_data_sleep': 0.0, |
| 'content_length': '', |
| 'redirect_location': ''} |
| query = urlparse.parse_qsl(parsed_path.query) |
| for params in query: |
| options[params[0]] = params[1] |
| |
| try: |
| content_len = int(self.headers.getheader('content-length')) |
| post_data = self.rfile.read(content_len) |
| time.sleep(float(options['before_response_sleep'])) |
| self.send_response(int(options['response'])) |
| time.sleep(float(options['before_head_sleep'])) |
| self.send_header('command', '%s' % self.command) |
| self.send_header('path', '%s' % self.path) |
| self.send_header('parsed_path', '%s' % parsed_path.path) |
| for name, value in sorted(self.headers.items()): |
| self.send_header('CLIENT_HEADER_%s' % name, '%s' % value) |
| if options['content_length']: |
| self.send_header('Content-Length', |
| options['content_length']) |
| if options['redirect_location']: |
| self.send_header('Location', |
| options['redirect_location']) |
| self.end_headers() |
| time.sleep(float(options['after_head_sleep'])) |
| self.wfile.write(post_data) |
| time.sleep(float(options['after_data_sleep'])) |
| return |
| except IOError, (errno, strerror): |
| print 'I/O error(%s): %s' % (errno, strerror) |
| return |
| |
| def do_HEAD(self): |
| # pylint: disable=g-bad-name |
| """Handles HEAD request.""" |
| parsed_path = urlparse.urlparse(self.path) |
| options = {'response': 200, |
| 'before_response_sleep': 0.0, |
| 'before_head_sleep': 0.0} |
| query = urlparse.parse_qsl(parsed_path.query) |
| for params in query: |
| options[params[0]] = params[1] |
| |
| try: |
| time.sleep(float(options['before_response_sleep'])) |
| self.send_response(options['response']) |
| time.sleep(float(options['before_head_sleep'])) |
| self.send_header('command', '%s' % self.command) |
| self.send_header('path', '%s' % self.path) |
| self.send_header('parsed_path', '%s' % parsed_path.path) |
| for name, value in sorted(self.headers.items()): |
| self.send_header('CLIENT_HEADER_%s' % name, '%s' % value) |
| self.end_headers() |
| except IOError, (errno, strerror): |
| print 'I/O error(%s): %s' % (errno, strerror) |
| return |
| |
| |
| class TestServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer): |
| def Configure(self, serving_dirs): |
| self.serving_dirs = serving_dirs |
| self.finished = False |
| self.result = 'Not Finished.' |
| self.retry_test_counter = 0 |
| |
| |
| def main(): |
| parser = optparse.OptionParser(usage='Usage: %prog [options]') |
| parser.add_option('--timeout', dest='timeout', action='store', type='float', |
| default=5.0, help='Timeout in seconds.') |
| parser.add_option('--browser_path', dest='browser_path', action='store', |
| type='string', default='/usr/bin/google-chrome', |
| help='The browser path.') |
| parser.add_option('--serving_dir', dest='serving_dirs', action='append', |
| type='string', default=[], |
| help='File directory to be served by HTTP server.') |
| parser.add_option('--load_extension', dest='load_extension', action='store', |
| type='string', default='', help='The extension path.') |
| parser.add_option('-u', '--url', dest='url', action='store', |
| type='string', default=None, help='The webpage to load.') |
| (options, _) = parser.parse_args() |
| # TODO(horo) Don't use the fixed port number. Find the way to pass the port |
| # number to the test module. |
| server = TestServer(('localhost', 9999), RequestHandler) |
| server.Configure(options.serving_dirs) |
| host, port = server.socket.getsockname() |
| print 'Starting server %s:%s' % (host, port) |
| |
| def Serve(): |
| while not server.finished: |
| server.handle_request() |
| thread.start_new_thread(Serve, ()) |
| |
| temp_dir = tempfile.mkdtemp() |
| if options.browser_path: |
| cmd = [options.browser_path, '--user-data-dir=%s' % temp_dir] |
| if options.load_extension: |
| cmd.append('--load-extension=%s' % options.load_extension) |
| if options.url: |
| cmd.append('http://%s:%s/%s' % (host, port, options.url)) |
| print cmd |
| browser_handle = subprocess.Popen(cmd) |
| |
| time_started = time.time() |
| result = 0 |
| |
| while True: |
| if time.time() - time_started >= options.timeout: |
| result = 'Timeout!: %s' % (time.time() - time_started) |
| break |
| if server.finished: |
| result = server.result |
| break |
| time.sleep(0.5) |
| |
| if options.browser_path: |
| browser_handle.kill() |
| browser_handle.wait() |
| shutil.rmtree(temp_dir) |
| sys.exit(result) |
| |
| if __name__ == '__main__': |
| main() |
