tools/python/google/httpd_utils.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """A class to help start/stop a local apache http server."""
   7
   8 import logging
   9 import optparse
  10 import os
  11 import subprocess
  12 import sys
  13 import time
  14 import urllib
  15
  16 import google.path_utils
  17 import google.platform_utils
  18
  19 class HttpdNotStarted(Exception): pass
  20
  21 def UrlIsAlive(url):
  22   """Checks to see if we get an http response from |url|.
  23   We poll the url 5 times with a 1 second delay.  If we don't
  24   get a reply in that time, we give up and assume the httpd
  25   didn't start properly.
  26
  27   Args:
  28     url: The URL to check.
  29   Return:
  30     True if the url is alive.
  31   """
  32   wait_time = 5
  33   while wait_time > 0:
  34     try:
  35       response = urllib.urlopen(url)
  36       # Server is up and responding.
  37       return True
  38     except IOError:
  39       pass
  40     wait_time -= 1
  41     # Wait a second and try again.
  42     time.sleep(1)
  43
  44   return False
  45
  46 def ApacheConfigDir(start_dir):
  47   """Returns a path to the directory holding the Apache config files."""
  48   return google.path_utils.FindUpward(start_dir, 'tools', 'python',
  49                                       'google', 'httpd_config')
  50
  51
  52 def GetCygserverPath(start_dir, apache2=False):
  53   """Returns the path to the directory holding cygserver.exe file."""
  54   cygserver_path = None
  55   if apache2:
  56     cygserver_path = google.path_utils.FindUpward(start_dir, 'third_party',
  57                                                   'cygwin', 'usr', 'sbin')
  58   return cygserver_path
  59
  60
  61 def StartServer(document_root=None, output_dir=None, apache2=False):
  62   """Starts a local server on port 8000 using the basic configuration files.
  63
  64   Args:
  65     document_root: If present, specifies the document root for the server;
  66         otherwise, the filesystem's root (e.g., C:/ or /) will be used.
  67     output_dir: If present, specifies where to put server logs; otherwise,
  68         they'll be placed in the system's temp dir (e.g., $TEMP or /tmp).
  69     apache2: boolean if true will cause this function to configure
  70              for Apache 2.x as opposed to Apache 1.3.x
  71
  72   Returns: the ApacheHttpd object that was created
  73   """
  74   script_dir = google.path_utils.ScriptDir()
  75   platform_util = google.platform_utils.PlatformUtility(script_dir)
  76   if not output_dir:
  77     output_dir = platform_util.GetTempDirectory()
  78   if not document_root:
  79     document_root = platform_util.GetFilesystemRoot()
  80   apache_config_dir = ApacheConfigDir(script_dir)
  81   if apache2:
  82     httpd_conf_path = os.path.join(apache_config_dir, 'httpd2.conf')
  83   else:
  84     httpd_conf_path = os.path.join(apache_config_dir, 'httpd.conf')
  85   mime_types_path = os.path.join(apache_config_dir, 'mime.types')
  86   start_cmd = platform_util.GetStartHttpdCommand(output_dir,
  87                                                  httpd_conf_path,
  88                                                  mime_types_path,
  89                                                  document_root,
  90                                                  apache2=apache2)
  91   stop_cmd = platform_util.GetStopHttpdCommand()
  92   httpd = ApacheHttpd(start_cmd, stop_cmd, [8000],
  93                       cygserver_path=GetCygserverPath(script_dir, apache2))
  94   httpd.StartServer()
  95   return httpd
  96
  97
  98 def StopServers(apache2=False):
  99   """Calls the platform's stop command on a newly created server, forcing it
 100   to stop.
 101
 102   The details depend on the behavior of the platform stop command. For example,
 103   it's often implemented to kill all running httpd processes, as implied by
 104   the name of this function.
 105
 106   Args:
 107     apache2: boolean if true will cause this function to configure
 108              for Apache 2.x as opposed to Apache 1.3.x
 109   """
 110   script_dir = google.path_utils.ScriptDir()
 111   platform_util = google.platform_utils.PlatformUtility(script_dir)
 112   httpd = ApacheHttpd('', platform_util.GetStopHttpdCommand(), [],
 113                       cygserver_path=GetCygserverPath(script_dir, apache2))
 114   httpd.StopServer(force=True)
 115
 116
 117 class ApacheHttpd(object):
 118   def __init__(self, start_command, stop_command, port_list,
 119                cygserver_path=None):
 120     """Args:
 121         start_command: command list to call to start the httpd
 122         stop_command: command list to call to stop the httpd if one has been
 123             started.  May kill all httpd processes running on the machine.
 124         port_list: list of ports expected to respond on the local machine when
 125             the server has been successfully started.
 126         cygserver_path: Path to cygserver.exe. If specified, exe will be started
 127             with server as well as stopped when server is stopped.
 128     """
 129     self._http_server_proc = None
 130     self._start_command = start_command
 131     self._stop_command = stop_command
 132     self._port_list = port_list
 133     self._cygserver_path = cygserver_path
 134
 135   def StartServer(self):
 136     if self._http_server_proc:
 137       return
 138     if self._cygserver_path:
 139       cygserver_exe = os.path.join(self._cygserver_path, "cygserver.exe")
 140       cygbin = google.path_utils.FindUpward(cygserver_exe, 'third_party',
 141                                             'cygwin', 'bin')
 142       env = os.environ
 143       env['PATH'] += ";" + cygbin
 144       subprocess.Popen(cygserver_exe, env=env)
 145     logging.info('Starting http server')
 146     self._http_server_proc = subprocess.Popen(self._start_command)
 147
 148     # Ensure that the server is running on all the desired ports.
 149     for port in self._port_list:
 150       if not UrlIsAlive('http://127.0.0.1:%s/' % str(port)):
 151         raise HttpdNotStarted('Failed to start httpd on port %s' % str(port))
 152
 153   def StopServer(self, force=False):
 154     """If we started an httpd.exe process, or if force is True, call
 155     self._stop_command (passed in on init so it can be platform-dependent).
 156     This will presumably kill it, and may also kill any other httpd.exe
 157     processes that are running.
 158     """
 159     if force or self._http_server_proc:
 160       logging.info('Stopping http server')
 161       kill_proc = subprocess.Popen(self._stop_command,
 162                                    stdout=subprocess.PIPE,
 163                                    stderr=subprocess.PIPE)
 164       logging.info('%s\n%s' % (kill_proc.stdout.read(),
 165                                kill_proc.stderr.read()))
 166       self._http_server_proc = None
 167       if self._cygserver_path:
 168         subprocess.Popen(["taskkill.exe", "/f", "/im", "cygserver.exe"],
 169                          stdout=subprocess.PIPE,
 170                          stderr=subprocess.PIPE)
 171
 172
 173 def main():
 174   # Provide some command line params for starting/stopping the http server
 175   # manually.
 176   option_parser = optparse.OptionParser()
 177   option_parser.add_option('-k', '--server', help='Server action (start|stop)')
 178   option_parser.add_option('-r', '--root', help='Document root (optional)')
 179   option_parser.add_option('-a', '--apache2', action='store_true',
 180       default=False, help='Starts Apache 2 instead of Apache 1.3 (default). '
 181                           'Ignored on Mac (apache2 is used always)')
 182   options, args = option_parser.parse_args()
 183
 184   if not options.server:
 185     print ("Usage: %s -k {start|stop} [-r document_root] [--apache2]" %
 186            sys.argv[0])
 187     return 1
 188
 189   document_root = None
 190   if options.root:
 191     document_root = options.root
 192
 193   if 'start' == options.server:
 194     StartServer(document_root, apache2=options.apache2)
 195   else:
 196     StopServers(apache2=options.apache2)
 197
 198
 199 if '__main__' == __name__:
 200   sys.exit(main())