Python metadef_object.MetadefObject类代码示例

 def index(self, req, namespace, marker=None, limit=None,
           sort_key='created_at', sort_dir='desc', filters=None):
     try:
         filters = filters or dict()
         filters['namespace'] = namespace
         object_repo = self.gateway.get_metadef_object_repo(req.context)
         db_metaobject_list = object_repo.list(
             marker=marker, limit=limit, sort_key=sort_key,
             sort_dir=sort_dir, filters=filters)
         object_list = [MetadefObject.to_wsme_model(
             db_metaobject,
             get_object_href(namespace, db_metaobject),
             self.obj_schema_link) for db_metaobject in db_metaobject_list]
         metadef_objects = MetadefObjects()
         metadef_objects.objects = object_list
     except exception.Forbidden as e:
         LOG.debug("User not permitted to retrieve metadata objects within "
                   "'%s' namespace", namespace)
         raise webob.exc.HTTPForbidden(explanation=e.msg)
     except exception.NotFound as e:
         raise webob.exc.HTTPNotFound(explanation=e.msg)
     except Exception as e:
         LOG.error(encodeutils.exception_to_unicode(e))
         raise webob.exc.HTTPInternalServerError()
     return metadef_objects

 def update(self, req, metadata_object, namespace, object_name):
     meta_repo = self.gateway.get_metadef_object_repo(req.context)
     try:
         metadef_object = meta_repo.get(namespace, object_name)
         metadef_object._old_name = metadef_object.name
         metadef_object.name = wsme_utils._get_value(
             metadata_object.name)
         metadef_object.description = wsme_utils._get_value(
             metadata_object.description)
         metadef_object.required = wsme_utils._get_value(
             metadata_object.required)
         metadef_object.properties = wsme_utils._get_value(
             metadata_object.properties)
         updated_metadata_obj = meta_repo.save(metadef_object)
     except exception.Forbidden as e:
         LOG.debug("User not permitted to update metadata object '%s' "
                   "within '%s' namespace ", object_name, namespace)
         raise webob.exc.HTTPForbidden(explanation=e.msg)
     except exception.NotFound as e:
         raise webob.exc.HTTPNotFound(explanation=e.msg)
     except exception.Duplicate as e:
         raise webob.exc.HTTPConflict(explanation=e.msg)
     except Exception as e:
         LOG.error(encodeutils.exception_to_unicode(e))
         raise webob.exc.HTTPInternalServerError()
     return MetadefObject.to_wsme_model(
         updated_metadata_obj,
         get_object_href(namespace, updated_metadata_obj),
         self.obj_schema_link)

    def show(self, req, namespace, filters=None):
        try:
            # Get namespace
            ns_repo = self.gateway.get_metadef_namespace_repo(req.context)
            namespace_obj = ns_repo.get(namespace)
            namespace_detail = Namespace.to_wsme_model(
                namespace_obj,
                get_namespace_href(namespace_obj),
                self.ns_schema_link)
            ns_filters = dict()
            ns_filters['namespace'] = namespace

            # Get objects
            object_repo = self.gateway.get_metadef_object_repo(req.context)
            db_metaobject_list = object_repo.list(filters=ns_filters)
            object_list = [MetadefObject.to_wsme_model(
                db_metaobject,
                get_object_href(namespace, db_metaobject),
                self.obj_schema_link) for db_metaobject in db_metaobject_list]
            if object_list:
                namespace_detail.objects = object_list

            # Get resource type associations
            rs_repo = self.gateway.get_metadef_resource_type_repo(req.context)
            db_resource_type_list = rs_repo.list(filters=ns_filters)
            resource_type_list = [ResourceTypeAssociation.to_wsme_model(
                resource_type) for resource_type in db_resource_type_list]
            if resource_type_list:
                namespace_detail.resource_type_associations = (
                    resource_type_list)

            # Get properties
            prop_repo = self.gateway.get_metadef_property_repo(req.context)
            db_properties = prop_repo.list(filters=ns_filters)
            property_list = Namespace.to_model_properties(db_properties)
            if property_list:
                namespace_detail.properties = property_list

            if filters and filters['resource_type']:
                namespace_detail = self._prefix_property_name(
                    namespace_detail, filters['resource_type'])

            # Get tags
            tag_repo = self.gateway.get_metadef_tag_repo(req.context)
            db_metatag_list = tag_repo.list(filters=ns_filters)
            tag_list = [MetadefTag(**{'name': db_metatag.name})
                        for db_metatag in db_metatag_list]
            if tag_list:
                namespace_detail.tags = tag_list

        except exception.Forbidden as e:
            LOG.debug("User not permitted to show metadata namespace "
                      "'%s'", namespace)
            raise webob.exc.HTTPForbidden(explanation=e.msg)
        except exception.NotFound as e:
            raise webob.exc.HTTPNotFound(explanation=e.msg)
        except Exception as e:
            LOG.error(encodeutils.exception_to_unicode(e))
            raise webob.exc.HTTPInternalServerError()
        return namespace_detail

    def create(self, req, metadata_object, namespace):
        object_factory = self.gateway.get_metadef_object_factory(req.context)
        object_repo = self.gateway.get_metadef_object_repo(req.context)
        try:
            new_meta_object = object_factory.new_object(
                namespace=namespace,
                **metadata_object.to_dict())
            object_repo.add(new_meta_object)

        except exception.Forbidden as e:
            LOG.debug("User not permitted to create metadata object within "
                      "'%s' namespace", namespace)
            raise webob.exc.HTTPForbidden(explanation=e.msg)
        except exception.Invalid as e:
            msg = (_("Couldn't create metadata object: %s")
                   % encodeutils.exception_to_unicode(e))
            raise webob.exc.HTTPBadRequest(explanation=msg)
        except exception.NotFound as e:
            raise webob.exc.HTTPNotFound(explanation=e.msg)
        except exception.Duplicate as e:
            raise webob.exc.HTTPConflict(explanation=e.msg)
        except Exception as e:
            LOG.error(encodeutils.exception_to_unicode(e))
            raise webob.exc.HTTPInternalServerError()
        return MetadefObject.to_wsme_model(
            new_meta_object,
            get_object_href(namespace, new_meta_object),
            self.obj_schema_link)

def get_schema():
    definitions = _get_base_definitions()
    properties = _get_base_properties()
    mandatory_attrs = MetadefObject.get_mandatory_attrs()
    schema = glance.schema.Schema(
        'object',
        properties,
        required=mandatory_attrs,
        definitions=definitions,
    )
    return schema

 def show(self, req, namespace, object_name):
     meta_object_repo = self.gateway.get_metadef_object_repo(
         req.context)
     try:
         metadef_object = meta_object_repo.get(namespace, object_name)
         return MetadefObject.to_wsme_model(
             metadef_object,
             get_object_href(namespace, metadef_object),
             self.obj_schema_link)
     except exception.Forbidden as e:
         raise webob.exc.HTTPForbidden(explanation=e.msg)
     except exception.NotFound as e:
         raise webob.exc.HTTPNotFound(explanation=e.msg)
     except Exception as e:
         LOG.error(utils.exception_to_str(e))
         raise webob.exc.HTTPInternalServerError()

 def show(self, req, namespace, object_name):
     meta_object_repo = self.gateway.get_metadef_object_repo(
         req.context)
     try:
         metadef_object = meta_object_repo.get(namespace, object_name)
         return MetadefObject.to_wsme_model(
             metadef_object,
             get_object_href(namespace, metadef_object),
             self.obj_schema_link)
     except exception.Forbidden as e:
         LOG.debug("User not permitted to show metadata object '%s' "
                   "within '%s' namespace", namespace, object_name)
         raise webob.exc.HTTPForbidden(explanation=e.msg)
     except exception.NotFound as e:
         raise webob.exc.HTTPNotFound(explanation=e.msg)
     except Exception as e:
         LOG.error(encodeutils.exception_to_unicode(e))
         raise webob.exc.HTTPInternalServerError()

    def create(self, req, metadata_object, namespace):
        object_factory = self.gateway.get_metadef_object_factory(req.context)
        object_repo = self.gateway.get_metadef_object_repo(req.context)
        try:
            new_meta_object = object_factory.new_object(
                namespace=namespace,
                **metadata_object.to_dict())
            object_repo.add(new_meta_object)

        except exception.Forbidden as e:
            raise webob.exc.HTTPForbidden(explanation=e.msg)
        except exception.NotFound as e:
            raise webob.exc.HTTPNotFound(explanation=e.msg)
        except exception.Duplicate as e:
            raise webob.exc.HTTPConflict(explanation=e.msg)
        except Exception as e:
            LOG.error(utils.exception_to_str(e))
            raise webob.exc.HTTPInternalServerError()
        return MetadefObject.to_wsme_model(
            new_meta_object,
            get_object_href(namespace, new_meta_object),
            self.obj_schema_link)