cdk-factory 0.16.11__py3-none-any.whl → 0.16.13__py3-none-any.whl

cdk_factory/configurations/cdk_config.py

@@ -183,9 +183,11 @@ class CdkConfig:
         if self._resolved_config_file_path is None:
             raise ValueError("Config file path is not set")
 
-        file_name = f".dynamic_{os.path.basename(self._resolved_config_file_path)}"
+        file_name = os.path.join(".dynamic", os.path.basename(self._resolved_config_file_path))
         path = os.path.join(Path(self._resolved_config_file_path).parent, file_name)
-
+        
+        if not os.path.exists(Path(path).parent):
+            os.makedirs(Path(path).parent)
         cdk = config.get("cdk", {})
         if replacements and len(replacements) > 0:
             config = JsonLoadingUtility.recursive_replace(config, replacements)
@@ -214,7 +216,7 @@ class CdkConfig:
             value = static_value
         elif environment_variable_name is not None and not value:
             value = os.environ.get(environment_variable_name, None)
-            if value is None and required:
+            if (value is None or str(value).strip() == "") and required:
                 raise ValueError(
                     f"Failed to get value for environment variable {environment_variable_name}"
                 )

cdk_factory/configurations/resources/ecs_cluster.py

@@ -0,0 +1,101 @@
+"""
+ECS Cluster Configuration
+
+Defines the configuration schema for ECS cluster stacks.
+"""
+
+from typing import Optional, Dict, Any, List
+
+
+class EcsClusterConfig:
+    """
+    Configuration for an ECS cluster.
+    
+    This class defines all the configurable parameters for an ECS cluster,
+    providing explicit control over cluster creation and settings.
+    """
+    
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self._config = config or {}
+    
+    @property
+    def name(self) -> str:
+        """Name of the ECS cluster. Supports template variables like {{WORKLOAD_NAME}}-{{ENVIRONMENT}}-cluster"""
+        return self._config.get("name", "cluster")
+    
+    @property
+    def container_insights(self) -> bool:
+        """Enable container insights for the cluster"""
+        return self._config.get("container_insights", True)
+    
+    @property
+    def cluster_settings(self) -> Optional[List[Dict[str, str]]]:
+        """Additional cluster settings as name-value pairs"""
+        return self._config.get("cluster_settings")
+    
+    @property
+    def cloud_map_namespace(self) -> Optional[Dict[str, Any]]:
+        """Cloud Map namespace configuration for service discovery"""
+        return self._config.get("cloud_map_namespace")
+    
+    @property
+    def execute_command_configuration(self) -> Optional[Dict[str, Any]]:
+        """Execute command configuration for ECS"""
+        return self._config.get("execute_command_configuration")
+    
+    @property
+    def vpc_id(self) -> Optional[str]:
+        """VPC ID where the cluster should be created"""
+        return self._config.get("vpc_id")
+    
+    @property
+    def ssm_vpc_id(self) -> Optional[str]:
+        """SSM parameter path to import VPC ID"""
+        return self._config.get("ssm_vpc_id")
+    
+    @property
+    def create_instance_role(self) -> bool:
+        """Whether to create an ECS instance role"""
+        return self._config.get("create_instance_role", True)
+    
+    @property
+    def instance_role_name(self) -> Optional[str]:
+        """Custom name for the ECS instance role"""
+        return self._config.get("instance_role_name")
+    
+    @property
+    def instance_profile_name(self) -> Optional[str]:
+        """Custom name for the ECS instance profile"""
+        return self._config.get("instance_profile_name")
+    
+    @property
+    def managed_policies(self) -> List[str]:
+        """List of AWS managed policies to attach to the instance role"""
+        return self._config.get("managed_policies", [
+            "service-role/AmazonEC2ContainerServiceforEC2Role",
+            "AmazonSSMManagedInstanceCore"
+        ])
+    
+    @property
+    def inline_policies(self) -> Optional[Dict[str, Dict[str, Any]]]:
+        """Inline IAM policies to attach to the instance role"""
+        return self._config.get("inline_policies")
+    
+    @property
+    def export_ssm_parameters(self) -> bool:
+        """Whether to export cluster information to SSM parameters"""
+        return self._config.get("export_ssm_parameters", True)
+
+    
+    @property
+    def ssm_exports(self) -> Dict[str, str]:
+        """SSM parameter exports"""
+        return self._config.get("ssm_exports", {})
+
+    @property
+    def ssm_imports(self) -> Dict[str, Any]:
+        """SSM parameter imports"""
+        # Check both nested and flat structures for backwards compatibility
+        if "ssm" in self._config and "imports" in self._config["ssm"]:
+            return self._config["ssm"]["imports"]
+        return self._config.get("ssm_imports", {})

cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py

@@ -632,56 +632,34 @@ class AutoScalingStack(IStack, VPCProviderMixin):
             # Scheduled action implementation would go here
             pass
 
-    def _create_ecs_cluster_if_needed(self, asg_name: str) -> None:
-        """Create ECS cluster if ECS configuration is detected"""
-        # Check if this is an ECS configuration by looking for ECS-related patterns
-        is_ecs_config = (
-            # Check if ECS managed policy is attached
-            any("AmazonEC2ContainerServiceforEC2Role" in policy for policy in self.asg_config.managed_policies) or
-            # Check for explicit ECS configuration
-            self.stack_config.dictionary.get("auto_scaling", {}).get("enable_ecs_cluster", False)
-        )
-        
-        if not is_ecs_config:
-            logger.debug("No ECS configuration detected, skipping cluster creation")
+    def _create_ecs_cluster_if_needed(self, asg_name: str):
+        """
+        ECS cluster creation should be handled by the dedicated EcsClusterStack module.
+        This method only handles SSM imports for cluster name injection.
+        """
+        # Check if ECS cluster name is available via SSM imports
+        if self.has_ssm_import("ecs_cluster_name"):
+            logger.info(f"ECS cluster name available via SSM imports")
+            # Inject cluster name into user data if available
+            if self.user_data and self.user_data_commands:
+                self._inject_cluster_name_into_user_data()
             return
         
-        # Generate cluster name from stack configuration
-        cluster_name = f"{self.workload.name}-{self.workload.environment}-cluster"
-        
-        logger.info(f"Creating ECS cluster: {cluster_name}")
-        
-        # Create ECS cluster
-        self.ecs_cluster = ecs.Cluster(
-            self,
-            "ECSCluster",
-            cluster_name=cluster_name,
-            vpc=self.vpc,
-            container_insights=True
-        )
-        
-        # Inject the cluster name into user data if user data exists
-        if self.user_data and self.user_data_commands:
-            self._inject_cluster_name_into_user_data(cluster_name)
-        
-        # Export cluster name
-        cdk.CfnOutput(
-            self,
-            f"{cluster_name}-name",
-            value=self.ecs_cluster.cluster_name,
-            export_name=f"{self.deployment.build_resource_name(cluster_name)}-name",
-        )
-        
-        # Export cluster ARN
-        cdk.CfnOutput(
-            self,
-            f"{cluster_name}-arn",
-            value=self.ecs_cluster.cluster_arn,
-            export_name=f"{self.deployment.build_resource_name(cluster_name)}-arn",
+        logger.warning(
+            "No ECS cluster name found in SSM imports. "
+            "Use the dedicated EcsClusterStack module to create ECS clusters."
         )
 
-    def _inject_cluster_name_into_user_data(self, cluster_name: str) -> None:
-        """Inject the ECS cluster name into user data commands"""
+    def _inject_cluster_name_into_user_data(self) -> None:
+        """Inject the ECS cluster name into user data commands using SSM imports"""
+        # Check if ECS cluster name is available via SSM imports
+        if self.has_ssm_import("ecs_cluster_name"):
+            cluster_name = self.get_ssm_imported_value("ecs_cluster_name")
+            logger.info(f"Using ECS cluster name from SSM: {cluster_name}")
+        else:
+            logger.warning("No ECS cluster name found in SSM imports, skipping cluster name injection")
+            return
+        
         injected_commands = []
         cluster_name_injected = False
         

cdk_factory/stack_library/ecs/__init__.py

@@ -0,0 +1,14 @@
+"""
+ECS Stack Library
+
+Contains ECS-related stack modules for creating and managing
+ECS clusters, services, and related resources.
+"""
+
+from .ecs_cluster_stack import EcsClusterStack
+from .ecs_service_stack import EcsServiceStack
+
+__all__ = [
+    "EcsClusterStack",
+    "EcsServiceStack"
+]

cdk_factory/stack_library/ecs/ecs_cluster_stack.py

@@ -0,0 +1,246 @@
+"""
+ECS Cluster Stack Module
+
+Provides a dedicated stack for creating and configuring ECS clusters
+with proper configurability and explicit resource management.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+
+from aws_cdk import (
+    aws_ecs as ecs,
+    aws_iam as iam,
+    CfnOutput,
+)
+from constructs import Construct
+
+from cdk_factory.configurations.stack import StackConfig
+from cdk_factory.configurations.deployment import DeploymentConfig
+from cdk_factory.configurations.workload import WorkloadConfig
+from cdk_factory.interfaces.vpc_provider_mixin import VPCProviderMixin
+from cdk_factory.configurations.resources.ecs_cluster import EcsClusterConfig
+from cdk_factory.stack.stack_module_registry import register_stack
+from cdk_factory.interfaces.istack import IStack
+
+logger = logging.getLogger(__name__)
+
+
+@register_stack("ecs_cluster_stack")
+class EcsClusterStack(IStack, VPCProviderMixin):
+    """
+    A dedicated stack for creating and managing ECS clusters.
+
+    This stack provides explicit configuration of ECS clusters including:
+    - Cluster naming
+    - Container insights
+    - Cluster settings
+    - SSM parameter exports
+    - IAM role configurations
+    """
+
+    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
+        """
+        Initialize the ECS Cluster stack.
+        
+        Args:
+            scope: The CDK construct scope
+            id: The construct ID
+        """
+        super().__init__(scope, id, **kwargs)
+        
+        self._initialize_vpc_cache()
+        
+        self.ecs_config: Optional[EcsClusterConfig] = None
+        self.stack_config: Optional[StackConfig] = None
+        self.deployment: Optional[DeploymentConfig] = None
+        self.workload: Optional[WorkloadConfig] = None
+        self.ecs_cluster: Optional[ecs.Cluster] = None
+        self.instance_role: Optional[iam.Role] = None
+        self.instance_profile: Optional[iam.CfnInstanceProfile] = None
+        
+        # SSM imported values
+        self.ssm_imported_values: Dict[str, Any] = {}
+
+    
+
+    def build(
+        self,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+    ) -> None:
+        """Build the ECS Cluster stack"""
+        self._build(stack_config, deployment, workload)
+
+    def _build(
+        self,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+    ) -> None:
+        """Internal build method for the ECS Cluster stack"""
+        self.stack_config = stack_config
+        self.deployment = deployment
+        self.workload = workload
+        
+        # Initialize VPC cache from mixin
+        self._initialize_vpc_cache()
+        
+        # Load ECS cluster configuration
+        self.ecs_config: EcsClusterConfig = EcsClusterConfig(
+            stack_config.dictionary.get("ecs_cluster", {})
+        )
+        
+        logger.info(f"Creating ECS Cluster stack: {self.stack_name}")
+        
+        # Process SSM imports first
+        self.process_ssm_imports(self.ecs_config, deployment, "ECS Cluster")
+        
+        # Create the ECS cluster
+        self._create_ecs_cluster()
+        
+        # Create IAM roles if needed
+        self._create_iam_roles()
+        
+        # Export cluster information
+        self._export_cluster_info()
+        
+        logger.info(f"ECS Cluster stack created: {self.stack_name}")
+
+    def _create_ecs_cluster(self):
+        """Create the ECS cluster with explicit configuration."""
+        logger.info(f"Creating ECS cluster: {self.ecs_config.name}")
+
+        # Build cluster settings
+        cluster_settings = []
+
+        # Add container insights if enabled
+        if self.ecs_config.container_insights:
+            cluster_settings.append({"name": "containerInsights", "value": "enabled"})
+
+        # Add custom cluster settings
+        if self.ecs_config.cluster_settings:
+            cluster_settings.extend(self.ecs_config.cluster_settings)
+
+        # Create the ECS cluster
+        self.vpc = self.resolve_vpc(
+            config=self.ecs_config,
+            deployment=self.deployment,
+            workload=self.workload
+        )
+        
+        self.ecs_cluster = ecs.Cluster(
+            self,
+            "ECSCluster",
+            cluster_name=self.ecs_config.name,
+            vpc=self.vpc,
+            container_insights=self.ecs_config.container_insights,
+            default_cloud_map_namespace=(
+                self.ecs_config.cloud_map_namespace
+                if self.ecs_config.cloud_map_namespace
+                else None
+            ),
+            execute_command_configuration=(
+                self.ecs_config.execute_command_configuration
+                if self.ecs_config.execute_command_configuration
+                else None
+            ),
+        )
+
+        logger.info(f"Created ECS cluster: {self.ecs_config.name}")
+
+    def _create_iam_roles(self):
+        """Create IAM roles for the ECS cluster if configured."""
+        if not self.ecs_config.create_instance_role:
+            return
+
+        logger.info("Creating ECS instance role")
+
+        # Create the instance role
+        self.instance_role = iam.Role(
+            self,
+            "ECSInstanceRole",
+            assumed_by=iam.ServicePrincipal("ec2.amazonaws.com"),
+            role_name=self.ecs_config.instance_role_name
+            or f"{self.ecs_config.name}-instance-role",
+        )
+
+        # Add managed policies
+        for policy in self.ecs_config.managed_policies:
+            self.instance_role.add_managed_policy(
+                iam.ManagedPolicy.from_aws_managed_policy_name(policy)
+            )
+
+        # Add inline policies if provided
+        if self.ecs_config.inline_policies:
+            for policy_name, policy_document in self.ecs_config.inline_policies.items():
+                self.instance_role.add_to_policy(
+                    iam.PolicyStatement.from_json(policy_document)
+                )
+
+        # Create instance profile
+        self.instance_profile = iam.CfnInstanceProfile(
+            self,
+            "ECSInstanceProfile",
+            roles=[self.instance_role.role_name],
+            instance_profile_name=self.ecs_config.instance_profile_name
+            or f"{self.ecs_config.name}-instance-profile",
+        )
+
+        logger.info("Created ECS instance role and profile")
+
+    def _export_cluster_info(self):
+        """Export cluster information via SSM parameters and CloudFormation outputs."""
+        logger.info("Exporting ECS cluster information")
+
+        # Export cluster name
+        self.export_ssm_parameter(
+            self, "ClusterNameParameter",
+            self.ecs_config.name,
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/name",
+            "ECS Cluster Name",
+        )
+
+        # Export cluster ARN
+        self.export_ssm_parameter(
+            self, "ClusterArnParameter",
+            self.ecs_cluster.cluster_arn,
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/arn",
+            "ECS Cluster ARN",
+        )
+
+        # Export instance role ARN if created
+        if hasattr(self, "instance_role"):
+            self.export_ssm_parameter(
+                self, "InstanceRoleArnParameter",
+                self.instance_role.role_arn,
+                f"/{self.deployment.name}/{self.workload.name}/ecs/instance-role/arn",
+                "ECS Instance Role ARN",
+            )
+
+        # CloudFormation outputs
+        CfnOutput(
+            self,
+            "cluster-name",
+            value=self.ecs_config.name,
+            description=f"Name of the ECS cluster: {self.ecs_config.name}",
+            export_name=f"{self.deployment.name}-ecs-cluster-name",
+        )
+
+        CfnOutput(
+            self,
+            "cluster-arn",
+            value=self.ecs_cluster.cluster_arn,
+            description=f"ARN of the ECS cluster: {self.ecs_config.name}",
+            export_name=f"{self.deployment.name}-ecs-cluster-arn",
+        )
+
+        if hasattr(self, "instance_role"):
+            CfnOutput(
+                self,
+                "instance-role-arn",
+                value=self.instance_role.role_arn,
+                description=f"ARN of the ECS instance role: {self.ecs_config.name}",
+                export_name=f"{self.deployment.name}-ecs-instance-role-arn",
+            )

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.16.11"
+__version__ = "0.16.13"

{cdk_factory-0.16.11.dist-info → cdk_factory-0.16.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.16.11
+Version: 0.16.13
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.16.11.dist-info → cdk_factory-0.16.13.dist-info}/RECORD

@@ -2,11 +2,11 @@ cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/app.py,sha256=RnX0-pwdTAPAdKJK_j13Zl8anf9zYKBwboR0KA8K8xM,10346
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
 cdk_factory/cli.py,sha256=FGbCTS5dYCNsfp-etshzvFlGDCjC28r6rtzYbe7KoHI,6407
-cdk_factory/version.py,sha256=EakrCPGyBoMWg8RWPZfDpree9gtV1Dzj_7yPvePXTLA,24
+cdk_factory/version.py,sha256=DRHGpx4GSQ3Kn3g7_X9lliE5ploF5wGkMt49I03ESBQ,24
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=JKjhNsy0RCUZy1s8n5D_aXXI-upR9izaLtCTfKYiV9k,9624
-cdk_factory/configurations/cdk_config.py,sha256=eYboaXcz9CUx4rJbEagX8ppgtIERUlopcJXii7Vn8Ws,8796
+cdk_factory/configurations/cdk_config.py,sha256=I1mgDcGJgDCoS_WelJUQdUJLAZgyUA1NVF2q2UJ1hBw,8939
 cdk_factory/configurations/deployment.py,sha256=LO2gd1yv1nqlX_2MIjRXptylFybWiTKsMKZU0N58rSM,12110
 cdk_factory/configurations/deployment_wave.py,sha256=TFX7CYgr5SmLyziEb-R_OTteFWtlMHB4pT53ekV3d1Y,233
 cdk_factory/configurations/devops.py,sha256=PG-s2ldZmMULheWdKf2lf2LSugLoKiOKyLELTZJJxu8,2506
@@ -31,6 +31,7 @@ cdk_factory/configurations/resources/cognito.py,sha256=udX2AJ1ITLhy4f1XiJQwrva6F
 cdk_factory/configurations/resources/docker.py,sha256=hUbuxkuhcQu9LnLX7I8_57eTmHefEAGVnOHO37MkqC4,2166
 cdk_factory/configurations/resources/dynamodb.py,sha256=HsZMOaRwfuNPwKIzokeeE3f5zAQLTB5hRb_GzYq2ibg,2903
 cdk_factory/configurations/resources/ecr.py,sha256=o9hHzEBVPoxUvWZGXGbRJ-98FmP6fMLY5a1-qg42jL0,8253
+cdk_factory/configurations/resources/ecs_cluster.py,sha256=oz8bXdW8dxYWQX0VIjvgAQA8quXJFF0NBTvtksS2vN4,3527
 cdk_factory/configurations/resources/ecs_service.py,sha256=fAW4EuBNhPrE7G0QcHXongKoAnFeGMRS6iP7OuGP5Fw,4926
 cdk_factory/configurations/resources/exisiting.py,sha256=EVOLnkB-DGfTlmDgyQ5DD5k2zYfpFxqI3gugDR7mifI,478
 cdk_factory/configurations/resources/lambda_edge.py,sha256=MjmiwDkys4aoRvDQhH3MT6BgeShzJXNWL7761HJrLtQ,3404
@@ -86,7 +87,7 @@ cdk_factory/stack_library/acm/__init__.py,sha256=4FNRLykblcKZvq_wieYwvv9N_jgrZnJ
 cdk_factory/stack_library/acm/acm_stack.py,sha256=hflRXyOSjqGeJxBx87EV3Z3MJ5HEX2rnrjJ_E9wwhH8,5862
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=l6J5uurBQqbhj9JuvQitV9PiIHS5kqa-dFWifCeA3GM,39347
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=5GeQDp0PNULaSI2FPEWLscbSZRK_QjRwk1cyaeD8STI,30787
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=8Ho7QLbW0MLEmnD0ApglFgZC8Bh5ODT2jERNoAUxz3Y,30128
 cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
@@ -97,7 +98,8 @@ cdk_factory/stack_library/cognito/cognito_stack.py,sha256=zEHkKVCIeyZywPs_GIMXCX
 cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=TVyOrUhgaSuN8uymkpaQcpOaSA0lkYJ8QUMgakTCKus,6771
 cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUNpqxVJX14Oo,179
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=1xA68sxFVyqreYjXrP_7U9I8RF9RtFeR6KeEfSWuC2U,2118
-cdk_factory/stack_library/ecs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdk_factory/stack_library/ecs/__init__.py,sha256=ZZLBmuSt6z_cnFz6OkIFv_APmjqf706wWROruZGyFEI,289
+cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=zAsaQsIWa9cOHcMngdWUAOXZ2PybC3Oc0JADqRgO2dg,8326
 cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=c6K3BjlXyldr8ikvEhfC9C-LpKJILQQkwwU9DNlepH4,27747
 cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
 cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=CdId_1kcZmYr1lLI9AD3-KqtE6voC3641PIloJmWiNI,16414
@@ -134,8 +136,8 @@ cdk_factory/utilities/lambda_function_utilities.py,sha256=S1GvBsY_q2cyUiaud3HORJ
 cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITEP7EuSU,1019
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/workload/workload_factory.py,sha256=yDI3cRhVI5ELNDcJPLpk9UY54Uind1xQoV3spzT4z7E,6068
-cdk_factory-0.16.11.dist-info/METADATA,sha256=Z14DgOnRweXe38PJbLFn1ZdMUOl13d3nbqRSGyMyQU8,2452
-cdk_factory-0.16.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.16.11.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.16.11.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.16.11.dist-info/RECORD,,
+cdk_factory-0.16.13.dist-info/METADATA,sha256=PDyT7iE3uveBVxNrEwsLMvpD0_J5yoVMh7L1DkoAjUE,2452
+cdk_factory-0.16.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.16.13.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.16.13.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.16.13.dist-info/RECORD,,