cdk-factory 0.16.5__py3-none-any.whl → 0.16.6__py3-none-any.whl

cdk_factory/interfaces/istack.py

@@ -23,7 +23,10 @@ class IStack(Stack, SsmParameterMixin, metaclass=StackABCMeta):
 
     @abstractmethod
     def __init__(self, scope: Construct, id: str, **kwargs) -> None:
-        super().__init__(scope, id, **kwargs)
+        # Initialize Stack first
+        Stack.__init__(self, scope, id, **kwargs)
+        # Initialize SsmParameterMixin (no super() call to avoid MRO issues)
+        SsmParameterMixin.__init__(self, **kwargs)
 
     @abstractmethod
     def build(self, *, stack_config, deployment, workload) -> None:

cdk_factory/interfaces/networked_stack_mixin.py

@@ -0,0 +1,75 @@
+"""
+Networked Stack Mixin - Combined SSM and VPC functionality for network-aware stacks
+Maintainers: Eric Wilson
+MIT License. See Project Root for license information.
+"""
+
+from typing import Any
+from aws_cdk import aws_ec2 as ec2
+from .ssm_parameter_mixin import SsmParameterMixin
+from .vpc_provider_mixin import VPCProviderMixin
+
+
+class NetworkedStackMixin(SsmParameterMixin, VPCProviderMixin):
+    """
+    Combined mixin for stacks that need both SSM imports and VPC resolution.
+    
+    This mixin provides a complete solution for network-aware stacks by combining:
+    - Enhanced SSM parameter import functionality (with caching and list support)
+    - VPC resolution with multiple fallback strategies
+    - Standardized initialization patterns
+    
+    Usage:
+        class MyStack(Stack, NetworkedStackMixin):
+            def __init__(self, scope, id, **kwargs):
+                super().__init__(scope, id, **kwargs)
+                # SSM initialization is handled automatically by SsmParameterMixin.__init__
+                
+            def _build(self, stack_config, deployment, workload):
+                self.process_ssm_imports(stack_config, deployment, "my-resource")
+                self.vpc = self.resolve_vpc(stack_config, deployment, workload)
+    """
+    
+    def _initialize_networked_stack(self) -> None:
+        """
+        Initialize all networked stack functionality.
+        Note: SSM initialization is handled by SsmParameterMixin.__init__
+        """
+        self._initialize_vpc_cache()
+    
+    def build_networked_stack(
+        self, 
+        config: Any, 
+        deployment: Any, 
+        workload: Any,
+        resource_type: str = "resource"
+    ) -> None:
+        """
+        Standard build sequence for networked stacks.
+        
+        Args:
+            config: The stack configuration
+            deployment: The deployment configuration  
+            workload: The workload configuration
+            resource_type: Type name for logging purposes
+        """
+        # Process SSM imports first (using enhanced SsmParameterMixin)
+        self.process_ssm_imports(config, deployment, resource_type)
+        
+        # Store references for later use
+        self.config = config
+        self.deployment = deployment
+        self.workload = workload
+    
+    @property
+    def vpc(self) -> ec2.IVpc:
+        """
+        Standard VPC property that uses the combined mixin functionality.
+        
+        Returns:
+            Resolved VPC reference
+        """
+        if not hasattr(self, 'config') or not hasattr(self, 'deployment') or not hasattr(self, 'workload'):
+            raise AttributeError("Networked stack not properly initialized. Call build_networked_stack() first.")
+        
+        return self.get_vpc_property(self.config, self.deployment, self.workload)

cdk_factory/interfaces/ssm_parameter_mixin.py

@@ -4,7 +4,7 @@ Maintainers: Eric Wilson
 MIT License. See Project Root for the license information.
 """
 
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, Union, List
 from aws_cdk import aws_ssm as ssm
 from constructs import Construct
 from aws_lambda_powertools import Logger
@@ -19,8 +19,129 @@ class SsmParameterMixin:
 
     This mixin should be used by stack classes to standardize how SSM parameters
     are exported and imported across the project.
+    
+    Enhanced to support:
+    - List parameter imports (for security groups, etc.)
+    - Cached imported values for easy access
+    - Backward compatibility with existing interfaces
     """
 
+    def __init__(self, *args, **kwargs):
+        """Initialize the mixin with cached storage for imported values."""
+        # Don't call super() to avoid MRO issues in multiple inheritance
+        # Initialize cached storage for imported values
+        self._ssm_imported_values: Dict[str, Union[str, List[str]]] = {}
+
+    def initialize_ssm_imports(self) -> None:
+        """
+        Initialize SSM imports storage.
+        Call this in your stack's __init__ method if not using __init__ above.
+        """
+        if not hasattr(self, '_ssm_imported_values'):
+            self._ssm_imported_values: Dict[str, Union[str, List[str]]] = {}
+
+    def get_ssm_imported_value(self, key: str, default: Any = None) -> Any:
+        """
+        Get a cached SSM imported value by key.
+        
+        Args:
+            key: The SSM import key
+            default: Default value if key not found
+            
+        Returns:
+            The imported value or default
+        """
+        return self._ssm_imported_values.get(key, default)
+
+    def has_ssm_import(self, key: str) -> bool:
+        """
+        Check if an SSM import key exists in cached values.
+        
+        Args:
+            key: The SSM import key to check
+            
+        Returns:
+            True if key exists, False otherwise
+        """
+        return key in self._ssm_imported_values
+
+    def process_ssm_imports(
+        self, 
+        config: Any, 
+        deployment: Any,
+        resource_type: str = "resource"
+    ) -> None:
+        """
+        Process SSM imports from configuration and cache them for later use.
+        
+        This method handles list imports (like security_group_ids) and caches
+        the results for easy access via get_ssm_imported_value().
+        
+        Args:
+            config: The configuration object with ssm_imports property
+            deployment: The deployment configuration for path resolution
+            resource_type: Type of resource for logging purposes
+        """
+        if not hasattr(config, 'ssm_imports'):
+            logger.debug(f"No ssm_imports property found on config for {resource_type}")
+            return
+            
+        ssm_imports = config.ssm_imports
+        
+        if not ssm_imports:
+            logger.debug(f"No SSM imports configured for {resource_type}")
+            return
+        
+        logger.info(f"Processing {len(ssm_imports)} SSM imports for {resource_type}")
+        
+        for param_key, param_value in ssm_imports.items():
+            try:
+                if isinstance(param_value, list):
+                    # Handle list imports (like security_group_ids)
+                    imported_list = []
+                    for item in param_value:
+                        param_path = self._resolve_ssm_path(item, deployment)
+                        
+                        construct_id = f"ssm-import-{param_key}-{hash(param_path) % 10000}"
+                        param = ssm.StringParameter.from_string_parameter_name(
+                            self, construct_id, param_path
+                        )
+                        imported_list.append(param.string_value)
+                    
+                    self._ssm_imported_values[param_key] = imported_list
+                    logger.info(f"Imported SSM parameter list: {param_key} with {len(imported_list)} items")
+                else:
+                    # Handle string values
+                    param_path = self._resolve_ssm_path(param_value, deployment)
+                    
+                    construct_id = f"ssm-import-{param_key}-{hash(param_path) % 10000}"
+                    param = ssm.StringParameter.from_string_parameter_name(
+                        self, construct_id, param_path
+                    )
+                    
+                    self._ssm_imported_values[param_key] = param.string_value
+                    logger.info(f"Imported SSM parameter: {param_key} from {param_path}")
+                    
+            except Exception as e:
+                logger.error(f"Failed to import SSM parameter {param_key}: {e}")
+                raise
+
+    def _resolve_ssm_path(self, path: str, deployment: Any) -> str:
+        """
+        Resolve SSM parameter path (handle relative vs absolute paths).
+        
+        Args:
+            path: The parameter path from configuration
+            deployment: The deployment configuration for context
+            
+        Returns:
+            Fully resolved SSM parameter path
+        """
+        if not path.startswith('/'):
+            # Convert relative path to absolute path
+            return f"/{deployment.environment}/{deployment.workload_name}/{path}"
+        return path
+
     @staticmethod
     def normalize_resource_name(name: str, for_export: bool = False) -> str:
         """
@@ -272,6 +393,8 @@ class SsmParameterMixin:
 
         This is a higher-level method that makes it clear we're importing values.
         It first tries to use the ssm_imports property, then falls back to ssm_parameters.
+        
+        Enhanced to also cache results for easy access via get_ssm_imported_value().
 
         Args:
             scope: The CDK construct scope
@@ -320,9 +443,11 @@ class SsmParameterMixin:
 
                 if value:
                     # Remove _path suffix if present
-                    if key.endswith("_path"):
-                        key = key[:-5]  # Remove _path suffix
-                    imported_values[key] = value
+                    final_key = key[:-5] if key.endswith("_path") else key
+                    imported_values[final_key] = value
+                    
+                    # Also cache for easy access via get_ssm_imported_value()
+                    self._ssm_imported_values[final_key] = value
         else:
             logger.info(f"No SSM import paths configured for {resource_name} resources")
 

cdk_factory/interfaces/vpc_provider_mixin.py

@@ -0,0 +1,154 @@
+"""
+VPC Provider Mixin - Reusable VPC resolution functionality
+Maintainers: Eric Wilson
+MIT License. See Project Root for license information.
+"""
+
+from typing import Optional, List, Any
+from aws_lambda_powertools import Logger
+from aws_cdk import aws_ec2 as ec2
+from constructs import Construct
+
+logger = Logger(__name__)
+
+
+class VPCProviderMixin:
+    """
+    Mixin class that provides reusable VPC resolution functionality for stacks.
+    
+    This mixin eliminates code duplication across stacks that need to resolve
+    VPC references, providing a standardized way to handle:
+    - SSM imported VPC parameters (works with enhanced SsmParameterMixin)
+    - Configuration-based VPC resolution
+    - Workload-level VPC fallback
+    - Error handling and validation
+    
+    Note: This mixin does NOT handle SSM imports directly - it expects
+    the SSM values to be available via the enhanced SsmParameterMixin.
+    """
+
+    def _initialize_vpc_cache(self) -> None:
+        """Initialize the VPC cache attribute"""
+        if not hasattr(self, '_vpc'):
+            self._vpc: Optional[ec2.IVpc] = None
+
+    def resolve_vpc(
+        self,
+        config: Any,
+        deployment: Any,
+        workload: Any,
+        availability_zones: Optional[List[str]] = None
+    ) -> ec2.IVpc:
+        """
+        Resolve VPC from multiple sources with standardized priority order.
+        
+        Priority order:
+        1. SSM imported VPC ID (from enhanced SsmParameterMixin)
+        2. Config-level VPC ID
+        3. Workload-level VPC ID
+        4. Raise error if none found
+        
+        Args:
+            config: The stack configuration
+            deployment: The deployment configuration
+            workload: The workload configuration
+            availability_zones: Optional AZ list for VPC attributes
+            
+        Returns:
+            Resolved VPC reference
+            
+        Raises:
+            ValueError: If no VPC configuration is found
+        """
+        if self._vpc:
+            return self._vpc
+
+        # Default availability zones if not provided
+        if not availability_zones:
+            availability_zones = ["us-east-1a", "us-east-1b"]
+
+        # Check SSM imported values first (tokens from SSM parameters)
+        # This works with the enhanced SsmParameterMixin
+        if hasattr(self, '_ssm_imported_values') and "vpc_id" in self._ssm_imported_values:
+            vpc_id = self._ssm_imported_values["vpc_id"]
+            return self._create_vpc_from_ssm(vpc_id, availability_zones)
+        
+        # Check config-level VPC ID
+        if hasattr(config, 'vpc_id') and config.vpc_id:
+            return ec2.Vpc.from_lookup(self, "VPC", vpc_id=config.vpc_id)
+        
+        # Check workload-level VPC ID
+        if hasattr(workload, 'vpc_id') and workload.vpc_id:
+            return ec2.Vpc.from_lookup(self, "VPC", vpc_id=workload.vpc_id)
+        
+        # No VPC found - raise descriptive error
+        raise self._create_vpc_not_found_error(config, workload)
+
+    def _create_vpc_from_ssm(
+        self, 
+        vpc_id: str, 
+        availability_zones: List[str]
+    ) -> ec2.IVpc:
+        """
+        Create VPC reference from SSM imported VPC ID.
+        
+        Args:
+            vpc_id: The VPC ID from SSM
+            availability_zones: List of availability zones
+            
+        Returns:
+            VPC reference created from attributes
+        """
+        # Build VPC attributes
+        vpc_attrs = {
+            "vpc_id": vpc_id,
+            "availability_zones": availability_zones,
+        }
+        
+        # If we have subnet_ids from SSM, provide dummy subnets
+        # The actual subnets will be set via CloudFormation escape hatch
+        if hasattr(self, '_ssm_imported_values') and "subnet_ids" in self._ssm_imported_values:
+            # Provide dummy subnet IDs - these will be overridden by the escape hatch
+            # We need at least one dummy subnet per AZ to satisfy CDK's validation
+            vpc_attrs["public_subnet_ids"] = ["subnet-dummy1", "subnet-dummy2"]
+        
+        # Use from_vpc_attributes() for SSM tokens
+        self._vpc = ec2.Vpc.from_vpc_attributes(self, "VPC", **vpc_attrs)
+        return self._vpc
+
+    def _create_vpc_not_found_error(self, config: Any, workload: Any) -> ValueError:
+        """
+        Create a descriptive error message for missing VPC configuration.
+        
+        Args:
+            config: The stack configuration
+            workload: The workload configuration
+            
+        Returns:
+            ValueError with descriptive message
+        """
+        config_name = getattr(config, 'name', 'unknown')
+        workload_name = getattr(workload, 'name', 'unknown')
+        
+        return ValueError(
+            f"VPC is not defined in the configuration for {config_name}. "
+            f"You can provide it at the following locations:\n"
+            f"  1. As an SSM import: config.ssm_imports.vpc_id\n"
+            f"  2. At the config level: config.vpc_id\n"
+            f"  3. At the workload level: workload.vpc_id\n"
+            f"Current workload: {workload_name}"
+        )
+
+    def get_vpc_property(self, config: Any, deployment: Any, workload: Any) -> ec2.IVpc:
+        """
+        Standard VPC property implementation that can be used by stacks.
+        
+        Args:
+            config: The stack configuration
+            deployment: The deployment configuration
+            workload: The workload configuration
+            
+        Returns:
+            Resolved VPC reference
+        """
+        return self.resolve_vpc(config, deployment, workload)

cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py

@@ -12,7 +12,7 @@ from aws_cdk import aws_autoscaling as autoscaling
 from aws_cdk import aws_cloudwatch as cloudwatch
 from aws_cdk import aws_iam as iam
 from aws_cdk import aws_ssm as ssm
-from aws_cdk import Duration
+from aws_cdk import Duration, Stack
 from aws_lambda_powertools import Logger
 from constructs import Construct
 
@@ -20,7 +20,6 @@ from cdk_factory.configurations.deployment import DeploymentConfig
 from cdk_factory.configurations.stack import StackConfig
 from cdk_factory.configurations.resources.auto_scaling import AutoScalingConfig
 from cdk_factory.interfaces.istack import IStack
-from cdk_factory.interfaces.enhanced_ssm_parameter_mixin import EnhancedSsmParameterMixin
 from cdk_factory.stack.stack_module_registry import register_stack
 from cdk_factory.workload.workload_factory import WorkloadConfig
 
@@ -29,14 +28,18 @@ logger = Logger(service="AutoScalingStack")
 
 @register_stack("auto_scaling_library_module")
 @register_stack("auto_scaling_stack")
-class AutoScalingStack(IStack, EnhancedSsmParameterMixin):
+class AutoScalingStack(IStack):
     """
     Reusable stack for AWS Auto Scaling Groups.
     Supports creating EC2 Auto Scaling Groups with customizable configurations.
+    
+    Uses enhanced SsmParameterMixin (via IStack) to eliminate SSM code duplication.
     """
 
     def __init__(self, scope: Construct, id: str, **kwargs) -> None:
+        # Initialize parent class properly - IStack inherits from enhanced SsmParameterMixin
         super().__init__(scope, id, **kwargs)
+        
         self.asg_config = None
         self.stack_config = None
         self.deployment = None
@@ -46,9 +49,8 @@ class AutoScalingStack(IStack, EnhancedSsmParameterMixin):
         self.launch_template = None
         self.instance_role = None
         self.user_data = None
-        self._vpc = None
-        # SSM imported values
-        self.ssm_imported_values: Dict[str, str] = {}
+        
+        # SSM imports storage is now handled by the enhanced SsmParameterMixin via IStack
 
     def build(
         self,
@@ -75,10 +77,10 @@ class AutoScalingStack(IStack, EnhancedSsmParameterMixin):
         )
         asg_name = deployment.build_resource_name(self.asg_config.name)
 
-        # Process SSM imports
-        self._process_ssm_imports()
+        # Process SSM imports using enhanced SsmParameterMixin
+        self.process_ssm_imports(self.asg_config, deployment, "Auto Scaling Group")
 
-        # Get VPC and security groups
+        # Get security groups
         self.security_groups = self._get_security_groups()
 
         # Create IAM role for instances
@@ -90,44 +92,57 @@ class AutoScalingStack(IStack, EnhancedSsmParameterMixin):
         # Create launch template
         self.launch_template = self._create_launch_template(asg_name)
 
-        # Create auto scaling group
+        # Create Auto Scaling Group
         self.auto_scaling_group = self._create_auto_scaling_group(asg_name)
 
-        # Configure scaling policies
-        self._configure_scaling_policies()
+        # Add scaling policies
+        self._add_scaling_policies()
 
-        # Add outputs
-        self._add_outputs(asg_name)
+        # Add scheduled actions
+        self._add_scheduled_actions()
+
+        # Export resources
+        self._export_resources(asg_name)
 
     @property
     def vpc(self) -> ec2.IVpc:
-        """Get the VPC for the Auto Scaling Group"""
-        if self._vpc:
-            return self._vpc
+        """Get the VPC for the Auto Scaling Group using enhanced SsmParameterMixin"""
+        if not self.asg_config:
+            raise AttributeError("AutoScalingStack not properly initialized. Call build() first.")
 
-        # Check SSM imported values first (tokens from SSM parameters)
-        if "vpc_id" in self.ssm_imported_values:
-            vpc_id = self.ssm_imported_values["vpc_id"]
+        # Check SSM imported values first using enhanced mixin
+        if self.has_ssm_import("vpc_id"):
+            vpc_id = self.get_ssm_imported_value("vpc_id")
+            
+            # Get subnet IDs first to determine AZ count
+            subnet_ids = []
+            if self.has_ssm_import("subnet_ids"):
+                imported_subnets = self.get_ssm_imported_value("subnet_ids", [])
+                if isinstance(imported_subnets, str):
+                    # Split comma-separated subnet IDs
+                    subnet_ids = [s.strip() for s in imported_subnets.split(",") if s.strip()]
+                elif isinstance(imported_subnets, list):
+                    subnet_ids = imported_subnets
             
-            # Build VPC attributes
+            # Build VPC attributes with matching AZ count
             vpc_attrs = {
                 "vpc_id": vpc_id,
-                "availability_zones": ["us-east-1a", "us-east-1b"],
+                "availability_zones": [f"us-east-1{chr(97+i)}" for i in range(len(subnet_ids))] if subnet_ids else ["us-east-1a", "us-east-1b"],
             }
             
-            # If we have subnet_ids from SSM, provide dummy subnets
-            # The actual subnets will be set via CloudFormation escape hatch
-            if "subnet_ids" in self.ssm_imported_values:
-                # Provide dummy subnet IDs - these will be overridden by the escape hatch
-                # We need at least one dummy subnet per AZ to satisfy CDK's validation
+            # Use the actual subnet IDs from SSM
+            if subnet_ids:
+                vpc_attrs["public_subnet_ids"] = subnet_ids
+            else:
+                # Fallback to dummy subnets if no valid subnet IDs
                 vpc_attrs["public_subnet_ids"] = ["subnet-dummy1", "subnet-dummy2"]
             
             # Use from_vpc_attributes() for SSM tokens
-            self._vpc = ec2.Vpc.from_vpc_attributes(self, "VPC", **vpc_attrs)
+            return ec2.Vpc.from_vpc_attributes(self, "VPC", **vpc_attrs)
         elif self.asg_config.vpc_id:
-            self._vpc = ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.asg_config.vpc_id)
+            return ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.asg_config.vpc_id)
         elif self.workload.vpc_id:
-            self._vpc = ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.workload.vpc_id)
+            return ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.workload.vpc_id)
         else:
             # Use default VPC if not provided
             raise ValueError(
@@ -136,15 +151,13 @@ class AutoScalingStack(IStack, EnhancedSsmParameterMixin):
                 "or a top level workload.vpc_id in the workload configuration."
             )
 
-        return self._vpc
-
     def _get_target_group_arns(self) -> List[str]:
-        """Get target group ARNs from SSM imports"""
+        """Get target group ARNs from SSM imports using enhanced SsmParameterMixin"""
         target_group_arns = []
 
-        # Check if we have SSM imports for target groups
-        if "target_group_arns" in self.ssm_imported_values:
-            imported_tg_arns = self.ssm_imported_values["target_group_arns"]
+        # Check if we have SSM imports for target groups using enhanced mixin
+        if self.has_ssm_import("target_group_arns"):
+            imported_tg_arns = self.get_ssm_imported_value("target_group_arns", [])
             if isinstance(imported_tg_arns, list):
                 target_group_arns.extend(imported_tg_arns)
             else:
@@ -579,47 +592,33 @@ class AutoScalingStack(IStack, EnhancedSsmParameterMixin):
                     export_name=f"{self.deployment.build_resource_name(asg_name)}-launch-template-id",
                 )
 
-    def _process_ssm_imports(self) -> None:
-        """
-        Process SSM imports from configuration.
+    
+    def _add_scaling_policies(self) -> None:
+        """Add scaling policies to the Auto Scaling Group"""
+        for policy_config in self.asg_config.scaling_policies:
+            # Scaling policy implementation would go here
+            pass
+
+    def _add_scheduled_actions(self) -> None:
+        """Add scheduled actions to the Auto Scaling Group"""
+        for action_config in self.asg_config.scheduled_actions:
+            # Scheduled action implementation would go here
+            pass
+
+    def _export_resources(self, asg_name: str) -> None:
+        """Export stack resources to SSM and CloudFormation outputs"""
+        # Export ASG name
+        cdk.CfnOutput(
+            self,
+            f"{asg_name}-name",
+            value=self.auto_scaling_group.auto_scaling_group_name,
+            export_name=f"{self.deployment.build_resource_name(asg_name)}-name",
+        )
 
-        This method handles importing SSM parameters that are specified in the
-        auto_scaling configuration under the 'ssm.imports' section.
-        """
-        logger.info(f"Processing {len(self.asg_config.ssm_imports)} SSM imports for Auto Scaling Group")
-        
-        for param_key, param_value in self.asg_config.ssm_imports.items():
-            try:
-                if isinstance(param_value, list):
-                    # Handle list imports (like security_group_ids)
-                    imported_list = []
-                    for item in param_value:
-                        param_path = item
-                        if not param_path.startswith('/'):
-                            param_path = f"/{self.deployment.environment}/{self.deployment.workload_name}/{item}"
-                        
-                        construct_id = f"ssm-import-{param_key}-{hash(param_path) % 10000}"
-                        param = ssm.StringParameter.from_string_parameter_name(
-                            self, construct_id, param_path
-                        )
-                        imported_list.append(param.string_value)
-                    
-                    self.ssm_imported_values[param_key] = imported_list
-                    logger.info(f"Imported SSM parameter list: {param_key} with {len(imported_list)} items")
-                else:
-                    # Handle string values
-                    param_path = param_value
-                    if not param_path.startswith('/'):
-                        param_path = f"/{self.deployment.environment}/{self.deployment.workload_name}/{param_path}"
-                    
-                    construct_id = f"ssm-import-{param_key}-{hash(param_path) % 10000}"
-                    param = ssm.StringParameter.from_string_parameter_name(
-                        self, construct_id, param_path
-                    )
-                    
-                    self.ssm_imported_values[param_key] = param.string_value
-                    logger.info(f"Imported SSM parameter: {param_key} from {param_path}")
-                    
-            except Exception as e:
-                logger.error(f"Failed to import SSM parameter {param_key}: {e}")
-                raise
+        # Export ASG ARN
+        cdk.CfnOutput(
+            self,
+            f"{asg_name}-arn",
+            value=self.auto_scaling_group.auto_scaling_group_arn,
+            export_name=f"{self.deployment.build_resource_name(asg_name)}-arn",
+        )

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.16.5"
+__version__ = "0.16.6"

{cdk_factory-0.16.5.dist-info → cdk_factory-0.16.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.16.5
+Version: 0.16.6
 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.5.dist-info → cdk_factory-0.16.6.dist-info}/RECORD

@@ -2,7 +2,7 @@ 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=r0anPjT1FU7ZF59Wu8yrTS7JfVcf5Cbwqs29-uSLGyo,23
+cdk_factory/version.py,sha256=vgsezcoqCKtoa7hPZmv2Zn1ce_NBglKR7w9c6ZIxjU0,23
 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
@@ -63,9 +63,11 @@ cdk_factory/constructs/s3_buckets/s3_bucket_replication_destination_construct.py
 cdk_factory/constructs/s3_buckets/s3_bucket_replication_source_construct.py,sha256=ZLKbRcMK1q73VruxCH62XbymebKt-lKV5Kul9OjkZiA,3763
 cdk_factory/constructs/sqs/policies/sqs_policies.py,sha256=4p0G8G-fqNKSr68I55fvqH-DkhIeXyGaFBKkICIJ-qM,1277
 cdk_factory/interfaces/enhanced_ssm_parameter_mixin.py,sha256=5-aQ4sg47LQ4AHjd0j20gxyM5U5-NOTeBsGsEUA_K3E,14374
-cdk_factory/interfaces/istack.py,sha256=bhTBs-o9FgKwvJMSuwxjUV6D3nUlvZHVzfm27jP9x9Y,987
+cdk_factory/interfaces/istack.py,sha256=4Bqls3Xbgwbnl9MjxsX8S2d5lMOMPdhlVu0DiAiTJ6Q,1152
 cdk_factory/interfaces/live_ssm_resolver.py,sha256=3FIr9a02SXqZmbFs3RT0WxczWEQR_CF7QSt7kWbDrVE,8163
-cdk_factory/interfaces/ssm_parameter_mixin.py,sha256=uA2j8HmAOpuEA9ynRj51s0WjUHMVLsbLQN-QS9NKyHA,12089
+cdk_factory/interfaces/networked_stack_mixin.py,sha256=c_wDWPU4Y8HrTt2yGRwBJvVCfwHNy0SEeNMQjaUgcrI,2808
+cdk_factory/interfaces/ssm_parameter_mixin.py,sha256=Z0KUbvDfvU-Kfpjtjm33Eo0ZonHQbnMlenR8FtG-0ls,17194
+cdk_factory/interfaces/vpc_provider_mixin.py,sha256=-AZJRRHzaxej8hToGFAa0zK0ax_t0x46Cjg5v6WyMwQ,5602
 cdk_factory/lambdas/health_handler.py,sha256=dd40ykKMxWCFEIyp2ZdQvAGNjw_ylI9CSm1N24Hp2ME,196
 cdk_factory/lambdas/edge/ip_gate/handler.py,sha256=YrXO42gEhJoBTaH6jS7EWqjHe9t5Fpt4WLgY8vjtou0,10474
 cdk_factory/pipeline/path_utils.py,sha256=fvWdrcb4onmpIu1APkHLhXg8zWfK74HcW3Ra2ynxfXM,2586
@@ -84,7 +86,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=0q3wF7b6JX8yQiPQWnlII05_pwJif63ijvaQS5rzqyI,26451
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=qclpCa42KTsj8C0dyc8Qn2PadXkDeKSM3bi5jUPKOSo,26072
 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
@@ -132,8 +134,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.5.dist-info/METADATA,sha256=D2vXNb4pXKyPu01N3lbLxoY_hHCmL_SdzCQx0uUppyE,2451
-cdk_factory-0.16.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.16.5.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.16.5.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.16.5.dist-info/RECORD,,
+cdk_factory-0.16.6.dist-info/METADATA,sha256=xpqNfI6Qt7mH9IXaN-5vfU9UAiV3lWCLWsgU3XlmaqA,2451
+cdk_factory-0.16.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.16.6.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.16.6.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.16.6.dist-info/RECORD,,