magic-pocket-cli 0.2.0__py3-none-any.whl

pocket_cli/resources/awscontainer.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import boto3
+
+from pocket import context
+from pocket.resources.base import ResourceStatus
+from pocket.utils import echo
+from pocket_cli.cli.runtime_config_cli import generate_runtime_config
+from pocket_cli.mediator import Mediator
+from pocket_cli.resources.aws.builders import Builder, create_builder
+from pocket_cli.resources.aws.cloudformation import ContainerStack
+from pocket_cli.resources.aws.ecr import Ecr
+from pocket_cli.resources.aws.lambdahandler import LambdaHandler
+from pocket_cli.resources.vpc import Vpc
+
+if TYPE_CHECKING:
+    from pocket.context import (
+        AwsContainerContext,
+        DsqlContext,
+        RdsContext,
+        SchedulerContext,
+    )
+
+
+class NotCreatedYetError(Exception):
+    pass
+
+
+class NoApiEndpointError(Exception):
+    pass
+
+
+class AwsContainer:
+    """This is abstructed resource to run container in aws.
+    This class depends on aws resources.
+    """
+
+    context: AwsContainerContext
+
+    def __init__(
+        self,
+        context: context.AwsContainerContext,
+        *,
+        state_bucket: str = "",
+        rds_context: RdsContext | None = None,
+        dsql_context: DsqlContext | None = None,
+        scheduler_context: SchedulerContext | None = None,
+    ) -> None:
+        self.context = context
+        self.client = boto3.client("lambda", region_name=context.region)
+        self._state_bucket = state_bucket
+        self._rds_context = rds_context
+        self._dsql_context = dsql_context
+        self._scheduler_context = scheduler_context
+
+    @property
+    def builder(self) -> Builder:
+        return create_builder(
+            self.context.build,
+            region=self.context.region,
+            resource_prefix=self.context.resource_prefix,
+            state_bucket=self._state_bucket,
+            permissions_boundary=self.context.permissions_boundary,
+        )
+
+    @property
+    def image_uri(self):
+        if self.ecr.uri:
+            return self.ecr.uri + ":" + self.context.stage
+
+    @property
+    def ecr(self):
+        return Ecr(
+            self.context.region,
+            self.context.ecr_name,
+            self.context.stage,
+            self.context.dockerfile_path,
+            self.context.platform,
+            builder=self.builder,
+        )
+
+    def build(self, tag: str):
+        """指定 tag (commit hash 等) で image を build & push する (deploy はしない)。
+
+        build once 用。`:stage` タグは付けない。昇格は deploy 側で行う。
+        pocket.runtime.toml は Dockerfile の COPY で image に焼き込まれるため、
+        deploy_init と同様に build 前へ生成する。
+        """
+        generate_runtime_config(self._runtime_toml_path())
+        ecr = self.ecr
+        ecr.ensure_exists()
+        ecr.build_and_push(tag=tag)
+
+    @property
+    def stack(self):
+        return ContainerStack(
+            self.context,
+            rds_context=self._rds_context,
+            dsql_context=self._dsql_context,
+            scheduler_context=self._scheduler_context,
+        )
+
+    @property
+    def handlers(self):
+        handlers: dict[str, LambdaHandler] = {}
+        for key, handler in self.context.handlers.items():
+            handlers[key] = LambdaHandler(handler)
+        return handlers
+
+    @property
+    def handlers_updating(self):
+        return any(handler.status == "PROGRESS" for handler in self.handlers.values())
+
+    @property
+    def status(self) -> ResourceStatus:
+        handler_status_list: list[ResourceStatus] = [
+            handler.status for handler in self.handlers.values()
+        ]
+        if ("FAILED" in handler_status_list) or (self.stack.status == "FAILED"):
+            return "FAILED"
+        if ("PROGRESS" in handler_status_list) or (self.stack.status == "PROGRESS"):
+            return "PROGRESS"
+        if self.stack.status in ["NOEXIST", "REQUIRE_UPDATE"]:
+            return self.stack.status
+        for handler in self.handlers.values():
+            if handler.configuration.hash != self.ecr.image_detail.hash:
+                return "REQUIRE_UPDATE"
+        return "COMPLETED"
+
+    @property
+    def description(self):
+        msg = "Create aws cloudformation stack: %s\nCreate ecr repository: %s" % (
+            self.stack.name,
+            self.ecr.name,
+        )
+        if self.context.secrets and self.context.secrets.managed:
+            msg += "\nCreate pocket managed secrets (%s): %s" % (
+                self.context.secrets.store,
+                self.context.secrets.pocket_key,
+            )
+        return msg
+
+    def _require_acm_manual_upadte(self):
+        manual_cert_ref_names = []
+        for handler in self.handlers.values():
+            apig_c = handler.context.apigateway
+            if apig_c and apig_c.domain and not apig_c.create_records:
+                manual_cert_ref_names.append(
+                    handler.context.cloudformation_cert_ref_name
+                )
+        yaml_diff = self.stack.yaml_diff
+        for ref_name in manual_cert_ref_names:
+            if t := yaml_diff.get("type_changes", {}).get("root", {}).get("old_type"):
+                if t == "NoneType":
+                    return True
+            resource = "root['Resources']['%s']" % ref_name
+            if resource in yaml_diff.get("dictionary_item_added", []):
+                return True
+            for changed_resource in yaml_diff.get("values_changed", {}).keys():
+                if changed_resource.startswith(resource):
+                    return True
+        return False
+
+    def show_acm_manual_request(self):
+        if self._require_acm_manual_upadte():
+            w = echo.warning
+            w("You need to request ACM manually to complete stack events.")
+            w("See CloudFormation stack log.")
+            w("Probably, you need to request dns A record to WsgiRegionalDomainName")
+
+    def state_info(self):
+        return {"ecr": {"repository_name": self.context.ecr_name}}
+
+    def _runtime_toml_path(self) -> Path:
+        """pocket.runtime.toml の出力先を返す。
+
+        django.project_dir が設定されていればその中に、
+        なければ CWD に配置する。
+        """
+        if self.context.django and self.context.django.project_dir:
+            return Path(self.context.django.project_dir) / "pocket.runtime.toml"
+        return Path("pocket.runtime.toml")
+
+    def deploy_init(self):
+        if self.context.promote_commit_hash:
+            # 昇格 (promote): 既存 :<hash> image へ :<stage> タグを移す。build しない。
+            # runtime config は build 時に image へ焼き込み済みのため生成もしない。
+            self.ecr.retag(self.context.promote_commit_hash, self.context.stage)
+        else:
+            generate_runtime_config(self._runtime_toml_path())
+            self.ecr.sync()
+        if self.context.vpc and not self.context.vpc.manage:
+            vpc_stack = Vpc(self.context.vpc).stack
+            if vpc_stack.status == "NOEXIST":
+                raise ValueError(
+                    f"外部 VPC スタック '{vpc_stack.name}' が見つかりません。"
+                )
+            if not vpc_stack.is_sharable:
+                raise ValueError(
+                    f"VPC '{vpc_stack.name}' は共有が許可されていません "
+                    "(sharable = true が必要です)"
+                )
+            vpc_stack.add_consumer_tag(self.context.slug)
+
+    def _wait_vpc_if_needed(self):
+        """managed VPC の場合、スタック完了を待つ"""
+        if self.context.vpc and self.context.vpc.manage:
+            Vpc(self.context.vpc).stack.wait_status("COMPLETED")
+
+    def create(self, mediator: Mediator):
+        self._wait_vpc_if_needed()
+        print("Creating secrets ...")
+        mediator.ensure_pocket_managed_secrets()
+        print("Creating cloudformation stack for awscontainer ...")
+        self.show_acm_manual_request()
+        self.stack.create()
+        self.stack.wait_status("COMPLETED", timeout=600, interval=10)
+
+    def update(self, mediator: Mediator):
+        mediator.ensure_pocket_managed_secrets()
+        self.show_acm_manual_request()
+        for key, handler in self.handlers.items():
+            if handler.status == "NOEXIST":
+                print(f"function {key} was not found and skipped.")
+            else:
+                handler.update(image_uri=self.image_uri)
+        for handler in self.handlers.values():
+            handler.wait_update()
+        if not self.stack.yaml_synced:
+            self.stack.update()
+            self.stack.wait_status("COMPLETED", timeout=600, interval=10)
+
+    def get_host(self, key: str):
+        handler = self.handlers[key]
+        if handler.context.apigateway is None:
+            raise NoApiEndpointError(f"ApiGateway is not defined in {key}")
+        if handler.context.apigateway.domain:
+            return handler.context.apigateway.domain
+        apiendpoint_key = key.capitalize() + "ApiEndpoint"
+        if self.stack.output and apiendpoint_key in self.stack.output:
+            return self.stack.output[apiendpoint_key][len("https://") :]
+        raise NotCreatedYetError(f"ApiGateway endpoint for {key} is not created yet.")
+
+    @property
+    def hosts(self) -> dict[str, str | None]:
+        data = {}
+        for key in self.handlers:
+            try:
+                data[key] = self.get_host(key)
+            except NotCreatedYetError:
+                data[key] = None
+            except NoApiEndpointError:
+                pass
+        return data
+
+    @property
+    def endpoints(self):
+        return {key: f"https://{host}" for key, host in self.hosts.items() if host}
+
+    @property
+    def queueurls(self) -> dict[str, str | None]:
+        return {key: handler.queueurl for key, handler in self.handlers.items()}