#!/usr/bin/python # Copyright (c) 2011 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Provides a convenient wrapper for spawning a test lighttpd instance. Usage: lighttpd_server PATH_TO_DOC_ROOT """ import codecs import contextlib import httplib import os import pexpect import random import shutil import socket import sys import tempfile class LighttpdServer(object): """Wraps lighttpd server, providing robust startup. Args: document_root: Path to root of this server's hosted files. port: TCP port on the _host_ machine that the server will listen on. If ommitted it will attempt to use 9000, or if unavailable it will find a free port from 8001 - 8999. lighttpd_path, lighttpd_module_path: Optional paths to lighttpd binaries. base_config_path: If supplied this file will replace the built-in default lighttpd config file. extra_config_contents: If specified, this string will be appended to the base config (default built-in, or from base_config_path). config_path, error_log, access_log: Optional paths where the class should place temprary files for this session. """ def __init__(self, document_root, port=None, lighttpd_path=None, lighttpd_module_path=None, base_config_path=None, extra_config_contents=None, config_path=None, error_log=None, access_log=None): self.temp_dir = tempfile.mkdtemp(prefix='lighttpd_for_chrome_android') self.document_root = os.path.abspath(document_root) self.fixed_port = port self.port = port or 9000 self.server_tag = 'LightTPD ' + str(random.randint(111111, 999999)) self.lighttpd_path = lighttpd_path or '/usr/sbin/lighttpd' self.lighttpd_module_path = lighttpd_module_path or '/usr/lib/lighttpd' self.base_config_path = base_config_path self.extra_config_contents = extra_config_contents self.config_path = config_path or self._Mktmp('config') self.error_log = error_log or self._Mktmp('error_log') self.access_log = access_log or self._Mktmp('access_log') self.pid_file = self._Mktmp('pid_file') self.process = None def _Mktmp(self, name): return os.path.join(self.temp_dir, name) def _GetRandomPort(self): # Ports 8001-8004 are reserved for other test servers. Ensure we don't # collide with them. return random.randint(8005, 8999) def StartupHttpServer(self): """Starts up a http server with specified document root and port.""" # Currently we use lighttpd as http sever in test. while True: if self.base_config_path: # Read the config with codecs.open(self.base_config_path, 'r', 'utf-8') as f: config_contents = f.read() else: config_contents = self._GetDefaultBaseConfig() if self.extra_config_contents: config_contents += self.extra_config_contents # Write out the config, filling in placeholders from the members of |self| with codecs.open(self.config_path, 'w', 'utf-8') as f: f.write(config_contents % self.__dict__) if (not os.path.exists(self.lighttpd_path) or not os.access(self.lighttpd_path, os.X_OK)): raise EnvironmentError( 'Could not find lighttpd at %s.\n' 'It may need to be installed (e.g. sudo apt-get install lighttpd)' % self.lighttpd_path) self.process = pexpect.spawn(self.lighttpd_path, ['-D', '-f', self.config_path, '-m', self.lighttpd_module_path], cwd=self.temp_dir) client_error, server_error = self._TestServerConnection() if not client_error: assert int(open(self.pid_file, 'r').read()) == self.process.pid break self.process.close() if self.fixed_port or not 'in use' in server_error: print 'Client error:', client_error print 'Server error:', server_error return False self.port = self._GetRandomPort() return True def ShutdownHttpServer(self): """Shuts down our lighttpd processes.""" if self.process: self.process.terminate() shutil.rmtree(self.temp_dir, ignore_errors=True) def _TestServerConnection(self): # Wait for server to start server_msg = '' for timeout in xrange(1, 5): client_error = None try: with contextlib.closing(httplib.HTTPConnection( '127.0.0.1', self.port, timeout=timeout)) as http: http.set_debuglevel(timeout > 3) http.request('HEAD', '/') r = http.getresponse() r.read() if (r.status == 200 and r.reason == 'OK' and r.getheader('Server') == self.server_tag): return (None, server_msg) client_error = ('Bad response: %s %s version %s\n ' % (r.status, r.reason, r.version) + '\n '.join([': '.join(h) for h in r.getheaders()])) except (httplib.HTTPException, socket.error) as client_error: pass # Probably too quick connecting: try again # Check for server startup error messages ix = self.process.expect([pexpect.TIMEOUT, pexpect.EOF, '.+'], timeout=timeout) if ix == 2: # stdout spew from the server server_msg += self.process.match.group(0) elif ix == 1: # EOF -- server has quit so giveup. client_error = client_error or 'Server exited' break return (client_error or 'Timeout', server_msg) def _GetDefaultBaseConfig(self): return """server.tag = "%(server_tag)s" server.modules = ( "mod_access", "mod_accesslog", "mod_alias", "mod_cgi", "mod_rewrite" ) # default document root required #server.document-root = "." # files to check for if .../ is requested index-file.names = ( "index.php", "index.pl", "index.cgi", "index.html", "index.htm", "default.htm" ) # mimetype mapping mimetype.assign = ( ".gif" => "image/gif", ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg", ".png" => "image/png", ".svg" => "image/svg+xml", ".css" => "text/css", ".html" => "text/html", ".htm" => "text/html", ".xhtml" => "application/xhtml+xml", ".xhtmlmp" => "application/vnd.wap.xhtml+xml", ".js" => "application/x-javascript", ".log" => "text/plain", ".conf" => "text/plain", ".text" => "text/plain", ".txt" => "text/plain", ".dtd" => "text/xml", ".xml" => "text/xml", ".manifest" => "text/cache-manifest", ) # Use the "Content-Type" extended attribute to obtain mime type if possible mimetype.use-xattr = "enable" ## # which extensions should not be handle via static-file transfer # # .php, .pl, .fcgi are most often handled by mod_fastcgi or mod_cgi static-file.exclude-extensions = ( ".php", ".pl", ".cgi" ) server.bind = "127.0.0.1" server.port = %(port)s ## virtual directory listings dir-listing.activate = "enable" #dir-listing.encoding = "iso-8859-2" #dir-listing.external-css = "style/oldstyle.css" ## enable debugging #debug.log-request-header = "enable" #debug.log-response-header = "enable" #debug.log-request-handling = "enable" #debug.log-file-not-found = "enable" #### SSL engine #ssl.engine = "enable" #ssl.pemfile = "server.pem" # Autogenerated test-specific config follows. cgi.assign = ( ".cgi" => "/usr/bin/env", ".pl" => "/usr/bin/env", ".asis" => "/bin/cat", ".php" => "/usr/bin/php-cgi" ) server.errorlog = "%(error_log)s" accesslog.filename = "%(access_log)s" server.upload-dirs = ( "/tmp" ) server.pid-file = "%(pid_file)s" server.document-root = "%(document_root)s" """ def main(argv): server = LighttpdServer(*argv[1:]) try: if server.StartupHttpServer(): raw_input('Server running at http://127.0.0.1:%s -' ' press Enter to exit it.' % server.port) else: print 'Server exit code:', server.process.exitstatus finally: server.ShutdownHttpServer() if __name__ == '__main__': sys.exit(main(sys.argv))