In This Package:

Control.py

Go to the documentation of this file.

#!/usr/bin/env python

import os, sys
import GaudiKernel.SystemOfUnits as units


class NuWa:
    """
    This is the main program to run NuWa offline jobs.
    
    It provides a job with a minimal, standard setup.  Non standard
    behavior can made using command line options or providing additional
    configuration in the form of python files or modules to load.
    
    Usage:
    
      nuwa.py [options] [-m|--module "mod.ule --mod-arg ..."] \\
              [config1.py config2.py ...] \\
              [mod.ule1 mod.ule2 ...] \\
              [[input1.root input2.root ...] or [input1.data ...]] \\

    Python modules can be specified with -m|--module options and may
    include any per-module arguments by enclosing them in shell quotes
    as in the above usage.  Modules that do not take arguments may
    also be listed as non-option arguments.  Modules may supply the
    following functions:

    configure(argv=[]) - if exists, executed at configuration time

    run(theApp) - if exists, executed at run time with theApp set to
    the AppMgr.

    Additionally, python job scripts may be specified.

    Modules and scripts are loaded in the order they are specified on
    the command line.

    Finally, input ROOT files may be specified.  These will be read in
    the order they are specified and will be assigned to supplying
    streams not specificially specified in any input-stream map.

    The listing of modules, job scripts and/or ROOT files may be
    interspersed but must follow all options.

    """

    def __init__(self):
        ' Create a NuWa instance.'
        from optparse import OptionParser
        from DybPython.hostid import hostid
        parser = OptionParser(usage=self.__doc__)

        parser.add_option("-A", "--aes-trim-window",default="0",type="string",
                          help="'None' for no AES. Turn on AES with zero or any positive value and use that for AES trimming window (in second).")

        parser.add_option("-l", "--log-level",default=3,type="int",
                          help="Set output log level.")

        parser.add_option("-M","--msg-stream-level", action="append",
                          help="Set individual MsgStream levels using form: 'StreamName,LevelNumber'")

        parser.add_option("-L", "--file-list", default=None, type="string",
                          help="Input file list")

        parser.add_option("-C", "--color",default="no",
                          help="Use colored logs assuming given background ('light' or 'dark')")

        parser.add_option("-i", "--interactive",action="store_true",default=False,
                          help="Enter interactive ipython shell after the run completes (def is batch).")

        parser.add_option("-s", "--show-includes", action="store_true",default=False,
                          help="Show printout of included files.")

        parser.add_option("-m", "--module", action="append", 
                          help="Load given module and pass optional argument list")

        parser.add_option("-n", "--executions", default=0, type="int",
                          help="Number of times to execute list of top level algorithms.")

        parser.add_option("-o", "--output",default="",
                          help="Output filename")

        parser.add_option("-O", "--output-streams",default="{}",
                          help="Output file map")

        parser.add_option("-I", "--input-streams",default="{}",
                          help="Input file map")

        parser.add_option("-H", "--hostid",default=hostid(), type="int",
                          help="Force given hostid")

        parser.add_option("-R", "--run",default=0, type="int",
                          help="Set run number")

        parser.add_option("-T", "--time",default="0", type="string",
                          help="Set wall time")

        parser.add_option("", "--dbconf",default=None , type="string",
                          help="Sets DBCONF envvar identifying section of ~/.my.cnf to use for DB connection parameters and triggering DBI to use this config (DbiCascader.cxx)  ")

        parser.add_option("-N", "--execution",default=0, type="int",
                          help="Set the starting execution number")

        parser.add_option("-V", "--visualize", action="store_true", default = False,
                          help="Run in visualize mode")

        parser.add_option("-E", "--external-loop", type='string', default='',
                          help="Delegate to an external loop, name a module with a 'start(app)' method defined.")

        parser.add_option("-G", "--detector",default= "",
                          help="Specify a non-default, top-level geometry file")

        parser.add_option("-K", "--leak-check-execute",action="store_true",default= False,
                          help="Use Hephaestus memory tracker")
        parser.add_option("","--leak-check-method",action="append",
                          default=[],
                          help="Add a method for the leak checker to focus on");

        parser.add_option("","--no-history",action='store_const',dest='history',
                          const='off',help='Same as --history=off')
        parser.add_option("","--history",default="on",
                          help="Control HistorySvc info.  'on'=send to log, 'off'=no history, anything else is a name of file to which to dump.");

        parser.add_option("","--daq", default="on" , type="string",
                          help="Set DaqFormat usage 'on' or 'off'");
        
        parser.add_option("","--raw-load",default="off",
                          help="Optional debug reading of raw data.  'off'=disable, 'packed'=load binary packed data, 'unpacked'=load unpacked data, 'both'=load both binary packed and unpacked data.");
        
        parser.add_option("","--random",default="on",
                          help="Enable source of random numbers.  'off'=disable, 'on'=enable.");

        parser.add_option("", "--output-stats",default=None,
                          help="Output file map for histograms.   Ex: {'file1':'histograms.root'}")

        parser.add_option("", "--input-stats",default=None,
                          help="Input file map for histograms.   Ex: {'file1':'histograms.root'}")
        parser.add_option("", "--force-readout", action="store_true",default=False,
                          help="Force Readout to be written to output file.")

        import uuid
        parser.add_option("", "--jobid",default=str(uuid.uuid1()),
                          help="Set the job ID for bookkeeping")

        parser.add_option("", "--job-info",default="{}",
                          help="Add or override job bookkeeping information")


        parser.disable_interspersed_args()
        self.opts_parser = parser
        self.DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
        self.post_user_algs = []

        # If the spade service (SpadeAlgo) is used it will register itself.
        self.spadeSvc = None;
        return

    def cmdline(self,argv):
        'Parse command line'
        (options,args) = self.opts_parser.parse_args(args=argv)

        self.opts = options
        self.args = args

        # convert string to dictionary object
        from Tools import mapify
        self.opts.input_streams = mapify(self.opts.input_streams)
        self.opts.output_streams = mapify(self.opts.output_streams)
        if self.opts.output_stats:
            self.opts.output_stats = mapify(self.opts.output_stats)
        if self.opts.input_stats:
            self.opts.input_stats = mapify(self.opts.input_stats)
        self.opts.job_info = mapify(self.opts.job_info)

        # Convert formatted time to seconds since Epoch
        from time import gmtime, mktime, strftime, strptime, timezone
        if -1 != self.opts.time.find('T'):
            self.opts.time = int(mktime(strptime(self.opts.time,
                                                 self.DATETIME_FORMAT))
                                 -timezone)
            # Note: mktime adds the timezone, so we need to subtract it.
        else:
            self.opts.time = int(self.opts.time)


        from Tools import mapify, unitify
        if self.opts.aes_trim_window.lower() == "none":
            self.use_AES = False
        else:
            self.use_AES = True
            self.AES_window = unitify(self.opts.aes_trim_window,"second")
            if self.AES_window >=0 :
                print "AES is turned on and trimming window is set to ",\
                    self.AES_window/units.second," seconds"
                # valid
                pass
            else :
                print "error: invalid AES trimming window"
                exit()

        return

    def known_input_type(self,fname):
        'Return True if file name has a recognized extension.'
        for ext in ['.root','.data','.rraw','.list']:
            if fname[-len(ext):] == ext:
                return True
            continue
        return False

    def add_input_file(self,fname):
        '''Add file name or list of file names to self.input_files,
        expanding if it is a .list file.'''

        if not fname: return

        #print 'add_input_file(%s)'%fname

        # recurse if list
        if isinstance(fname,list):
            for name in fname:
                self.add_input_file(name)
                continue
            return

        if not self.known_input_type(fname):
            msg = 'Got unknown input file type: "%s"'%fname
            print msg
            raise TypeError,msg

        if fname[-5:] != '.list':
            self.input_files.append(fname)
            return

        # process as a list file
        fp = open(fname)
        for line in fp.readlines():
            line = line.strip()
            if len(line) == 0: continue
            if line[0] == '#': pass
            if not line: pass
            if not self.known_input_type(line):
                print ' unknown file:',line
                continue
            self.add_input_file(line)
            continue
        fp.close()
        return


    def configure_python_features(self):
        'Set up python features'
        if not os.getcwd() in sys.path:
            sys.path = [ os.getcwd() ] + sys.path

        if not '' in sys.path:
            sys.path = [ '' ] + sys.path

        sys.ps1 = 'nuwa> '
        sys.ps2 = '. ... '


        if self.opts.interactive:
            try:
                import rlcompleter, readline, atexit
            except ImportError:
                print 'No readline available.'
            else:
                readline.parse_and_bind('tab: complete')
                readline.parse_and_bind('set show-all-if-ambiguous On')
            
                fhistory = os.path.expanduser( '~/.nuwa_history' )
                if os.path.exists(fhistory):
                    readline.read_history_file(fhistory)
                readline.set_history_length(1024)
                atexit.register(readline.write_history_file,fhistory)
        else:                   # batch
            if os.isatty(sys.stdin.fileno()):
                os.close(sys.stdin.fileno())
            pass
        

        if self.opts.leak_check_execute:
            try:
                import Hephaestus.MemoryTracker as memtrack
            except ImportError:
                print "ERROR: Hephaestus is not available."
                sys.exit(1)
            else:
                methods = []
                if "Algorithm::sysExecute" not in self.opts.leak_check_method:
                    methods.append("Algorithm::sysExecute")
                methods += self.opts.leak_check_method
                for m in methods:
                    print "Will leak check in",m
                    memtrack.trace(m)
                memtrack.start()

        if self.opts.dbconf:
            os.environ.update( DBCONF=self.opts.dbconf )
            print "Defining DBCONF to %s " % os.environ.get('DBCONF') 

        # to do:
        # * set up python side logging

        return


    def configure_ipython(self):
        """
             If ipython not available or are already inside ipython, setup a dummy 
             embedded ipython ipshell function, otherwise setup the real thing.
        """
        if not self.opts.interactive:
            return

        def ipshell(*args): pass
        self.ipshell = ipshell

        try:
            import IPython
        except ImportError:
            print "No ipython available."
            return

        try:
            __IPYTHON__
        except NameError:
            from IPython.Shell import IPShellEmbed
            irgs = [''] 
            banner = "entering ipython embedded shell, within the scope of the NuWa instance... try the locals() command " 
            self.ipshell = IPShellEmbed(irgs, banner=banner, exit_msg="exiting ipython" )



    def configure_framework(self):
        'Set up framework level defaults'

        # Fudge to make sure the right TimeStamp definition is loaded for MDC10b
        from GaudiPython import gbl
        t = gbl.TimeStamp()
        # end fudge
        
        from Gaudi.Configuration import ApplicationMgr
        self.theApp = ApplicationMgr()
        self.theApp.OutputLevel = self.opts.log_level

        # Setup history service 
        if self.opts.history.lower() not in ["off","no","none","n","false"] \
                and self.opts.executions != 0:
            from GaudiSvc.GaudiSvcConf import HistorySvc
            hs = HistorySvc()
            hs.OutputLevel = 1
            self.theApp.ExtSvc.append(hs)
            self.theApp.ActivateHistory = True
            if self.opts.history.lower() in ["on","yes","y","true"]:
                hs.Dump = True
            else:
                hs.OutputFile = self.opts.history

        # Use our event data service which will in turn use the
        # standard EvtDataSvc as an Archive Event Service by default
        import DybEventMgr
        DybEventMgr.Configure(self.use_AES) # double negative

        # Deal with I/O.
        try:
            import DybPython.Catalog as Catalog
            print 'Embedded Catalog is available'
        except ImportError:
            print 'No Embedded Catalog available'

        # Input files can be determined in several ways
        self.input_files = []

        # First add files that are specified on the command line
        left_overs = []
        for arg in self.args:
            if not self.known_input_type(arg):
                left_overs.append(arg)
                continue
            self.add_input_file(arg)
            continue
        self.args = left_overs
        del(left_overs)

        # Next, WTF is this code supposed to do?  The first half
        # requires a Python file to exist but then strips off the .py
        # and loads it as a module.  This unnecessarily limiting use
        # to a .py file in the current directory and won't allow use
        # of modules that are found via sys.path.  The second half
        # duplicates the functionality of just specifying input files
        # on the command line.
        if self.opts.file_list:
            if (os.path.exists(self.opts.file_list) and self.opts.file_list[-3:] == '.py'):
                # If python file, assume it is a List module
                listModule = self.opts.file_list[:-3]
                try:
                    exec('import ' + listModule)
                except Exception,err:
                    import traceback
                    traceback.print_exc()
                    print 'Failed to load', listModule
                    sys.exit(1)
                print "Loaded \"%s\""%listModule
                self.add_input_file(eval(listModule + '.list'))

            else:
                # Otherwise get list by evaluation the expression.
                fnames = eval(str(self.opts.file_list))
                # if evaluation is not a real list try and force it to be one.
                if not isinstance(fnames, type([])):
                    fnames = eval(str(fnames))
                self.add_input_file(fnames)


        # Check that all input files are of the same type
        inputFiletype = None
        if self.input_files:
            firstFile = self.input_files[0]
            inputFiletype = firstFile[-5:]
            for filename in self.input_files[1:]:
                if filename[-5:] != inputFiletype:
                    msg = "nuwa.py ERROR: Incorrect file type:",file
                    raise TypeError,msg
                    pass
                continue
            pass

        # Should check that the files exist unless they are 
        # xrootd files
        for fname in self.input_files:
            if fname[:7]=='root://' :
                if self.input_files.index( fname ) < 1 :
                    print 'Cannot test for existence of xrootd file. Here is first file',fname
            else:
                if not os.path.exists(fname):
                    msg = 'Warning: input file does not exist "%s"'%fname
                    raise RuntimeError,msg
                continue

        # For ROOT input, prepare streams
        if self.input_files and inputFiletype == '.root':
            try:
                default = self.opts.input_streams['default']
            except KeyError:
                default = self.input_files
            self.opts.input_streams['default'] = default
            pass
            
        if self.opts.input_streams and inputFiletype == '.root':
            # Enable reading of Run Data from ROOT input file
            from RunDataSvc.RunDataSvcConf import RunDataSvc
            runDataSvc = RunDataSvc()
            runDataSvc.ReadFromFile = True
            self.theApp.ExtSvc.append( runDataSvc )

            # Enable reading of Job Info from ROOT input file
            from JobInfoSvc.JobInfoSvcConf import JobInfoSvc
            jobInfoSvc = JobInfoSvc()
            jobInfoSvc.ReadFromFile = True
            self.theApp.ExtSvc.append( jobInfoSvc )

        # Merge default output files if needed
        if self.opts.output:
            self.opts.output_streams['default'] = self.opts.output

        if self.opts.output_streams:
            # Add Run Data to ROOT output file
            from RunDataSvc.RunDataSvcConf import RunDataWriterAlg
            runDataWriterAlg = RunDataWriterAlg()
            runDataWriterAlg.WriteToFile = True

            # Add Job Info to ROOT output file
            from JobInfoSvc.JobInfoSvcConf import JobInfoWriterAlg
            jobInfoWriterAlg = JobInfoWriterAlg()
            jobInfoWriterAlg.WriteToFile = True

        import RootIOSvc
        self.io = RootIOSvc.Configure(self.opts.input_streams,
                                      self.opts.output_streams,
                                      self.opts.force_readout)

        # Set up DaqFormat handling
        import DaqReadoutSvc
        daqSvc=DaqReadoutSvc.DaqReadoutSvc()
        if self.opts.daq == 'on':
            daqSvc.Generating=True
        if self.opts.daq == 'off':
            daqSvc.Generating=False
        daqSvc.RunNumber = self.opts.run

        # Enable Raw File I/O if given raw data files.
        if inputFiletype == '.data' or inputFiletype == '.rraw':
            if (self.opts.daq == 'off' and self.opts.raw_load == 'off') or self.opts.raw_load == 'raw':
                import RawDataIO
                self.rawIo = RawDataIO.Configure()
                self.rawIo.InputSvc.RawDataFiles = self.input_files
            elif self.opts.daq == 'on' or self.opts.raw_load == 'daq':
                import DaqFormatIO
                self.daqIO = DaqFormatIO.eventSelector()
                self.daqIO.InputFiles = self.input_files
                self.daqIO.SamplingInterval = 1
                # For ActionOnInvalid: 0 = exit, 1 = skip, 2 = process
                self.daqIO.ActionOnInvalid = 1
            elif self.opts.raw_load.startswith('daq-'):
                from DaqFormatModules.DaqFormatModulesConf import DybDaq__DaqFormatInput
                self.rawLoad = DybDaq__DaqFormatInput()
                self.theApp.TopAlg += [self.rawLoad]
                self.rawLoad.InputFiles = self.input_files
                if self.opts.raw_load =='daq-repackage':
                    self.rawLoad.Repackage = True
                else:
                    self.rawLoad.Repackage = False
                    if self.opts.raw_load in ['daq-both','daq-packed']:
                        self.rawLoad.UsePacked = True
                    else:
                        self.rawLoad.UsePacked = False
                    if self.opts.raw_load in ['daq-both','daq-unpacked']:
                        self.rawLoad.UseUnpacked = True
                    else:
                        self.rawLoad.UseUnpacked = False
            else:
                from DataDebug.DataDebugConf import DataLoaderAlg
                self.rawLoad = DataLoaderAlg()
                self.theApp.TopAlg += [self.rawLoad]
                self.rawLoad.InputFiles = self.input_files
                if self.opts.raw_load in ['both','packed']:
                    self.rawLoad.UsePacked = True
                else:
                    self.rawLoad.UsePacked = False
                if self.opts.raw_load in ['both','unpacked']:
                    self.rawLoad.UseUnpacked = True
                else:
                    self.rawLoad.UseUnpacked = False
                    
        # Configure Statistics Service for histogram I/O
        if self.opts.output_stats or self.opts.input_stats:
            print 'output_stats=',self.opts.output_stats
            print 'input_stats=',self.opts.input_stats
            from StatisticsSvc.StatisticsSvcConf import StatisticsSvc
            statsSvc = StatisticsSvc()
            if self.opts.output_stats:
                statsSvc.Output = self.opts.output_stats
            if self.opts.input_stats:
                statsSvc.Input = self.opts.input_stats 
            self.theApp.ExtSvc.append( statsSvc )
            pass

        ninput = len(self.input_files)
        for k,v in self.opts.input_streams.iteritems():
            ninput += len(v)
        if self.opts.executions == -1 and ninput == 0:
            err = 'Unbounded running with no input files, probably not what you wanted.\n'
            sys.stderr.write(err)
            sys.exit(1)
            pass
        
        return

    def configure_random(self):

        if self.opts.random == 'on':
            from DybAlg import RandomSeeder
            rs = RandomSeeder(hostid = self.opts.hostid,
                              run = self.opts.run,
                              execcountoffset = self.opts.execution-1);
        return

    def configure_run(self):
        # Catch command-line run number and wall time for simulation jobs
        # Send run number and wall time to RunDataSvc
        from RunDataSvc.RunDataSvcConf import RunDataSvc
        runDataSvc = RunDataSvc()
        runDataSvc.SimRunNumber = self.opts.run
        runDataSvc.SimStartTime = self.opts.time
        self.theApp.ExtSvc.append( runDataSvc )
        return

    def configure_job(self):
        # Catch job configuration info and feed to Job Info Service
        from JobInfoSvc.JobInfoSvcConf import JobInfoSvc
        jobInfoSvc = JobInfoSvc()
        # Initialize current job info
        import sys, time, os
        nuwaPath = os.path.realpath(os.path.expandvars('$DYBRELEASEROOT/../../'))
        # Get SVN revision number from file (faster than calling svnversion)
        revision = "Unknown"
        revPath = os.path.expandvars('$DYBPYTHONROOT/share/revision.txt')
        if os.path.isfile(revPath):
            revisionFile = open(revPath)
            if revisionFile:
                revLine = revisionFile.readline()
                if revLine != "":
                    revision = revLine.strip()
        jobConfigList = {'command':' '.join(sys.argv),
                         'revision':revision,
                         'nuwaPath':nuwaPath,
                         'cmtConfig':os.getenv('CMTCONFIG'),
                         'hostid':str(self.opts.hostid),
                         'jobTime':time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()),
                         'username':os.getenv('LOGNAME')}
        jobInfoSvc.JobId = self.opts.jobid
        # Process user-defined job information
        for key in self.opts.job_info.keys():
            print "User-defined job info: "+key+" = "+self.opts.job_info[key]
            jobConfigList[key] = self.opts.job_info[key]
        jobInfoSvc.JobConfig = jobConfigList
        self.theApp.ExtSvc.append( jobInfoSvc )
        return

    def configure_geometry(self):
        import XmlDetDesc
        if self.opts.detector:
            XmlDetDesc.Configure(self.opts.detector)
            print "Note: using non-default geometry in " \
                + self.opts.detector + " is loaded."
        else:
            XmlDetDesc.Configure()
        return


    def configure_optmods(self):
        """ load and configure() "-m" modules here   """
        if self.opts.module == None: return

        from DybPython.cmdline import quotedParse

        for modcmd in self.opts.module:
            argv = quotedParse(modcmd)
            modname = argv[0]
            if modname[-3:] == '.py':
                print 'Fixing assumed typo in module name from "%s" to "%s"'%(modname,modname[:-3])
                modname = modname[:-3]
            modargs = argv[1:]
            print "Importing modules",modname,"["," ".join(modargs),"]"
            exec('import %s'%modname) # Don't catch potential exception!
            mod = eval(modname)
            self.modules.append(mod)

            print "Trying to call configure() on",modname
            try:
                if modargs:
                    mod.configure(argv=modargs)
                else:
                    mod.configure()
                    
            except SyntaxError,err:
                print "Got SyntaxError:",str(err)
                print "Assuming",cfg,"has not configure() function"
                pass
            except AttributeError,err:
                if "object has no attribute 'configure" not in str(err):
                    raise
            pass


    def configure_args(self):
        """ spin over all non-option arguments """
        
        # At this point there should be no input files left in the args.
        for cfg in self.args:

            if cfg[-3:] == '.py':
                cfgf = open(cfg)
                try:
                    exec(cfgf)
                except Exception,err:
                    import traceback
                    traceback.print_exc()
                    print 'Failed to load',cfg
                    sys.exit(1)
                print "Loaded \"%s\""%cfg
                cfgf.close()
                continue
            else:               # assume this is a module
                print "Importing module",cfg
                exec('import %s'%cfg) # Don't catch potential exception!

                mod = eval(cfg)
                self.modules.append(mod)

                # if it has a configure() method, call it now
                print "Trying to call configure() on",cfg
                try:
                    mod.configure()
                except AttributeError,err:
                    if "object has no attribute 'configure'" not in str(err):
                        raise
                    pass
                pass
            continue
        return
    
    def configure_user(self):
        from DybPython.Include import include, IncludeError
        include.setShowIncludes(self.opts.show_includes)

        try:
            include("$HOME/.nuwarc")
            print "Included ~/.nuwarc"
        except IncludeError,err:
            pass

        self.modules = []
        self.configure_optmods()
        self.configure_args()
        return

    def configure_post_user(self):
        if not self.use_AES:
            if self.opts.output_streams:
                print "Using DybStoreAlg to trigger output."
                from RootIOTest.RootIOTestConf import DybStoreAlg
                dsa = DybStoreAlg()
                self.post_user_algs.append(dsa)
        else:
            if self.opts.executions != 0:
                print "Using DybTrimIO to trigger output and do AES trimming"
                # add DybTrimIO
                from DybAlg.DybAlgConf import DybTrimIO
                trimIO = DybTrimIO()
                self.post_user_algs.append(trimIO)
                # add Trimming service
                from DybEventMgr.DybEventMgrConf import ArchiveTrimSvc
                trimSvc = ArchiveTrimSvc()
                self.theApp.ExtSvc.append(trimSvc)
                trimSvc.DefaultWindowSeconds = self.AES_window/units.second

                # check whether io is involed
                if self.opts.output_streams:
                    # add SaveB4TrimAesSvc
                    from DybEventMgr.DybEventMgrConf import SaveB4TrimAesSvc
                    svb4t = SaveB4TrimAesSvc()
                    self.theApp.ExtSvc.append(svb4t)

                    trimIO.SaveFlag=True;
                else:
                    trimIO.SaveFlag=False;
        # Add Run Data Writer to the end of the list of algorithms
        from RunDataSvc.RunDataSvcConf import RunDataWriterAlg
        self.post_user_algs.append(RunDataWriterAlg())
        from JobInfoSvc.JobInfoSvcConf import JobInfoWriterAlg
        self.post_user_algs.append(JobInfoWriterAlg())
        return

  
    def configure_visualization(self):
        'Configure for "quanjing/panoramix" visualization'
        gui = os.getenv("QUANJINGROOT")
        if not gui:
            print "Warning: no QUANJINGROOT variable, no default gui, failure likely."
            return
        gui += "/xml/gui.onx"
        
        xmlvis = os.getenv("XMLVISROOT",None)
        if xmlvis is None:
            from VisSvc.VisSvcConf import VisualizationSvc
            vis = VisualizationSvc()
            vis.ColorDbLocation = os.path.dirname(gui) + '/gui/vis/colors.xml'

        from OnXSvc.OnXSvcConf import OnXSvc
        onx = OnXSvc()
        onx.Toolkit = "NATIVE"
        #onx.Toolkit = "Qt"
        onx.OutputToTerminal = True
        onx.File = gui

        # pre v19r5, suggestion from Pere
        import GaudiPython as gaudi
        appMgr = gaudi.AppMgr( selfoptions={'Runable':'OnXSvc'} )
        appMgr.config()
        return

    def configure(self):
        self.configure_python_features()
        self.configure_ipython()
        self.configure_framework()
        self.configure_random()
        self.configure_run()
        self.configure_job()
        self.configure_geometry()
        self.configure_user()
        self.configure_post_user()
        return


    def spade_files(self):
        if not self.spadeSvc: return []
        return self.spadeSvc.marked

    def run_post_user(self, app):
        # Add framework algorithms after user algorithms
        for alg in self.post_user_algs:
            app.addAlgorithm(alg.getFullJobOptName())
        return
        
    def run(self):

        if self.opts.visualize:
            self.configure_visualization()

        from GaudiPython import AppMgr
        appMgr = AppMgr()

        if self.opts.color == "dark":
            #print 'setting up for dark color terminals'
            msg = appMgr.property('MessageSvc')

            msg.OutputLevel = self.opts.log_level
            msg.useColors=True
            msg.fatalColorCode=['red','white']
            msg.errorColorCode=['red']
            msg.warningColorCode=['yellow']
            msg.debugColorCode=['blue']
            msg.verboseColorCode=['cyan']
            pass
        if self.opts.color == "light":
            #print 'setting up for light color terminals'
            msg = appMgr.property('MessageSvc')
            msg.OutputLevel = self.opts.log_level
            msg.useColors=True
            msg.fatalColorCode=['red','white']
            msg.errorColorCode=['red']
            msg.warningColorCode=['yellow']
            msg.debugColorCode=['blue']
            msg.verboseColorCode=['cyan']
            pass

        # Muck with the msg formatting to give more room to show component names
        msg = appMgr.property('MessageSvc')
        msg.Format="%% F%%%dW%%S%%7W%%R%%T %%0W%%M"%35

        msgSvc = appMgr.service('MessageSvc','IMessageSvc')
        if self.opts.msg_stream_level:
            for namelevel in self.opts.msg_stream_level:
                name,level = namelevel.split(',')
                msgSvc.setOutputLevel(name,int(level))
                continue
            pass

        # Run any modules with a run() function
        for mod in self.modules:
            try:
                print "Trying to call run() on",mod.__name__
                mod.run(appMgr)
            except AttributeError,err:
                if "object has no attribute 'run'" not in str(err):
                    raise
                pass

        self.run_post_user(appMgr)

        n = self.opts.executions
        appMgr.EvtMax = n
        #appMgr.initialize()

        print 'Starting run with these top algorithms:',appMgr.TopAlg

        # Run a main looper
        if self.opts.visualize:
            import Quanjing
            Quanjing.start()
            Quanjing.toui()
        elif self.opts.external_loop:
            print 'Delegating main loop to',self.opts.external_loop
            exec ("import %s"%self.opts.external_loop)
            mod = eval (self.opts.external_loop)
            mod.start(appMgr)
        else:
            appMgr.run(n)
            pass

        if self.opts.interactive:
            import DybPython.Interactive
            self.ipshell() 

        return

    def finalize(self):
        from GaudiPython import AppMgr
        appMgr = AppMgr()
        appMgr.exit()

        for fn in self.spade_files():
            base,ext = os.path.splitext(fn)
            meta = base + '.meta.xml'
            if not os.path.exists(meta):
                print 'Skipping non existent SPADE meta data file: "%s"'%meta
                continue
            sem = base + '.sem'
            os.rename(meta,sem)
            continue

    
nuwa = NuWa()

def main():
    global nuwa
    nuwa.cmdline(sys.argv[1:])
    if 1 == len(sys.argv): 
        nuwa.opts_parser.error("No arguments given, try nuwa.py --help")
        pass

    nuwa.configure()
    return nuwa

if '__main__' == __name__:
    nuwa = main()
    nuwa.run()
    nuwa.finalize()

---