예제 #1
0
 def _load_package(self, pkg_loader, name):
     try:
         parts = name.rsplit('/')
         if len(parts) == 2:
             name, pkg_version = parts
             version_spec = helpers.parse_version_spec(pkg_version)
         else:
             version_spec = helpers.parse_version_spec('*')
         package = pkg_loader.load_package(name, version_spec)
     except exceptions.NoPackageFound:
         if not CONF.engine.load_packages_from:
             msg = _('Local package is not found since "load-packages-from"'
                     ' engine parameter is not provided and specified '
                     'packages is not loaded to murano-api')
         else:
             msg = _('Specified package is not found: {0} were scanned '
                     'together with murano database').format(','.join(
                         CONF.engine.load_packages_from))
         LOG.error(msg)
         self.error(msg, show_help=False)
     except exc.CommunicationError:
         msg = ('Murano API is not running. '
                'Check configuration parameters.')
         LOG.error(msg)
         self.error(msg, show_help=False)
     return package
예제 #2
0
 def _load_package(self, pkg_loader, name):
     try:
         parts = name.rsplit('/')
         if len(parts) == 2:
             name, pkg_version = parts
             version_spec = helpers.parse_version_spec(pkg_version)
         else:
             version_spec = helpers.parse_version_spec('*')
         package = pkg_loader.load_package(name, version_spec)
     except exceptions.NoPackageFound:
         if not CONF.packages_opts.load_packages_from:
             msg = _('Local package is not found since "load-packages-from"'
                     ' engine parameter is not provided and specified '
                     'packages is not loaded to murano-api')
         else:
             msg = _('Specified package is not found: {0} were scanned '
                     'together with murano database'
                     ).format(','.join(
                         CONF.packages_opts.load_packages_from))
         LOG.error(msg)
         self.error(msg, show_help=False)
     except exc.CommunicationError:
         msg = ('Murano API is not running. '
                'Check configuration parameters.')
         LOG.error(msg)
         self.error(msg, show_help=False)
     return package
예제 #3
0
    def _process_item(self, obj, owner_id, path):
        if isinstance(obj, dict) and '?' in obj:
            obj_rule = self._create_object_rule(obj, owner_id)

            self._rules.append(obj_rule)
            # the environment has 'services' relationships
            # to all its top-level applications
            # traversal path is used to test whether
            # we are at the right place within the tree
            if path == ('applications', ):
                self._rules.append(
                    RelationshipRule(self._env_id, obj_rule.obj_id,
                                     "services"))
            self._rules.extend(self._create_propety_rules(
                obj_rule.obj_id, obj))

            cls = obj['?']['type']
            if 'classVersion' in obj['?']:
                version_spec = helpers.parse_version_spec(
                    semantic_version.Version(obj['?']['classVersion']))
            else:
                version_spec = semantic_version.Spec('*')
            types = self._get_parent_types(cls, self._package_loader,
                                           version_spec)
            self._rules.extend(
                self._create_parent_type_rules(obj['?']['id'], types))
            # current object will be the owner for its subtree
            return obj_rule.obj_id
예제 #4
0
def generate_schema(pkg_loader, context_manager,
                    class_name, method_names=None,
                    class_version=None, package_name=None):
    """Generate JSON schema

    JSON Schema is generated either for the class with all model builders
    or for specified model builders only. The return value is a dictionary
    with keys being model builder names and the values are JSON schemas for
    them. The class itself is represented by an empty string key.
    """

    if method_names and not isinstance(method_names, (list, tuple)):
        method_names = (method_names,)
    version = helpers.parse_version_spec(class_version)
    if package_name:
        package = pkg_loader.load_package(package_name, version)
    else:
        package = pkg_loader.load_class_package(class_name, version)

    cls = package.find_class(class_name, search_requirements=False)
    exc = executor.MuranoDslExecutor(pkg_loader, context_manager)
    with helpers.with_object_store(exc.object_store):
        context = exc.create_object_context(cls)
        model_builders = set(list_model_builders(cls, context))
        method_names = model_builders.intersection(
            method_names or model_builders)

        result = {
            name: generate_entity_schema(
                get_entity(cls, name), context, cls,
                get_meta(cls, name, context))
            for name in method_names
        }
        return result
예제 #5
0
    def load_package(self, package_name, version_spec):
        fixed_versions = self._fixations[package_name]
        version = version_spec.select(fixed_versions)
        if version:
            version_spec = helpers.parse_version_spec(version)

        packages = self._package_cache.get(package_name)
        if packages:
            version = version_spec.select(packages.keys())
            if version:
                return packages[version]

        filter_opts = {'fqn': package_name,
                       'version': helpers.breakdown_spec_to_query(
                           version_spec)}
        try:
            package_definition = self._get_definition(filter_opts)
            self._lock_usage(package_definition)
        except LookupError:
            exc_info = sys.exc_info()
            six.reraise(exceptions.NoPackageFound,
                        exceptions.NoPackageFound(package_name),
                        exc_info[2])
        else:
            package = self._get_package_by_definition(package_definition)
            self._fixations[package_name].add(package.version)
            self._new_fixations[package_name].add(package.version)
            return self._to_dsl_package(package)
예제 #6
0
    def __init__(self,
                 package_loader,
                 name,
                 version=None,
                 runtime_version=None,
                 requirements=None,
                 meta=None):
        super(MuranoPackage, self).__init__()
        self._package_loader = weakref.proxy(package_loader)
        self._name = name
        self._version = helpers.parse_version(version)
        self._runtime_version = helpers.parse_version(runtime_version)
        self._requirements = {
            name: semantic_version.Spec('==' + str(self._version.major))
        }
        if name != constants.CORE_LIBRARY:
            self._requirements[constants.CORE_LIBRARY] = \
                semantic_version.Spec('==0')
        self._classes = {}
        self._imported_types = {object, murano_object.MuranoObject}
        for key, value in six.iteritems(requirements or {}):
            self._requirements[key] = helpers.parse_version_spec(value)

        self._load_queue = {}
        self._native_load_queue = {}
        if self.name == constants.CORE_LIBRARY:
            principal_objects.register(self)
        self._package_class = self._create_package_class()
        self._meta = lambda: dslmeta.MetaData(meta, dsl_types.MetaTargets.
                                              Package, self._package_class)
예제 #7
0
    def __init__(self, package_loader, name, version=None,
                 runtime_version=None, requirements=None, meta=None):
        super(MuranoPackage, self).__init__()
        self._package_loader = weakref.proxy(package_loader)
        self._name = name
        self._version = helpers.parse_version(version)
        self._runtime_version = helpers.parse_version(runtime_version)
        self._requirements = {
            name: semantic_version.Spec('==' + str(self._version.major))
        }
        if name != constants.CORE_LIBRARY:
            self._requirements[constants.CORE_LIBRARY] = \
                semantic_version.Spec('==0')
        self._classes = {}
        self._imported_types = {object, murano_object.MuranoObject}
        for key, value in six.iteritems(requirements or {}):
            self._requirements[key] = helpers.parse_version_spec(value)

        self._load_queue = {}
        self._native_load_queue = {}
        if self.name == constants.CORE_LIBRARY:
            principal_objects.register(self)
        self._package_class = self._create_package_class()
        self._meta = lambda: dslmeta.MetaData(
            meta, dsl_types.MetaTargets.Package, self._package_class)
예제 #8
0
    def load_package(self, package_name, version_spec):
        fixed_versions = self._fixations[package_name]
        version = version_spec.select(fixed_versions)
        if version:
            version_spec = helpers.parse_version_spec(version)

        packages = self._package_cache.get(package_name)
        if packages:
            version = version_spec.select(six.iterkeys(packages))
            if version:
                return packages[version]

        filter_opts = {'fqn': package_name,
                       'version': helpers.breakdown_spec_to_query(
                           version_spec)}
        try:
            package_definition = self._get_definition(filter_opts)
            self._lock_usage(package_definition)
        except LookupError:
            exc_info = sys.exc_info()
            six.reraise(exceptions.NoPackageFound(package_name),
                        None, exc_info[2])
        else:
            package = self._get_package_by_definition(package_definition)
            self._fixations[package_name].add(package.version)
            self._new_fixations[package_name].add(package.version)
            return self._to_dsl_package(package)
예제 #9
0
    def find_class(self, name, search_requirements=True):
        payload = self._native_load_queue.pop(name, None)
        if payload is not None:
            return self._register_native_class(payload, name)

        payload = self._load_queue.pop(name, None)
        if payload is not None:
            result = self._register_mpl_classes(payload, name)
            if result:
                return result

        result = self._classes.get(name)
        if result:
            return result
        if search_requirements:
            pkgs_for_search = []
            for package_name, version_spec in six.iteritems(
                    self._requirements):
                if package_name == self.name:
                    continue
                referenced_package = self._package_loader.load_package(
                    package_name, version_spec)
                try:
                    return referenced_package.find_class(name, False)
                except exceptions.NoClassFound:
                    pkgs_for_search.append(referenced_package)
                    continue
            return self._package_loader.load_class_package(name, helpers.parse_version_spec(None)).find_class(name, False)
            #raise exceptions.NoClassFound(
            #    name, packages=pkgs_for_search + [self])

        raise exceptions.NoClassFound(name, packages=[self])
예제 #10
0
    def _process_item(self, obj, owner_id, path):
        if isinstance(obj, dict) and '?' in obj:
            obj_rule = self._create_object_rule(obj, owner_id)

            self._rules.append(obj_rule)
            # the environment has 'services' relationships
            # to all its top-level applications
            # traversal path is used to test whether
            # we are at the right place within the tree
            if path == ('applications',):
                self._rules.append(RelationshipRule(self._env_id,
                                                    obj_rule.obj_id,
                                                    "services"))
            self._rules.extend(
                self._create_propety_rules(obj_rule.obj_id, obj))

            cls = obj['?']['type']
            if 'classVersion' in obj['?']:
                version_spec = helpers.parse_version_spec(
                    semantic_version.Version(obj['?']['classVersion']))
            else:
                version_spec = semantic_version.Spec('*')
            types = self._get_parent_types(
                cls, self._package_loader, version_spec)
            self._rules.extend(self._create_parent_type_rules(obj['?']['id'],
                                                              types))
            # current object will be the owner for its subtree
            return obj_rule.obj_id
예제 #11
0
 def _get_parent_types(type_name, package_loader, version_spec):
     type_name, version_spec, _ = helpers.parse_type_string(
         type_name, version_spec, None)
     version_spec = helpers.parse_version_spec(version_spec)
     result = {type_name}
     if package_loader:
         pkg = package_loader.load_class_package(type_name, version_spec)
         cls = pkg.find_class(type_name, False)
         if cls:
             result.update(t.name for t in cls.ancestors())
     return result
예제 #12
0
def _load_package(pkg_loader, name):
    try:
        parts = name.rsplit('/')
        if len(parts) == 2:
            name, pkg_version = parts
            version_spec = helpers.parse_version_spec(pkg_version)
        else:
            version_spec = helpers.parse_version_spec('*')
        package = pkg_loader.load_package(name, version_spec)
    except exceptions.NoPackageFound:
        if not CONF.engine.load_packages_from:
            msg = _('Local package is not found since "load-packages-from" '
                    'engine parameter is not provided and specified packages '
                    'is not loaded to murano-api')
        else:
            msg = _('Specified package is not found: {0} were scanned together'
                    ' with murano database'
                    ).format(','.join(CONF.engine.load_packages_from))
        LOG.error(msg)
        sys.stderr.write("ERROR: {msg}".format(msg=msg))
        sys.exit(1)
    return package
예제 #13
0
 def load_package(self, package_name, version_spec):
     fixed_versions = self._fixations[package_name]
     version = version_spec.select(fixed_versions)
     if version:
         version_spec = helpers.parse_version_spec(version)
     packages = self._packages_by_name.get(package_name)
     if not packages:
         raise exceptions.NoPackageFound(package_name)
     version = version_spec.select(six.iterkeys(packages))
     if not version:
         raise exceptions.NoPackageFound(package_name)
     self._fixations[package_name].add(version)
     self._new_fixations[package_name].add(version)
     return packages[version]
예제 #14
0
    def load(self, value, owner, context=None):
        if value is None:
            return None
        if '?' not in value or 'type' not in value['?']:
            raise ValueError()
        system_key = value['?']
        object_id = system_key['id']
        obj_type = system_key['type']
        version_spec = helpers.parse_version_spec(
            system_key.get('classVersion'))

        if 'package' not in system_key:
            package = self.executor.package_loader.load_class_package(
                obj_type, version_spec)
        else:
            package = self.executor.package_loader.load_package(
                system_key['package'], version_spec)
        class_obj = package.find_class(obj_type, False)

        try:
            if owner is None:
                self._initializing = True

            if object_id in self._store:
                factory = self._store[object_id]
                if isinstance(factory, dsl_types.MuranoObject):
                    return factory
            else:
                factory = class_obj.new(owner,
                                        self,
                                        self.executor,
                                        name=system_key.get('name'),
                                        object_id=object_id)
                self._store[object_id] = factory
                system_value = ObjectStore._get_designer_attributes(system_key)
                self._designer_attributes_store[object_id] = system_value

            init_context = self.executor.create_object_context(
                factory.object, context)
            obj = factory(init_context, **value)
            if not self._initializing:
                self._store[object_id] = obj
            if owner is None:
                self._initializing = False
                self._store[object_id] = factory(init_context, **value)
        finally:
            if owner is None:
                self._initializing = False

        return factory.object
예제 #15
0
 def load_package(self, package_name, version_spec):
     fixed_versions = self._fixations[package_name]
     version = version_spec.select(fixed_versions)
     if version:
         version_spec = helpers.parse_version_spec(version)
     packages = self._packages_by_name.get(package_name)
     if not packages:
         raise exceptions.NoPackageFound(package_name)
     version = version_spec.select(packages.keys())
     if not version:
         raise exceptions.NoPackageFound(package_name)
     self._fixations[package_name].add(version)
     self._new_fixations[package_name].add(version)
     return packages[version]
예제 #16
0
    def load(self, value, owner, context=None, defaults=None):
        if value is None:
            return None
        if '?' not in value or 'type' not in value['?']:
            raise ValueError()
        system_key = value['?']
        object_id = system_key['id']
        obj_type = system_key['type']
        version_spec = helpers.parse_version_spec(
            system_key.get('classVersion'))

        if 'package' not in system_key:
            package = self.executor.package_loader.load_class_package(
                obj_type, version_spec)
        else:
            package = self.executor.package_loader.load_package(
                system_key['package'], version_spec)
        class_obj = package.find_class(obj_type, False)

        try:
            if owner is None:
                self._initializing = True

            if object_id in self._store:
                factory = self._store[object_id]
                if isinstance(factory, dsl_types.MuranoObject):
                    return factory
            else:
                factory = class_obj.new(
                    owner, self,
                    name=system_key.get('name'),
                    object_id=object_id, defaults=defaults)
                self._store[object_id] = factory
                system_value = ObjectStore._get_designer_attributes(system_key)
                self._designer_attributes_store[object_id] = system_value

            init_context = self.executor.create_object_context(
                factory.object, context)
            obj = factory(init_context, **value)
            if not self._initializing:
                self._store[object_id] = obj
            if owner is None:
                self._initializing = False
                self._store[object_id] = factory(init_context, **value)
        finally:
            if owner is None:
                self._initializing = False

        return factory.object
예제 #17
0
    def _invoke(self, mpl_executor):
        class_name = self.action['class_name']
        pkg_name = self.action['pkg_name']
        class_version = self.action['class_version']
        version_spec = helpers.parse_version_spec(class_version)
        if pkg_name:
            package = mpl_executor.package_loader.load_package(
                pkg_name, version_spec)
        else:
            package = mpl_executor.package_loader.load_class_package(
                class_name, version_spec)
        cls = package.find_class(class_name, search_requirements=False)
        method_name, kwargs = self.action['method'], self.action['args']

        return mpl_executor.run(cls, method_name, None, (), kwargs)
예제 #18
0
    def test_execute(self, mock_package_loader, mock_serializer):
        mock_class = mock.Mock()
        mock_package = mock.Mock(spec=murano_package.MuranoPackage)
        mock_package.find_class.return_value = mock_class
        mock_package_loader.load_package.return_value = mock_package
        version_spec = helpers.parse_version_spec(self.action['class_version'])

        self.task_executor.execute()
        mock_package_loader.load_package.assert_called_once_with(
            'TestPackage', version_spec)
        mock_package.find_class.assert_called_once_with(
            self.action['class_name'], search_requirements=False)
        mock_class.invoke.assert_called_once_with('TestAction', None, (),
                                                  {'name': 'foo'})
        self.assertTrue(mock_serializer.serialize.called)
예제 #19
0
    def _invoke(self, mpl_executor):
        class_name = self.action['class_name']
        pkg_name = self.action['pkg_name']
        class_version = self.action['class_version']
        version_spec = helpers.parse_version_spec(class_version)
        if pkg_name:
            package = mpl_executor.package_loader.load_package(
                pkg_name, version_spec)
        else:
            package = mpl_executor.package_loader.load_class_package(
                class_name, version_spec)
        cls = package.find_class(class_name, search_requirements=False)
        method_name, kwargs = self.action['method'], self.action['args']

        return mpl_executor.run(cls, method_name, None, (), kwargs)
예제 #20
0
 def check(self, expected, version_spec):
     self.assertEqual(expected, helpers.parse_version_spec(version_spec))
예제 #21
0
파일: runner.py 프로젝트: ldreamke/murano
 def on_class(self, class_name):
     cls = self.executor.package_loader.load_class_package(
         class_name,
         helpers.parse_version_spec(None)).find_class(class_name, False)
     return Runner.DslObjectWrapper(cls, self)