Port page_cycler_http to Mac

tools/python/google/platform_utils_mac.py

-# Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+#!/usr/bin/python
+# Copyright (c) 2006-2009 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.
+
 """Platform-specific utility methods shared by several scripts."""
 
 import os
-import re
 import subprocess
-import sys
 
 import google.path_utils
 
-# Cache a single cygpath process for use throughout, even across instances of
-# the PlatformUtility class.
-_cygpath_proc = None
 
 class PlatformUtility(object):
   def __init__(self, base_dir):
     """Args:
-         base_dir: a directory above which third_party/cygwin can be found,
-             used to locate the cygpath executable for path conversions.
+         base_dir: the base dir for running tests.
     """
-    self._cygwin_root = None
     self._base_dir = base_dir
+    self._httpd_cmd_string = None  # used for starting/stopping httpd
+    self._bash = "/bin/bash"
 
-  def _CygwinRoot(self):
-    """Returns the full path to third_party/cygwin/."""
-    if not self._cygwin_root:
-      self._cygwin_root = google.path_utils.FindUpward(self._base_dir,
-                                                       'third_party', 'cygwin')
-    return self._cygwin_root
-
-  def _PathToExecutable(self, executable):
-    """Returns the full path to an executable in Cygwin's bin dir."""
-    return os.path.join(self._CygwinRoot(), 'bin', executable)
-
-  def GetAbsolutePath(self, path, force=False):
-    """Returns an absolute windows path. If platform is cygwin, converts it to
-    windows style using cygpath.
-
-    For performance reasons, we use a single cygpath process, shared among all
-    instances of this class. Otherwise Python can run out of file handles.
-    """
-    if not force and sys.platform != "cygwin":
-      return os.path.abspath(path)
-    global _cygpath_proc
-    if not _cygpath_proc:
-      cygpath_command = [self._PathToExecutable("cygpath.exe"),
-                         "-a", "-m", "-f", "-"]
-      _cygpath_proc = subprocess.Popen(cygpath_command,
-                                       stdin=subprocess.PIPE,
-                                       stdout=subprocess.PIPE)
-    _cygpath_proc.stdin.write(path + "\n")
-    return _cygpath_proc.stdout.readline().rstrip()
+  def _UnixRoot(self):
+    """Returns the path to root."""
+    return "/"
 
   def GetFilesystemRoot(self):
     """Returns the root directory of the file system."""
-    return os.environ['SYSTEMDRIVE'] + '\\'
+    return self._UnixRoot()
 
   def GetTempDirectory(self):
-    """Returns the file system's base temp directory, or the filesystem root
-    if the standard temp directory can't be determined.
+    """Returns the file system temp directory
 
     Note that this does not use a random subdirectory, so it's not
     intrinsically secure.  If you need a secure subdir, use the tempfile
     package.
     """
-    return os.environ.get('TEMP', self.GetFilesystemRoot())
+    return os.getenv("TMPDIR", "/tmp")
 
   def FilenameToUri(self, path, use_http=False, use_ssl=False, port=8000):
-    """Convert a Windows style path to a URI.
+    """Convert a filesystem path to a URI.
 
     Args:
       path: For an http URI, the path relative to the httpd server's
           DocumentRoot; for a file URI, the full path to the file.
       use_http: if True, returns a URI of the form http://127.0.0.1:8000/.
           If False, returns a file:/// URI.
       use_ssl: if True, returns HTTPS URL (https://127.0.0.1:8000/).
           This parameter is ignored if use_http=False.
       port: The port number to append when returning an HTTP URI
     """
     if use_http:
       protocol = 'http'
       if use_ssl:
         protocol = 'https'
-      path = path.replace("\\", "/")
-      return "%s://127.0.0.1:%s/%s" % (protocol, str(port), path)
-    return "file:///" + self.GetAbsolutePath(path)
+      return "%s://127.0.0.1:%d/%s" % (protocol, port, path)
+    return "file://" + path
 
   def GetStartHttpdCommand(self, output_dir,
                            httpd_conf_path, mime_types_path,
                            document_root=None, apache2=False):
     """Prepares the config file and output directory to start an httpd server.
     Returns a list of strings containing the server's command line+args.
 
     Args:
       output_dir: the path to the server's output directory, for log files.
           It will be created if necessary.
       httpd_conf_path: full path to the httpd.conf file to be used.
       mime_types_path: full path to the mime.types file to be used.
       document_root: full path to the DocumentRoot.  If None, the DocumentRoot
           from the httpd.conf file will be used.  Note that the httpd.conf
           file alongside this script does not specify any DocumentRoot, so if
           you're using that one, be sure to specify a document_root here.
       apache2: boolean if true will cause this function to return start
-               command for Apache 2.x as opposed to Apache 1.3.x
+               command for Apache 2.x as opposed to Apache 1.3.x. This flag
+               is ignored on Mac (but preserved here for compatibility in
+               function signature with win), where httpd2 is used always
     """
 
-    if document_root:
-      document_root = GetCygwinPath(document_root)
     exe_name = "httpd"
-    cert_file = ""
-    if apache2:
-      exe_name = "httpd2"
-      cert_file = google.path_utils.FindUpward(self._base_dir, 'tools',
-                                               'python', 'google',
-                                               'httpd_config', 'httpd2.pem')
+    cert_file = google.path_utils.FindUpward(self._base_dir, 'tools',
+                                             'python', 'google',
+                                             'httpd_config', 'httpd2.pem')
     httpd_vars = {
-      "httpd_executable_path": GetCygwinPath(
-          os.path.join(self._CygwinRoot(), "usr", "sbin", exe_name)),
-      "httpd_conf_path": GetCygwinPath(httpd_conf_path),
-      "ssl_certificate_file": GetCygwinPath(cert_file),
+      "httpd_executable_path":
+          os.path.join(self._UnixRoot(), "usr", "sbin", exe_name),
+      "httpd_conf_path": httpd_conf_path,
+      "ssl_certificate_file": cert_file,
       "document_root" : document_root,
-      "server_root": GetCygwinPath(os.path.join(self._CygwinRoot(), "usr")),
-      "mime_types_path": GetCygwinPath(mime_types_path),
-      "output_dir": GetCygwinPath(output_dir),
-      "bindir": GetCygwinPath(os.path.join(self._CygwinRoot(), "bin")),
-      "user": os.environ.get("USERNAME", os.environ.get("USER", "")),
+      "server_root": os.path.join(self._UnixRoot(), "usr"),
+      "mime_types_path": mime_types_path,
+      "output_dir": output_dir,
+      "user": os.environ.get("USER", "#%d" % os.geteuid()),
+      "lock_file": os.path.join(output_dir, "accept.lock"),
     }
-    if not httpd_vars["user"]:
-      # Failed to get the username from the environment; use whoami.exe
-      # instead.
-      proc = subprocess.Popen(self._PathToExecutable("whoami.exe"),
-                              stdout=subprocess.PIPE)
-      httpd_vars["user"] = proc.stdout.read().strip()
-
-    if not httpd_vars["user"]:
-      raise Exception("Failed to get username.")
 
     google.path_utils.MaybeMakeDirectory(output_dir)
 
-    # We have to wrap the command in bash because the cygwin environment
-    # is required for httpd to run.
+    # We have to wrap the command in bash
     # -C: process directive before reading config files
     # -c: process directive after reading config files
     # Apache wouldn't run CGIs with permissions==700 unless we add
     # -c User "<username>"
-    bash = self._PathToExecutable("bash.exe")
     httpd_cmd_string = (
-      ' PATH=%(bindir)s %(httpd_executable_path)s'
+      '%(httpd_executable_path)s'
       ' -f %(httpd_conf_path)s'
       ' -c \'TypesConfig "%(mime_types_path)s"\''
       ' -c \'CustomLog "%(output_dir)s/access_log.txt" common\''
       ' -c \'ErrorLog "%(output_dir)s/error_log.txt"\''
       ' -c \'PidFile "%(output_dir)s/httpd.pid"\''
       ' -C \'User "%(user)s"\''
       ' -C \'ServerRoot "%(server_root)s"\''
+      ' -c \'LockFile "%(lock_file)s"\''
+      ' -c \'SSLCertificateFile "%(ssl_certificate_file)s"\''
     )
-    if apache2:
-      httpd_cmd_string = ('export CYGWIN=server;' + httpd_cmd_string +
-          ' -c \'SSLCertificateFile "%(ssl_certificate_file)s"\'')
+
     if document_root:
       httpd_cmd_string += ' -C \'DocumentRoot "%(document_root)s"\''
+    # Save a copy of httpd_cmd_string to use for stopping httpd
+    self._httpd_cmd_string = httpd_cmd_string % httpd_vars
 
-    httpd_cmd = [bash, "-c", httpd_cmd_string % httpd_vars]
+    httpd_cmd = [self._bash, "-c", self._httpd_cmd_string]
     return httpd_cmd
 
   def GetStopHttpdCommand(self):
     """Returns a list of strings that contains the command line+args needed to
     stop the http server used in the http tests.
+
+    This tries to fetch the pid of httpd (if available) and returns the
+    command to kill it. If pid is not available, kill all httpd processes
     """
-    # Force kill (/f) *all* httpd processes.  This has the side effect of
-    # killing httpd processes that we didn't start.
-    return ["taskkill.exe", "/f", "/im", "httpd*"]
 
-###########################################################################
-# This method is specific to windows, expected to be used only by *_win.py
-# files.
-
-def GetCygwinPath(path):
-  """Convert a Windows path to a cygwin path.
-
-  The cygpath utility insists on converting paths that it thinks are Cygwin
-  root paths to what it thinks the correct roots are.  So paths such as
-  "C:\b\slave\webkit-release-kjs\build\third_party\cygwin\bin" are converted to
-  plain "/usr/bin".  To avoid this, we do the conversion manually.
-
-  The path is expected to be an absolute path, on any drive.
-  """
-  drive_regexp = re.compile(r'([a-z]):[/\\]', re.IGNORECASE)
-  def LowerDrive(matchobj):
-    return '/cygdrive/%s/' % matchobj.group(1).lower()
-  path = drive_regexp.sub(LowerDrive, path)
-  return path.replace('\\', '/')
-
+    if not self._httpd_cmd_string:
+      return ["true"]   # Haven't been asked for the start cmd yet. Just pass.
+    return [self._bash, "-c", self._httpd_cmd_string + ' -k stop']