Changeset 5142bec in rtems-source-builder


Ignore:
Timestamp:
Apr 21, 2013, 8:37:02 AM (6 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, 4.9, master
Children:
5f44fcd
Parents:
ec56744
Message:

Refactor the logging support.

Location:
source-builder/sb
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • source-builder/sb/build.py

    rec56744 r5142bec  
    4949    sys.exit(1)
    5050
    51 def _notice(opts, text):
    52     if not opts.quiet() and not log.default.has_stdout():
    53         print text
    54     log.output(text)
    55     log.flush()
    56 
    5751class script:
    5852    """Create and manage a shell script."""
    5953
    60     def __init__(self, quiet = True, trace = False):
    61         self.quiet = quiet
    62         self.trace = trace
     54    def __init__(self):
    6355        self.reset()
    6456
     
    7062        if type(text) is str:
    7163            text = text.splitlines()
    72         if not self.quiet:
     64        if not log.quiet:
    7365            i = 0
    7466            for l in text:
    7567                i += 1
    7668                log.output('script:%3d: %s' % (self.lc + i, l))
    77                 if self.trace:
    78                     print '%3d: S %s' % (self.lc + i,  l)
    7969        self.lc += len(text)
    8070        self.body.extend(text)
     
    10898            self.macros = macros
    10999        self.create_tar_files = create_tar_files
    110         _notice(opts, 'config: ' + name)
     100        log.notice('config: ' + name)
    111101        self.config = config.file(name, opts, self.macros)
    112         self.script = script(quiet = opts.quiet(), trace = opts.trace())
    113 
    114     def _output(self, text):
    115         if not self.opts.quiet():
    116             log.output(text)
     102        self.script = script()
    117103
    118104    def rmdir(self, rmpath):
    119         self._output('removing: %s' % (path.host(rmpath)))
     105        log.output('removing: %s' % (path.host(rmpath)))
    120106        if not self.opts.dry_run():
    121107            if path.exists(rmpath):
     
    123109
    124110    def mkdir(self, mkpath):
    125         self._output('making dir: %s' % (path.host(mkpath)))
     111        log.output('making dir: %s' % (path.host(mkpath)))
    126112        if not self.opts.dry_run():
    127113            path.mkdir(mkpath)
     
    192178
    193179    def setup(self, package, args):
    194         self._output('prep: %s: %s' % (package.name(), ' '.join(args)))
     180        log.output('prep: %s: %s' % (package.name(), ' '.join(args)))
    195181        opts, args = getopt.getopt(args[1:], 'qDcTn:b:a:')
    196182        source_tag = 0
     
    255241        e = execute.capture_execution(log = log.default, dump = self.opts.quiet())
    256242        cmd = self.config.expand('%{___build_shell} -ex ' + shell_opts + ' ' + command)
    257         self._output('run: ' + cmd)
     243        log.output('run: ' + cmd)
    258244        exit_code, proc, output = e.shell(cmd, cwd = path.host(cwd))
    259245        if exit_code != 0:
     
    337323            buildcxcdir = self.config.abspath('_buildcxcdir')
    338324            tmproot = self.config.abspath('_tmproot')
    339             if self.opts.trace():
    340                 _notice(self.opts, 'cleanup: %s' % (buildroot))
     325            log.trace('cleanup: %s' % (buildroot))
    341326            self.rmdir(buildroot)
    342             if self.opts.trace():
    343                 _notice(self.opts, 'cleanup: %s' % (builddir))
     327            log.trace('cleanup: %s' % (builddir))
    344328            self.rmdir(builddir)
    345329            if self.canadian_cross():
    346                 if self.opts.trace():
    347                     _notice(self.opts, 'cleanup: %s' % (buildcxcdir))
     330                log.trace('cleanup: %s' % (buildcxcdir))
    348331                self.rmdir(buildcxcdir)
    349             if self.opts.trace():
    350                 _notice(self.opts, 'cleanup: %s' % (tmproot))
     332            log.trace('cleanup: %s' % (tmproot))
    351333            self.rmdir(tmproot)
    352334
     
    359341        name = package.name()
    360342        if self.canadian_cross():
    361             _notice(self.opts, 'package: (Cxc) %s' % (name))
    362         else:
    363             _notice(self.opts, 'package: %s' % (name))
    364         if self.opts.trace():
    365             print '---- macro maps', '-' * 55
    366             print self.config.macros
    367             print '-' * 70
     343            log.notice('package: (Cxc) %s' % (name))
     344        else:
     345            log.notice('package: %s' % (name))
     346        log.trace('---- macro maps %s' % ('-' * 55))
     347        log.trace('%s' % (str(self.config.macros)))
     348        log.trace('-' * 70)
    368349        self.script.reset()
    369350        self.script.append(self.config.expand('%{___build_template}'))
     
    374355            self.builddir()
    375356            sn = path.join(self.config.expand('%{_builddir}'), 'doit')
    376             self._output('write script: ' + sn)
     357            log.output('write script: ' + sn)
    377358            self.script.write(sn)
    378359            if self.canadian_cross():
    379                 _notice(self.opts, 'building: (Cxc) %s' % (name))
     360                log.notice('building: (Cxc) %s' % (name))
    380361            else:
    381                 _notice(self.opts, 'building: %s' % (name))
     362                log.notice('building: %s' % (name))
    382363            self.run(sn)
    383364
     
    423404        optargs = { '--list-configs': 'List available configurations' }
    424405        opts = options.load(args, optargs)
    425         log.default = log.log(opts.logfiles())
    426         _notice(opts, 'RTEMS Source Builder, Package Builder v%s' % (version.str()))
     406        log.notice('RTEMS Source Builder, Package Builder v%s' % (version.str()))
    427407        if not check.host_setup(opts):
    428408            if not opts.force():
    429409                raise error.general('host build environment is not set up' +
    430410                                    ' correctly (use --force to proceed)')
    431             _notice(opts, 'warning: forcing build with known host setup problems')
     411            log.notice('warning: forcing build with known host setup problems')
    432412        if opts.get_arg('--list-configs'):
    433413            configs = get_configs(opts)
     
    453433        pass
    454434    except KeyboardInterrupt:
    455         _notice(opts, 'abort: user terminated')
     435        log.notice('abort: user terminated')
    456436        sys.exit(1)
    457437    sys.exit(0)
  • source-builder/sb/check.py

    rec56744 r5142bec  
    3131import version
    3232
    33 def _notice(opts, text):
    34     if not opts.quiet() and log.default and not log.default.has_stdout():
    35         print text
    36     log.output(text)
    37     log.flush()
    38 
    39 
    4033def _check_none(_opts, macro, value, constraint):
    4134    return True
     
    4942    if constraint != 'none' and not path.isdir(value):
    5043        if constraint == 'required':
    51             _notice(_opts, 'error: dir: not found: (%s) %s' % (macro, value))
     44            log.notice('error: dir: not found: (%s) %s' % (macro, value))
    5245            return False
    5346        if _opts.warn_all():
    54             _notice(_opts, 'warning: dir: not found: (%s) %s' % (macro, value))
     47            log.notice('warning: dir: not found: (%s) %s' % (macro, value))
    5548    return True
    5649
     
    7871    if _check_paths(value, paths):
    7972        if absexe:
    80             _notice(_opts,
    81                     'warning: exe: absolute exe found in path: (%s) %s' % (macro, orig_value))
     73            log.notice('warning: exe: absolute exe found in path: (%s) %s' % (macro, orig_value))
    8274        return True
    8375
    8476    if constraint == 'optional':
    85         if _opts.trace():
    86             _notice(_opts, 'warning: exe: optional exe not found: (%s) %s' % (macro, orig_value))
     77        log.trace('warning: exe: optional exe not found: (%s) %s' % (macro, orig_value))
    8778        return True
    8879
    89     _notice(_opts, 'error: exe: not found: (%s) %s' % (macro, orig_value))
     80    log.notice('error: exe: not found: (%s) %s' % (macro, orig_value))
    9081    return False
    9182
     
    124115                raise error.general('invalid check test: %s [%r]' % (test, opts.defaults.get(d)))
    125116            ok = checks[test](opts, d, value, constraint)
    126             if opts.trace():
    127                 if ok:
    128                     tag = ' '
    129                 else:
    130                     tag = '*'
    131                 _notice(opts, '%c %15s: %r -> "%s"' % (tag, d, opts.defaults.get(d), value))
     117            if ok:
     118                tag = ' '
     119            else:
     120                tag = '*'
     121            log.trace('%c %15s: %r -> "%s"' % (tag, d, opts.defaults.get(d), value))
    132122            if sane and not ok:
    133123                sane = False
     
    140130    try:
    141131        _opts = options.load(args = sys.argv)
    142         _notice(_opts, 'RTEMS Source Builder - Check, v%s' % (version.str()))
     132        log.notice('RTEMS Source Builder - Check, v%s' % (version.str()))
    143133        if host_setup(_opts):
    144134            print 'Environment is ok'
     
    154144        pass
    155145    except KeyboardInterrupt:
    156         _notice(opts, 'abort: user terminated')
     146        log.notice('abort: user terminated')
    157147        sys.exit(1)
    158148    sys.exit(0)
  • source-builder/sb/config.py

    rec56744 r5142bec  
    228228        else:
    229229            self.macros = macros
    230         if self.opts.trace():
    231             print 'config: %s' % (name)
     230        self.init_name = name
     231        log.trace('config: %s' % (name))
    232232        self.disable_macro_reassign = False
    233233        self.configpath = []
     
    263263
    264264    def _name_line_msg(self,  msg):
    265         return '%s:%d: %s' % (path.basename(self.name), self.lc,  msg)
     265        return '%s:%d: %s' % (path.basename(self.init_name), self.lc,  msg)
    266266
    267267    def _output(self, text):
     
    269269            log.output(text)
    270270
    271     def _warning(self, msg):
    272         self._output('warning: %s' % (self._name_line_msg(msg)))
    273 
    274271    def _error(self, msg):
    275272        err = 'error: %s' % (self._name_line_msg(msg))
    276         print >> sys.stderr, err
    277         self._output(err)
     273        log.stderr(err)
     274        log.output(err)
    278275        self.in_error = True
    279276        if not self.opts.dry_run():
    280             print >> sys.stderr, 'warning: switched to dry run due to errors'
     277            log.stderr('warning: switched to dry run due to errors')
    281278            self.opts.set_dry_run()
    282279
     
    390387                    colon = m.find(':')
    391388                    if colon < 8:
    392                         self._warning('malformed expand macro, no colon found')
     389                        log.warning('malformed expand macro, no colon found')
    393390                    else:
    394391                        e = self._expand(m[colon + 1:-1].strip())
     
    409406                elif m.startswith('%{echo'):
    410407                    if not m.endswith('}'):
    411                         self._warning("malformed conditional macro '%s'" % (m))
     408                        log.warning("malformed conditional macro '%s'" % (m))
    412409                        mn = None
    413410                    else:
    414411                        e = self._expand(m[6:-1].strip())
    415                         self._output('%s' % (self._name_line_msg(e)))
     412                        log.output('%s' % (self._name_line_msg(e)))
    416413                        s = ''
    417414                        expanded = True
     
    433430                    if colon < 0:
    434431                        if not m.endswith('}'):
    435                             self._warning("malformed conditional macro '%s'" % (m))
     432                            log.warning("malformed conditional macro '%s'" % (m))
    436433                            mn = None
    437434                        else:
     
    475472    def _select(self, config, ls):
    476473        if len(ls) != 2:
    477             self._warning('invalid select statement')
     474            log.warning('invalid select statement')
    478475        else:
    479476            r = self.macros.set_read_map(ls[1])
    480             if self.opts.trace():
    481                 print '_select: ', r, ls[1], self.macros.maps()
     477            log.trace('config: %s: _select: %s %s %r' % \
     478                          (self.init_name, r, ls[1], self.macros.maps()))
    482479
    483480    def _define(self, config, ls):
    484481        if len(ls) <= 1:
    485             self._warning('invalid macro definition')
     482            log.warning('invalid macro definition')
    486483        else:
    487484            d = self._label(ls[1])
     
    494491                        self.macros[d] = ' '.join([f.strip() for f in ls[2:]])
    495492                else:
    496                     self._warning("macro '%s' already defined" % (d))
     493                    log.warning("macro '%s' already defined" % (d))
    497494            else:
    498495                if len(ls) == 2:
     
    503500    def _undefine(self, config, ls):
    504501        if len(ls) <= 1:
    505             self._warning('invalid macro definition')
     502            log.warning('invalid macro definition')
    506503        else:
    507504            mn = self._label(ls[1])
     
    509506                del self.macros[mn]
    510507            else:
    511                 self._warning("macro '%s' not defined" % (mn))
     508                log.warning("macro '%s' not defined" % (mn))
    512509
    513510    def _ifs(self, config, ls, label, iftrue, isvalid):
     
    617614            if invert:
    618615                istrue = not istrue
    619             if self.opts.trace():
    620                 print '_if:  ', ifls, istrue
     616            log.trace('config: %s: _if:  %s %s' % (self.init_name, ifls, str(istrue)))
    621617        return self._ifs(config, ls, '%if', istrue, isvalid)
    622618
     
    664660            if len(l) == 0:
    665661                continue
    666             if self.opts.trace():
    667                 print '%03d: %d %s' % (self.lc, isvalid, l)
     662            log.trace('config: %s: %03d: %s %s' % \
     663                          (self.init_name, self.lc, str(isvalid), l))
    668664            lo = l
    669665            if isvalid:
     
    719715                    if roc:
    720716                        return ('control', '%endif', '%endif')
    721                     self._warning("unexpected '" + ls[0] + "'")
     717                    log.warning("unexpected '" + ls[0] + "'")
    722718                elif ls[0] == '%else':
    723719                    if roc:
    724720                        return ('control', '%else', '%else')
    725                     self._warning("unexpected '" + ls[0] + "'")
     721                    log.warning("unexpected '" + ls[0] + "'")
    726722                elif ls[0].startswith('%defattr'):
    727723                    return ('data', [l])
     
    746742                            if ls[0].strip() == d:
    747743                                return ('directive', ls[0].strip(), ls[1:])
    748                         self._warning("unknown directive: '" + ls[0] + "'")
     744                        log.warning("unknown directive: '" + ls[0] + "'")
    749745                        return ('data', [lo])
    750746            else:
     
    838834
    839835        try:
    840             if self.opts.trace():
    841                 print '_open: %s' % (path.host(configname))
     836            log.trace('config: %s: _open: %s' % (self.init_name, path.host(configname)))
    842837            config = open(path.host(configname), 'r')
    843838        except IOError, err:
     
    859854                    if r[1] == '%end':
    860855                        break
    861                     self._warning("unexpected '%s'" % (r[1]))
     856                    log.warning("unexpected '%s'" % (r[1]))
    862857                elif r[0] == 'directive':
    863858                    new_data = []
     
    874869                        else:
    875870                            if r[2][0].strip() != '-n':
    876                                 self._warning("unknown directive option: '%s'" % (' '.join(r[2])))
     871                                log.warning("unknown directive option: '%s'" % (' '.join(r[2])))
    877872                            _package = r[2][1].strip()
    878873                        self._set_package(_package)
     
    888883                        elif l.startswith('%warning'):
    889884                            l = self._expand(l)
    890                             print >> sys.stderr, 'warning: %s' % (l[9:])
    891                             self._warning(l[9:])
     885                            log.stderr('warning: %s' % (l[9:]))
     886                            log.warning(l[9:])
    892887                        if not dir:
    893888                            l = self._expand(l)
    894889                            ls = self.tags.split(l, 1)
    895                             if self.opts.trace():
    896                                 print '_tag: ', l, ls
     890                            log.trace('config: %s: _tag: %s %s' % (self.init_name, l, ls))
    897891                            if len(ls) > 1:
    898892                                info = ls[0].lower()
     
    905899                                self._info_append(info, info_data)
    906900                            else:
    907                                 self._warning("invalid format: '%s'" % (info_data[:-1]))
     901                                log.warning("invalid format: '%s'" % (info_data[:-1]))
    908902                        else:
    909903                            data.append(l)
     
    977971        #
    978972        opts = options.load(sys.argv, defaults = 'defaults.mc')
    979         if opts.trace():
    980             print 'config: count %d' % (len(opts.config_files()))
     973        log.trace('config: count %d' % (len(opts.config_files())))
    981974        for config_file in opts.config_files():
    982975            s = file(config_file, opts)
     
    990983        sys.exit(1)
    991984    except KeyboardInterrupt:
    992         print 'user terminated'
     985        log.notice('abort: user terminated')
    993986        sys.exit(1)
    994987    sys.exit(0)
  • source-builder/sb/cvs.py

    rec56744 r5142bec  
    2626import error
    2727import execute
     28import log
    2829import options
    2930import path
     
    3435    def _cvs_exit_code(self, cmd, ec, output):
    3536        if ec:
    36             print output
     37            log.output(output)
    3738            raise error.general('cvs command failed (%s): %d' % (cmd, ec))
    3839
     
    5556            cwd = self.path
    5657        cmd = [self.cvs, '-q'] + args
     58        log.output('cmd: (%s) %s' % (str(cwd), ' '.join(cmd)))
    5759        exit_code, proc, output = e.spawn(cmd, cwd = cwd)
     60        log.trace(output)
    5861        if check:
    5962            self._cvs_exit_code(cmd, exit_code, output)
  • source-builder/sb/download.py

    rec56744 r5142bec  
    3434import log
    3535import path
    36 
    37 def _notice(opts, text):
    38     if not opts.quiet() and not log.default.has_stdout():
    39         print text
    40     log.output(text)
    41     log.flush()
    42 
    43 def _output(opts, text):
    44     if not opts.quiet():
    45         log.output(text)
    4636
    4737def _http_parser(source, config, opts):
     
    143133    if url.startswith('https://api.github.com'):
    144134        url = urlparse.urljoin(url, config.expand('tarball/%{version}'))
    145     _notice(opts, 'download: %s -> %s' % (url, os.path.relpath(path.host(local))))
     135    log.notice('download: %s -> %s' % (url, os.path.relpath(path.host(local))))
    146136    failed = False
    147137    if not opts.dry_run():
     
    153143            _out.write(_in.read())
    154144        except IOError, err:
    155             msg = 'download: %s: error: %s' % (url, str(err))
    156             _notice(opts, msg)
     145            log.notice('download: %s: error: %s' % (url, str(err)))
    157146            if path.exists(local):
    158147                os.remove(path.host(local))
    159148            failed = True
    160149        except ValueError, err:
    161             msg = 'download: %s: error: %s' % (url, str(err))
    162             _notice(opts, msg)
     150            log.notice('download: %s: error: %s' % (url, str(err)))
    163151            if path.exists(local):
    164152                os.remove(path.host(local))
     
    166154        except:
    167155            msg = 'download: %s: error' % (url)
    168             print >> sys.stderr, msg
     156            log.stderr(msd)
     157            log.notice(msg)
    169158            if _out is not None:
    170159                _out.close()
     
    184173    repo = git.repo(local, opts, config.macros)
    185174    if not repo.valid():
    186         _notice(opts, 'git: clone: %s -> %s' % (us[0], rlp))
     175        log.notice('git: clone: %s -> %s' % (us[0], rlp))
    187176        if not opts.dry_run():
    188177            repo.clone(us[0], local)
     
    190179        _as = a.split('=')
    191180        if _as[0] == 'branch':
    192             _notice(opts, 'git: checkout: %s => %s' % (us[0], _as[1]))
     181            log.notice('git: checkout: %s => %s' % (us[0], _as[1]))
    193182            if not opts.dry_run():
    194183                repo.checkout(_as[1])
    195184        elif _as[0] == 'pull':
    196             _notice(opts, 'git: pull: %s' % (us[0]))
     185            log.notice('git: pull: %s' % (us[0]))
    197186            if not opts.dry_run():
    198187                repo.pull()
    199188        elif _as[0] == 'fetch':
    200             _notice(opts, 'git: fetch: %s -> %s' % (us[0], rlp))
     189            log.notice('git: fetch: %s -> %s' % (us[0], rlp))
    201190            if not opts.dry_run():
    202191                repo.fetch()
     
    205194            if len(_as) > 1:
    206195                arg = ['--%s' % (_as[1])]
    207             _notice(opts, 'git: reset: %s' % (us[0]))
     196            log.notice('git: reset: %s' % (us[0]))
    208197            if not opts.dry_run():
    209198                repo.reset(arg)
     
    237226    repo = cvs.repo(local, opts, config.macros, src_prefix)
    238227    if not repo.valid():
    239         _notice(opts, 'cvs: checkout: %s -> %s' % (us[0], rlp))
     228        log.notice('cvs: checkout: %s -> %s' % (us[0], rlp))
    240229        if not opts.dry_run():
    241230            repo.checkout(':%s' % (us[0][6:]), module, tag, date)
     
    243232        _as = a.split('=')
    244233        if _as[0] == 'update':
    245             _notice(opts, 'cvs: update: %s' % (us[0]))
     234            log.notice('cvs: update: %s' % (us[0]))
    246235            if not opts.dry_run():
    247236                repo.update()
    248237        elif _as[0] == 'reset':
    249             _notice(opts, 'cvs: reset: %s' % (us[0]))
     238            log.notice('cvs: reset: %s' % (us[0]))
    250239            if not opts.dry_run():
    251240                repo.reset()
     
    267256        raise error.general('source/patch path invalid')
    268257    if not path.isdir(path.dirname(local)) and not opts.download_disabled():
    269         _notice(opts,
    270                 'Creating source directory: %s' % (os.path.relpath(path.host(path.dirname(local)))))
    271     _output(opts, 'making dir: %s' % (path.host(path.dirname(local))))
     258        log.notice('Creating source directory: %s' % \
     259                      (os.path.relpath(path.host(path.dirname(local)))))
     260    log.output('making dir: %s' % (path.host(path.dirname(local))))
    272261    if not opts.dry_run():
    273262        path.mkdir(path.dirname(local))
     
    291280            urls.append(urlparse.urljoin(base, url_file))
    292281    urls.append(url)
    293     if opts.trace():
    294         print '_url:', ','.join(urls), '->', local
     282    log.trace('_url: %s -> %s' % (','.join(urls), local))
    295283    for url in urls:
    296284        for dl in downloaders:
  • source-builder/sb/execute.py

    rec56744 r5142bec  
    182182                    if e not in ['.exe', '.com', '.bat']:
    183183                        command[0] = command[0] + '.exe'
     184            log.trace('exe: %s' % (command))
    184185            proc = subprocess.Popen(command, shell = shell,
    185186                                    cwd = cwd, env = env,
  • source-builder/sb/git.py

    rec56744 r5142bec  
    2626import error
    2727import execute
     28import log
    2829import options
    2930import path
     
    4243        else:
    4344            cwd = None
    44         exit_code, proc, output = e.spawn([self.git] + args, cwd = cwd)
     45        cmd = [self.git] + args
     46        log.trace('cmd: (%s) %s' % (str(cwd), ' '.join(cmd)))
     47        exit_code, proc, output = e.spawn(cmd, cwd = cwd)
     48        log.trace(output)
    4549        if check:
    4650            self._git_exit_code(exit_code)
  • source-builder/sb/log.py

    rec56744 r5142bec  
    3232default = None
    3333
     34#
     35# Global parameters.
     36#
     37tracing = False
     38quiet = False
     39
    3440def set_default_once(log):
    3541    if default is None:
    3642        default = log
    3743
    38 def output(text = os.linesep, log = None):
     44def _output(text = os.linesep, log = None):
    3945    """Output the text to a log if provided else send it to stdout."""
    4046    if text is None:
     
    5258        for l in text.replace(chr(13), '').splitlines():
    5359            print l
     60
     61def stderr(text = os.linesep, log = None):
     62    for l in text.replace(chr(13), '').splitlines():
     63        print >> sys.stderr, l
     64
     65def output(text = os.linesep, log = None):
     66    if not quiet:
     67        _output(text, log)
     68
     69def notice(text = os.linesep, log = None):
     70    if not quiet and default is not None and not default.has_stdout():
     71        for l in text.replace(chr(13), '').splitlines():
     72            print l
     73    _output(text, log)
     74
     75def trace(text = os.linesep, log = None):
     76    if tracing:
     77        _output(text, log)
     78
     79def warning(text = os.linesep, log = None):
     80    for l in text.replace(chr(13), '').splitlines():
     81        _output('warning: %s' % (l), log)
    5482
    5583def flush(log = None):
     
    95123            if self.fhs[f] is not None:
    96124                self.fhs[f].write(out)
     125        self.flush()
    97126
    98127    def flush(self):
     
    105134    l = log(['stdout', 'log.txt'])
    106135    for i in range(0, 10):
    107         l.output('hello world: %d\n' % (i))
    108     l.output('hello world CRLF\r\n')
    109     l.output('hello world NONE')
     136        l.output('log: hello world: %d\n' % (i))
     137    l.output('log: hello world CRLF\r\n')
     138    l.output('log: hello world NONE')
    110139    l.flush()
     140    for i in [0, 1]:
     141        quiet = False
     142        tracing = False
     143        print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     144        trace('trace with quiet and trace off')
     145        notice('notice with quiet and trace off')
     146        quiet = True
     147        tracing = False
     148        print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     149        trace('trace with quiet on and trace off')
     150        notice('notice with quiet on and trace off')
     151        quiet = False
     152        tracing = True
     153        print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     154        trace('trace with quiet off and trace on')
     155        notice('notice with quiet off and trace on')
     156        quiet = True
     157        tracing = True
     158        print '- quiet:%s - trace:%s %s' % (str(quiet), str(tracing), '-' * 30)
     159        trace('trace with quiet on and trace on')
     160        notice('notice with quiet on and trace on')
     161        default = l
    111162    del l
  • source-builder/sb/options.py

    rec56744 r5142bec  
    3131import execute
    3232import git
     33import log
    3334import macros
    3435import path
     
    244245
    245246    def post_process(self):
     247        # Handle the log first.
     248        log.default = log.log(self.logfiles())
     249        if self.trace():
     250            log.tracing = True
     251        if self.quiet():
     252            log.quiet = True
    246253        # Must have a host
    247254        if self.defaults['_host'] == self.defaults['nil']:
     
    271278            for m in um:
    272279                self.defaults.load(m)
     280
     281    def sb_git(self):
     282        repo = git.repo(self.defaults.expand('%{_sbdir}'), self)
     283        if repo.valid():
     284            repo_valid = '1'
     285            repo_head = repo.head()
     286            repo_clean = repo.clean()
     287            repo_id = repo_head
     288            if not repo_clean:
     289                repo_id += '-modified'
     290        else:
     291            repo_valid = '0'
     292            repo_head = '%{nil}'
     293            repo_clean = '%{nil}'
     294            repo_id = 'no-repo'
     295        self.defaults['_sbgit_valid'] = repo_valid
     296        self.defaults['_sbgit_head']  = repo_head
     297        self.defaults['_sbgit_clean'] = str(repo_clean)
     298        self.defaults['_sbgit_id']    = repo_id
    273299
    274300    def command(self):
     
    467493        o.defaults[k] = overrides[k]
    468494
     495    o.sb_git()
    469496    o.process()
    470497    o.post_process()
    471498
    472     repo = git.repo(o.defaults.expand('%{_sbdir}'), o)
    473     if repo.valid():
    474         repo_valid = '1'
    475         repo_head = repo.head()
    476         repo_clean = repo.clean()
    477         repo_id = repo_head
    478         if not repo_clean:
    479             repo_id += '-modified'
    480     else:
    481         repo_valid = '0'
    482         repo_head = '%{nil}'
    483         repo_clean = '%{nil}'
    484         repo_id = 'no-repo'
    485     o.defaults['_sbgit_valid'] = repo_valid
    486     o.defaults['_sbgit_head']  = repo_head
    487     o.defaults['_sbgit_clean'] = str(repo_clean)
    488     o.defaults['_sbgit_id']    = repo_id
    489499    return o
    490500
  • source-builder/sb/reports.py

    rec56744 r5142bec  
    4545    print 'error: unknown application load error'
    4646    sys.exit(1)
    47 
    48 def _notice(opts, text):
    49     if not opts.quiet() and not log.default.has_stdout():
    50         print text
    51     log.output(text)
    52     log.flush()
    5347
    5448class report:
     
    365359                    '--output':       'File name to output the report' }
    366360        opts = options.load(args, optargs)
    367         log.default = log.log(opts.logfiles())
    368361        if opts.get_arg('--output') and len(opts.params()) > 1:
    369362            raise error.general('--output can only be used with a single config')
    370363        print 'RTEMS Source Builder, Reporter v%s' % (version.str())
    371364        if not check.host_setup(opts):
    372             _notice(opts, 'warning: forcing build with known host setup problems')
     365            log.warning('forcing build with known host setup problems')
    373366        configs = build.get_configs(opts)
    374367        if not setbuilder.list_bset_cfg_files(opts, configs):
     
    410403        pass
    411404    except KeyboardInterrupt:
    412         _notice(opts, 'abort: user terminated')
     405        log.notice('abort: user terminated')
    413406        sys.exit(1)
    414407    sys.exit(0)
  • source-builder/sb/setbuilder.py

    rec56744 r5142bec  
    4747    sys.exit(1)
    4848
    49 def _trace(opts, text):
    50     if opts.trace():
    51         print text
    52 
    53 def _notice(opts, text):
    54     if not opts.quiet() and not log.default.has_stdout():
    55         print text
    56     log.output(text)
    57     log.flush()
    58 
    5949class buildset:
    6050    """Build a set builds a set of packages."""
    6151
    6252    def __init__(self, bset, _configs, opts, macros = None):
    63         _trace(opts, '_bset:%s: init' % (bset))
     53        log.trace('_bset: %s: init' % (bset))
    6454        self.configs = _configs
    6555        self.opts = opts
     
    7161        self.bset_pkg = '%s-%s-set' % (self.macros.expand('%{_target}'), self.bset)
    7262
    73     def _output(self, text):
    74         if not self.opts.quiet():
    75             log.output(text)
    76 
    7763    def copy(self, src, dst):
    7864        if not os.path.isdir(path.host(src)):
     
    8369                                                     path.host(dst))
    8470                for f in files:
    85                     self._output(f)
     71                    log.output(f)
    8672            except IOError, err:
    8773                raise error.general('copying tree: %s -> %s: %s' % (src, dst, str(err)))
     
    114100            outpath = path.host(path.join(buildroot, prefix, 'share', 'rtems-source-builder'))
    115101            outname = path.host(path.join(outpath, name))
    116             _notice(self.opts, 'reporting: %s -> %s' % (_config, name))
     102            log.notice('reporting: %s -> %s' % (_config, name))
    117103            if not _build.opts.dry_run():
    118104                _build.mkdir(outpath)
     
    124110        what = '%s -> %s' % \
    125111            (os.path.relpath(path.host(src)), os.path.relpath(path.host(dst)))
    126         if self.opts.trace():
    127             _notice(self.opts, 'collecting: %s' % (what))
     112        log.trace('_bset: %s: collecting: %s' % (self.bset, what))
    128113        if not self.opts.dry_run():
    129114            self.copy(src, dst)
     
    132117        dst = prefix
    133118        src = path.join(buildroot, prefix)
    134         _notice(self.opts, 'installing: %s -> %s' % (name, path.host(dst)))
     119        log.notice('installing: %s -> %s' % (name, path.host(dst)))
    135120        if not self.opts.dry_run():
    136121            self.copy(src, dst)
     
    171156            path.mkdir(tardir)
    172157            tar = path.join(tardir, _build.config.expand('%s.tar.bz2' % (self.bset_pkg)))
    173             _notice(self.opts, 'tarball: %s' % (os.path.relpath(path.host(tar))))
     158            log.notice('tarball: %s' % (os.path.relpath(path.host(tar))))
    174159            if not self.opts.dry_run():
    175160                tmproot = _build.config.expand('%{_tmproot}')
     
    199184                raise error.general('no build set file found: %s' % (bset))
    200185        try:
    201             if self.opts.trace():
    202                 print '_bset:%s: open: %s' % (self.bset, bsetname)
     186            log.trace('_bset: %s: open: %s' % (self.bset, bsetname))
    203187            bset = open(path.host(bsetname), 'r')
    204188        except IOError, err:
     
    214198                if len(l) == 0:
    215199                    continue
    216                 if self.opts.trace():
    217                     print '%03d: %s' % (lc, l)
     200                log.trace('_bset: %s: %03d: %s' % (self.bset, lc, l))
    218201                ls = l.split()
    219202                if ls[0][-1] == ':' and ls[0][:-1] == 'package':
     
    266249    def build(self, deps = None):
    267250
    268         _trace(self.opts, '_bset:%s: make' % (self.bset))
    269         _notice(self.opts, 'Build Set: %s' % (self.bset))
     251        log.trace('_bset: %s: make' % (self.bset))
     252        log.notice('Build Set: %s' % (self.bset))
    270253
    271254        configs = self.load()
    272255
    273         _trace(self.opts, '_bset:%s: configs: %s'  % (self.bset, ','.join(configs)))
     256        log.trace('_bset: %s: configs: %s'  % (self.bset, ','.join(configs)))
    274257
    275258        current_path = os.environ['PATH']
     
    319302                    (not self.opts.no_clean() or self.opts.always_clean()):
    320303                for b in builds:
    321                     _notice(self.opts, 'cleaning: %s' % (b.name()))
     304                    log.notice('cleaning: %s' % (b.name()))
    322305                    b.cleanup()
    323306            for b in builds:
     
    331314        os.environ['PATH'] = current_path
    332315
    333         _notice(self.opts, 'Build Set: Time %s' % (str(end - start)))
     316        log.notice('Build Set: Time %s' % (str(end - start)))
    334317
    335318def list_bset_cfg_files(opts, configs):
     
    358341                    '--pkg-tar-files': 'Create package tar files' }
    359342        opts = options.load(sys.argv, optargs)
    360         log.default = log.log(opts.logfiles())
    361         _notice(opts, 'RTEMS Source Builder - Set Builder, v%s' % (version.str()))
     343        log.notice('RTEMS Source Builder - Set Builder, v%s' % (version.str()))
    362344        if not check.host_setup(opts):
    363345            raise error.general('host build environment is not set up correctly')
     
    391373        pass
    392374    except KeyboardInterrupt:
    393         _notice(opts, 'abort: user terminated')
     375        log.notice('abort: user terminated')
    394376        sys.exit(1)
    395377    sys.exit(0)
Note: See TracChangeset for help on using the changeset viewer.