Attachment #2757 for bug #2631

View | Details | Raw Unified | Return to bug 2631
Collapse All | Expand All




from bake.Exceptions import TaskError 
from bake.ModuleSource import SystemDependency 
from bake.ModuleBuild import NoneModuleBuild
from bake.Module import ModuleDependency

def signal_handler(signal, frame):
    """ Handles Ctrl+C keyboard interruptions """

        
        parser = OptionParser(usage='usage: %prog fix-config [options]')
        self._enable_disable_options(parser)
        parser.add_option("-f", "--conffile", action="store", type="string",
                          dest="bakeconf", default="bakeconf.xml",
                          help="The Bake meta-data configuration from where to"
                          " get the updated modules file to use. Default: %default.")


        config = self.check_configuration_file(config, True)

        contribconf = []
        try:
            for cfile in os.listdir("contrib"):
                if cfile.endswith(".xml"):
                    contribconf.append("contrib/"+cfile)
        except Exception as e:
            True

        # Stores the present configuration         
        old_config = Configuration(config)
        old_config.read()

            new_config.read_metadata(options.bakeconf)
        except Exception as e:
            self._error('Problem reading Configuration file "%s" \n Error: %s'  % (options.bakeconf, str(e)))

        for cconf in contribconf:
            try:
                new_config.read_metadata(cconf)
            except Exception as e:
                self._error('Problem reading Configuration file "%s" \n Error: %s'  % (cconf, str(e)))
        
        # Checks if the directories where set and if so set the new config file
        # with the new parameters, or let the old ones

                          dest="enable_minimal", default=None,
                          help="Disable all non-mandatory dependencies.")

    def resolve_contrib_dependencies (self, module, fmod, configuration):
        """ Handles the contrib type dependencies"""
        for dep in module.dependencies ():
            dep_mod = configuration.lookup (dep.name())
            if dep_mod.mtype() == "ns-contrib":
                dep_mod.get_source().attribute("module_directory").value = fmod+'/contrib/'+dep_mod.get_source().attribute("module_directory").value
                dep_mod.addDependencies(ModuleDependency(fmod, False))
                self.resolve_contrib_dependencies (dep_mod, fmod, configuration)

    def _enable(self, enable, configuration):
        """ Handles the --enable option, setting defined modules as enable."""
        
        for module_name in enable:
            module = configuration.lookup(module_name)
            if not module:
                self._error('Module "%s" not found' % module_name)
            if module.mtype() == "ns-contrib":
                found=0
                fmod = None
                for mod in enable:
                    if configuration.lookup(mod).mtype() == "ns" and ((mod>=module.minver() and (mod<=module.maxver() or module.maxver() == None)) or (mod == "ns-3-dev" and module.maxver() == None)):
                        found+= 1
                        fmod = mod
                if not found==1:
                    self._error('Module "%s" has unmet dependency: %s' % (module_name, module.minver()))
                module.get_source().attribute("module_directory").value = fmod+'/contrib/'+module.get_source().attribute("module_directory").value
                module.addDependencies(ModuleDependency(fmod, False))
                self.resolve_contrib_dependencies (module, fmod, configuration)
            configuration.enable(module)

    def _disable(self, disable, configuration):

            if not module:
                self._error('Module "%s" not found' % module_name)
            configuration.disable(module)
            if module.mtype() == "ns":
                enabled_list = configuration.enabled()
                for mod in enabled_list:
                    if mod.mtype() == "ns-contrib":
                        configuration.disable(mod)

    def _variables_process(self, items, configuration, is_append):
        """ Handles the defined configured variables ."""

        
        # enables/disables the explicit enable/disable modules passed as argument
        self._enable(options.enable, configuration)
        for mod in options.disable:
            if not mod in options.enable:
                self._error('Module "%s" not enabled' % mod)
        self._disable(options.disable, configuration)
        
        # if the option -a is used, meaning all the modules should be enabled
        if options.enable_all:
            for module in configuration.modules():
                configuration.enable(module)
            
                
        # if the option -m is used, meaning the minimum configuration should be used
        # it disables all the non mandatory dependencies

        configuration.append(lastConfig)
        self.save_resource_file(configuration, fileName)

    def _list(self, config, args):
        """ Handles the list option for %prog """
        
        # sets the options the parser should recognize for the configuration
        parser = OptionParser(usage='usage: %prog list [options]')
        parser.add_option("-f", "--conffile", action="store", type="string",
                          dest="bakeconf", default="bakeconf.xml",
                          help="The Bake meta-data configuration file to use. "
                          "Default: %default.")
        parser.add_option("-c", "--contrib", action="store_true",
                          dest="contrib", default="False",
                          help="Show only contrib modules.")
        (options, args_left) = parser.parse_args(args)
        listconf = Configuration(config)
        contrib_list = []
        module_list = []

        contribconf = []
        try:
            for cfile in os.listdir("contrib"):
                if cfile.endswith(".xml"):
                    contribconf.append("contrib/"+cfile)
        except Exception as e:
            True

        try:
            listconf.read_metadata(options.bakeconf)
        except Exception as e:
            self._error('Problem reading Configuration file "%s" \n Error: %s'  % (options.bakeconf, str(e)))

        for cconf in contribconf:
            try:
                listconf.read_metadata(cconf)
            except Exception as e:
                self._error('Problem reading Configuration file "%s" \n Error: %s'  % (cconf, str(e)))

        for mod in listconf.modules():
            if mod.mtype() == "ns-contrib":
                contrib_list.append(mod.name())
            elif not options.contrib == True:
                module_list.append(mod.name())

        contrib_list.sort()
        module_list.sort()
        for m in module_list:
            print("module: "+m)
        for c in contrib_list:
            print("contrib: "+c)
        
    def _configure(self, config, args):
        """ Handles the configuration option for %prog """

        # sets the options the parser should recognize for the configuration
        parser = OptionParser(usage='usage: %prog configure [options]')
        self._enable_disable_options(parser)
        parser.add_option("-f", "--conffile", action="store", type="string",
                          dest="bakeconf", default="bakeconf.xml",
                          help="The Bake meta-data configuration file to use. "
                          "Default: %default.")

                          default=0, help='Increase the log verbosity level')
        parser.add_option('-q', '--quiet', action='count', dest='quiet', 
                          default=0, help='Increase the log quietness level')
        parser.add_option("-c", "--clean", action="store_true",
                          dest="remove", default=False,
                          help="Remove all enabled modules")

        # sets the configuration values got from the line command
        (options, args_left) = parser.parse_args(args)

        if options.bakeconf == "bakeconf.xml":
            options.bakeconf = self.check_configuration_file(options.bakeconf, False);

        contribconf = []
        try:
            for cfile in os.listdir("contrib"):
                if cfile.endswith(".xml"):
                    contribconf.append("contrib/"+cfile)
        except Exception as e:
            True

        configuration = Configuration(config)

        if not options.remove:
            try:
                configuration.read()
                for m in  configuration.enabled():
                    if m.name() not in options.enable:
                        options.enable.append(m.name())
            except Exception as e:
                True
       
        try:
            configuration.read_metadata(options.bakeconf)
        except Exception as e:
            self._error('Problem reading Configuration file "%s" \n Error: %s'  % (options.bakeconf, str(e)))

        for cconf in contribconf:
            try:
                configuration.read_metadata(cconf)
            except Exception as e:
                self._error('Problem reading Configuration file "%s" \n Error: %s'  % (cconf, str(e)))
                   
        configuration.set_sourcedir(options.sourcedir)
        configuration.set_objdir(options.objdir)

                    self._error('--predefined: "%s" not found.' % p)
                    
        # Registers the modules are that enabled/disabled 
        # handles the -a, -m, --disable, --enable tags           
        self._parse_enable_disable(options, configuration)

        # handles the set command line option, to overwrite the specific 
        # module setting with the new specified value
        for variable in options.set:

                module.get_build().attribute(name).value = current_value + ' ' + value
        configuration.write()
        
        if not configuration._enabled and not options.append and not options.remove:
            env =  self._get_dummy_env(options)
            env._logger.commands.write(' > No module enabled: Bake configuration requires at least one module to be enabled'
                                       ' (enable, predefined), or appended.\n'

        if not state:
            return
        for mod in state:
            if mod.mtype():
                print('module %s: %s (%s)' % (mod.mtype(), mod.name(), label))
            else:
                print('module: %s (%s)' % (mod.name(), label))
            dependencies = mod.dependencies()
            
            # Stores the system dependencies

            if not mod.name() in depen:
                depen[mod.name()] = dict()
            
            if dependencies and not options.brief == True:
                print('  depends on:')
                for dependsOn in mod.dependencies():
                    print('     %s (optional:%s)' % 
                          (dependsOn.name(), dependsOn.is_optional())) 
                    depen[mod.name()][dependsOn.name()]=  dependsOn.is_optional()
            elif not options.brief == True:
                print('  No dependencies!')
                
            

        parser.add_option('--showSystemDep', action='store_true', dest='showSystemDep', 
                          default=True,
                          help='Shows the system dependency of the enabled/disabled modules')
        parser.add_option('-b', '--brief', action='store_true', dest='brief', 
                          default=False,
                          help='Show only the module name')
        parser.add_option('-c', '--configured', action='store_true', dest='configured', 
                          default=False,
                          help='Show only the configured module')
        (options, args_left) = parser.parse_args(args)
        # adds a default value so that show will show something even if there is
        # no option 

            options.enabled = True
            options.showSystemDep = True
        else:
            if not options.disabled and not options.enabled and not options.configured:
                options.enabled=True

        config= self.check_configuration_file(config, True);

                  "   Call bake with -f [full path configuration file name].\n")
            return
#            configuration = Configuration(config)
#            configuration.read_metadata(config)       
            
        if options.all:
            options.enabled = True
            options.disabled = True

        if options.enabled:
            self.show_module(enabled, options, config, 'enabled')

        if options.configured:
            self.show_module(configuration.configured(), options, config, 'configured')

        if options.disabled:
            self.show_module(disabled, options, config, 'disabled')
            

                ['show', self._show],
                ['show-builtin', self._show_builtin],
                ['check', self._check],
                ['list', self._list],
               ]
        recognizedCommand = False
        

(-)a/bake/Configuration.py (-3 / +14 lines)

Lines 85-90	Link Here

        self._enabled = []

        self._enabled = []

        self._disabled = []

        self._disabled = []

        self._modules = []

        self._modules = []

        self._configured = []

        self._installdir = None

        self._installdir = None

        self._objdir = None

        self._objdir = None

        self._sourcedir = None

        self._sourcedir = None

Lines 318-323	Link Here

318

        modules = et.findall('modules/module')

319

        modules = et.findall('modules/module')

319

        for module_node in modules:

320

        for module_node in modules:

320

            name = module_node.get('name')

321

            name = module_node.get('name')

322

            mtype = module_node.get('type')

323

            min_ver = module_node.get('min_version')

324

            max_ver = module_node.get('max_version')

321

            installed = self._read_installed(module_node)

325

            installed = self._read_installed(module_node)

322

326

323

            source_node = module_node.find('source')

327

            source_node = module_node.find('source')

Lines 333-339	Link Here

333

            for dep_node in module_node.findall('depends_on'):

337

            for dep_node in module_node.findall('depends_on'):

334

                dependencies.append(ModuleDependency(dep_node.get('name'),

338

                dependencies.append(ModuleDependency(dep_node.get('name'),

335

                                                     bool(dep_node.get('optional', '').upper()=='TRUE')))

339

                                                     bool(dep_node.get('optional', '').upper()=='TRUE')))

336

            module = Module(name, source, build, dependencies=dependencies,

340

            module = Module(name, source, build, mtype, min_ver, max_ver, dependencies=dependencies,

337

                            built_once=bool(module_node.get('built_once', '').upper()=='TRUE'),

341

                            built_once=bool(module_node.get('built_once', '').upper()=='TRUE'),

338

                            installed=installed)

342

                            installed=installed)

339

            self._modules.append(module)

343

            self._modules.append(module)

Lines 346-352	Link Here

346

350

347

        for module in self._modules:

351

        for module in self._modules:

348

            module_attrs = {'name' : module.name()}

352

            module_attrs = {'name' : module.name()}

349

353

            if module.mtype():

354

                module_attrs['type'] = module.mtype()

355

            if module.minver():

356

                module_attrs['min_version'] = module.minver()

350

            if module.is_built_once():

357

            if module.is_built_once():

351

                module_attrs['built_once'] = 'True'

358

                module_attrs['built_once'] = 'True'

352

            module_node = ET.Element('module', module_attrs)

359

            module_node = ET.Element('module', module_attrs)

Lines 441-446	Link Here

441

        # read which modules are enabled

448

        # read which modules are enabled

442

        modules = root.findall('enabled')

449

        modules = root.findall('enabled')

443

        for module in modules:

450

        for module in modules:

451

            self._configured.append(self.lookup(module.get('name')))

444

            enabled = self.lookup(module.get('name'))

452

            enabled = self.lookup(module.get('name'))

445

            self.enable(enabled)

453

            self.enable(enabled)

446

454

Lines 499-505	Link Here

499

507

500

        if module in self._disabled:

508

        if module in self._disabled:

501

            self._disabled.remove(module)

509

            self._disabled.remove(module)

502

        else:

510

        elif module not in self._enabled:

503

            self._enabled.append(module)

511

            self._enabled.append(module)

504

512

505

    def disable(self, module):

513

    def disable(self, module):

Lines 528-530	Link Here

528

536

529

    def modules(self):

537

    def modules(self):

530

        return self._modules

538

        return self._modules

539

540

    def configured(self):

541

        return self._configured

(-)a/bake/Module.py (+17 lines)

Lines 57-71	Link Here

    def __init__(self, name,

    def __init__(self, name,

                 source,

                 source,

                 build,

                 build,

                 mtype,

                 min_ver,

                 max_ver,

                 dependencies = [],

                 dependencies = [],

                 built_once = False,

                 built_once = False,

                 installed = []):

                 installed = []):

        self._name = name

        self._name = name

        self._type = mtype

        self._dependencies = copy.copy(dependencies)

        self._dependencies = copy.copy(dependencies)

        self._source = source

        self._source = source

        self._build = build

        self._build = build

        self._built_once = built_once

        self._built_once = built_once

        self._installed = installed

        self._installed = installed

        self._minVersion = min_ver

        self._maxVersion = max_ver

    @property

    @property

Lines 556-558	Link Here

556

        return self._name

562

        return self._name

557

    def dependencies(self):

563

    def dependencies(self):

558

        return self._dependencies

564

        return self._dependencies

565

    def mtype(self):

566

        return self._type

567

    def minver(self):

568

        return self._minVersion

569

    def maxver(self):

570

        return self._maxVersion

571

    def addDependencies(self, depend):

572

        for d in self._dependencies:

573

            if d.name() == depend.name():

574

                return

575

        self._dependencies.append(depend)

Return to bug 2631