4705e3668d
components: apr-1.4.6 -> 1.4.8 and apr-util-1.4.1 -> 1.5.2. This is a post point-zero bug-fix / fix-sharp-edges release, including some workarounds for UTF-8 for people who haven't yet turned on WITH_ICONV.
865 lines
29 KiB
Python
865 lines
29 KiB
Python
#
|
|
#
|
|
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing,
|
|
# software distributed under the License is distributed on an
|
|
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
# KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
#
|
|
"""
|
|
Driver for running the tests on Windows.
|
|
|
|
For a list of options, run this script with the --help option.
|
|
"""
|
|
|
|
# $HeadURL: http://svn.apache.org/repos/asf/subversion/branches/1.8.x/win-tests.py $
|
|
# $LastChangedRevision: 1492044 $
|
|
|
|
import os, sys, subprocess
|
|
import filecmp
|
|
import shutil
|
|
import traceback
|
|
try:
|
|
# Python >=3.0
|
|
import configparser
|
|
except ImportError:
|
|
# Python <3.0
|
|
import ConfigParser as configparser
|
|
import string
|
|
import random
|
|
|
|
import getopt
|
|
try:
|
|
my_getopt = getopt.gnu_getopt
|
|
except AttributeError:
|
|
my_getopt = getopt.getopt
|
|
|
|
def _usage_exit():
|
|
"print usage, exit the script"
|
|
|
|
print("Driver for running the tests on Windows.")
|
|
print("Usage: python win-tests.py [option] [test-path]")
|
|
print("")
|
|
print("Valid options:")
|
|
print(" -r, --release : test the Release configuration")
|
|
print(" -d, --debug : test the Debug configuration (default)")
|
|
print(" --bin=PATH : use the svn binaries installed in PATH")
|
|
print(" -u URL, --url=URL : run ra_dav or ra_svn tests against URL;")
|
|
print(" will start svnserve for ra_svn tests")
|
|
print(" -v, --verbose : talk more")
|
|
print(" -q, --quiet : talk less")
|
|
print(" -f, --fs-type=type : filesystem type to use (fsfs is default)")
|
|
print(" -c, --cleanup : cleanup after running a test")
|
|
print(" -t, --test=TEST : Run the TEST test (all is default); use")
|
|
print(" TEST#n to run a particular test number,")
|
|
print(" multiples also accepted e.g. '2,4-7'")
|
|
print(" --log-level=LEVEL : Set log level to LEVEL (E.g. DEBUG)")
|
|
print(" --log-to-stdout : Write log results to stdout")
|
|
|
|
print(" --svnserve-args=list : comma-separated list of arguments for")
|
|
print(" svnserve")
|
|
print(" default is '-d,-r,<test-path-root>'")
|
|
print(" --asp.net-hack : use '_svn' instead of '.svn' for the admin")
|
|
print(" dir name")
|
|
print(" --httpd-dir : location where Apache HTTPD is installed")
|
|
print(" --httpd-port : port for Apache HTTPD; random port number")
|
|
print(" will be used, if not specified")
|
|
print(" --httpd-daemon : Run Apache httpd as daemon")
|
|
print(" --httpd-service : Run Apache httpd as Windows service (default)")
|
|
print(" --httpd-no-log : Disable httpd logging")
|
|
print(" --http-short-circuit : Use SVNPathAuthz short_circuit on HTTP server")
|
|
print(" --disable-http-v2 : Do not advertise support for HTTPv2 on server")
|
|
print(" --disable-bulk-updates : Disable bulk updates on HTTP server")
|
|
print(" --ssl-cert : Path to SSL server certificate to trust.")
|
|
print(" --javahl : Run the javahl tests instead of the normal tests")
|
|
print(" --list : print test doc strings only")
|
|
print(" --milestone-filter=RE : RE is a regular expression pattern that (when")
|
|
print(" used with --list) limits the tests listed to")
|
|
print(" those with an associated issue in the tracker")
|
|
print(" which has a target milestone that matches RE.")
|
|
print(" --mode-filter=TYPE : limit tests to expected TYPE = XFAIL, SKIP, PASS,")
|
|
print(" or 'ALL' (default)")
|
|
print(" --enable-sasl : enable Cyrus SASL authentication for")
|
|
print(" svnserve")
|
|
print(" -p, --parallel : run multiple tests in parallel")
|
|
print(" --server-minor-version : the minor version of the server being")
|
|
print(" tested")
|
|
print(" --config-file : Configuration file for tests")
|
|
print(" --fsfs-sharding : Specify shard size (for fsfs)")
|
|
print(" --fsfs-packing : Run 'svnadmin pack' automatically")
|
|
|
|
sys.exit(0)
|
|
|
|
CMDLINE_TEST_SCRIPT_PATH = 'subversion/tests/cmdline/'
|
|
CMDLINE_TEST_SCRIPT_NATIVE_PATH = CMDLINE_TEST_SCRIPT_PATH.replace('/', os.sep)
|
|
|
|
sys.path.insert(0, os.path.join('build', 'generator'))
|
|
sys.path.insert(1, 'build')
|
|
|
|
import gen_win
|
|
version_header = os.path.join('subversion', 'include', 'svn_version.h')
|
|
cp = configparser.ConfigParser()
|
|
cp.read('gen-make.opts')
|
|
gen_obj = gen_win.GeneratorBase('build.conf', version_header,
|
|
cp.items('options'))
|
|
all_tests = gen_obj.test_progs + gen_obj.bdb_test_progs \
|
|
+ gen_obj.scripts + gen_obj.bdb_scripts
|
|
client_tests = [x for x in all_tests if x.startswith(CMDLINE_TEST_SCRIPT_PATH)]
|
|
|
|
svn_dlls = []
|
|
for section in gen_obj.sections.values():
|
|
if section.options.get("msvc-export"):
|
|
dll_basename = section.name + "-" + str(gen_obj.version) + ".dll"
|
|
svn_dlls.append(os.path.join("subversion", section.name, dll_basename))
|
|
|
|
opts, args = my_getopt(sys.argv[1:], 'hrdvqct:pu:f:',
|
|
['release', 'debug', 'verbose', 'quiet', 'cleanup',
|
|
'test=', 'url=', 'svnserve-args=', 'fs-type=', 'asp.net-hack',
|
|
'httpd-dir=', 'httpd-port=', 'httpd-daemon',
|
|
'httpd-server', 'http-short-circuit', 'httpd-no-log',
|
|
'disable-http-v2', 'disable-bulk-updates', 'help',
|
|
'fsfs-packing', 'fsfs-sharding=', 'javahl',
|
|
'list', 'enable-sasl', 'bin=', 'parallel',
|
|
'config-file=', 'server-minor-version=', 'log-level=',
|
|
'log-to-stdout', 'mode-filter=', 'milestone-filter=',
|
|
'ssl-cert='])
|
|
if len(args) > 1:
|
|
print('Warning: non-option arguments after the first one will be ignored')
|
|
|
|
# Interpret the options and set parameters
|
|
base_url, fs_type, verbose, quiet, cleanup = None, None, None, None, None
|
|
repo_loc = 'local repository.'
|
|
objdir = 'Debug'
|
|
log = 'tests.log'
|
|
faillog = 'fails.log'
|
|
run_svnserve = None
|
|
svnserve_args = None
|
|
run_httpd = None
|
|
httpd_port = None
|
|
httpd_service = None
|
|
httpd_no_log = None
|
|
http_short_circuit = False
|
|
advertise_httpv2 = True
|
|
http_bulk_updates = True
|
|
list_tests = None
|
|
milestone_filter = None
|
|
test_javahl = None
|
|
enable_sasl = None
|
|
svn_bin = None
|
|
parallel = None
|
|
fsfs_sharding = None
|
|
fsfs_packing = None
|
|
server_minor_version = None
|
|
config_file = None
|
|
log_to_stdout = None
|
|
mode_filter=None
|
|
tests_to_run = []
|
|
log_level = None
|
|
ssl_cert = None
|
|
|
|
for opt, val in opts:
|
|
if opt in ('-h', '--help'):
|
|
_usage_exit()
|
|
elif opt in ('-u', '--url'):
|
|
base_url = val
|
|
elif opt in ('-f', '--fs-type'):
|
|
fs_type = val
|
|
elif opt in ('-v', '--verbose'):
|
|
verbose = 1
|
|
elif opt in ('-q', '--quiet'):
|
|
quiet = 1
|
|
elif opt in ('-c', '--cleanup'):
|
|
cleanup = 1
|
|
elif opt in ('-t', '--test'):
|
|
tests_to_run.append(val)
|
|
elif opt in ['-r', '--release']:
|
|
objdir = 'Release'
|
|
elif opt in ['-d', '--debug']:
|
|
objdir = 'Debug'
|
|
elif opt == '--svnserve-args':
|
|
svnserve_args = val.split(',')
|
|
run_svnserve = 1
|
|
elif opt == '--asp.net-hack':
|
|
os.environ['SVN_ASP_DOT_NET_HACK'] = opt
|
|
elif opt == '--httpd-dir':
|
|
abs_httpd_dir = os.path.abspath(val)
|
|
run_httpd = 1
|
|
elif opt == '--httpd-port':
|
|
httpd_port = int(val)
|
|
elif opt == '--httpd-daemon':
|
|
httpd_service = 0
|
|
elif opt == '--httpd-service':
|
|
httpd_service = 1
|
|
elif opt == '--httpd-no-log':
|
|
httpd_no_log = 1
|
|
elif opt == '--http-short-circuit':
|
|
http_short_circuit = True
|
|
elif opt == '--disable-http-v2':
|
|
advertise_httpv2 = False
|
|
elif opt == '--disable-bulk-updates':
|
|
http_bulk_updates = False
|
|
elif opt == '--fsfs-sharding':
|
|
fsfs_sharding = int(val)
|
|
elif opt == '--fsfs-packing':
|
|
fsfs_packing = 1
|
|
elif opt == '--javahl':
|
|
test_javahl = 1
|
|
elif opt == '--list':
|
|
list_tests = 1
|
|
elif opt == '--milestone-filter':
|
|
milestone_filter = val
|
|
elif opt == '--mode-filter':
|
|
mode_filter = val
|
|
elif opt == '--enable-sasl':
|
|
enable_sasl = 1
|
|
base_url = "svn://localhost/"
|
|
elif opt == '--server-minor-version':
|
|
server_minor_version = val
|
|
elif opt == '--bin':
|
|
svn_bin = val
|
|
elif opt in ('-p', '--parallel'):
|
|
parallel = 1
|
|
elif opt in ('--config-file'):
|
|
config_file = val
|
|
elif opt == '--log-to-stdout':
|
|
log_to_stdout = 1
|
|
elif opt == '--log-level':
|
|
log_level = val
|
|
elif opt == '--ssl-cert':
|
|
ssl_cert = val
|
|
|
|
# Calculate the source and test directory names
|
|
abs_srcdir = os.path.abspath("")
|
|
abs_objdir = os.path.join(abs_srcdir, objdir)
|
|
if len(args) == 0:
|
|
abs_builddir = abs_objdir
|
|
create_dirs = 0
|
|
else:
|
|
abs_builddir = os.path.abspath(args[0])
|
|
create_dirs = 1
|
|
|
|
# Default to fsfs explicitly
|
|
if not fs_type:
|
|
fs_type = 'fsfs'
|
|
|
|
# Don't run bdb tests if they want to test fsfs
|
|
if fs_type == 'fsfs':
|
|
all_tests = gen_obj.test_progs + gen_obj.scripts
|
|
|
|
if run_httpd:
|
|
if not httpd_port:
|
|
httpd_port = random.randrange(1024, 30000)
|
|
if not base_url:
|
|
base_url = 'http://localhost:' + str(httpd_port)
|
|
|
|
if base_url:
|
|
repo_loc = 'remote repository ' + base_url + '.'
|
|
if base_url[:4] == 'http':
|
|
log = 'dav-tests.log'
|
|
faillog = 'dav-fails.log'
|
|
elif base_url[:3] == 'svn':
|
|
log = 'svn-tests.log'
|
|
faillog = 'svn-fails.log'
|
|
run_svnserve = 1
|
|
else:
|
|
# Don't know this scheme, but who're we to judge whether it's
|
|
# correct or not?
|
|
log = 'url-tests.log'
|
|
faillog = 'url-fails.log'
|
|
|
|
# Have to move the executables where the tests expect them to be
|
|
copied_execs = [] # Store copied exec files to avoid the final dir scan
|
|
|
|
def create_target_dir(dirname):
|
|
tgt_dir = os.path.join(abs_builddir, dirname)
|
|
if not os.path.exists(tgt_dir):
|
|
if verbose:
|
|
print("mkdir: %s" % tgt_dir)
|
|
os.makedirs(tgt_dir)
|
|
|
|
def copy_changed_file(src, tgt):
|
|
if not os.path.isfile(src):
|
|
print('Could not find ' + src)
|
|
sys.exit(1)
|
|
if os.path.isdir(tgt):
|
|
tgt = os.path.join(tgt, os.path.basename(src))
|
|
if os.path.exists(tgt):
|
|
assert os.path.isfile(tgt)
|
|
if filecmp.cmp(src, tgt):
|
|
if verbose:
|
|
print("same: %s" % src)
|
|
print(" and: %s" % tgt)
|
|
return 0
|
|
if verbose:
|
|
print("copy: %s" % src)
|
|
print(" to: %s" % tgt)
|
|
shutil.copy(src, tgt)
|
|
return 1
|
|
|
|
def copy_execs(baton, dirname, names):
|
|
copied_execs = baton
|
|
for name in names:
|
|
if not name.endswith('.exe'):
|
|
continue
|
|
src = os.path.join(dirname, name)
|
|
tgt = os.path.join(abs_builddir, dirname, name)
|
|
create_target_dir(dirname)
|
|
if copy_changed_file(src, tgt):
|
|
copied_execs.append(tgt)
|
|
|
|
def locate_libs():
|
|
"Move DLLs to a known location and set env vars"
|
|
|
|
dlls = []
|
|
|
|
# look for APR 1.x dll's and use those if found
|
|
apr_test_path = os.path.join(gen_obj.apr_path, objdir, 'libapr-1.dll')
|
|
if os.path.exists(apr_test_path):
|
|
suffix = "-1"
|
|
else:
|
|
suffix = ""
|
|
|
|
if cp.has_option('options', '--with-static-apr'):
|
|
dlls.append(os.path.join(gen_obj.apr_path, objdir,
|
|
'libapr%s.dll' % (suffix)))
|
|
dlls.append(os.path.join(gen_obj.apr_util_path, objdir,
|
|
'libaprutil%s.dll' % (suffix)))
|
|
|
|
if gen_obj.libintl_path is not None:
|
|
dlls.append(os.path.join(gen_obj.libintl_path, 'bin', 'intl3_svn.dll'))
|
|
|
|
if gen_obj.bdb_lib is not None:
|
|
partial_path = os.path.join(gen_obj.bdb_path, 'bin', gen_obj.bdb_lib)
|
|
if objdir == 'Debug':
|
|
dlls.append(partial_path + 'd.dll')
|
|
else:
|
|
dlls.append(partial_path + '.dll')
|
|
|
|
if gen_obj.sasl_path is not None:
|
|
dlls.append(os.path.join(gen_obj.sasl_path, 'lib', 'libsasl.dll'))
|
|
|
|
for dll in dlls:
|
|
copy_changed_file(dll, abs_objdir)
|
|
|
|
# Copy the Subversion library DLLs
|
|
if not cp.has_option('options', '--disable-shared'):
|
|
for svn_dll in svn_dlls:
|
|
copy_changed_file(os.path.join(abs_objdir, svn_dll), abs_objdir)
|
|
|
|
# Copy the Apache modules
|
|
if run_httpd and cp.has_option('options', '--with-httpd'):
|
|
mod_dav_svn_path = os.path.join(abs_objdir, 'subversion',
|
|
'mod_dav_svn', 'mod_dav_svn.so')
|
|
mod_authz_svn_path = os.path.join(abs_objdir, 'subversion',
|
|
'mod_authz_svn', 'mod_authz_svn.so')
|
|
mod_dontdothat_path = os.path.join(abs_objdir, 'tools', 'server-side',
|
|
'mod_dontdothat', 'mod_dontdothat.so')
|
|
|
|
copy_changed_file(mod_dav_svn_path, abs_objdir)
|
|
copy_changed_file(mod_authz_svn_path, abs_objdir)
|
|
copy_changed_file(mod_dontdothat_path, abs_objdir)
|
|
|
|
os.environ['PATH'] = abs_objdir + os.pathsep + os.environ['PATH']
|
|
|
|
def fix_case(path):
|
|
path = os.path.normpath(path)
|
|
parts = path.split(os.path.sep)
|
|
drive = parts[0].upper()
|
|
parts = parts[1:]
|
|
path = drive + os.path.sep
|
|
for part in parts:
|
|
dirs = os.listdir(path)
|
|
for dir in dirs:
|
|
if dir.lower() == part.lower():
|
|
path = os.path.join(path, dir)
|
|
break
|
|
return path
|
|
|
|
class Svnserve:
|
|
"Run svnserve for ra_svn tests"
|
|
def __init__(self, svnserve_args, objdir, abs_objdir, abs_builddir):
|
|
self.args = svnserve_args
|
|
self.name = 'svnserve.exe'
|
|
self.kind = objdir
|
|
self.path = os.path.join(abs_objdir,
|
|
'subversion', 'svnserve', self.name)
|
|
self.root = os.path.join(abs_builddir, CMDLINE_TEST_SCRIPT_NATIVE_PATH)
|
|
self.proc_handle = None
|
|
|
|
def __del__(self):
|
|
"Stop svnserve when the object is deleted"
|
|
self.stop()
|
|
|
|
def _quote(self, arg):
|
|
if ' ' in arg:
|
|
return '"' + arg + '"'
|
|
else:
|
|
return arg
|
|
|
|
def start(self):
|
|
if not self.args:
|
|
args = [self.name, '-d', '-r', self.root]
|
|
else:
|
|
args = [self.name] + self.args
|
|
print('Starting %s %s' % (self.kind, self.name))
|
|
try:
|
|
import win32process
|
|
import win32con
|
|
args = ' '.join([self._quote(x) for x in args])
|
|
self.proc_handle = (
|
|
win32process.CreateProcess(self._quote(self.path), args,
|
|
None, None, 0,
|
|
win32con.CREATE_NEW_CONSOLE,
|
|
None, None, win32process.STARTUPINFO()))[0]
|
|
except ImportError:
|
|
os.spawnv(os.P_NOWAIT, self.path, args)
|
|
|
|
def stop(self):
|
|
if self.proc_handle is not None:
|
|
try:
|
|
import win32process
|
|
print('Stopping %s' % self.name)
|
|
win32process.TerminateProcess(self.proc_handle, 0)
|
|
return
|
|
except ImportError:
|
|
pass
|
|
print('Svnserve.stop not implemented')
|
|
|
|
class Httpd:
|
|
"Run httpd for DAV tests"
|
|
def __init__(self, abs_httpd_dir, abs_objdir, abs_builddir, httpd_port,
|
|
service, no_log, httpv2, short_circuit, bulk_updates):
|
|
self.name = 'apache.exe'
|
|
self.httpd_port = httpd_port
|
|
self.httpd_dir = abs_httpd_dir
|
|
|
|
if httpv2:
|
|
self.httpv2_option = 'on'
|
|
else:
|
|
self.httpv2_option = 'off'
|
|
|
|
if bulk_updates:
|
|
self.bulkupdates_option = 'on'
|
|
else:
|
|
self.bulkupdates_option = 'off'
|
|
|
|
self.service = service
|
|
self.proc_handle = None
|
|
self.path = os.path.join(self.httpd_dir, 'bin', self.name)
|
|
|
|
if short_circuit:
|
|
self.path_authz_option = 'short_circuit'
|
|
else:
|
|
self.path_authz_option = 'on'
|
|
|
|
if not os.path.exists(self.path):
|
|
self.name = 'httpd.exe'
|
|
self.path = os.path.join(self.httpd_dir, 'bin', self.name)
|
|
if not os.path.exists(self.path):
|
|
raise RuntimeError("Could not find a valid httpd binary!")
|
|
|
|
self.root_dir = os.path.join(CMDLINE_TEST_SCRIPT_NATIVE_PATH, 'httpd')
|
|
self.root = os.path.join(abs_builddir, self.root_dir)
|
|
self.authz_file = os.path.join(abs_builddir,
|
|
CMDLINE_TEST_SCRIPT_NATIVE_PATH,
|
|
'svn-test-work', 'authz')
|
|
self.dontdothat_file = os.path.join(abs_builddir,
|
|
CMDLINE_TEST_SCRIPT_NATIVE_PATH,
|
|
'svn-test-work', 'dontdothat')
|
|
self.httpd_config = os.path.join(self.root, 'httpd.conf')
|
|
self.httpd_users = os.path.join(self.root, 'users')
|
|
self.httpd_mime_types = os.path.join(self.root, 'mime.types')
|
|
self.abs_builddir = abs_builddir
|
|
self.abs_objdir = abs_objdir
|
|
self.service_name = 'svn-test-httpd-' + str(httpd_port)
|
|
|
|
if self.service:
|
|
self.httpd_args = [self.name, '-n', self._quote(self.service_name),
|
|
'-f', self._quote(self.httpd_config)]
|
|
else:
|
|
self.httpd_args = [self.name, '-f', self._quote(self.httpd_config)]
|
|
|
|
create_target_dir(self.root_dir)
|
|
|
|
self._create_users_file()
|
|
self._create_mime_types_file()
|
|
self._create_dontdothat_file()
|
|
|
|
# Determine version.
|
|
if os.path.exists(os.path.join(self.httpd_dir,
|
|
'modules', 'mod_access_compat.so')):
|
|
self.httpd_ver = 2.3
|
|
elif os.path.exists(os.path.join(self.httpd_dir,
|
|
'modules', 'mod_auth_basic.so')):
|
|
self.httpd_ver = 2.2
|
|
else:
|
|
self.httpd_ver = 2.0
|
|
|
|
# Create httpd config file
|
|
fp = open(self.httpd_config, 'w')
|
|
|
|
# Limit the number of threads (default = 64)
|
|
fp.write('<IfModule mpm_winnt.c>\n')
|
|
fp.write('ThreadsPerChild 16\n')
|
|
fp.write('</IfModule>\n')
|
|
|
|
# Global Environment
|
|
fp.write('ServerRoot ' + self._quote(self.root) + '\n')
|
|
fp.write('DocumentRoot ' + self._quote(self.root) + '\n')
|
|
fp.write('ServerName localhost\n')
|
|
fp.write('PidFile pid\n')
|
|
fp.write('ErrorLog log\n')
|
|
fp.write('Listen ' + str(self.httpd_port) + '\n')
|
|
|
|
if not no_log:
|
|
fp.write('LogFormat "%h %l %u %t \\"%r\\" %>s %b" common\n')
|
|
fp.write('Customlog log common\n')
|
|
fp.write('LogLevel Debug\n')
|
|
else:
|
|
fp.write('LogLevel Crit\n')
|
|
|
|
# Write LoadModule for minimal system module
|
|
fp.write(self._sys_module('dav_module', 'mod_dav.so'))
|
|
if self.httpd_ver >= 2.3:
|
|
fp.write(self._sys_module('access_compat_module', 'mod_access_compat.so'))
|
|
fp.write(self._sys_module('authz_core_module', 'mod_authz_core.so'))
|
|
fp.write(self._sys_module('authz_user_module', 'mod_authz_user.so'))
|
|
fp.write(self._sys_module('authn_core_module', 'mod_authn_core.so'))
|
|
if self.httpd_ver >= 2.2:
|
|
fp.write(self._sys_module('auth_basic_module', 'mod_auth_basic.so'))
|
|
fp.write(self._sys_module('authn_file_module', 'mod_authn_file.so'))
|
|
else:
|
|
fp.write(self._sys_module('auth_module', 'mod_auth.so'))
|
|
fp.write(self._sys_module('alias_module', 'mod_alias.so'))
|
|
fp.write(self._sys_module('mime_module', 'mod_mime.so'))
|
|
fp.write(self._sys_module('log_config_module', 'mod_log_config.so'))
|
|
|
|
# Write LoadModule for Subversion modules
|
|
fp.write(self._svn_module('dav_svn_module', 'mod_dav_svn.so'))
|
|
fp.write(self._svn_module('authz_svn_module', 'mod_authz_svn.so'))
|
|
|
|
# And for mod_dontdothat
|
|
fp.write(self._svn_module('dontdothat_module', 'mod_dontdothat.so'))
|
|
|
|
# Don't handle .htaccess, symlinks, etc.
|
|
fp.write('<Directory />\n')
|
|
fp.write('AllowOverride None\n')
|
|
fp.write('Options None\n')
|
|
fp.write('</Directory>\n\n')
|
|
|
|
# Define two locations for repositories
|
|
fp.write(self._svn_repo('repositories'))
|
|
fp.write(self._svn_repo('local_tmp'))
|
|
|
|
# And two redirects for the redirect tests
|
|
fp.write('RedirectMatch permanent ^/svn-test-work/repositories/'
|
|
'REDIRECT-PERM-(.*)$ /svn-test-work/repositories/$1\n')
|
|
fp.write('RedirectMatch ^/svn-test-work/repositories/'
|
|
'REDIRECT-TEMP-(.*)$ /svn-test-work/repositories/$1\n')
|
|
|
|
fp.write('TypesConfig ' + self._quote(self.httpd_mime_types) + '\n')
|
|
fp.write('HostNameLookups Off\n')
|
|
|
|
fp.close()
|
|
|
|
def __del__(self):
|
|
"Stop httpd when the object is deleted"
|
|
self.stop()
|
|
|
|
def _quote(self, arg):
|
|
if ' ' in arg:
|
|
return '"' + arg + '"'
|
|
else:
|
|
return arg
|
|
|
|
def _create_users_file(self):
|
|
"Create users file"
|
|
htpasswd = os.path.join(self.httpd_dir, 'bin', 'htpasswd.exe')
|
|
# Create the cheapest to compare password form for our testsuite
|
|
os.spawnv(os.P_WAIT, htpasswd, ['htpasswd.exe', '-bcp', self.httpd_users,
|
|
'jrandom', 'rayjandom'])
|
|
os.spawnv(os.P_WAIT, htpasswd, ['htpasswd.exe', '-bp', self.httpd_users,
|
|
'jconstant', 'rayjandom'])
|
|
|
|
def _create_mime_types_file(self):
|
|
"Create empty mime.types file"
|
|
fp = open(self.httpd_mime_types, 'w')
|
|
fp.close()
|
|
|
|
def _create_dontdothat_file(self):
|
|
"Create empty mime.types file"
|
|
# If the tests have not previously been run or were cleaned
|
|
# up, then 'svn-test-work' does not exist yet.
|
|
parent_dir = os.path.dirname(self.dontdothat_file)
|
|
if not os.path.exists(parent_dir):
|
|
os.makedirs(parent_dir)
|
|
|
|
fp = open(self.dontdothat_file, 'w')
|
|
fp.write('[recursive-actions]\n')
|
|
fp.write('/ = deny\n')
|
|
fp.close()
|
|
|
|
def _sys_module(self, name, path):
|
|
full_path = os.path.join(self.httpd_dir, 'modules', path)
|
|
return 'LoadModule ' + name + " " + self._quote(full_path) + '\n'
|
|
|
|
def _svn_module(self, name, path):
|
|
full_path = os.path.join(self.abs_objdir, path)
|
|
return 'LoadModule ' + name + ' ' + self._quote(full_path) + '\n'
|
|
|
|
def _svn_repo(self, name):
|
|
path = os.path.join(self.abs_builddir,
|
|
CMDLINE_TEST_SCRIPT_NATIVE_PATH,
|
|
'svn-test-work', name)
|
|
location = '/svn-test-work/' + name
|
|
ddt_location = '/ddt-test-work/' + name
|
|
return \
|
|
'<Location ' + location + '>\n' \
|
|
' DAV svn\n' \
|
|
' SVNParentPath ' + self._quote(path) + '\n' \
|
|
' SVNAdvertiseV2Protocol ' + self.httpv2_option + '\n' \
|
|
' SVNPathAuthz ' + self.path_authz_option + '\n' \
|
|
' SVNAllowBulkUpdates ' + self.bulkupdates_option + '\n' \
|
|
' AuthzSVNAccessFile ' + self._quote(self.authz_file) + '\n' \
|
|
' AuthType Basic\n' \
|
|
' AuthName "Subversion Repository"\n' \
|
|
' AuthUserFile ' + self._quote(self.httpd_users) + '\n' \
|
|
' Require valid-user\n' \
|
|
'</Location>\n' \
|
|
'<Location ' + ddt_location + '>\n' \
|
|
' DAV svn\n' \
|
|
' SVNParentPath ' + self._quote(path) + '\n' \
|
|
' SVNAdvertiseV2Protocol ' + self.httpv2_option + '\n' \
|
|
' SVNPathAuthz ' + self.path_authz_option + '\n' \
|
|
' SVNAllowBulkUpdates ' + self.bulkupdates_option + '\n' \
|
|
' AuthzSVNAccessFile ' + self._quote(self.authz_file) + '\n' \
|
|
' AuthType Basic\n' \
|
|
' AuthName "Subversion Repository"\n' \
|
|
' AuthUserFile ' + self._quote(self.httpd_users) + '\n' \
|
|
' Require valid-user\n' \
|
|
' DontDoThatConfigFile ' + self._quote(self.dontdothat_file) + '\n' \
|
|
'</Location>\n'
|
|
|
|
def start(self):
|
|
if self.service:
|
|
self._start_service()
|
|
else:
|
|
self._start_daemon()
|
|
|
|
def stop(self):
|
|
if self.service:
|
|
self._stop_service()
|
|
else:
|
|
self._stop_daemon()
|
|
|
|
def _start_service(self):
|
|
"Install and start HTTPD service"
|
|
print('Installing service %s' % self.service_name)
|
|
os.spawnv(os.P_WAIT, self.path, self.httpd_args + ['-k', 'install'])
|
|
print('Starting service %s' % self.service_name)
|
|
os.spawnv(os.P_WAIT, self.path, self.httpd_args + ['-k', 'start'])
|
|
|
|
def _stop_service(self):
|
|
"Stop and uninstall HTTPD service"
|
|
os.spawnv(os.P_WAIT, self.path, self.httpd_args + ['-k', 'stop'])
|
|
os.spawnv(os.P_WAIT, self.path, self.httpd_args + ['-k', 'uninstall'])
|
|
|
|
def _start_daemon(self):
|
|
"Start HTTPD as daemon"
|
|
print('Starting httpd as daemon')
|
|
print(self.httpd_args)
|
|
try:
|
|
import win32process
|
|
import win32con
|
|
args = ' '.join([self._quote(x) for x in self.httpd_args])
|
|
self.proc_handle = (
|
|
win32process.CreateProcess(self._quote(self.path), args,
|
|
None, None, 0,
|
|
win32con.CREATE_NEW_CONSOLE,
|
|
None, None, win32process.STARTUPINFO()))[0]
|
|
except ImportError:
|
|
os.spawnv(os.P_NOWAIT, self.path, self.httpd_args)
|
|
|
|
def _stop_daemon(self):
|
|
"Stop the HTTPD daemon"
|
|
if self.proc_handle is not None:
|
|
try:
|
|
import win32process
|
|
print('Stopping %s' % self.name)
|
|
win32process.TerminateProcess(self.proc_handle, 0)
|
|
return
|
|
except ImportError:
|
|
pass
|
|
print('Httpd.stop_daemon not implemented')
|
|
|
|
# Move the binaries to the test directory
|
|
locate_libs()
|
|
if create_dirs:
|
|
old_cwd = os.getcwd()
|
|
try:
|
|
os.chdir(abs_objdir)
|
|
baton = copied_execs
|
|
for dirpath, dirs, files in os.walk('subversion'):
|
|
copy_execs(baton, dirpath, files)
|
|
for dirpath, dirs, files in os.walk('tools/server-side'):
|
|
copy_execs(baton, dirpath, files)
|
|
except:
|
|
os.chdir(old_cwd)
|
|
raise
|
|
else:
|
|
os.chdir(old_cwd)
|
|
|
|
# Create the base directory for Python tests
|
|
create_target_dir(CMDLINE_TEST_SCRIPT_NATIVE_PATH)
|
|
|
|
# Ensure the tests directory is correctly cased
|
|
abs_builddir = fix_case(abs_builddir)
|
|
|
|
daemon = None
|
|
# Run the tests
|
|
|
|
# No need to start any servers if we are only listing the tests.
|
|
if not list_tests:
|
|
if run_svnserve:
|
|
daemon = Svnserve(svnserve_args, objdir, abs_objdir, abs_builddir)
|
|
|
|
if run_httpd:
|
|
daemon = Httpd(abs_httpd_dir, abs_objdir, abs_builddir, httpd_port,
|
|
httpd_service, httpd_no_log,
|
|
advertise_httpv2, http_short_circuit,
|
|
http_bulk_updates)
|
|
|
|
# Start service daemon, if any
|
|
if daemon:
|
|
daemon.start()
|
|
|
|
# Find the full path and filename of any test that is specified just by
|
|
# its base name.
|
|
if len(tests_to_run) != 0:
|
|
tests = []
|
|
for t in tests_to_run:
|
|
tns = None
|
|
if '#' in t:
|
|
t, tns = t.split('#')
|
|
|
|
test = [x for x in all_tests if x.split('/')[-1] == t]
|
|
if not test and not (t.endswith('-test.exe') or t.endswith('_tests.py')):
|
|
# The lengths of '-test.exe' and of '_tests.py' are both 9.
|
|
test = [x for x in all_tests if x.split('/')[-1][:-9] == t]
|
|
|
|
if not test:
|
|
print("Skipping test '%s', test not found." % t)
|
|
elif tns:
|
|
tests.append('%s#%s' % (test[0], tns))
|
|
else:
|
|
tests.extend(test)
|
|
|
|
tests_to_run = tests
|
|
else:
|
|
tests_to_run = all_tests
|
|
|
|
|
|
if list_tests:
|
|
print('Listing %s configuration on %s' % (objdir, repo_loc))
|
|
else:
|
|
print('Testing %s configuration on %s' % (objdir, repo_loc))
|
|
sys.path.insert(0, os.path.join(abs_srcdir, 'build'))
|
|
|
|
if not test_javahl:
|
|
import run_tests
|
|
if log_to_stdout:
|
|
log_file = None
|
|
fail_log_file = None
|
|
else:
|
|
log_file = os.path.join(abs_builddir, log)
|
|
fail_log_file = os.path.join(abs_builddir, faillog)
|
|
|
|
th = run_tests.TestHarness(abs_srcdir, abs_builddir,
|
|
log_file,
|
|
fail_log_file,
|
|
base_url, fs_type, 'serf',
|
|
server_minor_version, not quiet,
|
|
cleanup, enable_sasl, parallel, config_file,
|
|
fsfs_sharding, fsfs_packing,
|
|
list_tests, svn_bin, mode_filter,
|
|
milestone_filter,
|
|
set_log_level=log_level, ssl_cert=ssl_cert)
|
|
old_cwd = os.getcwd()
|
|
try:
|
|
os.chdir(abs_builddir)
|
|
failed = th.run(tests_to_run)
|
|
except:
|
|
os.chdir(old_cwd)
|
|
raise
|
|
else:
|
|
os.chdir(old_cwd)
|
|
else:
|
|
failed = False
|
|
args = (
|
|
'java.exe',
|
|
'-Dtest.rootdir=' + os.path.join(abs_builddir, 'javahl'),
|
|
'-Dtest.srcdir=' + os.path.join(abs_srcdir,
|
|
'subversion/bindings/javahl'),
|
|
'-Dtest.rooturl=',
|
|
'-Dtest.fstype=' + fs_type ,
|
|
'-Dtest.tests=',
|
|
|
|
'-Djava.library.path='
|
|
+ os.path.join(abs_objdir,
|
|
'subversion/bindings/javahl/native'),
|
|
'-classpath',
|
|
os.path.join(abs_srcdir, 'subversion/bindings/javahl/classes') +';' +
|
|
gen_obj.junit_path
|
|
)
|
|
|
|
sys.stderr.flush()
|
|
print('Running org.apache.subversion tests:')
|
|
sys.stdout.flush()
|
|
|
|
r = subprocess.call(args + tuple(['org.apache.subversion.javahl.RunTests']))
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
if (r != 0):
|
|
print('[Test runner reported failure]')
|
|
failed = True
|
|
|
|
print('Running org.tigris.subversion tests:')
|
|
sys.stdout.flush()
|
|
r = subprocess.call(args + tuple(['org.tigris.subversion.javahl.RunTests']))
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
if (r != 0):
|
|
print('[Test runner reported failure]')
|
|
failed = True
|
|
|
|
# Stop service daemon, if any
|
|
if daemon:
|
|
del daemon
|
|
|
|
# Remove the execs again
|
|
for tgt in copied_execs:
|
|
try:
|
|
if os.path.isfile(tgt):
|
|
if verbose:
|
|
print("kill: %s" % tgt)
|
|
os.unlink(tgt)
|
|
except:
|
|
traceback.print_exc(file=sys.stdout)
|
|
pass
|
|
|
|
|
|
if failed:
|
|
sys.exit(1)
|