Merge pull request #69 from whdalsrnt/master

feat: add dashboard template APIs

Author: Jongmin Kim

src/spaceone/repository/error/__init__.py

@@ -1,2 +1,3 @@
 from spaceone.repository.error.plugin import *
+from spaceone.repository.error.dashboard_template import *
 from spaceone.repository.error.repository import *

src/spaceone/repository/error/dashboard_template.py

@@ -0,0 +1,9 @@
+from spaceone.core.error import *
+
+
+class ERROR_NO_DASHBOARD_TEMPLATE(ERROR_INVALID_ARGUMENT):
+    _message = 'Dashboard Template does not exists. (template_id = {template_id})'
+
+
+class ERROR_MANAGED_REPOSITORY_NOT_SUPPORT_LIST(ERROR_INVALID_ARGUMENT):
+    _message = 'Managed Repository does not support list method.'

src/spaceone/repository/error/plugin.py

@@ -5,10 +5,6 @@ class ERROR_NO_PLUGIN(ERROR_INVALID_ARGUMENT):
     _message = 'Plugin does not exists. (plugin_id = {plugin_id})'
 
 
-class ERROR_INVALID_IMAGE_FORMAT(ERROR_INVALID_ARGUMENT):
-    _message = 'Image format is <repository name>/<image name> in {name}'
-
-
 class ERROR_INVALID_IMAGE_NAME_FORMAT(ERROR_INVALID_ARGUMENT):
     _message = 'Image name format is [a-zA-Z0-9\-]+ in {name}'
 

src/spaceone/repository/info/__init__.py

@@ -1,3 +1,4 @@
 from spaceone.repository.info.common_info import *
 from spaceone.repository.info.plugin_info import *
+from spaceone.repository.info.dashboard_template_info import *
 from spaceone.repository.info.repository_info import *

src/spaceone/repository/info/dashboard_template_info.py

@@ -0,0 +1,47 @@
+import functools
+from spaceone.api.repository.v1 import dashboard_template_pb2, repository_pb2
+from spaceone.core.pygrpc.message_type import *
+from spaceone.core import utils
+
+__all__ = ["DashboardTemplateInfo", "DashboardTemplatesInfo"]
+
+
+def DashboardTemplateInfo(template_info: dict, minimal=False):
+    info = {
+        "template_id": template_info.get("template_id"),
+        "name": template_info.get("name"),
+        "state": template_info.get("state"),
+        "template_type": template_info.get("template_type"),
+    }
+
+    if not minimal:
+        info.update(
+            {
+                "dashboards": change_list_value_type(template_info.get("dashboards")),
+                "tags": change_struct_type(template_info.get("tags")),
+                "labels": change_list_value_type(template_info.get("labels")),
+                "domain_id": template_info.get("domain_id"),
+                "created_at": utils.datetime_to_iso8601(template_info.get("created_at")),
+                "updated_at": utils.datetime_to_iso8601(template_info.get("updated_at")),
+            }
+        )
+
+        if repository_info := template_info.get("repository_info"):
+            info.update(
+                {
+                    "repository_info": repository_pb2.RepositoryInfo(
+                        repository_id=repository_info.get("repository_id"),
+                        name=repository_info.get("name"),
+                        repository_type=repository_info.get("repository_type"),
+                    )
+                }
+            )
+
+    return dashboard_template_pb2.DashboardTemplateInfo(**info)
+
+
+def DashboardTemplatesInfo(templates_info, total_count, **kwargs):
+    return dashboard_template_pb2.DashboardTemplatesInfo(
+        results=list(map(functools.partial(DashboardTemplateInfo, **kwargs), templates_info)),
+        total_count=total_count,
+    )

src/spaceone/repository/interface/grpc/__init__.py

@@ -1,10 +1,12 @@
 from spaceone.core.pygrpc.server import GRPCServer
 from .repository import Repository
 from .plugin import Plugin
+from .dashboard_template import DashboardTemplate
 
 
 _all_ = ['app']
 
 app = GRPCServer()
 app.add_service(Repository)
 app.add_service(Plugin)
+app.add_service(DashboardTemplate)

src/spaceone/repository/interface/grpc/dashboard_template.py

@@ -0,0 +1,51 @@
+from spaceone.api.repository.v1 import dashboard_template_pb2, dashboard_template_pb2_grpc
+from spaceone.core.pygrpc import BaseAPI
+
+
+class DashboardTemplate(BaseAPI, dashboard_template_pb2_grpc.DashboardTemplateServicer):
+
+    pb2 = dashboard_template_pb2
+    pb2_grpc = dashboard_template_pb2_grpc
+
+    def register(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            template_data = template_svc.register(params)
+            return self.locator.get_info('DashboardTemplateInfo', template_data)
+
+    def update(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            template_data = template_svc.update(params)
+            return self.locator.get_info('DashboardTemplateInfo', template_data)
+
+    def deregister(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            template_svc.deregister(params)
+            return self.locator.get_info('EmptyInfo')
+
+    def enable(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            template_data = template_svc.enable(params)
+            return self.locator.get_info('DashboardTemplateInfo', template_data)
+
+    def disable(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            template_data = template_svc.disable(params)
+            return self.locator.get_info('DashboardTemplateInfo', template_data)
+
+    def get(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            template_data = template_svc.get(params)
+            return self.locator.get_info('DashboardTemplateInfo', template_data)
+
+    def list(self, request, context):
+        params, metadata = self.parse_request(request, context)
+        with self.locator.get_service('DashboardTemplateService', metadata) as template_svc:
+            templates_data, total_count = template_svc.list(params)
+            return self.locator.get_info('DashboardTemplatesInfo', templates_data, total_count, minimal=self.get_minimal(params))
+

src/spaceone/repository/manager/__init__.py

@@ -12,3 +12,13 @@
 from spaceone.repository.manager.plugin_manager.remote_plugin_manager import (
     RemotePluginManager,
 )
+
+from spaceone.repository.manager.dashboard_template_manager.local_dashboard_template_manager import (
+    LocalDashboardTemplateManager,
+)
+from spaceone.repository.manager.dashboard_template_manager.remote_dashboard_template_manager import (
+    RemoteDashboardTemplateManager,
+)
+from spaceone.repository.manager.dashboard_template_manager.managed_dashboard_template_manager import (
+    ManagedDashboardTemplateManager,
+)

src/spaceone/repository/manager/dashboard_template_manager/__init__.py

@@ -0,0 +1,45 @@
+import logging
+from abc import abstractmethod
+
+from spaceone.core.manager import BaseManager
+
+__all__ = ["DashboardTemplateManager"]
+_LOGGER = logging.getLogger(__name__)
+
+
+class DashboardTemplateManager(BaseManager):
+    def create_template(self, params):
+        pass
+
+    def update_template(self, params):
+        pass
+
+    def enable_template(self, template_id, domain_id):
+        pass
+
+    def disable_template(self, template_id, domain_id):
+        pass
+
+    def delete_template(self, template_id, domain_id):
+        pass
+
+    @abstractmethod
+    def get_template(self, repo_info: dict, template_id, domain_id):
+        pass
+
+    @abstractmethod
+    def list_templates(self, repo_info: dict, query: dict, params: dict):
+        pass
+
+    @staticmethod
+    def change_response(
+            info: dict, repo_info: dict = None
+    ) -> dict:
+        if repo_info:
+            info["repository_info"] = {
+                "repository_id": repo_info["repository_id"],
+                "name": repo_info["name"],
+                "repository_type": repo_info["repository_type"],
+            }
+
+        return info

src/spaceone/repository/manager/dashboard_template_manager/local_dashboard_template_manager.py

@@ -0,0 +1,94 @@
+import logging
+
+from spaceone.repository.model.dashboard_template_model import DashboardTemplate
+from spaceone.repository.manager.dashboard_template_manager import DashboardTemplateManager
+from spaceone.repository.manager.repository_manager import RepositoryManager
+
+__all__ = ["LocalDashboardTemplateManager"]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class LocalDashboardTemplateManager(DashboardTemplateManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.template_model: DashboardTemplate = self.locator.get_model("DashboardTemplate")
+        self.repo_info = RepositoryManager.get_repositories(repository_type="LOCAL")[0]
+
+    def create_template(self, params: dict):
+        def _rollback(vo: DashboardTemplate):
+            vo.delete()
+
+        template_vo: DashboardTemplate = self.template_model.create(params)
+        self.transaction.add_rollback(_rollback, template_vo)
+
+        template_info = template_vo.to_dict()
+        return self.change_response(template_info, self.repo_info)
+
+    def update_template(self, params):
+        template_vo = self.template_model.get(
+            template_id=params["template_id"], domain_id=params["domain_id"]
+        )
+        return self.update_template_by_vo(params, template_vo)
+
+    def enable_template(self, template_id, domain_id):
+        template_vo = self.template_model.get(template_id=template_id, domain_id=domain_id)
+        return self.update_template_by_vo({"state": "ENABLED"}, template_vo)
+
+    def disable_template(self, template_id, domain_id):
+        template_vo = self.template_model.get(template_id=template_id, domain_id=domain_id)
+        return self.update_template_by_vo({"state": "DISABLED"}, template_vo)
+
+    def update_template_by_vo(self, params, template_vo):
+        def _rollback(old_data):
+            _LOGGER.info(
+                f'[ROLLBACK] Revert DashboardTemplate Data : {old_data["name"]} ({old_data["template_id"]})'
+            )
+            template_vo.update(old_data)
+
+        self.transaction.add_rollback(_rollback, template_vo.to_dict())
+        template_vo = template_vo.update(params)
+        template_info = template_vo.to_dict()
+        return self.change_response(template_info, self.repo_info)
+
+    def delete_template(self, template_id, domain_id):
+        template_vo = self.template_model.get(template_id=template_id, domain_id=domain_id)
+        template_vo.delete()
+
+    def get_template(self, repo_info: dict, template_id, domain_id: str):
+        template_vo = self.template_model.get(template_id=template_id, domain_id=domain_id)
+
+        template_info = template_vo.to_dict()
+        return self.change_response(template_info, self.repo_info)
+
+    def list_templates(self, repos_info: dict, query: dict, params: dict):
+        domain_id = params.get("domain_id")
+        keyword = query.get("keyword")
+        query_filter = query.get("filter", [])
+        query_filter_or = query.get("filter_or", [])
+        query["filter"] = self._append_domain_filter(query_filter, domain_id)
+        query["filter_or"] = self._append_keyword_filter(query_filter_or, keyword)
+        if "repository" in query.get("only", []):
+            query["only"].remove("repository")
+
+        template_vos, total_count = self.template_model.query(**query)
+        results = []
+        for template_vo in template_vos:
+            template_info = template_vo.to_dict()
+            results.append(self.change_response(template_info, repos_info))
+
+        return results, total_count
+
+    @staticmethod
+    def _append_domain_filter(query_filter, domain_id=None):
+        if domain_id:
+            query_filter.append({"k": "domain_id", "v": domain_id, "o": "eq"})
+
+        return query_filter
+
+    @staticmethod
+    def _append_keyword_filter(query_filter_or, keyword):
+        if keyword:
+            query_filter_or.append({"k": "name", "v": keyword, "o": "contain"})
+
+        return query_filter_or