예제 #1
0
파일: check.py 프로젝트: RTEMS/rtems-tools
 def load(self, name, variation):
     if not path.exists(name):
         raise error.general('config: cannot read configuration: %s' % (name))
     self.name = name
     try:
         self.config.read(name)
     except configparser.ParsingError as ce:
         raise error.general('config: %s' % (ce))
     archs = []
     self.profiles['profiles'] = self._comma_list('profiles', 'profiles', error = False)
     if len(self.profiles['profiles']) == 0:
         self.profiles['profiles'] = ['tier_%d' % (t) for t in range(1,4)]
     for p in self.profiles['profiles']:
         profile = {}
         profile['name'] = p
         profile['archs'] = self._comma_list(profile['name'], 'archs')
         archs += profile['archs']
         for arch in profile['archs']:
             bsps = 'bsps_%s' % (arch)
             profile[bsps] = self._comma_list(profile['name'], bsps)
         self.profiles[profile['name']] = profile
     for a in set(archs):
         arch = {}
         arch['excludes'] = {}
         for exclude in self._comma_list(a, 'exclude', error = False):
             arch['excludes'][exclude] = ['all']
         for i in self._get_items(a, False):
             if i[0].startswith('exclude_'):
                 exclude = i[0][len('exclude_'):]
                 if exclude not in arch['excludes']:
                     arch['excludes'][exclude] = []
                 arch['excludes'][exclude] += sorted(set([b.strip() for b in i[1].split(',')]))
         arch['bsps'] = self._comma_list(a, 'bsps', error = False)
         for b in arch['bsps']:
             arch[b] = {}
             arch[b]['bspopts'] = self._comma_list(a, 'bspopts_%s' % (b), error = False)
         self.archs[a] = arch
     builds = {}
     builds['default'] = self._get_item('builds', 'default').split()
     builds['variations'] = self._comma_list('builds', 'variations')
     if variation is None:
         variation = builds['default']
     builds['variation'] = variation
     builds['base'] = self._get_item('builds', 'standard').split()
     builds['variations'] = self._comma_list('builds', variation)
     builds['var_options'] = {}
     for v in builds['variations']:
         if v == 'base':
             builds['var_options'][v] = self._get_item('builds', v).split()
         else:
             builds['var_options'][v] = []
     self.builds = builds
예제 #2
0
파일: stty.py 프로젝트: bengras/rtems-tools
 def __init__(self, dev):
     if options.host_windows:
         raise error.general('termios not support on host')
     self.dev = dev
     self.default_attr = None
     self.fd = None
     self.if_on = False
     if options.host_windows:
         raise error.general('TTY consoles not supported on Windows.')
     if not path.exists(dev):
         raise error.general('dev not found: %s' % (dev))
     try:
         self.fd = open(dev, 'rw')
     except IOError, ioe:
         raise error.general('opening tty dev: %s: %s' % (dev, ioe))
예제 #3
0
 def load(self, name):
     if not path.exists(name):
         raise error.general('config: cannot read configuration: %s' % (name))
     self.name = name
     self.config.read(name)
     archs = []
     self.profiles['profiles'] = self._comma_list('profiles', 'profiles', error = False)
     if len(self.profiles['profiles']) == 0:
         self.profiles['profiles'] = ['tier_%d' % (t) for t in range(1,4)]
     for p in self.profiles['profiles']:
         profile = {}
         profile['name'] = p
         profile['archs'] = self._comma_list(profile['name'], 'archs')
         archs += profile['archs']
         for arch in profile['archs']:
             bsps = 'bsps_%s' % (arch)
             profile[bsps] = self._comma_list(profile['name'], bsps)
         self.profiles[profile['name']] = profile
     for a in set(archs):
         arch = {}
         arch['excludes'] = self._comma_list(a, 'excludes', error = False)
         arch['bsps'] = self._comma_list(a, 'bsps', error = False)
         for b in arch['bsps']:
             arch[b] = {}
             arch[b]['bspopts'] = self._comma_list(a, 'bspopts_%s' % (b), error = False)
             arch[b]['config'] = self._comma_list(a, 'config_%s' % (b), error = False)
         self.archs[a] = arch
     builds = {}
     builds['default'] = self._get_item('builds', 'default').split()
     builds['variations'] = self._comma_list('builds', 'variations')
     builds['var_options'] = {}
     for v in builds['variations']:
         builds['var_options'][v] = self._get_item('builds', v).split()
     self.builds = builds
예제 #4
0
 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)
예제 #5
0
    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)
예제 #6
0
def find_executables(files):
    executables = []
    for f in files:
        if not path.isfile(f):
            raise error.general('executable is not a file: %s' % (f))
        executables += [f]
    return sorted(executables)
예제 #7
0
 def _dir_gdb(self, data, total, index, exe, bsp_arch, bsp):
     if len(data) < 3 or len(data) > 4:
         raise error.general('invalid %gdb arguments')
     self.process = tester.rt.gdb.gdb(bsp_arch,
                                      bsp,
                                      trace=self.exe_trace('gdb'),
                                      mi_trace=self.exe_trace('gdb-mi'))
     script = self.expand('%%{%s}' % data[2])
     if script:
         script = [l.strip() for l in script.splitlines()]
     if not self.in_error:
         if self.console:
             self.console.open()
         if not self.opts.dry_run():
             self.process.open(
                 data[0],
                 data[1],
                 script=script,
                 output=self.capture,
                 gdb_console=self.capture_console,
                 timeout=(int(self.expand('%{timeout}')),
                          int(self.expand('%{max_test_period}')),
                          self._timeout, self._test_too_long))
         if self.console:
             self.console.close()
예제 #8
0
 def _target_exe_filter(self, exe):
     if self.defined('target_exe_filter'):
         f = self.expand('%{target_exe_filter}').strip()
         # Be like sed and use the first character as the delmiter.
         if len(f) > 0:
             delimiter = f[0]
             pat = ''
             repl = ''
             repl_not_pat = False
             esc = False
             for c in f[1:]:
                 add = True
                 if not esc and c == '\\':
                     esc = True
                     add = False
                 elif esc:
                     if c == delimiter:
                         c = delimiter
                     else:
                         c = '\\' + c
                         esc = False
                 elif c == delimiter:
                     if repl_not_pat:
                         exe = re.sub(r'%s' % (pat), repl, exe)
                         self._capture_console('target exe filter: find:%s subst:%s -> %s' % \
                                               (pat, repl, exe))
                         return exe
                     repl_not_pat = True
                     add = False
                 if add:
                     if repl_not_pat:
                         repl += c
                     else:
                         pat += c
             raise error.general('invalid exe filter: %s' % (f))
예제 #9
0
 def open(self,
          command,
          capture=True,
          shell=False,
          cwd=None,
          env=None,
          stdin=None,
          stdout=None,
          stderr=None,
          timeout=None):
     if not capture:
         raise error.general(
             'output capture must be true; leave as default')
     #self.snapper.get_and_clear()
     exit_code, proc = execute.open(self,
                                    command,
                                    capture=True,
                                    shell=shell,
                                    cwd=cwd,
                                    env=env,
                                    stdin=stdin,
                                    stdout=stdout,
                                    stderr=stderr,
                                    timeout=timeout)
     return (exit_code, proc, self.snapper.get_and_clear())
예제 #10
0
파일: gdb.py 프로젝트: bengras/rtems-tools
 def open(self, command, executable,
          output, gdb_console, script = None, tty = None,
          timeout = 300):
     self._lock('_open')
     try:
         cmds = execute.arg_list(command) + ['-i=mi',
                                             '--nx',
                                             '--quiet']
         if tty:
             cmds += ['--tty=%s' % tty]
         if executable:
             cmds += [executable]
         self.output = output
         self.gdb_console = gdb_console
         self.script = script
         self.running = False
         self.process = execute.execute(output = self._reader,
                                        input = self._writer,
                                        cleanup = self._cleanup)
     finally:
         self._unlock('_open')
     try:
         self.gdb_console('gdb: %s' % (' '.join(cmds)))
         ec, proc = self.process.open(cmds, timeout = (timeout, self._timeout))
         if self.trace:
             print 'gdb done', ec
         if ec > 0:
             raise error.general('gdb exec: %s' % (os.strerror(ec)))
     except:
         raise
     self._lock('_open')
     try:
         self.process = None
     finally:
         self._unlock('_open')
예제 #11
0
파일: report.py 프로젝트: RTEMS/rtems-tools
    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)
예제 #12
0
 def _ifs(self, config, ls, label, iftrue, isvalid, dir, info):
     in_iftrue = True
     data = []
     while True:
         if isvalid and \
                 ((iftrue and in_iftrue) or (not iftrue and not in_iftrue)):
             this_isvalid = True
         else:
             this_isvalid = False
         r = self._parse(config, dir, info, roc = True, isvalid = this_isvalid)
         if r[0] == 'control':
             if r[1] == '%end':
                 self._error(label + ' without %endif')
                 raise error.general('terminating build')
             if r[1] == '%endif':
                 log.trace('config: %s: _ifs: %s %s' % (self.init_name, r[1], this_isvalid))
                 return data
             if r[1] == '%else':
                 in_iftrue = False
         elif r[0] == 'directive':
             if this_isvalid:
                 if r[1] == '%include':
                     self.load(r[2][0])
                     continue
                 dir, info, data = self._process_directive(r, dir, info, data)
         elif r[0] == 'data':
             if this_isvalid:
                 dir, info, data = self._process_data(r, dir, info, data)
         else:
             dir, info, data = self._process_block(r, dir, info, data)
예제 #13
0
 def process(self):
     arg = 0
     while arg < len(self.args):
         a = self.args[arg]
         if a == '-?':
             self.help()
         elif a.startswith('--'):
             los = a.split('=')
             lo = los[0]
             if lo in self.long_opts:
                 long_opt = self.long_opts[lo]
                 if len(los) == 1:
                     if long_opt[2]:
                         if arg == len(self.args) - 1:
                             raise error.general(
                                 'option requires a parameter: %s' % (lo))
                         arg += 1
                         value = self.args[arg]
                     else:
                         value = None
                 else:
                     value = '='.join(los[1:])
                 long_opt[1](lo, long_opt[0], value)
         else:
             self.opts['params'].append(a)
         arg += 1
예제 #14
0
 def __init__(self, config, version, prefix, tools, rtems, build_dir,
              options):
     self.config = config
     self.build_dir = build_dir
     self.rtems_version = version
     self.prefix = prefix
     self.tools = tools
     self.rtems = rtems
     self.options = options
     self.counts = {'h': 0, 'exes': 0, 'objs': 0, 'libs': 0}
     self.results = results(
         rtems, {
             'groups':
             ['Shared', 'BSP', 'Network', 'Tests', 'LibCPU', 'CPU Kit'],
             'exclude':
             '.*Makefile.*',
             'CPU Kit':
             '.*cpukit/.*',
             'Network':
             '.*libnetworking/.*|.*librpc/.*',
             'Tests':
             '.*testsuites/.*',
             'BSP':
             '.*libbsp/.*',
             'LibCPU':
             '.*libcpu/.*',
             'Shared':
             '.*shared/.*'
         })
     if not path.exists(path.join(rtems, 'configure')) or \
        not path.exists(path.join(rtems, 'Makefile.in')) or \
        not path.exists(path.join(rtems, 'cpukit')):
         raise error.general('RTEMS source path does not look like RTEMS')
예제 #15
0
 def run(self):
     try:
         if self.executables is None:
             raise error.general('no test executables provided.')
         build_dir = build_path_generator(self.executables, self.target).run()
         parser = symbol_parser(self.symbol_config_path,
                                self.symbol_select_path,
                                self.symbol_set,
                                build_dir,
                                self.bsp_name,
                                self.target)
         symbol_sets = parser.parse()
         for sset in symbol_sets:
             parser.write_ini(sset)
             covoar_runner = covoar(self.test_dir,
                                    self.symbol_select_path,
                                    self.executables,
                                    self.trace,
                                    self.prefix,
                                    self.covoar_cmd)
             covoar_runner.run(sset, self.symbol_select_path)
         self._generate_reports(symbol_sets);
         self._summarize();
     finally:
         self._cleanup();
예제 #16
0
 def _process_data(self, results, directive, info, data):
     new_data = []
     for l in results[1]:
         if l.startswith('%error'):
             l = self._expand(l)
             raise error.general('config error: %s' % (l[7:]))
         elif l.startswith('%warning'):
             l = self._expand(l)
             log.stderr('warning: %s' % (l[9:]))
             log.warning(l[9:])
         if not directive:
             l = self._expand(l)
             ls = self.tags.split(l, 1)
             log.trace('config: %s: _tag: %s %s' % (self.init_name, l, ls))
             if len(ls) > 1:
                 info = ls[0].lower()
                 if info[-1] == ':':
                     info = info[:-1]
                 info_data = ls[1].strip()
             else:
                 info_data = ls[0].strip()
             if info is not None:
                 self._info_append(info, info_data)
             else:
                 log.warning("invalid format: '%s'" % (info_data[:-1]))
         else:
             log.trace('config: %s: _data: %s %s' % (self.init_name, l, new_data))
             new_data.append(l)
     return (directive, info, data + new_data)
예제 #17
0
 def arch_jobs(self, archs):
     jobs = []
     for arch in archs:
         if not self.config.arch_present(arch):
             raise error.general('Architecture not found: %s' % (arch))
         jobs += self.arch_bsp_jobs(arch, self._bsps(arch))
     return jobs
예제 #18
0
 def open(self,
          command,
          executable,
          output,
          gdb_console,
          timeout,
          script=None,
          tty=None):
     self._lock('_open')
     self.timeout = timeout[2]
     self.test_too_long = timeout[3]
     try:
         cmds = execute.arg_list(command) + ['-i=mi', '--nx', '--quiet']
         if tty:
             cmds += ['--tty=%s' % tty]
         if executable:
             cmds += [executable]
         self.output = output
         self.gdb_console = gdb_console
         self.script = script
         self.process = execute.execute(output=self._reader,
                                        input=self._writer,
                                        cleanup=self._cleanup)
         exec_thread = threading.Thread(target=self._execute_gdb,
                                        args=[cmds])
         exec_thread.start()
         self._monitor(timeout)
         if self.ecode is not None and self.ecode > 0:
             raise error.general('gdb exec: %s: %s' %
                                 (cmds[0], os.strerror(self.ecode)))
     finally:
         self._unlock('_open')
예제 #19
0
 def _interpolate(self, section, rec):
     #
     # On Python 2.7 there is no extended interpolation so add support here.
     # On Python 3 we disable the built in support and also the code here.
     #
     if not self.raw:
         not_found = []
         while True:
             macros = [
                 m for m in self.macro_filter.findall(rec)
                 if m not in not_found
             ]
             if len(macros) == 0:
                 break
             for m in macros:
                 if m in not_found:
                     continue
                 if ':' in m:
                     section_value = m[2:-1].split(':')
                     if len(section_value) != 2:
                         err = 'config: interpolation is ${section:item}: %s' % (
                             m)
                         raise error.general(err)
                 else:
                     section_value = [section, m[2:-1]]
                 try:
                     ref = self.config.get(section_value[0],
                                           section_value[1],
                                           raw=True).replace(
                                               os.linesep, ' ')
                     rec = rec.replace(m, ref)
                 except:
                     not_found += [m]
                     pass
     return rec
예제 #20
0
def _load_released_version():
    '''Load the release data if present. If not found the package is not released.

    A release can be made by adding a file called `VERSION` to the top level
    directory of a package. This is useful for user deploying a package and
    making custom releases.

    The RTEMS project reserves the `rtems-version.ini` file for it's
    releases. This is the base release and should not be touched by users
    deploying a package.

    '''
    global _version
    global _revision
    global _released
    global _version_str
    global _is_loaded

    if not _is_loaded:
        vc, v = _load_released_version_config()
        if v is not None:
            try:
                ver_str = v.get('version', 'revision')
            except Exception as e:
                raise error.general('Invalid version file: %s: %s' % (vc, e))
            ver_split = ver_str.split('.')
            if len(ver_split) < 2:
                raise error.general('Invalid version release value: %s: %s' %
                                    (vc, ver_str))
            ver = ver_split[0]
            rev = '.'.join(ver_split[1:])
            try:
                _version = int(ver)
            except:
                raise error.general('Invalid version config value: %s: %s' %
                                    (vc, ver))
            try:
                _revision = int(''.join(
                    itertools.takewhile(str.isdigit, str(rev))))
            except Exception as e:
                raise error.general(
                    'Invalid revision config value: %s: %s: %s' % (vc, rev, e))
            if not 'not_released' in ver:
                _released = True
            _version_str = ver_str
            _is_loaded = True
    return _released
예제 #21
0
    def _directive_filter(self, results, directive, info, data):
        if results[0] == 'directive':
            _directive = results[1]
            _data = results[2]
            ds = []
            if len(_data):
                ds = [_data[0]]
                if len(_data) > 1:
                    ds += _data[1].split()
            ds = self.expand(ds)

            if _directive == '%console':
                self._dir_console(ds)
            else:
                self._lock()
                try:
                    self.output = []
                    total = int(self.expand('%{test_total}'))
                    index = int(self.expand('%{test_index}'))
                    exe = self.expand('%{test_executable}')
                    bsp_arch = self.expand('%{arch}')
                    bsp = self.expand('%{bsp}')
                    fexe = self._target_exe_filter(exe)
                    self.report.start(index, total, exe, fexe,
                                      bsp_arch, bsp, self.show_header)
                    if self.index == 1:
                        self._target_command('on', bsp_arch, bsp, exe, fexe)
                    self._target_command('pretest', bsp_arch, bsp, exe, fexe)
                finally:
                    self._unlock()
                if _directive == '%execute':
                    self._dir_execute(ds, total, index, fexe, bsp_arch, bsp)
                elif _directive == '%gdb':
                    self._dir_gdb(ds, total, index, fexe, bsp_arch, bsp)
                elif _directive == '%tftp':
                    self._dir_tftp(ds, total, index, fexe, bsp_arch, bsp)
                else:
                    raise error.general(self._name_line_msg('invalid directive'))
                self._lock()
                if self.index == self.total:
                    self._target_command('off', bsp_arch, bsp, exe, fexe)
                self._target_command('posttest', bsp_arch, bsp, exe, fexe)
                try:
                    status = self.report.end(exe, self.output, self.console_prefix)
                    version = self.report.get_config('version', not_found = 'n/p')
                    build = self.report.get_config('build', not_found = 'n/p')
                    tools = self.report.get_config('tools', not_found = 'n/p')
                    self._capture_console('test result: %s' % (status))
                    self._capture_console('test version: %s' % (version))
                    self._capture_console('test build: %s' % (build))
                    self._capture_console('test tools: %s' % (tools))
                    if status == 'timeout':
                        if self.index != self.total:
                            self._target_command('reset', bsp_arch, bsp, exe, fexe)
                    self.process = None
                    self.output = None
                finally:
                    self._unlock()
        return None, None, None
예제 #22
0
 def profile_jobs(self, profiles):
     jobs = []
     for profile in profiles:
         if not self.config.profile_present(profile):
             raise error.general('Profile not found: %s' % (profile))
         for arch in self.config.profile_archs(profile):
             jobs += self.bsp_jobs(self.config.profile_arch_bsps(profile, arch))
     return jobs
예제 #23
0
 def bsp_jobs(self, bsps):
     jobs = []
     for bsp in bsps:
         if bsp.count('/') != 1:
             raise error.general('invalid bsp format (use: arch/bsp): %s' % (bsp))
         arch, bsp = bsp.split('/')
         jobs += build_jobs(self.config, arch, bsp).jobs()
     return jobs
예제 #24
0
 def _load(self, config):
     self.config.load(config)
     clients = self.config.comma_list('default', 'clients', err=False)
     if len(clients) == 0:
         raise error.general(
             '\'clients\'" entry not found in config [defaults]')
     for client in clients:
         self._load_client(client)
예제 #25
0
 def _get_items(self, section, err=True):
     try:
         items = self.config.items(section)
         return items
     except:
         if err:
             raise error.general('config: section %s not found' % (section))
     return []
예제 #26
0
 def get_item_names(self, section, err=True):
     try:
         return [item[0] for item in self.config.items(section, raw=True)]
     except:
         if err:
             raise error.general('config: section "%s" not found' %
                                 (section))
     return []
예제 #27
0
 def _listener(self):
     tftpy.log.setLevel(100)
     try:
         self.server = tftpy.TftpServer(tftproot='.',
                                        dyn_file_func=self._exe_handle)
     except tftpy.TftpException as te:
         raise error.general('tftp: %s' % (str(te)))
     if self.server is not None:
         try:
             self.server.listen('0.0.0.0', self.port, 0.5)
         except tftpy.TftpException as te:
             raise error.general('tftp: %s' % (str(te)))
         except IOError as ie:
             if ie.errno == errno.EACCES:
                 raise error.general(
                     'tftp: permissions error: check tftp server port')
             raise error.general('tftp: io error: %s' % (str(ie)))
예제 #28
0
 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()
예제 #29
0
파일: check.py 프로젝트: RTEMS/rtems-tools
 def _get_items(self, section, err = True):
     try:
         items = self.config.items(section)
         return items
     except:
         if err:
             raise error.general('config: section %s not found' % (section))
     return []
예제 #30
0
파일: check.py 프로젝트: RTEMS/rtems-tools
 def _get_item(self, section, label, err = True):
     try:
         rec = self.config.get(section, label).replace(os.linesep, ' ')
         return rec
     except:
         if err:
             raise error.general('config: no %s found in %s' % (label, section))
     return None
예제 #31
0
 def baudrate(self, flag):
     mask = self._baudrate_mask(flag)
     if mask:
         self.attr[4] = mask
         self.attr[5] = mask
     else:
         raise error.general('invalid setting: %s' % (flag))
     self._update()
예제 #32
0
 def baudrate(self, flag):
     mask = self._baudrate_mask(flag)
     if mask:
         self.attr[4] = mask
         self.attr[5] = mask
     else:
         raise error.general('invalid setting: %s' % (flag))
     self._update()
예제 #33
0
파일: path.py 프로젝트: zulusw/rtems-tools
def listdir(path, error = True):
    path = host(path)
    files = []
    if not os.path.exists(path):
        if error:
            raise error.general('path does not exist : %s' % (path))
    elif not isdir(path):
        if error:
            raise error.general('path is not a directory: %s' % (path))
    else:
        if windows:
            try:
                files = os.listdir(host(path))
            except IOError:
                raise error.general('Could not list files: %s' % (path))
            except OSError as e:
                raise error.general('Could not list files: %s: %s' % (path, str(e)))
            except WindowsError as e:
                raise error.general('Could not list files: %s: %s' % (path, str(e)))
        else:
            try:
                files = os.listdir(host(path))
            except IOError:
                raise error.general('Could not list files: %s' % (path))
            except OSError as e:
                raise error.general('Could not list files: %s: %s' % (path, str(e)))
    return files
예제 #34
0
파일: report.py 프로젝트: RTEMS/rtems-tools
 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()
예제 #35
0
 def __init__(self, dev):
     if host.is_windows:
         raise error.general('termios not support on host')
     self.dev = dev
     self.default_attr = None
     self.fd = None
     self.if_on = False
     if host.is_windows:
         raise error.general('TTY consoles not supported on Windows.')
     if not path.exists(dev):
         raise error.general('dev not found: %s' % (dev))
     try:
         self.fd = open(dev, 'rw')
     except IOError as ioe:
         raise error.general('opening tty dev: %s: %s' % (dev, ioe))
     except:
         raise error.general('opening tty dev: %s: unknown' % (dev))
     try:
         self.default_attr = termios.tcgetattr(self.fd)
     except:
         close(self.fd)
         raise error.general('cannot get termios attrs: %s' % (dev))
     try:
         fcntl.fcntl(self.fd, fcntl.F_SETFL,
                     fcntl.fcntl(self.fd, fcntl.F_GETFL) | os.O_NONBLOCK)
     except:
         close(self.fd)
         raise error.general('cannot make tty non-blocking: %s' % (dev))
     self.attr = self.default_attr
예제 #36
0
 def _get_item(self, section, label, err=True):
     try:
         rec = self.config.get(section, label).replace(os.linesep, ' ')
         return rec
     except:
         if err:
             raise error.general('config: no %s found in %s' %
                                 (label, section))
     return None
예제 #37
0
 def get_items(self, section, err = True):
     try:
         items = [(name, key.replace(os.linesep, ' ')) \
                  for name, key in self.config.items(section)]
         return items
     except:
         if err:
             raise error.general('config: section "%s" not found' % (section))
     return []
예제 #38
0
 def send_file_as_body(self, to_addr, subject, name, intro=None):
     try:
         with open(name, 'r') as f:
             body = f.readlines()
     except IOError as err:
         raise error.general('error reading mail body: %s' % (name))
     if intro is not None:
         body = intro + body
     self.send(to_addr, from_addr, body)
예제 #39
0
 def host_format_partition(self, device, pformat, plabel):
     formats = {
         'fat16': ('newfs_msdos', '16'),
         'fat32': ('newfs_msdos', '32')
     }
     if pformat not in formats:
         raise error.general('unknown format: %s' % (pformat))
     self.command('sudo %s -F %s %s' %
                  (formats[pformat][0], formats[pformat][1], device))
예제 #40
0
 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
     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)
예제 #41
0
파일: config.py 프로젝트: RTEMS/rtems-tools
 def _dir_console(self, data):
     if self.console is not None:
         raise error.general(self._name_line_msg('console already configured'))
     if len(data) == 0:
         raise error.general(self._name_line_msg('no console configuration provided'))
     console_trace = trace = self.debug_trace('console')
     if data[0] == 'stdio':
         self.console = console.stdio(trace = console_trace)
     elif data[0] == 'tty':
         if len(data) < 2 or len(data) >3:
             raise error.general(self._name_line_msg('no tty configuration provided'))
         if len(data) == 3:
             settings = data[2]
         else:
             settings = None
         self.console = console.tty(data[1],
                                    output = self.capture,
                                    setup = settings,
                                    trace = console_trace)
     else:
         raise error.general(self._name_line_msg('invalid console type'))
예제 #42
0
 def set(self, flags):
     for f in flags.split(','):
         if len(f) < 2:
             raise error.general('invalid flag: %s' % (f))
         if f[0] == '~':
             on = False
             flag = f[1:]
         else:
             on = True
             flag = f
         if f.startswith('VMIN'):
             vs = f.split('=')
             if len(vs) != 2:
                 raise error.general('invalid vmin flag: %s' % (f))
             try:
                 _vmin = int(vs[1])
             except:
                 raise error.general('invalid vmin flag: %s' % (f))
             self.vmin(_vmin)
             continue
         if f.startswith('VTIME'):
             vs = f.split('=')
             if len(vs) != 2:
                 raise error.general('invalid vtime flag: %s' % (f))
             try:
                 _vtime = int(vs[1])
             except:
                 raise error.general('invalid vtime flag: %s' % (f))
             self.vtime(_vtime)
             continue
         mask = self._baudrate_mask(flag)
         if mask:
             if not on:
                 raise error.general('baudrates are not flags: %s' % (f))
             self.attr[4] = mask
             self.attr[5] = mask
             continue
         mask = self._input_mask(flag)
         if mask:
             self._set(0, mask, on)
             continue
         mask = self._output_mask(flag)
         if mask:
             self._set(1, mask, on)
             continue
         mask = self._control_mask(flag)
         if mask:
             self._set(2, mask, on)
             continue
         mask = self._local_mask(flag)
         if mask:
             self._set(3, mask, on)
             continue
         raise error.general('unknown tty flag: %s' % (f))
     self._update()
예제 #43
0
 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())
예제 #44
0
파일: check.py 프로젝트: RTEMS/rtems-tools
 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())
예제 #45
0
파일: config.py 프로젝트: RTEMS/rtems-tools
 def _dir_gdb(self, data, total, index, exe, bsp_arch, bsp):
     if len(data) < 3 or len(data) > 4:
         raise error.general('invalid %gdb arguments')
     self.process = gdb.gdb(bsp_arch, bsp,
                            trace = self.debug_trace('gdb'),
                            mi_trace = self.debug_trace('gdb-mi'))
     script = self.expand('%%{%s}' % data[2])
     if script:
         script = [l.strip() for l in script.splitlines()]
     if not self.in_error:
         if self.console:
             self.console.open()
         self.process.open(data[0], data[1],
                           script = script,
                           output = self.capture,
                           gdb_console = self.capture_console,
                           timeout = int(self.expand('%{timeout}')))
         if self.console:
             self.console.close()
예제 #46
0
 def __init__(self, config, version, prefix, tools, rtems, build_dir, options):
     self.config = config
     self.build_dir = build_dir
     self.rtems_version = version
     self.prefix = prefix
     self.tools = tools
     self.rtems = rtems
     self.options = options
     self.errors = { 'configure': 0,
                     'build':     0,
                     'tests':     0 }
     self.counts = { 'h'        : 0,
                     'exes'     : 0,
                     'objs'     : 0,
                     'libs'     : 0 }
     self.warnings = warnings_counter(rtems)
     if not path.exists(path.join(rtems, 'configure')) or \
        not path.exists(path.join(rtems, 'Makefile.in')) or \
        not path.exists(path.join(rtems, 'cpukit')):
         raise error.general('RTEMS source path does not look like RTEMS')
예제 #47
0
파일: report.py 프로젝트: RTEMS/rtems-tools
 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))
예제 #48
0
파일: config.py 프로젝트: RTEMS/rtems-tools
    def _directive_filter(self, results, directive, info, data):
        if results[0] == 'directive':
            _directive = results[1]
            _data = results[2]
            ds = []
            if len(_data):
                ds = [_data[0]]
                if len(_data) > 1:
                    ds += _data[1].split()
            ds = self.expand(ds)

            if _directive == '%console':
                self._dir_console(ds)
            else:
                self._lock()
                try:
                    total = int(self.expand('%{test_total}'))
                    index = int(self.expand('%{test_index}'))
                    exe = self.expand('%{test_executable}')
                    bsp_arch = self.expand('%{bsp_arch}')
                    bsp = self.expand('%{bsp}')
                    self.report.start(index, total, exe, exe, bsp_arch, bsp)
                    self.output = []
                finally:
                    self._unlock()
                if _directive == '%execute':
                    self._dir_execute(ds, total, index, exe, bsp_arch, bsp)
                elif _directive == '%gdb':
                    self._dir_gdb(ds, total, index, exe, bsp_arch, bsp)
                else:
                    raise error.general(self._name_line_msg('invalid directive'))
                self._lock()
                try:
                    self.report.end(exe, self.output)
                    self.process = None
                    self.output = None
                finally:
                    self._unlock()
        return None, None, None
예제 #49
0
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)
예제 #50
0
파일: check.py 프로젝트: RTEMS/rtems-tools
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)
예제 #51
0
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)
예제 #52
0
파일: check.py 프로젝트: RTEMS/rtems-tools
 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
예제 #53
0
파일: stty.py 프로젝트: bengras/rtems-tools
        if options.host_windows:
            raise error.general('termios not support on host')
        self.dev = dev
        self.default_attr = None
        self.fd = None
        self.if_on = False
        if options.host_windows:
            raise error.general('TTY consoles not supported on Windows.')
        if not path.exists(dev):
            raise error.general('dev not found: %s' % (dev))
        try:
            self.fd = open(dev, 'rw')
        except IOError, ioe:
            raise error.general('opening tty dev: %s: %s' % (dev, ioe))
        except:
            raise error.general('opening tty dev: %s: unknown' % (dev))
        try:
            self.default_attr = termios.tcgetattr(self.fd)
        except:
            raise error.general('cannot get termios attrs: %s' % (dev))
        self.attr = self.default_attr

    def __del__(self):
        if self.fd and self.default_attr:
            try:
                self.fd.close()
            except:
                pass

    def __str__(self):
        def _input(attr):
예제 #54
0
 def output(self, flag, on):
     mask = self._output_mask(flag)
     if mask is None:
         raise error.general('invalid output flag: %s' % (flag))
     self._set(1, mask, on)
     self._update()
예제 #55
0
 def control(self, flag, on):
     mask = self._control_mask(flag)
     if mask is None:
         raise error.general('invalid control flag: %s' % (flag))
     self._set(2, mask, on)
     self._update()
예제 #56
0
 def local(self, flag, on):
     mask = self._local_mask(flag)
     if mask is None:
         raise error.general('invalid local flag: %s' % (flag))
     self._set(3, mask, on)
     self._update()
예제 #57
0
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]