def run(self, setName, covoarConfigFile, symbolFile):
covoarResultDir = path.join(self.baseResultDir, setName)
if (not path.exists(covoarResultDir)):
path.mkdir(covoarResultDir)
if (not path.exists(symbolFile)):
log.stderr("Symbol set file: " + symbolFile + " doesn't exists! Covoar can not be run!")
log.stderr("Skipping " + setName)
return
command = "covoar -C" + covoarConfigFile + " -S " + symbolFile + " -O " + covoarResultDir + " " + path.join(self.tracesDir, "*.exe")
log.notice("Running covoar for " + setName, stdout_only=True)
log.notice(command, stdout_only=True)
executor = execute.execute(verbose=True, output=output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
shutil.copy2(path.join(self.covoarSrcDir, 'table.js'), path.join(covoarResultDir, 'table.js'))
shutil.copy2(path.join(self.covoarSrcDir, 'covoar.css'), path.join(covoarResultDir, 'covoar.css'))
log.notice("Coverage run for " + setName + " finished ")
status = "success"
if (exit_code[0] != 0):
status = "failure. Error code: " + str(exit_code[0])
log.notice("Coverage run for " + setName + " finished " + status)
log.notice("-----------------------------------------------")
def run():
import sys
try:
#
# Run where defaults.mc is located
#
long_opts = {
# key macro handler param defs init
'--file' : ('_file', 'path', True, None, False)
}
opts = options.command_line(base_path = '.',
argv = sys.argv,
long_opts = long_opts)
options.load(opts)
s = file(opts.defaults['_file'], opts)
s.load(opts.defaults['_file'])
print(s)
del s
except error.general as gerr:
print(gerr)
sys.exit(1)
except error.internal as ierr:
print(ierr)
sys.exit(1)
except KeyboardInterrupt:
log.notice('abort: user terminated')
sys.exit(1)
sys.exit(0)
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(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 _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 install_configuration(self, image, mountpoint):
uenv_txt = self['uenv_txt']
if uenv_txt is not None:
log.output('Uenv txt: %s' % (uenv_txt))
image.install(path.abspath(uenv_txt), mountpoint)
else:
template = None
if self['net_dhcp'] or self['net_ip'] is not None:
if self['net_dhcp']:
template = 'uenv_net_dhcp'
else:
template = 'uenv_net_static'
if self['net_server_ip']:
template += '_sip'
if self['net_fdt']:
template += '_net_fdt'
else:
if self['kernel'] is not None:
template = 'uenv_exe'
elif self['fdt'] is not None:
template = 'uenv'
if self['fdt'] is not None:
template += '_fdt'
if template is not None:
log.notice('Uenv template: %s' % (template))
uenv_start = self.comma_split(self['uenv_start'])
uenv_body = self.comma_split(self[template])
uenv_end = self.comma_split(self['uenv_end'])
uenv = uenv_start + uenv_body + uenv_end
image.install_text(self.filter_text(uenv),
path.join(mountpoint, self['boot_config']))
def _generate_reports(self, symbol_sets):
log.notice('Coverage generating reports')
if self.report_format == 'html':
report = report_gen_html(symbol_sets, self.build_dir, self.rtdir,
self.macros['bsp'])
report.generate()
report.add_covoar_css()
def _generate_reports(self):
log.notice('Generating reports')
if self.report_format == 'html':
report = report_gen_html(self.symbol_sets, self.target_dir,
self.rtdir)
report.generate()
report.add_covoar_src_path()
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 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 parse(self):
if (not path.exists(self.summary_file_path)):
log.notice('summary file %s does not exist!' %
(self.summary_file_path))
self.is_failure = True
return
with open(self.summary_file_path, 'r') as summary_file:
self.bytes_analyzed = self._get_next_with_colon(summary_file)
self.bytes_not_executed = self._get_next_with_colon(summary_file)
self.percentage_executed = self._get_next_with_colon(summary_file)
self.percentage_not_executed = self._get_next_with_colon(
summary_file)
self.ranges_uncovered = self._get_next_with_colon(summary_file)
self.branches_total = self._get_next_with_colon(summary_file)
self.branches_uncovered = self._get_next_with_colon(summary_file)
self.branches_always_taken = self._get_next_without_colon(
summary_file)
self.branches_never_taken = self._get_next_without_colon(
summary_file)
if len(self.branches_uncovered) > 0 and len(self.branches_total) > 0:
self.percentage_branches_covered = \
1 - (float(self.branches_uncovered) / float(self.branches_total))
else:
self.percentage_branches_covered = 0.0
return
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 run(self, set_name, covoar_config_file, symbol_file, gcnos_file):
covoar_result_dir = path.join(self.base_result_dir, set_name)
if (not path.exists(covoar_result_dir)):
path.mkdir(covoar_result_dir)
if (not path.exists(symbol_file)):
log.stderr("Symbol set file: " + symbol_file +
" doesn't exists! Covoar can not be run!")
log.stderr("Skipping " + set_name)
return
command = "covoar -v -C" + covoar_config_file + " -S " + symbol_file + " -O " + covoar_result_dir + " " + path.join(
self.traces_dir, "*.exe")
if (path.exists(gcnos_file)):
command = command + " -g " + gcnos_file
log.notice("Running covoar for " + set_name, stdout_only=True)
log.notice(command, stdout_only=True)
executor = execute.execute(verbose=True, output=output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
shutil.copy2(path.join(self.covoar_src_dir, 'table.js'),
path.join(covoar_result_dir, 'table.js'))
shutil.copy2(path.join(self.covoar_src_dir, 'covoar.css'),
path.join(covoar_result_dir, 'covoar.css'))
log.notice("Coverage run for " + set_name + " finished ")
status = "success"
if (exit_code[0] != 0):
status = "failure. Error code: " + str(exit_code[0])
log.notice("Coverage run for " + set_name + " finished " + status)
log.notice("-----------------------------------------------")
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 run(args):
try:
long_opts = {
# key macro handler param defs init
'--test-path' : ('_test_path', 'path', True, None, False),
'--test-jobs' : ('_test_jobs', 'jobs', True, 'max', True),
'--test-bool' : ('_test_bool', 'bool', False, '0', True)
}
opts = command_line(base_path = '.',
argv = args,
optargs = None,
defaults = macros.macros(),
long_opts = long_opts,
command_path = '.')
load(opts)
log.notice('RTEMS Tools Project - Defaults, v%s' % (version.string()))
opts.log_info()
log.notice('Options:')
log.notice(str(opts))
log.notice('Defaults:')
log.notice(str(opts.defaults))
except error.general as gerr:
print(gerr)
sys.exit(1)
except error.internal as ierr:
print(ierr)
sys.exit(1)
except error.exit:
pass
except KeyboardInterrupt:
_notice(opts, 'abort: user terminated')
sys.exit(1)
sys.exit(0)
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 _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 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 _cleanup(self):
if not self.no_clean:
log.notice('***Cleaning tempfiles***')
path.removeall(self.traces_dir)
for exe in self.executables:
trace_file = exe + '.cov'
if path.exists(trace_file):
os.remove(trace_file)
def _check_dir(_opts, macro, value, constraint, silent=False):
if constraint != 'none' and not path.isdir(value):
if constraint == 'required':
if not silent:
log.notice('error: dir: not found: (%s) %s' % (macro, value))
return False
if not silent and _opts.warn_all():
log.notice('warning: dir: not found: (%s) %s' % (macro, value))
return True
def build(self):
for arch in self.config.archs():
self.build_arch(arch)
log.notice('^ Profile Time %s' % (str(end - start)))
log.notice('+ warnings:%d exes:%d objs:%d libs:%d' % \
(self.warnings.get(), self.counts['exes'],
self.counts['objs'], self.counts['libs']))
log.output('Profile Warnings:')
log.output(self.warnings.report())
def build(self):
for arch in self.config.archs():
self.build_arch(arch)
log.notice('^ Profile Time %s' % (str(end - start)))
log.notice('+ warnings:%d exes:%d objs:%d libs:%d' % \
(self.warnings.get(), self.counts['exes'],
self.counts['objs'], self.counts['libs']))
log.output('Profile Warnings:')
log.output(self.warnings.report())
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 run(args):
try:
_opts = load(args=args, defaults=defaults_mc)
log.notice("RTEMS Test - Defaults, v%s" % (version.str()))
_opts.log_info()
log.notice("Options:")
log.notice(str(_opts))
log.notice("Defaults:")
log.notice(str(_opts.defaults))
except error.general, gerr:
print gerr
sys.exit(1)
def _check_exes(exes):
ok = True
first = True
for exe in exes:
log.output('check exe: %s' % (exe))
if not check.check_exe(None, exe):
if first:
log.notice('Host executable(s) not found:')
first = False
log.notice(' %s' % (exe))
ok = False
return ok
def run(args):
try:
_opts = load(args = args, defaults = 'rtems/testing/defaults.mc')
log.notice('RTEMS Test - Defaults, v%s' % (version.str()))
_opts.log_info()
log.notice('Options:')
log.notice(str(_opts))
log.notice('Defaults:')
log.notice(str(_opts.defaults))
except error.general, gerr:
print gerr
sys.exit(1)
def cleanup(self):
log.notice('Cleaning up')
for m in self.unmount_paths:
log.output('unmount: %s' % (m))
self.unmount(m)
for i in self.detach_images:
log.output('detach: %s' % (i))
self.image_detach(i)
if self.loader.clean:
for r in self.remove_paths:
if path.exists(r):
log.output('remove: %s' % (r))
path.removeall(r)
def is_valid(self):
if len(self.name) == 0:
raise error.general('symbol set has no name in symbol_sets.cfg')
if len(self.libs) == 0:
raise error.general(
'symbol set contains no libraries to analyse in symbol_sets.cfg'
)
for lib in self.libs:
if not path.exists(lib):
log.notice('Invalid library path: %s in symbol_sets.cfg' %
(lib))
return False
return True
def report(self):
self.lock.acquire()
log_lock.acquire()
passes = self.pass_count()
fails = self.fail_count()
log.notice('Passes: %d Failures: %d' % (passes, fails))
log.output()
log.output('Build Report')
log.output(' Passes: %d Failures: %d' % (passes, fails))
log.output(' Failures:')
if fails == 0:
log.output(' None')
else:
max_col = self._max_col('fails')
for build in self.errors['fails']:
arch, bsp, build_config = arch_bsp_build_parse(build)
arch_bsp = self._arch_bsp(arch, bsp)
for f in self.errors['fails'][build]:
config_cmd = f[2]
config_at = config_cmd.find('configure')
if config_at != -1:
config_cmd = config_cmd[config_at:]
log.output(' %*s:' % (max_col + 2, arch_bsp))
s1 = ' ' * 6
log.output(wrap([s1, config_cmd], lineend='\\', width=75))
if f[3] is not None:
s1 = ' ' * len(s1)
for msg in f[3]:
log.output(wrap([s1, msg], lineend='\\'))
log.output(' Passes:')
if passes == 0:
log.output(' None')
else:
max_col = self._max_col('passes')
for build in self.errors['passes']:
arch, bsp, build_config = arch_bsp_build_parse(build)
arch_bsp = self._arch_bsp(arch, bsp)
for f in self.errors['passes'][build]:
config_cmd = f[1]
config_at = config_cmd.find('configure')
if config_at != -1:
config_cmd = config_cmd[config_at:]
log.output(' %s (%5d):' % (arch_bsp, f[2]))
log.output(
wrap([' ' * 6, config_cmd], lineend='\\', width=75))
log_lock.release()
self.lock.release()
def start(self):
log.notice('Proxy: %s:%i' % (self.host, self.port))
if self.host == 'all':
host = ''
else:
host = self.host
try:
self.server = udp_server((host, self.port), udp_handler)
except Exception as e:
raise error.general('proxy create: %s' % (e))
self.server.proxy = self
self._lock()
try:
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
finally:
self._unlock()
def handle(self):
client_ip = self.client_address[0]
client_port = self.client_address[1]
client = '%s:%i' % (client_ip, client_port)
session = tftp_session()
finished = session.data(client_ip, client_port, self.request[0])
if not finished:
timeout = session.get_timeout(self.server.proxy.session_timeout, 1)
host = self.server.proxy.get_host(client_ip)
if host is not None:
session_count = self.server.proxy.get_session_count()
log.notice(' ] %6d: session: %s -> %s: start' %
(session_count, client, host))
host_ip, host_server_port = host_port_split(host)
host_port = host_server_port
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(timeout)
log.trace(
' > ' +
session.decode(client_ip, client_port, self.request[0]))
sock.sendto(self.request[0], (host_ip, host_port))
while not finished:
try:
data, address = sock.recvfrom(16 * 1024)
except socket.error as se:
log.notice(' ] session: %s -> %s: error: %s' %
(client, host, se))
return
except socket.gaierror as se:
log.notice(' ] session: %s -> %s: error: %s' %
(client, host, se))
return
except:
return
finished = session.data(address[0], address[1], data)
if address[0] == host_ip:
if host_port == host_server_port:
host_port = address[1]
if address[1] == host_port:
log.trace(
' < ' +
session.decode(address[0], address[1], data))
sock.sendto(data, (client_ip, client_port))
elif address[0] == client_ip and address[1] == client_port:
log.trace(' > ' +
session.decode(address[0], address[1], data))
sock.sendto(data, (host_ip, host_port))
log.notice(' ] %6d: session: %s -> %s: end' %
(session_count, client, host))
else:
mac = getmac.get_mac_address(ip=client_ip)
log.trace(' . request: host not found: %s (%s)' %
(client, mac))
def report(self):
log.notice('* Passes: %d Failures: %d' %
(len(self.passes), len(self.fails)))
log.output()
log.output('Build Report')
log.output(' Passes: %d Failures: %d' %
(len(self.passes), len(self.fails)))
log.output(' Failures:')
if len(self.fails) == 0:
log.output('None')
else:
max_col = 0
for f in self.fails:
arch_bsp = self._arch_bsp(f[0], f[1])
if len(arch_bsp) > max_col:
max_col = len(arch_bsp)
for f in self.fails:
config_cmd = f[2]
config_at = config_cmd.find('configure')
if config_at != -1:
config_cmd = config_cmd[config_at:]
log.output(' %*s: %s' % (max_col + 2,
self._arch_bsp(f[0], f[1]),
config_cmd))
log.output(' Passes:')
if len(self.passes) == 0:
log.output('None')
else:
max_col = 0
for f in self.passes:
arch_bsp = self._arch_bsp(f[0], f[1])
if len(arch_bsp) > max_col:
max_col = len(arch_bsp)
for f in self.passes:
config_cmd = f[2]
config_at = config_cmd.find('configure')
if config_at != -1:
config_cmd = config_cmd[config_at:]
log.output(' %*s: %5d %s' % (max_col + 2,
self._arch_bsp(f[0], f[1]),
f[3],
config_cmd))
def report(self):
log.notice('* Passes: %d Failures: %d' %
(len(self.passes), len(self.fails)))
log.output()
log.output('Build Report')
log.output(' Passes: %d Failures: %d' %
(len(self.passes), len(self.fails)))
log.output(' Failures:')
if len(self.fails) == 0:
log.output('None')
else:
max_col = 0
for f in self.fails:
arch_bsp = self._arch_bsp(f[0], f[1])
if len(arch_bsp) > max_col:
max_col = len(arch_bsp)
for f in self.fails:
config_cmd = f[2]
config_at = config_cmd.find('configure')
if config_at != -1:
config_cmd = config_cmd[config_at:]
log.output(
' %*s: %s' %
(max_col + 2, self._arch_bsp(f[0], f[1]), config_cmd))
log.output(' Passes:')
if len(self.passes) == 0:
log.output('None')
else:
max_col = 0
for f in self.passes:
arch_bsp = self._arch_bsp(f[0], f[1])
if len(arch_bsp) > max_col:
max_col = len(arch_bsp)
for f in self.passes:
config_cmd = f[2]
config_at = config_cmd.find('configure')
if config_at != -1:
config_cmd = config_cmd[config_at:]
log.output(
' %*s: %5d %s' % (max_col + 2, self._arch_bsp(
f[0], f[1]), f[3], config_cmd))
def prepare_environment(self):
symbol_set_files = []
if (path.exists(self.traces_dir)):
path.removeall(self.traces_dir)
path.mkdir(self.traces_dir)
if self.config_map is None:
raise error.general(
'no coverage configuration map specified in %s config file' %
{bsp})
self.symbol_config.load(self.symbol_config_path, self.path_to_builddir)
for sset in self.symbol_config.symbol_sets:
if sset.is_valid():
symbol_set_file = (path.join(self.traces_dir,
sset.name + '.symcfg'))
sset.write_set_file(symbol_set_file)
self.symbol_sets.append(sset.name)
else:
log.notice(
'Invalid symbol set %s in symbol_sets.cfg. skipping covoar run.'
% (sset.name))
log.notice('Coverage environment prepared')
def run(self, set_name, symbol_file):
covoar_result_dir = path.join(self.base_result_dir, set_name)
if not path.exists(covoar_result_dir):
path.mkdir(covoar_result_dir)
if not path.exists(symbol_file):
raise error.general('coverage: no symbol set file: %s' %
(symbol_file))
exe = self._find_covoar()
command = exe + ' -O ' + covoar_result_dir + \
' -p ' + self.project_name + \
' ' + self.executables + ' '
command += self.covoar_cmd
log.notice()
log.notice('Running coverage analysis: %s (%s)' %
(set_name, covoar_result_dir))
start_time = datetime.datetime.now()
executor = execute.execute(verbose=self.trace,
output=self.output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
if exit_code[0] != 0:
raise error.general('coverage: covoar failure:: %d' %
(exit_code[0]))
end_time = datetime.datetime.now()
log.notice('Coverage time: %s' % (str(end_time - start_time)))
def run(args):
import sys
try:
_opts = options.command_line(argv=args)
options.load(_opts)
log.notice('RTEMS Toolkit - Check, v%s' % (version.string()))
if host_setup(_opts):
print('Environment is ok')
else:
print('Environment is not correctly set up')
except error.general as gerr:
print(gerr)
sys.exit(1)
except error.internal as ierr:
print(ierr)
sys.exit(1)
except error.exit:
pass
except KeyboardInterrupt:
log.notice('abort: user terminated')
sys.exit(1)
sys.exit(0)
def summary(self):
def show_state(results, state, max_len):
for name in results:
if results[name]['result'] == state:
log.output(' %s' % (path.basename(name)))
log.output()
log.notice('Passed: %*d' % (self.total_len, self.passed))
log.notice('Failed: %*d' % (self.total_len, self.failed))
log.notice('Timeouts: %*d' % (self.total_len, self.timeouts))
log.notice('Invalid: %*d' % (self.total_len, self.invalids))
log.output('----------%s' % ('-' * self.total_len))
log.notice('Total: %*d' % (self.total_len, self.total))
log.output()
if self.failed:
log.output('Failures:')
show_state(self.results, 'failed', self.name_max_len)
if self.timeouts:
log.output('Timeouts:')
show_state(self.results, 'timeout', self.name_max_len)
if self.invalids:
log.output('Invalid:')
show_state(self.results, 'invalid', self.name_max_len)
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 summary(self):
def show_state(results, state, max_len):
for name in results:
if results[name]['result'] == state:
log.output(' %s' % (path.basename(name)))
log.output()
log.notice('Passed: %*d' % (self.total_len, self.passed))
log.notice('Failed: %*d' % (self.total_len, self.failed))
log.notice('Timeouts: %*d' % (self.total_len, self.timeouts))
log.notice('Invalid: %*d' % (self.total_len, self.invalids))
log.output('----------%s' % ('-' * self.total_len))
log.notice('Total: %*d' % (self.total_len, self.total))
log.output()
if self.failed:
log.output('Failures:')
show_state(self.results, 'failed', self.name_max_len)
if self.timeouts:
log.output('Timeouts:')
show_state(self.results, 'timeout', self.name_max_len)
if self.invalids:
log.output('Invalid:')
show_state(self.results, 'invalid', self.name_max_len)
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 build_arch(self, arch):
start = datetime.datetime.now()
log.output('=' * 70)
log.notice(']] Architecture: %s' % (arch))
if not self.confif.arch_present(arch):
raise error.general('Architecture not found: %s' % (arch))
for bsp in self._bsps(arch):
self.build_arch_bsp(arch, bsp)
log.notice('^ Architecture Time %s' % (str(end - start)))
log.notice(' warnings:%d exes:%d objs:%s libs:%d' % \
self.warnings.get(), self.counts['exes'],
self.counts['objs'], self.counts['libs'])
log.output('Architecture Warnings:')
log.output(self.warnings.report())
def build_profile(self, profile):
if not self.config.profile_present(profile):
raise error.general('BSP not found: %s/%s' % (arch, bsp))
start = datetime.datetime.now()
log.notice(']] Profile: %s' % (profile))
for arch in self.config.profile_archs(profile):
for bsp in self.config.profile_arch_bsps(profile, arch):
self.build_arch_bsp(arch, bsp)
end = datetime.datetime.now()
log.notice('^ Profile Time %s' % (str(end - start)))
log.notice(' warnings:%d exes:%d objs:%d libs:%d' % \
(self.warnings.get(), self.counts['exes'],
self.counts['objs'], self.counts['libs']))
log.output('Profile Warnings:')
log.output(self.warnings.report())
rtdir = command_path),
command_path)
options.load(opts)
return opts
def run(args):
try:
_opts = load(args = args, defaults = 'rtems/testing/defaults.mc')
log.notice('RTEMS Test - Defaults, v%s' % (version.str()))
_opts.log_info()
log.notice('Options:')
log.notice(str(_opts))
log.notice('Defaults:')
log.notice(str(_opts.defaults))
except error.general, gerr:
print gerr
sys.exit(1)
except error.internal, ierr:
print ierr
sys.exit(1)
except error.exit, eerr:
pass
except KeyboardInterrupt:
log.notice('abort: user terminated')
sys.exit(1)
sys.exit(0)
if __name__ == '__main__':
import sys
run(sys.argv)
def build_arch_bsp(self, arch, bsp):
if not self.config.bsp_present(arch, bsp):
raise error.general('BSP not found: %s/%s' % (arch, bsp))
log.output('-' * 70)
log.notice('] BSP: %s/%s' % (arch, bsp))
log.notice('. Creating: %s' % (self._path(arch, bsp)))
self._arch_bsp_dir_clean(arch, bsp)
self._arch_bsp_dir_make(arch, bsp)
variations = self._variations(arch, bsp)
build_set = self._build_set(variations)
bsp_start = datetime.datetime.now()
bsp_warnings = warnings_counter(self.rtems)
env_path = os.environ['PATH']
os.environ['PATH'] = path.host(path.join(self.tools, 'bin')) + \
os.pathsep + os.environ['PATH']
for bs in sorted(build_set.keys()):
warnings = warnings_counter(self.rtems)
start = datetime.datetime.now()
log.output('- ' * 35)
log.notice('. Configuring: %s' % (bs))
try:
result = '+ Pass'
bpath = self._build_dir(arch, bsp, bs)
path.mkdir(bpath)
config_cmd = self._config_command(build_set[bs], arch, bsp)
cmd = config_cmd
e = execute.capture_execution(log = warnings)
log.output('run: ' + cmd)
if self.options['dry-run']:
exit_code = 0
else:
exit_code, proc, output = e.shell(cmd, cwd = path.host(bpath))
if exit_code != 0:
result = '- FAIL'
self.errors['configure'] += 1
log.notice('- Configure failed: %s' % (bs))
log.output('cmd failed: %s' % (cmd))
if self.options['stop-on-error']:
raise error.general('Configuring %s failed' % (bs))
else:
log.notice('. Building: %s' % (bs))
cmd = 'make'
if 'jobs' in self.options:
cmd += ' -j %s' % (self.options['jobs'])
log.output('run: ' + cmd)
if self.options['dry-run']:
exit_code = 0
else:
exit_code, proc, output = e.shell(cmd, cwd = path.host(bpath))
if exit_code != 0:
result = '- FAIL'
self.errors['build'] += 1
log.notice('- FAIL: %s: %s' % (bs, self._error_str()))
log.output('cmd failed: %s' % (cmd))
if self.options['stop-on-error']:
raise error.general('Building %s failed' % (bs))
files = self._count_files(arch, bsp, bs)
log.notice('%s: %s: warnings:%d exes:%d objs:%s libs:%d' % \
(result, bs, warnings.get(),
files['exes'], files['objs'], files['libs']))
log.notice(' %s' % (self._error_str()))
self.results.add(result[0] == '+', arch, bsp, config_cmd, warnings.get())
finally:
end = datetime.datetime.now()
if not self.options['no-clean']:
log.notice('. Cleaning: %s' % (self._build_dir(arch, bsp, bs)))
path.removeall(self._build_dir(arch, bsp, bs))
log.notice('^ Time %s' % (str(end - start)))
log.output('Warnings Report:')
log.output(warnings.report())
warnings.accumulate(bsp_warnings)
warnings.accumulate(self.warnings)
bsp_end = datetime.datetime.now()
log.notice('^ BSP Time %s' % (str(bsp_end - bsp_start)))
log.output('BSP Warnings Report:')
log.output(bsp_warnings.report())
os.environ['PATH'] = env_path
def prepareEnvironment(self):
if(path.exists(self.tracesDir)):
path.removeall(self.tracesDir)
path.mkdir(self.tracesDir)
log.notice("Coverage environment prepared", stdout_only = True)
def run(command_path = None):
import sys
stdtty = console.save()
opts = None
try:
optargs = { '--rtems-tools': 'The path to the RTEMS tools',
'--rtems-bsp': 'The RTEMS BSP to run the test on',
'--report-mode': 'Reporting modes, failures (default),all,none',
'--list-bsps': 'List the supported BSPs',
'--debug-trace': 'Debug trace based on specific flags',
'--stacktrace': 'Dump a stack trace on a user termination (^C)' }
opts = options.load(sys.argv,
optargs = optargs,
command_path = command_path)
log.notice('RTEMS Testing - Tester, v%s' % (version.str()))
if opts.find_arg('--list-bsps'):
list_bsps(opts)
opts.log_info()
debug_trace = opts.find_arg('--debug-trace')
if debug_trace:
debug_trace = debug_trace[1]
else:
debug_trace = ''
opts.defaults['debug_trace'] = debug_trace
job_trace = 'jobs' in debug_trace.split(',')
rtems_tools = opts.find_arg('--rtems-tools')
if rtems_tools:
rtems_tools = rtems_tools[1]
bsp = opts.find_arg('--rtems-bsp')
if bsp is None:
raise error.general('no RTEMS BSP provided')
opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1]))
bsp = opts.defaults.get('%{bsp}')
if not bsp:
raise error.general('BSP definition (%{bsp}) not found in the global map')
bsp = bsp[2]
if not opts.defaults.set_read_map(bsp):
raise error.general('no BSP map found')
bsp_script = opts.defaults.get(bsp)
if not bsp_script:
raise error.general('BSP script not found: %s' % (bsp))
bsp_config = opts.defaults.expand(opts.defaults[bsp])
report_mode = opts.find_arg('--report-mode')
if report_mode:
if report_mode[1] != 'failures' and \
report_mode[1] != 'all' and \
report_mode[1] != 'none':
raise error.general('invalid report mode')
report_mode = report_mode[1]
else:
report_mode = 'failures'
executables = find_executables(opts.params())
if len(executables) == 0:
raise error.general('no executbles supplied')
start_time = datetime.datetime.now()
total = len(executables)
reports = report.report(total)
invalid_tests = opts.defaults['invalid_tests']
if invalid_tests:
reports.set_invalid_tests([l.strip() for l in invalid_tests.splitlines()])
reporting = 1
jobs = int(opts.jobs(opts.defaults['_ncpus']))
exe = 0
tests = []
finished = []
if jobs > len(executables):
jobs = len(executables)
while exe < total or len(tests) > 0:
if exe < total and len(tests) < jobs:
tst = test_run(exe + 1, total, reports,
executables[exe],
rtems_tools, bsp, bsp_config,
opts)
exe += 1
tests += [tst]
if job_trace:
_job_trace(tst, 'create',
total, exe, tests, reporting)
tst.run()
else:
dead = [t for t in tests if not t.is_alive()]
tests[:] = [t for t in tests if t not in dead]
for tst in dead:
if job_trace:
_job_trace(tst, 'dead',
total, exe, tests, reporting)
finished += [tst]
tst.reraise()
del dead
if len(tests) >= jobs or exe >= total:
time.sleep(0.250)
if len(finished):
reporting = report_finished(reports,
report_mode,
reporting,
finished,
job_trace)
finished_time = datetime.datetime.now()
reporting = report_finished(reports, report_mode,
reporting, finished, job_trace)
if reporting < total:
log.warning('finished jobs does match: %d' % (reporting))
report_finished(reports, report_mode, -1, finished, job_trace)
reports.summary()
end_time = datetime.datetime.now()
log.notice('Testing time: %s' % (str(end_time - start_time)))
except error.general, gerr:
print gerr
sys.exit(1)
def run(command_path = None):
import sys
tests = []
stdtty = console.save()
opts = None
default_exefilter = '*.exe'
try:
optargs = { '--rtems-tools': 'The path to the RTEMS tools',
'--rtems-bsp': 'The RTEMS BSP to run the test on',
'--report-mode': 'Reporting modes, failures (default),all,none',
'--list-bsps': 'List the supported BSPs',
'--debug-trace': 'Debug trace based on specific flags',
'--filter': 'Glob that executables must match to run (default: ' +
default_exefilter + ')',
'--stacktrace': 'Dump a stack trace on a user termination (^C)',
'--rtems-builddir': 'The path to the build directory ( including e.g. /b-leon2/ )'}
opts = options.load(sys.argv,
optargs = optargs,
command_path = command_path)
log.notice('RTEMS Testing - Tester, v%s' % (version.str()))
if opts.find_arg('--list-bsps'):
bsps.list(opts)
exe_filter = opts.find_arg('--filter')
if exe_filter:
exe_filter = exe_filter[1]
else:
exe_filter = default_exefilter
opts.log_info()
debug_trace = opts.find_arg('--debug-trace')
if debug_trace:
debug_trace = debug_trace[1]
else:
debug_trace = ''
opts.defaults['debug_trace'] = debug_trace
job_trace = 'jobs' in debug_trace.split(',')
rtems_tools = opts.find_arg('--rtems-tools')
if rtems_tools:
bla = '%{_prefix}'
print "prefixx: " + bla
if len(rtems_tools) != 2:
raise error.general('invalid RTEMS tools option')
rtems_tools = rtems_tools[1]
else:
rtems_tools = '%{_prefix}'
bsp = opts.find_arg('--rtems-bsp')
if bsp is None or len(bsp) != 2:
raise error.general('RTEMS BSP not provided or invalid option')
opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1]))
bsp = opts.defaults.get('%{bsp}')
if not bsp:
raise error.general('BSP definition (%{bsp}) not found in the global map')
bsp = bsp[2]
if not opts.defaults.set_read_map(bsp):
raise error.general('no BSP map found')
bsp_script = opts.defaults.get(bsp)
if not bsp_script:
raise error.general('BSP script not found: %s' % (bsp))
bsp_config = opts.defaults.expand(opts.defaults[bsp])
path_to_builddir= opts.find_arg('--rtems-builddir')
if not path_to_builddir:
raise error.general("Path to build directory not provided")
coverage_enabled = opts.coverage()
if coverage_enabled:
import coverage
from rtemstoolkit import check
log.notice("Coverage analysis requested")
opts.defaults.load('%%{_configdir}/coverage.mc')
if not check.check_exe('__covoar', opts.defaults['__covoar']):
raise error.general("Covoar not found!")
coverage = coverage.coverage_run(opts.defaults, path_to_builddir[1])
coverage.prepareEnvironment();
report_mode = opts.find_arg('--report-mode')
if report_mode:
if report_mode[1] != 'failures' and \
report_mode[1] != 'all' and \
report_mode[1] != 'none':
raise error.general('invalid report mode')
report_mode = report_mode[1]
else:
report_mode = 'failures'
executables = find_executables(opts.params(), exe_filter, path_to_builddir[1])
if len(executables) == 0:
raise error.general('no executables supplied')
start_time = datetime.datetime.now()
total = len(executables)
reports = report.report(total)
invalid_tests = opts.defaults['invalid_tests']
if invalid_tests:
reports.set_invalid_tests([l.strip() for l in invalid_tests.splitlines()])
reporting = 1
jobs = int(opts.jobs(opts.defaults['_ncpus']))
exe = 0
finished = []
if jobs > len(executables):
jobs = len(executables)
while exe < total or len(tests) > 0:
if exe < total and len(tests) < jobs:
tst = test_run(exe + 1, total, reports,
executables[exe],
rtems_tools, bsp, bsp_config,
opts)
exe += 1
tests += [tst]
if job_trace:
_job_trace(tst, 'create',
total, exe, tests, reporting)
tst.run()
else:
dead = [t for t in tests if not t.is_alive()]
tests[:] = [t for t in tests if t not in dead]
for tst in dead:
if job_trace:
_job_trace(tst, 'dead',
total, exe, tests, reporting)
finished += [tst]
tst.reraise()
del dead
if len(tests) >= jobs or exe >= total:
time.sleep(0.250)
if len(finished):
reporting = report_finished(reports,
report_mode,
reporting,
finished,
job_trace)
finished_time = datetime.datetime.now()
reporting = report_finished(reports, report_mode,
reporting, finished, job_trace)
if reporting < total:
log.warning('finished jobs does match: %d' % (reporting))
report_finished(reports, report_mode, -1, finished, job_trace)
reports.summary()
end_time = datetime.datetime.now()
log.notice('Average test time: %s' % (str((end_time - start_time) / total)))
log.notice('Testing time : %s' % (str(end_time - start_time)))
if coverage_enabled:
coverage.config_map = opts.defaults.macros['coverage']
coverage.executables = executables
print [c for c in coverage.config_map]
print [e for e in executables]
def _summarize(self):
log.notice("Coverage analysis finished. You can find results in " + self.targetDir)
def output_handler(text):
log.notice(text, stdout_only = False)
return opts
def run(args):
try:
_opts = load(args=args, defaults=defaults_mc)
log.notice("RTEMS Test - Defaults, v%s" % (version.str()))
_opts.log_info()
log.notice("Options:")
log.notice(str(_opts))
log.notice("Defaults:")
log.notice(str(_opts.defaults))
except error.general, gerr:
print gerr
sys.exit(1)
except error.internal, ierr:
print ierr
sys.exit(1)
except error.exit, eerr:
pass
except KeyboardInterrupt:
log.notice("abort: user terminated")
sys.exit(1)
sys.exit(0)
if __name__ == "__main__":
import sys
run(sys.argv)
def run(args):
try:
_opts = load(args = args, defaults = defaults_mc)
log.notice('RTEMS Test - Defaults, v%s' % (version.str()))
_opts.log_info()
log.notice('Options:')
log.notice(str(_opts))
log.notice('Defaults:')
log.notice(str(_opts.defaults))
except error.general as gerr:
print(gerr)
sys.exit(1)
except error.internal as ierr:
print(ierr)
sys.exit(1)
except error.exit:
pass
except KeyboardInterrupt:
log.notice('abort: user terminated')
sys.exit(1)
sys.exit(0)
def _cleanup(self):
log.notice("Cleaning workspace up")
path.removeall(self.tracesDir)
def run(command_path = None):
import sys
tests = []
stdtty = console.save()
opts = None
default_exefilter = '*.exe'
try:
optargs = { '--rtems-tools': 'The path to the RTEMS tools',
'--rtems-bsp': 'The RTEMS BSP to run the test on',
'--report-mode': 'Reporting modes, failures (default),all,none',
'--list-bsps': 'List the supported BSPs',
'--debug-trace': 'Debug trace based on specific flags',
'--filter': 'Glob that executables must match to run (default: ' +
default_exefilter + ')',
'--stacktrace': 'Dump a stack trace on a user termination (^C)' }
opts = options.load(sys.argv,
optargs = optargs,
command_path = command_path)
log.notice('RTEMS Testing - Tester, v%s' % (version.str()))
if opts.find_arg('--list-bsps'):
bsps.list(opts)
exe_filter = opts.find_arg('--filter')
if exe_filter:
exe_filter = exe_filter[1]
else:
exe_filter = default_exefilter
opts.log_info()
debug_trace = opts.find_arg('--debug-trace')
if debug_trace:
debug_trace = debug_trace[1]
else:
debug_trace = ''
opts.defaults['debug_trace'] = debug_trace
job_trace = 'jobs' in debug_trace.split(',')
rtems_tools = opts.find_arg('--rtems-tools')
if rtems_tools:
if len(rtems_tools) != 2:
raise error.general('invalid RTEMS tools option')
rtems_tools = rtems_tools[1]
else:
rtems_tools = '%{_prefix}'
bsp = opts.find_arg('--rtems-bsp')
if bsp is None or len(bsp) != 2:
raise error.general('RTEMS BSP not provided or invalid option')
opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1]))
bsp = opts.defaults.get('%{bsp}')
if not bsp:
raise error.general('BSP definition (%{bsp}) not found in the global map')
bsp = bsp[2]
if not opts.defaults.set_read_map(bsp):
raise error.general('no BSP map found')
bsp_script = opts.defaults.get(bsp)
if not bsp_script:
raise error.general('BSP script not found: %s' % (bsp))
bsp_config = opts.defaults.expand(opts.defaults[bsp])
report_mode = opts.find_arg('--report-mode')
if report_mode:
if report_mode[1] != 'failures' and \
report_mode[1] != 'all' and \
report_mode[1] != 'none':
raise error.general('invalid report mode')
report_mode = report_mode[1]
else:
report_mode = 'failures'
executables = find_executables(opts.params(), exe_filter)
if len(executables) == 0:
raise error.general('no executables supplied')
start_time = datetime.datetime.now()
total = len(executables)
reports = report.report(total)
invalid_tests = opts.defaults['invalid_tests']
if invalid_tests:
reports.set_invalid_tests([l.strip() for l in invalid_tests.splitlines()])
reporting = 1
jobs = int(opts.jobs(opts.defaults['_ncpus']))
exe = 0
finished = []
if jobs > len(executables):
jobs = len(executables)
while exe < total or len(tests) > 0:
if exe < total and len(tests) < jobs:
tst = test_run(exe + 1, total, reports,
executables[exe],
rtems_tools, bsp, bsp_config,
opts)
exe += 1
tests += [tst]
if job_trace:
_job_trace(tst, 'create',
total, exe, tests, reporting)
tst.run()
else:
dead = [t for t in tests if not t.is_alive()]
tests[:] = [t for t in tests if t not in dead]
for tst in dead:
if job_trace:
_job_trace(tst, 'dead',
total, exe, tests, reporting)
finished += [tst]
tst.reraise()
del dead
if len(tests) >= jobs or exe >= total:
time.sleep(0.250)
if len(finished):
reporting = report_finished(reports,
report_mode,
reporting,
finished,
job_trace)
finished_time = datetime.datetime.now()
reporting = report_finished(reports, report_mode,
reporting, finished, job_trace)
if reporting < total:
log.warning('finished jobs does match: %d' % (reporting))
report_finished(reports, report_mode, -1, finished, job_trace)
reports.summary()
end_time = datetime.datetime.now()
log.notice('Average test time: %s' % (str((end_time - start_time) / total)))
log.notice('Testing time : %s' % (str(end_time - start_time)))
except error.general as gerr:
print(gerr)
sys.exit(1)
except error.internal as ierr:
print(ierr)
sys.exit(1)
except error.exit:
sys.exit(2)
except KeyboardInterrupt:
if opts is not None and opts.find_arg('--stacktrace'):
print('}} dumping:', threading.active_count())
for t in threading.enumerate():
print('}} ', t.name)
print(stacktraces.trace())
log.notice('abort: user terminated')
killall(tests)
sys.exit(1)
finally:
console.restore(stdtty)
sys.exit(0)
def run_args(args):
b = None
ec = 0
try:
#
# On Windows MSYS2 prepends a path to itself to the environment
# path. This means the RTEMS specific automake is not found and which
# breaks the bootstrap. We need to remove the prepended path. Also
# remove any ACLOCAL paths from the environment.
#
if os.name == 'nt':
cspath = os.environ['PATH'].split(os.pathsep)
if 'msys' in cspath[0] and cspath[0].endswith('bin'):
os.environ['PATH'] = os.pathsep.join(cspath[1:])
top = os.path.dirname(os.path.dirname(os.path.abspath(sys.argv[0])))
prefix = '/opt/rtems/%s' % (rtems_version())
tools = prefix
build_dir = 'bsp-builds'
logf = 'bsp-build-%s.txt' % (datetime.datetime.now().strftime('%Y%m%d-%H%M%S'))
config_file = path.join(top, 'share', 'rtems', 'tester', 'rtems', 'rtems-bsps.ini')
if not path.exists(config_file):
config_file = path.join(top, 'tester', 'rtems', 'rtems-bsps.ini')
argsp = argparse.ArgumentParser()
argsp.add_argument('--prefix', help = 'Prefix to build the BSP.', type = str)
argsp.add_argument('--rtems-tools', help = 'The RTEMS tools directory.', type = str)
argsp.add_argument('--rtems', help = 'The RTEMS source tree.', type = str)
argsp.add_argument('--build-path', help = 'Path to build in.', type = str)
argsp.add_argument('--log', help = 'Log file.', type = str)
argsp.add_argument('--stop-on-error', help = 'Stop on an error.',
action = 'store_true')
argsp.add_argument('--no-clean', help = 'Do not clean the build output.',
action = 'store_true')
argsp.add_argument('--profiles', help = 'Build the listed profiles.',
type = str, default = 'tier-1')
argsp.add_argument('--build', help = 'Build variation.', type = str)
argsp.add_argument('--arch', help = 'Build the specific architecture.', type = str)
argsp.add_argument('--bsp', help = 'Build the specific BSP.', type = str)
argsp.add_argument('--dry-run', help = 'Do not run the actual builds.',
action = 'store_true')
opts = argsp.parse_args(args[1:])
if opts.log is not None:
logf = opts.log
log.default = log.log([logf])
log.notice('RTEMS Tools Project - RTEMS Kernel BSP Builder, %s' % (version.str()))
if opts.rtems is None:
raise error.general('No RTEMS source provided on the command line')
if opts.prefix is not None:
prefix = path.shell(opts.prefix)
if opts.rtems_tools is not None:
tools = path.shell(opts.rtems_tools)
if opts.build_path is not None:
build_dir = path.shell(opts.build_path)
if opts.bsp is not None and opts.arch is None:
raise error.general('BSP provided but no architecture')
config = configuration()
config.load(config_file, opts.build)
options = { 'stop-on-error' : opts.stop_on_error,
'no-clean' : opts.no_clean,
'dry-run' : opts.dry_run,
'jobs' : 8 }
b = build(config, rtems_version(), prefix, tools,
path.shell(opts.rtems), build_dir, options)
if opts.arch is not None:
if opts.bsp is not None:
b.build_arch_bsp(opts.arch, opts.bsp)
else:
b.build_arch(opts.arch)
else:
for profile in opts.profiles.split(','):
b.build_profile(profile.strip())
except error.general as gerr:
print(gerr)
print('BSP Build FAILED', file = sys.stderr)
ec = 1
except error.internal as ierr:
print(ierr)
print('BSP Build FAILED', file = sys.stderr)
ec = 1
except error.exit as eerr:
pass
except KeyboardInterrupt:
log.notice('abort: user terminated')
ec = 1
if b is not None:
b.results.report()
sys.exit(ec)
def _generateReports(self):
log.notice("Generating reports")
report = reportGen(self.symbolSets, self.targetDir)
report.generate()
