Esempio n. 1
0
def getMergerObject(file_ext):
    """Returns an instance of the correct merger tool, or None if there is not one"""
    from Ganga.Utility.Plugin.GangaPlugin import PluginManagerError
    result = None
    try:
        config = getConfig('Mergers')
        if file_ext == 'std_merge':
            result = allPlugins.find('postprocessor', config[file_ext])()
        else:
            # load the dictionary of file assocaitions # Why was there _ever_ an eval statement here? rcurrie
            file_types = config['associate']
            associate_merger = file_types[file_ext]
            result = allPlugins.find('postprocessor', associate_merger)()
    except ConfigError, err:
        logger.debug("ConfError %s" % str(err))
Esempio n. 2
0
def getMergerObject(file_ext):
    """Returns an instance of the correct merger tool, or None if there is not one"""
    from Ganga.Utility.Plugin.GangaPlugin import PluginManagerError
    result = None
    try:
        config = getConfig('Mergers')
        if file_ext == 'std_merge':
            result = allPlugins.find('postprocessor', config[file_ext])()
        else:
            # load the dictionary of file assocaitions # Why was there _ever_ an eval statement here? rcurrie
            file_types = config['associate']
            associate_merger = file_types[file_ext]
            result = allPlugins.find('postprocessor', associate_merger)()
    except ConfigError, err:
        logger.debug("ConfError %s" % str(err))
Esempio n. 3
0
        def start_element(name, attrs):
            # logger.debug('Start element: name=%s attrs=%s', name, attrs) #FIXME: for 2.4 use CurrentColumnNumber and CurrentLineNumber
            # if higher level element had error, ignore the corresponding part
            # of the XML tree as we go down
            if self.ignore_count:
                self.ignore_count += 1
                return

            # initialize object stack
            if name == 'root':
                assert self.stack is None, "duplicated <root> element"
                self.stack = []
                return

            assert not self.stack is None, "missing <root> element"

            # load a class, make empty object and push it as the current object
            # on the stack
            if name == 'class':
                try:
                    cls = allPlugins.find(attrs['category'], attrs['name'])
                except PluginManagerError as e:
                    self.errors.append(e)
                    #self.errors.append('Unknown class: %(name)s'%attrs)
                    obj = EmptyGangaObject()
                    # ignore all elemenents until the corresponding ending
                    # element (</class>) is reached
                    self.ignore_count = 1
                else:
                    version = Version(
                        *[int(v) for v in attrs['version'].split('.')])
                    if not cls._schema.version.isCompatible(version):
                        attrs['currversion'] = '%s.%s' % (
                            cls._schema.version.major,
                            cls._schema.version.minor)
                        self.errors.append(
                            SchemaVersionError(
                                'Incompatible schema of %(name)s, repository is %(version)s currently in use is %(currversion)s'
                                % attrs))
                        obj = EmptyGangaObject()
                        # ignore all elemenents until the corresponding ending
                        # element (</class>) is reached
                        self.ignore_count = 1
                    else:
                        # make a new ganga object
                        obj = super(cls, cls).__new__(cls)
                        obj._data = {}
                self.stack.append(obj)

            # push the attribute name on the stack
            if name == 'attribute':
                self.stack.append(attrs['name'])

            # start value_contruct mode and initialize the value buffer
            if name == 'value':
                self.value_construct = ''

            # save a marker where the sequence begins on the stack
            if name == 'sequence':
                self.sequence_start.append(len(self.stack))
Esempio n. 4
0
        def start_element(name, attrs):
            #logger.debug('Start element: name=%s attrs=%s', name, attrs) #FIXME: for 2.4 use CurrentColumnNumber and CurrentLineNumber
            # if higher level element had error, ignore the corresponding part
            # of the XML tree as we go down
            if self.ignore_count:
                self.ignore_count += 1
                return

            # initialize object stack
            if name == 'root':
                assert self.stack is None, "duplicated <root> element"
                self.stack = []
                return

            assert not self.stack is None, "missing <root> element"

            # load a class, make empty object and push it as the current object
            # on the stack
            if name == 'class':
                try:
                    cls = allPlugins.find(attrs['category'], attrs['name'])
                except PluginManagerError as e:
                    self.errors.append(e)
                    #self.errors.append('Unknown class: %(name)s'%attrs)
                    obj = EmptyGangaObject()
                    # ignore all elemenents until the corresponding ending
                    # element (</class>) is reached
                    self.ignore_count = 1
                else:
                    version = Version(
                        *[int(v) for v in attrs['version'].split('.')])
                    if not cls._schema.version.isCompatible(version):
                        attrs['currversion'] = '%s.%s' % (
                            cls._schema.version.major,
                            cls._schema.version.minor)
                        self.errors.append(
                            SchemaVersionError(
                                'Incompatible schema of %(name)s, repository is %(version)s currently in use is %(currversion)s'
                                % attrs))
                        obj = EmptyGangaObject()
                        # ignore all elemenents until the corresponding ending
                        # element (</class>) is reached
                        self.ignore_count = 1
                    else:
                        # make a new ganga object
                        obj = cls()
                self.stack.append(obj)

            # push the attribute name on the stack
            if name == 'attribute':
                self.stack.append(attrs['name'])

            # start value_contruct mode and initialize the value buffer
            if name == 'value':
                self.value_construct = ''

            # save a marker where the sequence begins on the stack
            if name == 'sequence':
                self.sequence_start.append(len(self.stack))
Esempio n. 5
0
def string_type_shortcut_filter(val,item):
    if type(val) is type(''):
        if item is None:
            raise ValueError('cannot apply default string conversion, probably you are trying to use it in the constructor')
        from Ganga.Utility.Plugin import allPlugins, PluginManagerError
        try:
            obj = allPlugins.find(item['category'],val)()
            obj._auto__init__()
            return obj
        except PluginManagerError,x:
            raise ValueError(x)
Esempio n. 6
0
    def _make_empty_object_(self, id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found"""
        cls = allPlugins.find(category, classname)
        obj  = super(cls, cls).__new__(cls)
        obj._proxyObject = None
        obj._data = None

        self._internal_setitem__(id,obj)
        return obj
Esempio n. 7
0
def string_type_shortcut_filter(val, item):
    if isinstance(val, type('')):
        if item is None:
            raise ValueError('cannot apply default string conversion, probably you are trying to use it in the constructor')
        from Ganga.Utility.Plugin import allPlugins, PluginManagerError
        try:
            obj = allPlugins.find(item['category'], val)()
            obj._auto__init__()
            return obj
        except PluginManagerError as err:
            logger.debug("string_type_shortcut_filter Exception: %s" % str(err))
            raise ValueError(err)
    return None
Esempio n. 8
0
    def _getDefaultValueInternal(self, attr, val=None, check=False):
        """ Get the default value of a schema item, both simple and component.
        If check is True then val is used instead of default value: this is used to check if the val may be used as a default value (e.g. if it is OK to use it as a value in the config file)
        """
        def_name = defaultConfigSectionName(self.name)

        item = self.getItem(attr)

        stored_attr_key = def_name + ':' + str(attr)

        from Ganga.Utility.Config import Config
        from Ganga.Utility.Config import getConfig
        is_finalized = Config._after_bootstrap

        if is_finalized and stored_attr_key in _found_attrs.keys():
            defvalue = _found_attrs[stored_attr_key]
        else:
            config = Ganga.Utility.Config.getConfig(def_name)

            # hidden, protected and sequence values are not represented in config
            if attr in config:
                defvalue = config[attr]
            else:
                defvalue = item['defvalue']
            _found_attrs[stored_attr_key] = defvalue

        # in the checking mode, use the provided value instead
        if check:
            defvalue = val

        if item.isA(ComponentItem):

            # FIXME: limited support for initializing non-empty sequences (i.e.
            # apps => ['DaVinci','Executable'] is NOT correctly initialized)

            if not item['sequence']:
                if defvalue is None:
                    if not item['load_default']:
                        assert(item['optional'])
                        return None

                # if a defvalue of a component item is an object (not string) just process it as for SimpleItems (useful for FileItems)
                # otherwise do a lookup via plugin registry

                if isinstance(defvalue, str) or defvalue is None:
                    return allPlugins.find(item['category'], defvalue)()

        # make a copy of the default value (to avoid strange effects if the
        # original modified)
        return copy.deepcopy(defvalue)
Esempio n. 9
0
def getMergerObject(file_ext):
    """Returns an instance of the correct merger tool, or None if there is not one"""
    from Ganga.Utility.Plugin.GangaPlugin import PluginManagerError
    result = None
    try:
        config = getConfig('Mergers')

        if file_ext == 'std_merge':
            result = allPlugins.find('mergers',config[file_ext])()
        else:
            #load the dictionary of file assocaitions
            file_types = eval(config['associate'])
            result = allPlugins.find('mergers',file_types[file_ext])()
    except ConfigError:
        pass
    except KeyError:
        pass
    except PluginManagerError:
        pass
    except SyntaxError:
        pass
    except TypeError:#TypeError as we may not be able to call ()
        pass #just return None
    return result
Esempio n. 10
0
    def _make_empty_object_(self, this_id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found"""
        if (category, classname) not in self._found_classes:
            cls = allPlugins.find(category, classname)
            self._found_classes[(category, classname)] = cls
        cls = self._found_classes[(category, classname)]
        obj = super(cls, cls).__new__(cls)
        obj.__init__()
        obj._proxyObject = None
        obj.setNodeData({})

        self._internal_setitem__(this_id, obj)
        return obj
Esempio n. 11
0
def gangaObjectFactory(attrDict, migration_class=None):
    ## gangaObjectFactory(...) --> (object, migrated, [<list of errors>])
    migrated = [False]
    errors = []
    if attrDict["simple"]:
        return (None, migrated[0], errors)
    if migration_class:
        cls = migration_class
    else:
        try:
            cls = allPlugins.find(attrDict["category"], attrDict["name"])
        except PluginManagerError, e:
            msg = "Plugin Manager Error: %s" % str(e)
            errors.append(GangaObjectFactoryError(e, msg=msg))
            return (EmptyGangaObject(), migrated[0], errors)
Esempio n. 12
0
    def _make_empty_object_(self, this_id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found"""
        compound_name = str(category+"_"+classname)
        if compound_name not in self._found_classes:
            cls = allPlugins.find(category, classname)
            self._found_classes[compound_name] = cls
        cls = self._found_classes[compound_name]
        obj = cls()
        obj._data = {}

        obj._setFlushed()
        self._internal_setitem__(this_id, obj)
        return obj
Esempio n. 13
0
    def _make_empty_object_(self, this_id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found"""
        compound_name = str(category+"_"+classname)
        if compound_name not in self._found_classes:
            cls = allPlugins.find(category, classname)
            self._found_classes[compound_name] = cls
        cls = self._found_classes[compound_name]
        obj = cls()
        #setattr(obj, '_parent', None)
        #obj.__init__()
        obj.setNodeData({})
        obj.setNodeAttribute('id', this_id)

        self._internal_setitem__(this_id, obj)
        return obj
Esempio n. 14
0
    def _make_empty_object_(self, this_id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found"""
        compound_name = str(category + "_" + classname)
        if compound_name not in self._found_classes:
            cls = allPlugins.find(category, classname)
            self._found_classes[compound_name] = cls
        cls = self._found_classes[compound_name]
        obj = cls()
        #setattr(obj, '_parent', None)
        #obj.__init__()
        obj.setNodeData({})
        obj.setNodeAttribute('id', this_id)

        self._internal_setitem__(this_id, obj)
        return obj
Esempio n. 15
0
def autoPopulateGPI(my_interface=None):
    """
    Fully expose all plugins registered with the interface in a single line.
    By default only populate GPI, but also populate any other interface requested
    """
    if not my_interface:
        import Ganga.GPI
        my_interface = Ganga.GPI
    from Ganga.Runtime.GPIexport import exportToInterface
    from Ganga.Utility.Plugin import allPlugins
    # make all plugins visible in GPI
    for k in allPlugins.allCategories():
        for n in allPlugins.allClasses(k):
            cls = allPlugins.find(k, n)
            if not cls._declared_property('hidden'):
                if n != cls.__name__:
                    exportToInterface(my_interface, cls.__name__, cls, 'Classes')
                exportToInterface(my_interface, n, cls, 'Classes')
Esempio n. 16
0
def autoPopulateGPI(my_interface=None):
    """
    Fully expose all plugins registered with the interface in a single line.
    By default only populate GPI, but also populate any other interface requested
    """
    if not my_interface:
        import Ganga.GPI
        my_interface = Ganga.GPI
    from Ganga.Runtime.GPIexport import exportToInterface
    from Ganga.Utility.Plugin import allPlugins
    # make all plugins visible in GPI
    for k in allPlugins.allCategories():
        for n in allPlugins.allClasses(k):
            cls = allPlugins.find(k, n)
            if not cls._declared_property('hidden'):
                if n != cls.__name__:
                    exportToInterface(my_interface, cls.__name__, cls, 'Classes')
                exportToInterface(my_interface, n, cls, 'Classes')
Esempio n. 17
0
    def _make_empty_object_(self, this_id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found
        Args:
            this_id (int): This is the id to assign to the empty object
            category (str): This is the category the object belongs to
            classname (str): This is the name of the class of the object which is used to construct it
        """
        compound_name = str(category+"_"+classname)
        if compound_name not in self._found_classes:
            cls = allPlugins.find(category, classname)
            self._found_classes[compound_name] = cls
        cls = self._found_classes[compound_name]
        obj = cls()
        obj._data = {}

        obj._setFlushed()
        self._internal_setitem__(this_id, obj)
        return obj
Esempio n. 18
0
    def _make_empty_object_(self, this_id, category, classname):
        """Internal helper: adds an empty GangaObject of the given class to the repository.
        Raise RepositoryError
        Raise PluginManagerError if the class name is not found
        Args:
            this_id (int): This is the id to assign to the empty object
            category (str): This is the category the object belongs to
            classname (str): This is the name of the class of the object which is used to construct it
        """
        compound_name = str(category + "_" + classname)
        if compound_name not in self._found_classes:
            cls = allPlugins.find(category, classname)
            self._found_classes[compound_name] = cls
        cls = self._found_classes[compound_name]
        obj = cls()
        obj._data = {}

        obj._setFlushed()
        self._internal_setitem__(this_id, obj)
        return obj
Esempio n. 19
0
    def _getDefaultValueInternal(self, attr, val=None, check=False):
        """ Get the default value of a schema item, both simple and component.
        If check is True then val is used instead of default value: this is used to check if the val may be used as a default value (e.g. if it is OK to use it as a value in the config file)
        """
        def_name = defaultConfigSectionName(self.name)

        item = self.getItem(attr)

        stored_attr_key = def_name + ':' + str(attr)

        from Ganga.Utility.Config import Config
        is_finalized = Config._after_bootstrap

        useDefVal = False

        try:
            # Attempt to get the relevant config section
            config = Config.getConfig(def_name)

            if is_finalized and stored_attr_key in _found_attrs and not config.hasModified:
                defvalue = _found_attrs[stored_attr_key]
            else:
                if attr in config.getEffectiveOptions():
                    defvalue = config[attr]
                    from Ganga.GPIDev.Base.Proxy import isProxy
                    if isProxy(defvalue):
                        raise GangaException("(1)Proxy found where it shouldn't be in the Config: %s" % stored_attr_key)
                    ## Just in case a developer puts the proxied object into the default value!
                    _found_attrs[stored_attr_key] = defvalue
                else:
                    useDefVal = True
        except (KeyError, Config.ConfigError):
            useDefVal = True

        if useDefVal:
            # hidden, protected and sequence values are not represented in config
            defvalue = item['defvalue']
            from Ganga.GPIDev.Base.Proxy import isProxy
            if isProxy(defvalue):
                raise GangaException("(2)Proxy found where is shouldn't be in the Config" % stored_attr_key)
            ## Just in case a developer puts the proxied object into the default value!
            _found_attrs[stored_attr_key] = defvalue

        # in the checking mode, use the provided value instead
        if check is True:
            defvalue = val

        if isinstance(item, ComponentItem):

            # FIXME: limited support for initializing non-empty sequences (i.e.
            # apps => ['DaVinci','Executable'] is NOT correctly initialized)

            if not item['sequence']:
                if defvalue is None:
                    if not item['load_default']:
                        assert(item['optional'])
                        return None

                # if a defvalue of a component item is an object (not string) just process it as for SimpleItems (useful for FileItems)
                # otherwise do a lookup via plugin registry

                category = item['category']

                if isinstance(defvalue, str) or defvalue is None:
                    try:
                        config = Config.getConfig(def_name)
                        has_modified = config.hasModified
                    except KeyError:
                        has_modified = False

                    if category not in _found_components or has_modified:
                        _found_components[category] = allPlugins.find(category, defvalue)
                    return _found_components[category]()

        # If needed/requested make a copy of the function elsewhwre
        return defvalue
Esempio n. 20
0
        logger.error('problems with loading Named Templates for %s', n)
        logger.error('Reason: %s' % str(err))

for r in allRuntimes.values():
    try:
        r.loadPlugins()
    except Exception as err:
        logger.error("problems with loading plugins for %s -- ignored" %
                     r.name)
        logger.error('Reason: %s' % str(err))

# ------------------------------------------------------------------------------------
# make all plugins visible in GPI
for k in allPlugins.allCategories():
    for n in allPlugins.allClasses(k):
        cls = allPlugins.find(k, n)
        if not cls._declared_property('hidden'):
            exportToPublicInterface(n, cls._proxyClass, 'Classes')

# ------------------------------------------------------------------------------------
# set the default value for the plugins
default_plugins_cfg = getConfig("Plugins")

for opt in default_plugins_cfg:
    try:
        category, tag = opt.split('_')
    except ValueError, err:
        logger.warning("do not understand option %s in [Plugins]", opt)
        logger.debug('Reason: want %s' % str(err))
    else:
        if tag == 'default':
Esempio n. 21
0
    def _getDefaultValueInternal(self, attr, val=None, check=False):
        """ Get the default value of a schema item, both simple and component.
        If check is True then val is used instead of default value: this is used to check if the val may be used as a default value (e.g. if it is OK to use it as a value in the config file)
        """
        def_name = defaultConfigSectionName(self.name)

        item = self.getItem(attr)

        stored_option_key = def_name
        stored_attr_key = def_name + ':' + attr

        is_finalized = Config._after_bootstrap

        useDefVal = False

        try:

            # Attempt to get the relevant config section
            if is_finalized:
                if stored_option_key in _stored_configs:
                    config = _stored_configs[stored_option_key]
                else:
                    config = Config.getConfig(def_name)
                    _stored_configs[stored_option_key] = config
            else:
                config = Config.getConfig(def_name)

            if is_finalized and not config.hasModified and stored_attr_key in _found_attrs:
                defvalue = _found_attrs[stored_attr_key]
            else:
                if is_finalized:
                    if stored_option_key in _stored_options and not config.hasModified:
                        eff_ops = _stored_options[stored_option_key]
                    else:
                        eff_ops = config.getEffectiveOptions()
                        _stored_options[stored_option_key] = eff_ops
                else:
                    eff_ops = config.getEffectiveOptions()

                if attr in eff_ops:
                    defvalue = config[attr]
                    from Ganga.GPIDev.Base.Proxy import isProxy
                    if isProxy(defvalue):
                        raise GangaException("(1)Proxy found where it shouldn't be in the Config: %s" % stored_attr_key)
                    ## Just in case a developer puts the proxied object into the default value!
                    _found_attrs[stored_attr_key] = defvalue
                else:
                    useDefVal = True
        except (KeyError, Config.ConfigError):
            useDefVal = True

        if useDefVal:
            # hidden, protected and sequence values are not represented in config
            defvalue = item['defvalue']
            from Ganga.GPIDev.Base.Proxy import isProxy
            if isProxy(defvalue):
                raise GangaException("(2)Proxy found where is shouldn't be in the Config" % stored_attr_key)
            ## Just in case a developer puts the proxied object into the default value!
            _found_attrs[stored_attr_key] = defvalue

        # in the checking mode, use the provided value instead
        if check is True:
            defvalue = val

        if isinstance(item, ComponentItem):

            # FIXME: limited support for initializing non-empty sequences (i.e.
            # apps => ['DaVinci','Executable'] is NOT correctly initialized)

            if not item['sequence']:
                if defvalue is None:
                    if not item['load_default']:
                        try:
                            assert(item['optional'])
                        except AssertionError:
                            raise SchemaError("This item '%s' is not a sequence, doesn't have a load_default and is not optional. This is unsupported!" % type(item))
                        return None

                # if a defvalue of a component item is an object (not string) just process it as for SimpleItems (useful for FileItems)
                # otherwise do a lookup via plugin registry

                category = item['category']

                if isinstance(defvalue, str) or defvalue is None:
                    try:
                        config = Config.getConfig(def_name)
                        has_modified = config.hasModified
                    except KeyError:
                        has_modified = False

                    if category not in _found_components or has_modified:
                        _found_components[category] = allPlugins.find(category, defvalue)
                    return _found_components[category]()
                if isclass(defvalue):
                    return defvalue()

        # If needed/requested make a copy of the function elsewhwre
        return defvalue
Esempio n. 22
0
    except Exception as err:
        logger.error('problems with loading Named Templates for %s', n)
        logger.error('Reason: %s' % str(err))

for r in allRuntimes.values():
    try:
        r.loadPlugins()
    except Exception as err:
        logger.error("problems with loading plugins for %s -- ignored" % r.name)
        logger.error('Reason: %s' % str(err))

# ------------------------------------------------------------------------------------
# make all plugins visible in GPI
for k in allPlugins.allCategories():
    for n in allPlugins.allClasses(k):
        cls = allPlugins.find(k, n)
        if not cls._declared_property('hidden'):
            exportToPublicInterface(n, getProxyClass(cls), 'Classes')

# ------------------------------------------------------------------------------------
# set the default value for the plugins
default_plugins_cfg = getConfig("Plugins")

for opt in default_plugins_cfg:
    try:
        category, tag = opt.split('_')
    except ValueError, err:
        logger.warning("do not understand option %s in [Plugins]", opt)
        logger.debug('Reason: want %s' % str(err))
    else:
        if tag == 'default':
Esempio n. 23
0
    def _getDefaultValueInternal(self, attr, val=None, check=False):
        """ Get the default value of a schema item, both simple and component.
        If check is True then val is used instead of default value: this is used to check if the val may be used as a default value (e.g. if it is OK to use it as a value in the config file)
        """
        def_name = defaultConfigSectionName(self.name)

        item = self.getItem(attr)

        stored_attr_key = def_name + ':' + str(attr)

        from Ganga.Utility.Config import Config
        is_finalized = Config._after_bootstrap

        useDefVal = False

        try:
            # Attempt to get the relevant config section
            config = Config.getConfig(def_name, create=False)

            if is_finalized and stored_attr_key in _found_attrs and not config.hasModified():
                defvalue = _found_attrs[stored_attr_key]
            else:
                if attr in config.getEffectiveOptions():
                    defvalue = config[attr]
                    from Ganga.GPIDev.Base.Proxy import isProxy
                    if isProxy(defvalue):
                        raise GangaException("(1)Proxy found where it shouldn't be in the Config: %s" % stored_attr_key)
                    ## Just in case a developer puts the proxied object into the default value!
                    _found_attrs[stored_attr_key] = defvalue
                else:
                    useDefVal = True
        except (KeyError, Config.ConfigError):
            useDefVal = True

        if useDefVal:
            # hidden, protected and sequence values are not represented in config
            defvalue = item['defvalue']
            from Ganga.GPIDev.Base.Proxy import isProxy
            if isProxy(defvalue):
                raise GangaException("(2)Proxy found where is shouldn't be in the Config" % stored_attr_key)
            ## Just in case a developer puts the proxied object into the default value!
            _found_attrs[stored_attr_key] = defvalue

        # in the checking mode, use the provided value instead
        if check is True:
            defvalue = val

        if isinstance(item, ComponentItem):

            # FIXME: limited support for initializing non-empty sequences (i.e.
            # apps => ['DaVinci','Executable'] is NOT correctly initialized)

            if not item['sequence']:
                if defvalue is None:
                    if not item['load_default']:
                        assert(item['optional'])
                        return None

                # if a defvalue of a component item is an object (not string) just process it as for SimpleItems (useful for FileItems)
                # otherwise do a lookup via plugin registry

                category = item['category']

                if isinstance(defvalue, str) or defvalue is None:
                    try:
                        config = Config.getConfig(def_name, create=False)
                        has_modified = config.hasModified()
                    except KeyError:
                        has_modified = False

                    if category not in _found_components or has_modified:
                        _found_components[category] = allPlugins.find(category, defvalue)
                    return _found_components[category]()

        # make a copy of the default value (to avoid strange effects if the
        # original modified)
        try:
            from Ganga.GPIDev.Base.Proxy import isType, getRuntimeGPIObject, stripProxy, getName
            from Ganga.GPIDev.Base.Objects import Node
            if isinstance(defvalue, Node):
                return stripProxy(getRuntimeGPIObject(getName(defvalue)))
            else:
                return copy.deepcopy(defvalue)
        except ImportError:
            return copy.deepcopy(defvalue)
Esempio n. 24
0
            logger.warning("do not understand option %s in [Plugins]", opt)
            logger.debug('Reason: want %s' % str(err))
        else:
            if tag == 'default':
                try:
                    allPlugins.setDefault(category, default_plugins_cfg[opt])
                except Ganga.Utility.Plugin.PluginManagerError as x:
                    logger.warning('cannot set the default plugin "%s": %s' % (opt, x))
            else:
                logger.warning("do not understand option %s in [Plugins]", opt)


    # set alias for default Batch plugin (it will not appear in the
    # configuration)

    batch_default_name = getConfig('Configuration').getEffectiveOption('Batch')
    try:
        batch_default = allPlugins.find('backends', batch_default_name)
    except Exception as x:
        raise Ganga.Utility.Config.ConfigError('Check configuration. Unable to set default Batch backend alias (%s)' % str(x))
    else:
        allPlugins.add(batch_default, 'backends', 'Batch')
        from Ganga.Runtime.GPIexport import exportToInterface
        if not my_interface:
            import Ganga.GPI
            my_interface = Ganga.GPI
        exportToInterface(my_interface, 'Batch', batch_default, 'Classes')



Esempio n. 25
0
def gangaObjectFactory(attrDict, migration_class=None):
    # gangaObjectFactory(...) --> (object, migrated, [<list of errors>])
    migrated = [False]
    errors = []
    if attrDict['simple']:
        return (None, migrated[0], errors)
    if migration_class:
        cls = migration_class
    else:
        try:
            cls = allPlugins.find(attrDict['category'], attrDict['name'])
        except PluginManagerError as e:
            msg = "Plugin Manager Error: %s" % str(e)
            errors.append(GangaObjectFactoryError(e, msg=msg))
            return (EmptyGangaObject(), migrated[0], errors)

    schema = cls._schema
    major, minor = attrDict['version']
    version = Version(major, minor)

    if not schema.version.isCompatible(version):
        v1 = '.'.join(map(str, [major, minor]))
        v2 = '.'.join(map(str, [schema.version.major, schema.version.minor]))
        msg = "Incompatible schema versions of plugin %s in the category %s. Current version %s. Repository version %s." % (
            attrDict['name'], attrDict['category'], v2, v1)
        if schema.version.major > version.major:  # no forward migration
            from .MigrationControl import migration
            if migration.isAllowed(attrDict['category'], attrDict['name'], attrDict['version'], msg=msg):
                # try if migration provided by the plugin class
                try:
                    old_cls = cls.getMigrationClass(version)
                except:
                    old_cls = None
                if old_cls:
                    old_obj, old_migrated, old_errors = gangaObjectFactory(
                        attrDict, migration_class=old_cls)
                    if old_migrated:
                        migrated[0] = old_migrated
                    if not old_errors:
                        try:
                            obj = cls.getMigrationObject(old_obj)
                            #assert(isinstance(obj, cls))
                        except Exception as e:
                            msg += ' Error in object migration: ' + str(e)
                        else:
                            obj.__setstate__(obj.__dict__)
                            migrated[0] = True
                            return (obj, migrated[0], errors)
                    else:
                        msg += ' Errors in object migration ' + \
                            str(map(str, old_errors))
                else:
                    msg += ' No migration class is provided.'
            else:
                msg += ' Migration was denied in the migration control object.'
        errors.append(GangaObjectFactoryError(msg=msg))
        return (EmptyGangaObject(), migrated[0], errors)

    obj = super(cls, cls).__new__(cls)
    obj._data = {}

    def mapper(attrDict):
        if attrDict['simple']:
            val = attrDict['data']
        else:
            val, attr_migrated, attr_errors = gangaObjectFactory(attrDict)
            if attr_migrated:
                migrated[0] = attr_migrated
            for err in attr_errors:
                if str(err) not in map(str, errors):
                    # don't duplicate the same errors
                    errors.append(err)
        return val

    data = attrDict['data']
    for attr, item in schema.allItems():
        if attr in data:
            val = data[attr]
            if item['sequence']:
                val = makeGangaList(val, mapper, parent=obj)
            else:
                val = mapper(val)
        else:
            val = schema.getDefaultValue(attr)
        obj._data[attr] = val
    obj.__setstate__(obj.__dict__)
    return (obj, migrated[0], errors)
Esempio n. 26
0
            logger.warning("do not understand option %s in [Plugins]", opt)
            logger.debug('Reason: want %s' % str(err))
        else:
            if tag == 'default':
                try:
                    allPlugins.setDefault(category, default_plugins_cfg[opt])
                except Ganga.Utility.Plugin.PluginManagerError as x:
                    logger.warning('cannot set the default plugin "%s": %s' % (opt, x))
            else:
                logger.warning("do not understand option %s in [Plugins]", opt)


    # set alias for default Batch plugin (it will not appear in the
    # configuration)

    batch_default_name = getConfig('Configuration').getEffectiveOption('Batch')
    try:
        batch_default = allPlugins.find('backends', batch_default_name)
    except Exception as x:
        raise Ganga.Utility.Config.ConfigError('Check configuration. Unable to set default Batch backend alias (%s)' % str(x))
    else:
        allPlugins.add(batch_default, 'backends', 'Batch')
        from Ganga.Runtime.GPIexport import exportToInterface
        if not my_interface:
            import Ganga.GPI
            my_interface = Ganga.GPI
        exportToInterface(my_interface, 'Batch', batch_default, 'Classes')



Esempio n. 27
0
        if item.isA(ComponentItem):

            # FIXME: limited support for initializing non-empty sequences (i.e. apps => ['DaVinci','Executable'] is NOT correctly initialized)

            if not item['sequence']: 
                if defvalue is None:
                    if not item['load_default']:
                        assert(item['optional'])
                        return None

                # if a defvalue of a component item is an object (not string) just process it as for SimpleItems (useful for FileItems)
                # otherwise do a lookup via plugin registry

                if type(defvalue) is type('') or defvalue is None:
                    from Ganga.Utility.Plugin import allPlugins
                    return allPlugins.find(item['category'],defvalue)()

        # make a copy of the default value (to avoid strange effects if the original modified)
        import copy
        return copy.deepcopy(defvalue)

        

# Items in schema may be either Components,Simples, Files or BindingItems.
#
# Component, Simple, File are data items and have implicit storage.
#
# Metaproperties of all Items:
#
# transient : never stored on persistent media
# protected : not modifiable via GPI