Mpt-4856 Add Cloud Account (#26)

Author: antoniodimariano

app/datasources/__init__.py renamed to app/api/__init__.py

@@ -0,0 +1,57 @@
+import logging
+
+from fastapi import APIRouter, Depends
+from fastapi import status as http_status
+from starlette.responses import JSONResponse
+
+from app.api.cloud_account.cloud_accounts_manager import (
+    CloudStrategyConfiguration,
+    CloudStrategyManager,
+)
+from app.api.cloud_account.model import AddCloudAccount, AddCloudAccountResponse
+from app.api.invitations.api import get_bearer_token
+from app.core.exceptions import (
+    CloudAccountConfigError,
+    OptScaleAPIResponseError,
+    format_error_response,
+)
+
+logger = logging.getLogger("api.organizations")
+router = APIRouter()
+
+
+@router.post(
+    path="",
+    status_code=http_status.HTTP_201_CREATED,
+    response_model=AddCloudAccountResponse,
+    response_model_exclude_none=True,
+)
+async def add_cloud_account(
+    data: AddCloudAccount, user_access_token: str = Depends(get_bearer_token)
+):
+    # Here the config as received is validated
+    cloud_account_config = CloudStrategyConfiguration(
+        name=data.name,
+        provider_type=data.type,
+        config=data.config,
+        process_recommendations=data.process_recommendations,
+        auto_import=data.auto_import,
+    )
+    try:
+        # let's select the correct strategy for the given cloud account
+        cloud_account_strategy = cloud_account_config.select_strategy()
+        strategy_manager = CloudStrategyManager(strategy=cloud_account_strategy)
+        # here the conf will be processed in order to use the OptScale API
+        response = await strategy_manager.add_cloud_account(
+            config=cloud_account_config,
+            org_id=data.org_id,
+            user_access_token=user_access_token,
+        )
+
+        return JSONResponse(
+            status_code=response.get("status_code", http_status.HTTP_201_CREATED),
+            content=response.get("data", {}),
+        )
+    except (OptScaleAPIResponseError, CloudAccountConfigError, ValueError) as error:
+        logger.error(f"An error occurred adding the cloud account {data.type} {error}")
+        return format_error_response(error)

app/invitations/__init__.py renamed to app/api/cloud_account/__init__.py

@@ -0,0 +1,12 @@
+import logging
+
+from app.api.cloud_account.cloud_accounts_conf.cloud_config_strategy import (
+    CloudConfigStrategy,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AWSConfigStrategy(CloudConfigStrategy):
+    def required_fields(self) -> list:
+        return ["access_key_id", "secret_access_key"]

app/api/cloud_account/api.py

@@ -0,0 +1,17 @@
+import logging
+
+from app.api.cloud_account.cloud_accounts_conf.cloud_config_strategy import (
+    CloudConfigStrategy,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AzureCNRConfigStrategy(CloudConfigStrategy):
+    def required_fields(self) -> list:
+        return ["subscription_id", "client_id", "tenant", "secret"]
+
+
+class AzureTenantConfigStrategy(CloudConfigStrategy):
+    def required_fields(self) -> list:
+        return ["client_id", "tenant", "secret"]

app/invitations/services/__init__.py renamed to app/api/cloud_account/cloud_accounts_conf/__init__.py

@@ -0,0 +1,48 @@
+import logging
+from abc import ABC, abstractmethod
+
+from app.core.exceptions import CloudAccountConfigError
+from app.optscale_api.cloud_accounts import OptScaleCloudAccountAPI
+
+logger = logging.getLogger(__name__)
+
+
+class CloudConfigStrategy(ABC):
+    def __init__(self, optscale_cloud_account_api: OptScaleCloudAccountAPI):
+        self.optscale_cloud_account_api = optscale_cloud_account_api
+
+    @abstractmethod
+    def required_fields(self) -> list:
+        pass
+
+    def validate_config(self, config: dict):
+        for field in self.required_fields():
+            if field not in config:
+                logger.error(f"The {field} is required in the configuration")
+                raise CloudAccountConfigError(f"The {field} is required ")
+
+    async def link_cloud_account_to_org(
+        self,
+        config: dict[str, str],
+        org_id: str,
+        user_access_token: str,
+    ):  # noqa: E501
+        """
+        This method acts as a wrapper for the OptScale API link_cloud_account_with_org method
+        :param config: The Cloud Account payload
+        :param org_id: The user's ORG to link the Cloud Account with
+        :param user_access_token: The user's access token
+        :return: The response as it comes from OptScale
+        :raise: Rethrow OptScaleAPIResponseError if an error occurred consuming the
+        OptScale APIs.
+        """
+        response = await self.optscale_cloud_account_api.link_cloud_account_with_org(
+            user_access_token=user_access_token,  # noqa: E501
+            org_id=org_id,
+            conf=config,
+        )
+        cloud_account_type = config.get("type")
+        logger.info(
+            f"The Cloud Account {cloud_account_type} has been added to the org {org_id}"
+        )
+        return response

app/api/cloud_account/cloud_accounts_conf/aws.py

@@ -0,0 +1,12 @@
+import logging
+
+from app.api.cloud_account.cloud_accounts_conf.cloud_config_strategy import (
+    CloudConfigStrategy,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GCPCNRConfigStrategy(CloudConfigStrategy):
+    def required_fields(self) -> list:
+        return ["credentials", "billing_data"]

app/api/cloud_account/cloud_accounts_conf/azure.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import logging
+
+from fastapi import status as http_status
+
+from app.api.cloud_account.cloud_accounts_conf.aws import AWSConfigStrategy
+from app.api.cloud_account.cloud_accounts_conf.azure import (
+    AzureCNRConfigStrategy,
+    AzureTenantConfigStrategy,
+)
+from app.api.cloud_account.cloud_accounts_conf.cloud_config_strategy import (
+    CloudConfigStrategy,
+)
+from app.api.cloud_account.cloud_accounts_conf.gcp import GCPCNRConfigStrategy
+from app.core.exceptions import (
+    CloudAccountConfigError,
+    OptScaleAPIResponseError,
+)
+from app.optscale_api.cloud_accounts import OptScaleCloudAccountAPI
+
+logger = logging.getLogger(__name__)
+
+
+class CloudStrategyConfiguration:
+    ALLOWED_PROVIDERS = {
+        "aws_cnr": AWSConfigStrategy,
+        "gcp_cnr": GCPCNRConfigStrategy,
+        "azure_cnr": AzureCNRConfigStrategy,
+        "azure_tenant": AzureTenantConfigStrategy,
+    }
+
+    def __init__(
+        self,
+        name: str,
+        provider_type: str,
+        auto_import: bool = True,
+        process_recommendations: bool = True,  # noqa: E501
+        config: dict = None,
+    ):
+        self.name = name
+        self.type = provider_type
+        self.config = config if config else {}
+        self.auto_import = auto_import
+        self.process_recommendations = process_recommendations
+
+    def select_strategy(self):
+        """
+        This method checks if the Cloud Account type is allowed.
+        If it's valid, an instance of the Cloud Account Class's Strategy
+        will be created and validated.
+        :return:
+        :rtype:
+        """
+        if self.type not in self.ALLOWED_PROVIDERS:
+            raise OptScaleAPIResponseError(
+                title="Wrong Cloud Account",
+                error_code="OE0436",
+                reason=f"{self.type} is not supported",
+                params=[f"{self.type}"],
+                status_code=http_status.HTTP_403_FORBIDDEN,
+            )
+
+        strategy_class = self.ALLOWED_PROVIDERS[self.type]
+        strategy = strategy_class(optscale_cloud_account_api=OptScaleCloudAccountAPI())
+        strategy.validate_config(config=self.config)
+        cloud_account_type = self.config.get("type")
+        logger.info(f"Cloud Account Conf for {cloud_account_type} has been validated")
+        return strategy
+
+
+async def build_payload_dict(
+    config: CloudStrategyConfiguration, required_fields: dict | None = None
+):
+    """
+    This function builds the configuration dict that will be used
+    as payload for linking a given Cloud Account with a user organization.
+    :param required_fields: Optional. The required fields to be available in order to build
+    the conf.
+    :param config: An instance of CloudStrategyConfiguration with the fields to process
+    :return: two dictionaries. One is the datasource_conf with the expected fields
+    {   'auto_import': False,
+        'config': {'access_key_id': 'ciao', 'secret_access_key': 'cckkckdkkdskd'}, 'name': 'Test',
+        'process_recommendations': False, 'type': 'aws_cnr'}
+    The second one is needed to check if there are missing fields. If the missing_fields is
+    not empty, it means that one or more of the required fields are missing.
+
+    """
+    if required_fields is None:  # pragma: no cover
+        required_fields = {
+            "name",
+            "type",
+            "config",
+            "auto_import",
+            "process_recommendations",
+        }
+    cloud_account_payload = {
+        key: value for key, value in config.__dict__.items() if key in required_fields
+    }
+    # Ensure all required fields are present
+    missing_fields = required_fields - cloud_account_payload.keys()
+    return cloud_account_payload, missing_fields
+
+
+class CloudStrategyManager:
+    def __init__(self, strategy: CloudConfigStrategy):
+        self.strategy = strategy
+
+    async def add_cloud_account(
+        self, config: CloudStrategyConfiguration, org_id: str, user_access_token: str
+    ):
+        """
+        Link the given Cloud Account Configuration with
+        the user's organization.
+
+        :param config: An instance of CloudStrategyConfiguration with the chosen Cloud Account
+        configuration
+        :param org_id: The user's organization ID to be linked with the Cloud Account.
+        :param user_access_token: The user's access token
+        :return: If the datasource is created, a dict like this one will be returned
+        {
+            "deleted_at": 0,
+            "id": "8e8501fa-403a-477b-bd6f-e7569f277f54",
+            "created_at": 1736349441,
+            "name": "Test2",
+            "type": "azure_tenant",
+            "config": {
+              "client_id": "my_client_id",
+              "tenant": "my_tenant_id"
+            },
+            "organization_id": "my_org_id",
+            "auto_import": false,
+            "import_period": 1,
+            "last_import_at": 0,
+            "last_import_modified_at": 0,
+            "account_id": "my_account_id",
+            "process_recommendations": false,
+            "last_import_attempt_at": 0,
+            "last_import_attempt_error": null,
+            "last_getting_metrics_at": 0,
+            "last_getting_metric_attempt_at": 0,
+            "last_getting_metric_attempt_error": null,
+            "cleaned_at": 0,
+            "parent_id": null
+          }
+          raises: ValueError if the previously built CloudStrategyConfiguration is tampered.
+          Rethrow OptScaleAPIResponseError if an error occurred during the communication with the
+          OptScale API.
+        """
+        if not isinstance(config, CloudStrategyConfiguration):
+            raise CloudAccountConfigError
+
+        cloud_account_payload, missing_fields = await build_payload_dict(config)
+        if missing_fields:
+            logger.error(
+                "Something has been altered in the CloudStrategyConfiguration."
+                "There are missing required fields in the Cloud Account Conf: {missing_fields}"
+            )  # noqa: E501
+            raise ValueError(
+                f"Missing required fields in the Cloud Account Conf: {missing_fields}"
+            )
+
+        response = await self.strategy.link_cloud_account_to_org(
+            config=cloud_account_payload,
+            org_id=org_id,
+            user_access_token=user_access_token,
+        )
+        return response

app/api/cloud_account/cloud_accounts_conf/cloud_config_strategy.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class AddCloudAccount(BaseModel):
+    name: str
+    type: str
+    config: dict[str, Any]
+    auto_import: bool = Field(default=True)
+    process_recommendations: bool = Field(default=True)
+    org_id: str
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "name": "AWS HQ",
+                    "type": "aws_cnr",
+                    "config": {
+                        "bucket_name": "opt_bucket",
+                        "access_key_id": "key_id",
+                        "secret_access_key": "secret",
+                    },
+                    "auto_import": False,
+                    "process_recommendations": False,
+                }
+            ]
+        }
+    }
+
+
+class AddCloudAccountResponse(BaseModel):
+    name: str
+    type: str
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "name": "AWS HQ",
+                    "type": "aws_cnr",
+                    "config": {
+                        "bucket_name": "opt_bucket",
+                        "access_key_id": "key_id",
+                        "secret_access_key": "secret",
+                    },
+                    "auto_import": True,
+                    "process_recommendations": True,
+                }
+            ]
+        }
+    }