Merge pull request #200 from ImMin5/feature-cost-router

Modify logic for manual sync duplicated job

src/spaceone/cost_analysis/interface/grpc/data_source.py

@@ -7,78 +7,125 @@
 
 
 class DataSource(BaseAPI, data_source_pb2_grpc.DataSourceServicer):
-
     pb2 = data_source_pb2
     pb2_grpc = data_source_pb2_grpc
 
     def register(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('DataSourceInfo', data_source_service.register(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.register(params)
+            )
 
     def update(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('DataSourceInfo', data_source_service.update(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.update(params)
+            )
+
+    def update_secret_data(self, request, context):
+        params, metadata = self.parse_request(request, context)
+
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.update_secret_data(params)
+            )
 
     def update_plugin(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('DataSourceInfo', data_source_service.update_plugin(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.update_plugin(params)
+            )
 
     def verify_plugin(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
             data_source_service.verify_plugin(params)
-            return self.locator.get_info('EmptyInfo')
+            return self.locator.get_info("EmptyInfo")
 
     def enable(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('DataSourceInfo', data_source_service.enable(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.enable(params)
+            )
 
     def disable(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('DataSourceInfo', data_source_service.disable(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.disable(params)
+            )
 
     def deregister(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
             data_source_service.deregister(params)
-            return self.locator.get_info('EmptyInfo')
+            return self.locator.get_info("EmptyInfo")
 
     def sync(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('JobInfo', data_source_service.sync(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info("JobInfo", data_source_service.sync(params))
 
     def get(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('DataSourceInfo', data_source_service.get(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "DataSourceInfo", data_source_service.get(params)
+            )
 
     def list(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
             data_source_vos, total_count = data_source_service.list(params)
-            return self.locator.get_info('DataSourcesInfo',
-                                         data_source_vos,
-                                         total_count,
-                                         minimal=self.get_minimal(params))
+            return self.locator.get_info(
+                "DataSourcesInfo",
+                data_source_vos,
+                total_count,
+                minimal=self.get_minimal(params),
+            )
 
     def stat(self, request, context):
         params, metadata = self.parse_request(request, context)
 
-        with self.locator.get_service('DataSourceService', metadata) as data_source_service:
-            return self.locator.get_info('StatisticsInfo', data_source_service.stat(params))
+        with self.locator.get_service(
+            "DataSourceService", metadata
+        ) as data_source_service:
+            return self.locator.get_info(
+                "StatisticsInfo", data_source_service.stat(params)
+            )

src/spaceone/cost_analysis/manager/secret_manager.py

@@ -20,34 +20,53 @@ def __init__(self, *args, **kwargs):
 
     def create_secret(
         self,
-        secret_data: dict,
-        resource_group: str,
-        schema_id: str,
-        workspace_id: str,
-    ):
+        params: dict,
+        domain_id: str = None,
+        workspace_id: str = None,
+    ) -> dict:
+        """
+        Args:
+            params (dict): {
+                'data': 'dict',
+                'resource_group': 'str',
+                'schema_id': 'str',
+                'workspace_id': 'str',
+            },
+            'workspace_id' : 'str',
+            'domain_id' : 'str'
+
+        Returns:
+            secret_info (dict)
+        """
+
         def _rollback(secret_id: str):
             _LOGGER.info(f"[create_secret._rollback] Delete secret : {secret_id}")
-            self.delete_secret(secret_id)
-
-        params = {
-            "name": utils.generate_id("secret-cost-data-source"),
-            "resource_group": resource_group,
-            "data": secret_data,
-            "schema_id": schema_id,
-            "workspace_id": workspace_id,
-        }
+            self.delete_secret(secret_id, domain_id)
 
-        response = self.secret_connector.dispatch("Secret.create", params)
+        params.update({"name": utils.generate_id("secret-cost-data-source")})
+        if self.token_type == "SYSTEM_TOKEN":
+            response = self.secret_connector.dispatch(
+                "Secret.create",
+                params,
+                x_domain_id=domain_id,
+                x_workspace_id=workspace_id,
+            )
+        else:
+            response = self.secret_connector.dispatch("Secret.create", params)
 
         _LOGGER.debug(f"[_create_secret] {response}")
-        secret_id = response["secret_id"]
 
-        self.transaction.add_rollback(_rollback, secret_id)
+        self.transaction.add_rollback(_rollback, response["secret_id"])
 
-        return secret_id
+        return response
 
-    def delete_secret(self, secret_id: str):
-        self.secret_connector.dispatch("Secret.delete", {"secret_id": secret_id})
+    def delete_secret(self, secret_id: str, domain_id: str = None):
+        if self.token_type == "SYSTEM_TOKEN":
+            self.secret_connector.dispatch(
+                "Secret.delete", {"secret_id": secret_id}, x_domain_id=domain_id
+            )
+        else:
+            self.secret_connector.dispatch("Secret.delete", {"secret_id": secret_id})
 
     def list_secrets(self, query: dict, domain_id: str = None) -> dict:
         params = {"query": query}

src/spaceone/cost_analysis/service/data_source_service.py

@@ -108,14 +108,16 @@ def register(self, params):
                 self._verify_plugin(endpoint, plugin_info, domain_id)
 
                 secret_mgr: SecretManager = self.locator.get_manager("SecretManager")
-                secret_id = secret_mgr.create_secret(
-                    secret_data,
-                    resource_group,
-                    plugin_info.get("schema_id"),
-                    params["workspace_id"],
-                )
 
-                params["plugin_info"]["secret_id"] = secret_id
+                create_secret_params = {
+                    "data": secret_data,
+                    "resource_group": resource_group,
+                    "schema_id": plugin_info.get("schema_id"),
+                    "workspace_id": params["workspace_id"],
+                }
+                secret_info = secret_mgr.create_secret(create_secret_params, domain_id)
+
+                params["plugin_info"]["secret_id"] = secret_info["secret_id"]
                 del params["plugin_info"]["secret_data"]
 
         else:
@@ -187,6 +189,65 @@ def update(self, params):
 
         return self.data_source_mgr.update_data_source_by_vo(params, data_source_vo)
 
+    @transaction(
+        permission="cost-analysis:DataSource.write",
+        role_types=["DOMAIN_ADMIN", "WORKSPACE_OWNER"],
+    )
+    @check_required(["data_source_id", "secret_schema_id", "secret_data", "domain_id"])
+    def update_secret_data(self, params: dict) -> DataSource:
+        """Update secret data of data source
+        Args:
+            params (dict): {
+                'data_source_id': 'str',        # required
+                'secret_schema_id': 'str',      # required
+                'secret_data': 'dict',          # required
+                'workspace_id': 'str',          # injected from auth
+                'domain_id': 'str'              # injected from auth
+            }
+        Returns:
+            data_source_vo (object)
+        """
+
+        secret_data = params["secret_data"]
+        secret_schema_id = params["secret_schema_id"]
+        data_source_id = params["data_source_id"]
+        workspace_id = params.get("workspace_id")
+        domain_id = params["domain_id"]
+
+        data_source_vo: DataSource = self.data_source_mgr.get_data_source(
+            data_source_id=data_source_id,
+            domain_id=domain_id,
+            workspace_id=workspace_id,
+        )
+
+        if data_source_vo.secret_type == "MANUAL" and secret_data:
+            secret_mgr: SecretManager = self.locator.get_manager("SecretManager")
+            # TODO : validate schema
+
+            # Delete old secret
+            if secret_id := data_source_vo.plugin_info.secret_id:
+                secret_mgr.delete_secret(secret_id, domain_id)
+
+            # Create new secret
+            create_secret_params = {
+                "schema_id": secret_schema_id,
+                "data": secret_data,
+                "resource_group": data_source_vo.resource_group,
+                "workspace_id": data_source_vo.workspace_id,
+            }
+
+            secret_info = secret_mgr.create_secret(create_secret_params, domain_id)
+            plugin_info = data_source_vo.plugin_info.to_dict()
+            plugin_info.update(
+                {"secret_id": secret_info["secret_id"], "schema_id": secret_schema_id}
+            )
+
+            self.data_source_mgr.update_data_source_by_vo(
+                {"plugin_info": plugin_info}, data_source_vo
+            )
+
+        return data_source_vo
+
     @transaction(
         permission="cost-analysis:DataSource.write",
         role_types=["DOMAIN_ADMIN", "WORKSPACE_OWNER"],
@@ -374,8 +435,6 @@ def deregister(self, params):
             data_source_id, domain_id, workspace_id
         )
 
-        workspace_id = data_source_vo.workspace_id
-
         if cascade_delete_cost:
             self.cost_mgr.delete_cost_with_datasource(domain_id, data_source_id)
             self.budget_usage_mgr.update_budget_usage(domain_id, data_source_id)
@@ -387,7 +446,7 @@ def deregister(self, params):
 
             if secret_id:
                 secret_mgr: SecretManager = self.locator.get_manager("SecretManager")
-                secret_mgr.delete_secret(secret_id)
+                secret_mgr.delete_secret(secret_id, domain_id)
 
         self.data_source_mgr.deregister_data_source_by_vo(data_source_vo)