Spaces:
Runtime error
Runtime error
| from typing import Optional, Any, Dict, List | |
| from phi.aws.api_client import AwsApiClient | |
| from phi.aws.resource.base import AwsResource | |
| from phi.cli.console import print_info | |
| from phi.utils.log import logger | |
| class EcsCluster(AwsResource): | |
| """ | |
| Reference: | |
| - https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/ecs.html | |
| """ | |
| resource_type: Optional[str] = "EcsCluster" | |
| service_name: str = "ecs" | |
| # Name of the cluster. | |
| name: str | |
| # Name for the cluster. | |
| # Use name if not provided. | |
| ecs_cluster_name: Optional[str] = None | |
| tags: Optional[List[Dict[str, str]]] = None | |
| # The setting to use when creating a cluster. | |
| settings: Optional[List[Dict[str, Any]]] = None | |
| # The execute command configuration for the cluster. | |
| configuration: Optional[Dict[str, Any]] = None | |
| # The short name of one or more capacity providers to associate with the cluster. | |
| # A capacity provider must be associated with a cluster before it can be included as part of the default capacity | |
| # provider strategy of the cluster or used in a capacity provider strategy when calling the CreateService/RunTask. | |
| capacity_providers: Optional[List[str]] = None | |
| # The capacity provider strategy to set as the default for the cluster. After a default capacity provider strategy | |
| # is set for a cluster, when you call the RunTask or CreateService APIs with no capacity provider strategy or | |
| # launch type specified, the default capacity provider strategy for the cluster is used. | |
| default_capacity_provider_strategy: Optional[List[Dict[str, Any]]] = None | |
| # Use this parameter to set a default Service Connect namespace. | |
| # After you set a default Service Connect namespace, any new services with Service Connect turned on that are | |
| # created in the cluster are added as client services in the namespace. | |
| service_connect_namespace: Optional[str] = None | |
| def get_ecs_cluster_name(self): | |
| return self.ecs_cluster_name or self.name | |
| def _create(self, aws_client: AwsApiClient) -> bool: | |
| """Creates the EcsCluster | |
| Args: | |
| aws_client: The AwsApiClient for the current cluster | |
| """ | |
| print_info(f"Creating {self.get_resource_type()}: {self.get_resource_name()}") | |
| # create a dict of args which are not null, otherwise aws type validation fails | |
| not_null_args: Dict[str, Any] = {} | |
| if self.tags is not None: | |
| not_null_args["tags"] = self.tags | |
| if self.settings is not None: | |
| not_null_args["settings"] = self.settings | |
| if self.configuration is not None: | |
| not_null_args["configuration"] = self.configuration | |
| if self.capacity_providers is not None: | |
| not_null_args["capacityProviders"] = self.capacity_providers | |
| if self.default_capacity_provider_strategy is not None: | |
| not_null_args["defaultCapacityProviderStrategy"] = self.default_capacity_provider_strategy | |
| if self.service_connect_namespace is not None: | |
| not_null_args["serviceConnectDefaults"] = { | |
| "namespace": self.service_connect_namespace, | |
| } | |
| # Create EcsCluster | |
| service_client = self.get_service_client(aws_client) | |
| try: | |
| create_response = service_client.create_cluster( | |
| clusterName=self.get_ecs_cluster_name(), | |
| **not_null_args, | |
| ) | |
| logger.debug(f"EcsCluster: {create_response}") | |
| resource_dict = create_response.get("cluster", {}) | |
| # Validate resource creation | |
| if resource_dict is not None: | |
| self.active_resource = create_response | |
| return True | |
| except Exception as e: | |
| logger.error(f"{self.get_resource_type()} could not be created.") | |
| logger.error(e) | |
| return False | |
| def _read(self, aws_client: AwsApiClient) -> Optional[Any]: | |
| """Returns the EcsCluster | |
| Args: | |
| aws_client: The AwsApiClient for the current cluster | |
| """ | |
| logger.debug(f"Reading {self.get_resource_type()}: {self.get_resource_name()}") | |
| from botocore.exceptions import ClientError | |
| service_client = self.get_service_client(aws_client) | |
| try: | |
| cluster_name = self.get_ecs_cluster_name() | |
| describe_response = service_client.describe_clusters(clusters=[cluster_name]) | |
| logger.debug(f"EcsCluster: {describe_response}") | |
| resource_list = describe_response.get("clusters", None) | |
| if resource_list is not None and isinstance(resource_list, list): | |
| for resource in resource_list: | |
| _cluster_identifier = resource.get("clusterName", None) | |
| if _cluster_identifier == cluster_name: | |
| _cluster_status = resource.get("status", None) | |
| if _cluster_status == "ACTIVE": | |
| self.active_resource = resource | |
| break | |
| except ClientError as ce: | |
| logger.debug(f"ClientError: {ce}") | |
| except Exception as e: | |
| logger.error(f"Error reading {self.get_resource_type()}.") | |
| logger.error(e) | |
| return self.active_resource | |
| def _delete(self, aws_client: AwsApiClient) -> bool: | |
| """Deletes the EcsCluster | |
| Args: | |
| aws_client: The AwsApiClient for the current cluster | |
| """ | |
| print_info(f"Deleting {self.get_resource_type()}: {self.get_resource_name()}") | |
| service_client = self.get_service_client(aws_client) | |
| self.active_resource = None | |
| try: | |
| delete_response = service_client.delete_cluster(cluster=self.get_ecs_cluster_name()) | |
| logger.debug(f"EcsCluster: {delete_response}") | |
| return True | |
| except Exception as e: | |
| logger.error(f"{self.get_resource_type()} could not be deleted.") | |
| logger.error("Please try again or delete resources manually.") | |
| logger.error(e) | |
| return False | |
| def get_arn(self, aws_client: AwsApiClient) -> Optional[str]: | |
| tg = self._read(aws_client) | |
| if tg is None: | |
| return None | |
| tg_arn = tg.get("ListenerArn", None) | |
| return tg_arn | |