1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
# 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.
"""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.
"""
self._cygwin_root = None
self._base_dir = base_dir
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 GetFilesystemRoot(self):
"""Returns the root directory of the file system."""
return os.environ['SYSTEMDRIVE'] + '\\'
def GetTempDirectory(self):
"""Returns the file system's base temp directory, or the filesystem root
if the standard temp directory can't be determined.
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())
def FilenameToUri(self, path, use_http=False, use_ssl=False, port=8000):
"""Convert a Windows style 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)
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
"""
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')
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),
"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", "")),
}
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.
# -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'
' -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"\''
)
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"\''
httpd_cmd = [bash, "-c", httpd_cmd_string % httpd_vars]
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.
"""
# 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('\\', '/')
|
