def _job_trace(tst, msg, total, exe, active, reporting):
s = ''
for a in active:
s += ' %d:%s' % (a.index, path.basename(a.executable))
log.notice('}} %*d: %s: %s (%d %d %d%s)' %
(len(str(tst.total)), tst.index, path.basename(
tst.executable), msg, reporting, total, exe, s))
def _job_trace(tst, msg, total, exe, active, reporting):
s = ''
for a in active:
s += ' %d:%s' % (a.index, path.basename(a.executable))
log.notice('}} %*d: %s: %s (%d %d %d%s)' % (len(str(tst.total)), tst.index,
path.basename(tst.executable),
msg,
reporting, total, exe, s))
def _linkExecutables(self):
log.notice("Linking executables to " + self.tracesDir)
for exe in self.executables:
dst = path.join(self.tracesDir, path.basename(exe))
os.link(exe, dst)
log.notice("Symlinks made")
def list(opts):
path_ = opts.defaults.expand('%%{_configdir}/bsps/*.ini')
bsps = path.collect_files(path_)
log.notice(' BSP List:')
for bsp in bsps:
log.notice(' %s' % (path.basename(bsp[:-4])))
raise error.exit()
def load(self, name):
#
# Load all the files.
#
self.ini = {'base': path.dirname(name), 'files': []}
includes = [name]
still_loading = True
while still_loading:
still_loading = False
for include in includes:
if not path.exists(include):
rebased_inc = path.join(self.ini['base'],
path.basename(include))
if not path.exists(rebased_inc):
e = 'config: cannot find configuration: %s' % (include)
raise error.general(e)
include = rebased_inc
if include not in self.ini['files']:
try:
self.config.read(include)
except configparser.ParsingError as ce:
raise error.general('config: %s' % (ce))
still_loading = True
self.ini['files'] += [include]
includes = []
if still_loading:
for section in self.config.sections():
includes += self.comma_list(section, 'include', err=False)
def __init__(self, index, total, report, executable, rtems_tools, bsp,
bsp_config, opts):
self.index = index
self.total = total
self.report = report
self.bsp = bsp
self.bsp_config = bsp_config
self.opts = copy.copy(opts)
self.opts.defaults['test_index'] = str(index)
self.opts.defaults['test_total'] = str(total)
self.opts.defaults['bsp'] = bsp
self.opts.defaults['bsp_arch'] = '%%{%s_arch}' % (bsp)
self.opts.defaults['bsp_opts'] = '%%{%s_opts}' % (bsp)
if not path.isfile(executable):
raise error.general('cannot find executable: %s' % (executable))
self.opts.defaults['test_executable'] = executable
self.opts.defaults['test_executable_name'] = path.basename(executable)
if rtems_tools:
rtems_tools_bin = path.join(self.opts.defaults.expand(rtems_tools),
'bin')
if not path.isdir(rtems_tools_bin):
raise error.general('cannot find RTEMS tools path: %s' %
(rtems_tools_bin))
self.opts.defaults['rtems_tools'] = rtems_tools_bin
self.config = config.file(self.report, self.bsp_config, self.opts)
def report_finished(reports, report_mode, reporting, finished, job_trace):
processing = True
while processing:
processing = False
reported = []
for tst in finished:
if tst not in reported and \
(reporting < 0 or tst.index == reporting):
if job_trace:
log.notice('}} %*d: %s: %s (%d)' % (len(str(tst.total)), tst.index,
path.basename(tst.executable),
'reporting',
reporting))
processing = True
reports.log(tst.executable, report_mode)
reported += [tst]
reporting += 1
finished[:] = [t for t in finished if t not in reported]
if len(reported):
del reported[:]
if job_trace:
print('}} threading:', threading.active_count())
for t in threading.enumerate():
print('}} ', t.name)
return reporting
def start(self, index, total, name, executable, bsp_arch, bsp):
header = '[%*d/%*d] p:%-*d f:%-*d t:%-*d i:%-*d | %s/%s: %s' % \
(len(str(total)), index,
len(str(total)), total,
len(str(total)), self.passed,
len(str(total)), self.failed,
len(str(total)), self.timeouts,
len(str(total)), self.invalids,
bsp_arch,
bsp,
path.basename(executable))
self.lock.acquire()
if name in self.results:
self.lock.release()
raise error.general('duplicate test: %s' % (name))
self.results[name] = { 'index': index,
'bsp': bsp,
'bsp_arch': bsp_arch,
'exe': executable,
'start': datetime.datetime.now(),
'end': None,
'result': None,
'output': None,
'header': header }
self.lock.release()
log.notice(header, stdout_only = True)
def fdt_convert(self, image, fdt):
dst = path.join(path.abspath(self['build']), path.basename(fdt))
self['fdt_build'] = dst
log.output('Copy (into build): %s -> %s' % (fdt, dst))
image.clean_path(dst)
path.copy(fdt, dst)
return self['fdt_image'].replace('@FDT@', dst)
def log(self, name, mode):
status_fails = [
'failed', 'timeout', 'invalid', 'wrong-version', 'wrong-build',
'wrong-tools'
]
if mode != 'none':
self.lock.acquire()
if name not in self.results:
self.lock.release()
raise error.general('test report missing: %s' % (name))
exe = path.basename(self.results[name]['exe'])
result = self.results[name]['result']
time = self.results[name]['end'] - self.results[name]['start']
failed = result in status_fails
result = 'Result: %-10s Time: %s %s' % (result, str(time), exe)
if mode != 'none':
header = self.results[name]['header']
if mode == 'all' or failed:
output = self.results[name]['output']
else:
output = None
self.lock.release()
if header:
log.output(header)
if output:
log.output(result)
log.output(output)
def start(self, index, total, name, executable, bsp_arch, bsp):
header = '[%*d/%*d] p:%-*d f:%-*d t:%-*d i:%-*d | %s/%s: %s' % \
(len(str(total)), index,
len(str(total)), total,
len(str(total)), self.passed,
len(str(total)), self.failed,
len(str(total)), self.timeouts,
len(str(total)), self.invalids,
bsp_arch,
bsp,
path.basename(executable))
self.lock.acquire()
if name in self.results:
self.lock.release()
raise error.general('duplicate test: %s' % (name))
self.results[name] = {
'index': index,
'bsp': bsp,
'bsp_arch': bsp_arch,
'exe': executable,
'start': datetime.datetime.now(),
'end': None,
'result': None,
'output': None,
'header': header
}
self.lock.release()
log.notice(header, stdout_only=True)
def install(self, src, dst):
src_base = path.basename(src)
log.notice('Install: %s' % (src_base))
asrc = path.abspath(src)
adst = path.join(path.abspath(dst), src_base)
log.output('Copy: %s -> %s' % (asrc, adst))
path.copy(asrc, adst)
def list_bsps(opts):
path_ = opts.defaults.expand('%%{_configdir}/bsps/*.mc')
bsps = path.collect_files(path_)
log.notice(' BSP List:')
for bsp in bsps:
log.notice(' %s' % (path.basename(bsp[:-3])))
raise error.exit()
def report_finished(reports, report_mode, reporting, finished, job_trace):
processing = True
while processing:
processing = False
reported = []
for tst in finished:
if tst not in reported and \
(reporting < 0 or tst.index == reporting):
if job_trace:
log.notice('}} %*d: %s: %s (%d)' % (len(str(tst.total)), tst.index,
path.basename(tst.executable),
'reporting',
reporting))
processing = True
reports.log(tst.executable, report_mode)
reported += [tst]
reporting += 1
finished[:] = [t for t in finished if t not in reported]
if len(reported):
del reported[:]
if job_trace:
print('}} threading:', threading.active_count())
for t in threading.enumerate():
print('}} ', t.name)
return reporting
def install_text(self, text, dst):
dst_base = path.basename(dst)
log.notice('Install: %s' % (dst_base))
adst = path.abspath(dst)
log.output('Copy: text[%d] -> %s' % (len(text), adst))
log.output([' ] ' + l for l in text])
with open(adst, "w") as o:
o.write(os.linesep.join(text))
def end(self, name, output):
start = False
end = False
timeout = False
prefixed_output = []
for line in output:
if line[0] == ']':
if line[1].startswith('*** '):
if line[1][4:].startswith('END OF '):
end = True
if line[1][4:].startswith('TIMEOUT TIMEOUT'):
timeout = True
else:
start = True
prefixed_output += [line[0] + ' ' + line[1]]
self.lock.acquire()
if name not in self.results:
self.lock.release()
raise error.general('test report missing: %s' % (name))
if self.results[name]['end'] is not None:
self.lock.release()
raise error.general('test already finished: %s' % (name))
self.results[name]['end'] = datetime.datetime.now()
if start and end:
status = 'passed'
self.passed += 1
elif timeout:
status = 'timeout'
self.timeouts += 1
elif start:
if not end:
status = 'failed'
self.failed += 1
else:
if self.invalid_tests and path.basename(
name) in self.invalid_tests:
status = 'passed'
self.passed += 1
else:
status = 'invalid'
self.invalids += 1
self.results[name]['result'] = status
self.results[name]['output'] = prefixed_output
if self.name_max_len < len(path.basename(name)):
self.name_max_len = len(path.basename(name))
self.lock.release()
def end(self, name, output):
start = False
end = False
timeout = False
prefixed_output = []
for line in output:
if line[0] == ']':
if line[1].startswith('*** '):
if line[1][4:].startswith('END OF '):
end = True
if line[1][4:].startswith('TIMEOUT TIMEOUT'):
timeout = True
else:
start = True
prefixed_output += [line[0] + ' ' + line[1]]
self.lock.acquire()
if name not in self.results:
self.lock.release()
raise error.general('test report missing: %s' % (name))
if self.results[name]['end'] is not None:
self.lock.release()
raise error.general('test already finished: %s' % (name))
self.results[name]['end'] = datetime.datetime.now()
if start and end:
status = 'passed'
self.passed += 1
elif timeout:
status = 'timeout'
self.timeouts += 1
elif start:
if not end:
status = 'failed'
self.failed += 1
else:
if self.invalid_tests and path.basename(name) in self.invalid_tests:
status = 'passed'
self.passed += 1
else:
status = 'invalid'
self.invalids += 1
self.results[name]['result'] = status
self.results[name]['output'] = prefixed_output
if self.name_max_len < len(path.basename(name)):
self.name_max_len = len(path.basename(name))
self.lock.release()
def kernel_convert(self, image, kernel):
dst = path.join(path.abspath(self['build']), path.basename(kernel))
self['kernel_build'] = dst
log.output('Copy (into build): %s -> %s' % (kernel, dst))
image.clean_path(dst)
path.copy(kernel, dst)
cmds = self.filter_text(self.comma_split(self['kernel_converter']))
for cmd in cmds:
_command(cmd, self['build'])
return self['kernel_image'].replace('@KERNEL@', dst)
def _link_executables(self):
log.notice("Linking executables to " + self.traces_dir)
for exe in self.executables:
dst = path.join(self.traces_dir, path.basename(exe))
try:
os.link(exe, dst)
except OSError, e:
log.stderr("creating hardlink from " + path.abspath(exe) +
" to " + dst + " failed!")
raise
def filter_text(self, lines):
out = []
for line in lines:
if '@KERNEL@' in line:
line = line.replace('@KERNEL@', path.basename(self['kernel']))
if '@KERNEL_IMAGE@' in line:
line = line.replace('@KERNEL_IMAGE@', self.kernel_image())
if '@FDT@' in line:
line = line.replace('@FDT@', path.basename(self['fdt']))
if '@FDT_IMAGE@' in line:
line = line.replace('@FDT_IMAGE@', self.fdt_image())
if '@NET_SERVER_IP@' in line and self['net_server_ip'] is not None:
line = line.replace('@NET_SERVER_IP@', self['net_server_ip'])
if '@NET_IP@' in line and self['net_ip'] is not None:
line = line.replace('@NET_IP@', self['net_ip'])
if '@NET_BOOTEXE@' in line and self['net_exe'] is not None:
line = line.replace('@NET_BOOTEXE@', self['net_exe'])
if '@NET_BOOTFDT@' in line and self['net_fdt'] is not None:
line = line.replace('@NET_BOOTFDT@', self['net_fdt'])
out += [line]
return out
def load(bsp, opts):
mandatory = ['bsp', 'arch', 'tester']
cfg = configuration.configuration()
path_ = opts.defaults.expand('%%{_configdir}/bsps/%s.ini' % (bsp))
ini_name = path.basename(path_)
for p in path.dirname(path_).split(':'):
if path.exists(path.join(p, ini_name)):
cfg.load(path.join(p, ini_name))
if not cfg.has_section(bsp):
raise error.general('bsp section not found in ini: [%s]' %
(bsp))
item_names = cfg.get_item_names(bsp, err=False)
for m in mandatory:
if m not in item_names:
raise error.general(
'mandatory item not found in bsp section: %s' % (m))
opts.defaults.set_write_map(bsp, add=True)
for i in cfg.get_items(bsp, flatten=False):
opts.defaults[i[0]] = i[1]
if not opts.defaults.set_read_map(bsp):
raise error.general('cannot set BSP read map: %s' % (bsp))
# Get a copy of the required fields we need
requires = cfg.comma_list(bsp, 'requires', err=False)
del cfg
user_config = opts.find_arg('--user-config')
if user_config is not None:
user_config = path.expanduser(user_config[1])
if not path.exists(user_config):
raise error.general(
'cannot find user configuration file: %s' %
(user_config))
else:
if 'HOME' in os.environ:
user_config = path.join(os.environ['HOME'],
'.rtemstesterrc')
if user_config:
if path.exists(user_config):
cfg = configuration.configuration()
cfg.load(user_config)
if cfg.has_section(bsp):
for i in cfg.get_items(bsp, flatten=False):
opts.defaults[i[0]] = i[1]
# Check for the required values.
for r in requires:
if opts.defaults.get(r) is None:
raise error.general('user value missing, BSP %s requires \'%s\': missing: %s' % \
(bsp, ', '.join(requires), r))
return opts.defaults['bsp']
raise error.general('cannot find bsp configuration file: %s.ini' % (bsp))
def log(self, name, mode):
if mode != 'none':
self.lock.acquire()
if name not in self.results:
self.lock.release()
raise error.general('test report missing: %s' % (name))
exe = path.basename(self.results[name]['exe'])
result = self.results[name]['result']
time = self.results[name]['end'] - self.results[name]['start']
if mode != 'none':
header = self.results[name]['header']
if mode == 'all' or result != 'passed':
output = self.results[name]['output']
else:
output = None
self.lock.release()
if header:
log.output(header)
if output:
log.output(output)
log.output('Result: %-10s Time: %s %s' % (result, str(time), exe))
def __init__(self, index, total, report, executable, rtems_tools, bsp, bsp_config, opts):
self.index = index
self.total = total
self.report = report
self.bsp = bsp
self.bsp_config = bsp_config
self.opts = copy.copy(opts)
self.opts.defaults['test_index'] = str(index)
self.opts.defaults['test_total'] = str(total)
self.opts.defaults['bsp'] = bsp
self.opts.defaults['bsp_arch'] = '%%{%s_arch}' % (bsp)
self.opts.defaults['bsp_opts'] = '%%{%s_opts}' % (bsp)
if not path.isfile(executable):
raise error.general('cannot find executable: %s' % (executable))
self.opts.defaults['test_executable'] = executable
self.opts.defaults['test_executable_name'] = path.basename(executable)
if rtems_tools:
rtems_tools_bin = path.join(self.opts.defaults.expand(rtems_tools), 'bin')
if not path.isdir(rtems_tools_bin):
raise error.general('cannot find RTEMS tools path: %s' % (rtems_tools_bin))
self.opts.defaults['rtems_tools'] = rtems_tools_bin
self.config = config.file(self.report, self.bsp_config, self.opts)
def log(self, name, mode):
if mode != 'none':
self.lock.acquire()
if name not in self.results:
self.lock.release()
raise error.general('test report missing: %s' % (name))
exe = path.basename(self.results[name]['exe'])
result = self.results[name]['result']
time = self.results[name]['end'] - self.results[name]['start']
if mode != 'none':
header = self.results[name]['header']
if mode == 'all' or result != 'passed':
output = self.results[name]['output']
else:
output = None
self.lock.release()
if header:
log.output(header)
if output:
log.output(output)
log.output('Result: %-10s Time: %s %s' %
(result, str(time), exe))
def start(self, index, total, name, executable, bsp_arch, bsp,
show_header):
header = '[%*d/%*d] p:%-*d f:%-*d u:%-*d e:%-*d I:%-*d B:%-*d ' \
't:%-*d L:%-*d i:%-*d W:%-*d | %s/%s: %s' % \
(len(str(total)), index,
len(str(total)), total,
len(str(total)), self.passed,
len(str(total)), self.failed,
len(str(total)), self.user_input,
len(str(total)), self.expected_fail,
len(str(total)), self.indeterminate,
len(str(total)), self.benchmark,
len(str(total)), self.timeouts,
len(str(total)), self.test_too_long,
len(str(total)), self.invalids,
len(str(total)), self.wrong_version + self.wrong_build + self.wrong_tools,
bsp_arch,
bsp,
path.basename(name))
self.lock.acquire()
if name in self.results:
self.lock.release()
raise error.general('duplicate test: %s' % (name))
self.results[name] = {
'index': index,
'bsp': bsp,
'bsp_arch': bsp_arch,
'exe': name,
'start': datetime.datetime.now(),
'end': None,
'result': None,
'output': None,
'header': header
}
self.lock.release()
if show_header:
log.notice(header, stdout_only=True)
def _check_exe(_opts, macro, value, constraint, silent=False):
if len(value) == 0 or constraint == 'none':
return True
orig_value = value
if path.isabspath(value):
if path.isfile(value):
return True
if os.name == 'nt':
if path.isfile('%s.exe' % (value)):
return True
value = path.basename(value)
absexe = True
else:
absexe = False
paths = os.environ['PATH'].split(os.pathsep)
if _check_paths(value, paths):
if absexe:
if not silent:
log.notice(
'warning: exe: absolute exe found in path: (%s) %s' %
(macro, orig_value))
return True
if constraint == 'optional':
if not silent:
log.trace('warning: exe: optional exe not found: (%s) %s' %
(macro, orig_value))
return True
if not silent:
log.notice('error: exe: not found: (%s) %s' % (macro, orig_value))
return False
def fdt_image(self):
return self['fdt_image'].replace('@FDT@', path.basename(self['fdt']))
def end(self, name, output, output_prefix):
start = False
end = False
state = None
version = None
build = None
tools = None
timeout = False
prefixed_output = []
for line in output:
if line[0] == output_prefix:
if line[1].startswith('*** '):
banner = line[1][4:]
if banner.startswith('BEGIN OF '):
start = True
elif line[1][4:].startswith('END OF '):
end = True
elif banner.startswith('TIMEOUT TIMEOUT'):
timeout = True
elif banner.startswith('TEST VERSION:'):
version = banner[13:].strip()
elif banner.startswith('TEST STATE:'):
state = banner[11:].strip()
elif banner.startswith('TEST BUILD:'):
build = ','.join(banner[11:].strip().split(' '))
elif banner.startswith('TEST TOOLS:'):
tools = banner[11:].strip()
prefixed_output += [line[0] + ' ' + line[1]]
self.lock.acquire()
try:
if name not in self.results:
raise error.general('test report missing: %s' % (name))
if self.results[name]['end'] is not None:
raise error.general('test already finished: %s' % (name))
self.results[name]['end'] = datetime.datetime.now()
if state is not None and state not in [
'BENCHMARK', 'EXPECTED_FAIL', 'INDETERMINATE', 'USER_INPUT'
]:
if version:
if 'version' not in self.config:
self.config['version'] = version
else:
if version != self.config['version']:
state = 'WRONG-VERSION'
if build:
if 'build' not in self.config:
self.config['build'] = build
else:
if build != self.config['build']:
state = 'WRONG-BUILD'
if tools:
if 'tools' not in self.config:
self.config['tools'] = tools
else:
if tools != self.config['tools']:
state = 'WRONG-TOOLS'
if state is None or state == 'EXPECTED-PASS':
if start and end:
if state is None or state == 'EXPECTED-PASS':
status = 'passed'
self.passed += 1
elif timeout:
status = 'timeout'
self.timeouts += 1
elif start:
if not end:
status = 'failed'
self.failed += 1
else:
exe_name = path.basename(name).split('.')[0]
if exe_name in test_fail_excludes:
status = 'passed'
self.passed += 1
else:
status = 'invalid'
self.invalids += 1
else:
if state == 'EXPECTED_FAIL':
if start and end:
status = 'passed'
self.passed += 1
else:
status = 'expected-fail'
self.expected_fail += 1
elif state == 'USER_INPUT':
status = 'user-input'
self.user_input += 1
elif state == 'INDETERMINATE':
if start and end:
status = 'passed'
self.passed += 1
else:
status = 'indeterminate'
self.indeterminate += 1
elif state == 'BENCHMARK':
status = 'benchmark'
self.benchmark += 1
elif state == 'WRONG-VERSION':
status = 'wrong-version'
self.wrong_version += 1
elif state == 'WRONG-BUILD':
status = 'wrong-build'
self.wrong_build += 1
elif state == 'WRONG-TOOLS':
status = 'wrong-tools'
self.wrong_tools += 1
else:
raise error.general('invalid test state: %s: %s' %
(name, state))
self.results[name]['result'] = status
self.results[name]['output'] = prefixed_output
if self.name_max_len < len(path.basename(name)):
self.name_max_len = len(path.basename(name))
finally:
self.lock.release()
return status
def end(self, name, output):
start = False
end = False
state = None
timeout = False
prefixed_output = []
for line in output:
if line[0] == ']':
if line[1].startswith('*** '):
if line[1][4:].startswith('END OF '):
end = True
if line[1][4:].startswith('TEST STATE:'):
state = line[1][15:].strip()
if line[1][4:].startswith('TIMEOUT TIMEOUT'):
timeout = True
else:
start = True
prefixed_output += [line[0] + ' ' + line[1]]
self.lock.acquire()
if name not in self.results:
self.lock.release()
raise error.general('test report missing: %s' % (name))
if self.results[name]['end'] is not None:
self.lock.release()
raise error.general('test already finished: %s' % (name))
self.results[name]['end'] = datetime.datetime.now()
if state is None:
if start and end:
if state is None:
status = 'passed'
self.passed += 1
elif timeout:
status = 'timeout'
self.timeouts += 1
elif start:
if not end:
status = 'failed'
self.failed += 1
else:
status = 'invalid'
self.invalids += 1
else:
if state == 'EXPECTED_FAIL':
if start and end:
status = 'passed'
self.passed += 1
else:
status = 'expected-fail'
self.expected_fail += 1
elif state == 'USER_INPUT':
status = 'user-input'
self.user_input += 1
elif state == 'INDETERMINATE':
if start and end:
status = 'passed'
self.passed += 1
else:
status = 'indeterminate'
self.indeterminate += 1
elif state == 'BENCHMARK':
status = 'benchmark'
self.benchmark += 1
else:
raise error.general('invalid test state: %s: %s' %
(name, state))
self.results[name]['result'] = status
self.results[name]['output'] = prefixed_output
if self.name_max_len < len(path.basename(name)):
self.name_max_len = len(path.basename(name))
self.lock.release()
def show_state(results, state, max_len):
for name in results:
if results[name]['result'] == state:
log.output(' %s' % (path.basename(name)))
def run(self):
self.thread = threading.Thread(target = self.runner,
name = 'test[%s]' % path.basename(self.executable))
self.thread.start()
def run(self):
name = 'test[%s]' % path.basename(self.executable)
self.thread = threading.Thread(target=self.runner, name=name)
self.thread.start()
def show_state(results, state, max_len):
for name in results:
if results[name]['result'] == state:
log.output(' %s' % (path.basename(name)))
def kernel_image(self):
return self['kernel_image'].replace('@KERNEL@',
path.basename(self['kernel']))
def show_state(results, state, max_len):
l = []
for name in results:
if results[name]['result'] == state:
l += [' %s' % (path.basename(name))]
return l
def load(self, name):
def common_end(left, right):
end = ''
while len(left) and len(right):
if left[-1] != right[-1]:
return end
end = left[-1] + end
left = left[:-1]
right = right[:-1]
return end
if self.load_depth == 0:
self.in_error = False
self.lc = 0
self.name = name
self.conditionals = {}
self.load_depth += 1
save_name = self.name
save_lc = self.lc
self.name = name
self.lc = 0
#
# Locate the config file. Expand any macros then add the
# extension. Check if the file exists, therefore directly
# referenced. If not see if the file contains ':' or the path
# separator. If it does split the path else use the standard config dir
# path in the defaults.
#
exname = self.expand(name)
#
# Macro could add an extension.
#
if exname.endswith('.cfg'):
configname = exname
else:
configname = '%s.cfg' % (exname)
name = '%s.cfg' % (name)
if ':' in configname:
cfgname = path.basename(configname)
else:
cfgname = common_end(configname, name)
if not path.exists(configname):
if ':' in configname:
configdirs = path.dirname(configname).split(':')
else:
configdirs = self.define('_configdir').split(':')
for cp in configdirs:
configname = path.join(path.abspath(cp), cfgname)
if path.exists(configname):
break
configname = None
if configname is None:
raise error.general('no config file found: %s' % (cfgname))
try:
log.trace('config: %s: _open: %s' % (self.init_name, path.host(configname)))
config = open(path.host(configname), 'r')
except IOError as err:
raise error.general('error opening config file: %s' % (path.host(configname)))
self.configpath += [configname]
self._includes += [configname]
try:
dir = None
info = None
data = []
while True:
r = self._parse(config, dir, info)
if r[0] == 'control':
if r[1] == '%end':
break
log.warning("unexpected '%s'" % (r[1]))
elif r[0] == 'directive':
if r[1] == '%include':
self.load(r[2][0])
continue
dir, info, data = self._process_directive(r, dir, info, data)
elif r[0] == 'data':
dir, info, data = self._process_data(r, dir, info, data)
else:
self._error("%d: invalid parse state: '%s" % (self.lc, r[0]))
if dir is not None:
self._directive_extend(dir, data)
except:
config.close()
raise
config.close()
self.name = save_name
self.lc = save_lc
self.load_depth -= 1
def __init__(self, base_path = None, argv = None, optargs = None,
defaults = None, long_opts = None, long_opts_help = None,
command_path = '', log_default = None):
if argv is None:
return
global basepath
if long_opts == None:
long_opts = {}
basepath = base_path
if log_default is not None and type(log_default) is not list:
raise error.general('log default is not a list')
self.log_default = log_default
if defaults is None:
defaults = macros.macros()
self.long_opts = {
# key macro handler param defs init
'--jobs' : ('_jobs', self._lo_jobs, True, 'default', True),
'--log' : ('_logfile', self._lo_string, True, None, False),
'--macros' : ('_macros', self._lo_string, True, None, False),
'--force' : ('_force', self._lo_bool, False, '0', True),
'--quiet' : ('_quiet', self._lo_bool, False, '0', True),
'--trace' : ('_trace', self._lo_bool, False, '0', True),
'--dry-run' : ('_dry_run', self._lo_bool, False, '0', True),
'--warn-all' : ('_warn_all', self._lo_bool, False, '0', True),
'--no-clean' : ('_no_clean', self._lo_bool, False, '0', True),
'--keep-going' : ('_keep_going', self._lo_bool, False, '0', True),
'--always-clean' : ('_always_clean', self._lo_bool, False, '0', True),
'--no-install' : ('_no_install', self._lo_bool, False, '0', True),
'--help' : (None, self._lo_help, False, None, False)
}
self.long_opts_help = {
'--force': 'Force the build to proceed',
'--quiet': 'Quiet output (not used)',
'--trace': 'Trace the execution',
'--dry-run': 'Do everything but actually run the build',
'--warn-all': 'Generate warnings',
'--no-clean': 'Do not clean up the build tree',
'--always-clean': 'Always clean the build tree, even with an error',
'--keep-going': 'Do not stop on an error.',
'--jobs=[0..n,none,half,full]': 'Run with specified number of jobs, default: num CPUs.',
'--macros file[,file]': 'Macro format files to load after the defaults',
'--log file': 'Log file where all build output is written to',
}
self.opts = { 'params' : [] }
self.command_path = command_path
self.command_name = path.basename(argv[0])
self.argv = argv
self.args = argv[1:]
self.optargs = optargs
self.defaults = defaults
for lo in self.long_opts:
self.opts[lo[2:]] = self.long_opts[lo][3]
if self.long_opts[lo][4]:
self.defaults[self.long_opts[lo][0]] = ('none', 'none', self.long_opts[lo][3])
for lo in long_opts:
if lo in self.long_opts:
raise error.general('suplicate option: %s' % (lo))
self.opts[lo[2:]] = long_opts[lo][3]
if long_opts[lo][4]:
self.defaults[long_opts[lo][0]] = ('none', 'none', long_opts[lo][3])
if long_opts[lo][1] == 'int':
handler = self._lo_int
elif long_opts[lo][1] == 'string':
handler = self._lo_string
elif long_opts[lo][1] == 'path':
handler = self._lo_path
elif long_opts[lo][1] == 'jobs':
handler = self._lo_jobs
elif long_opts[lo][1] == 'bool':
handler = self._lo_bool
elif long_opts[lo][1] == 'triplet':
handler = self._lo_triplets
else:
raise error.general('invalid option handler: %s: %s' % (lo, long_opts[lo][1]))
self.long_opts[lo] = (long_opts[lo][0], handler, long_opts[lo][2],
long_opts[lo][3], long_opts[lo][4])
if long_opts_help is not None:
if lo not in long_opts_help:
raise error.general('no help for option: %s' % (lo))
self.long_opts_help[lo] = long_opts_help[lo]
def _name_line_msg(self, msg):
return '%s:%d: %s' % (path.basename(self.init_name), self.lc, msg)
