pangea 0.0.45 → 0.0.47

data/lib/pangea/components/multi_region_active_active/types/region_config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Components
+    module MultiRegionActiveActive
+      # Region configuration for active-active deployment
+      class RegionConfig < Dry::Struct
+        transform_keys(&:to_sym)
+
+        attribute :region, Types::String
+        attribute :vpc_cidr, Types::String
+        attribute :availability_zones, Types::Array.of(Types::String).constrained(min_size: 2, max_size: 6)
+        attribute :vpc_ref, Types::ResourceReference.optional
+        attribute :is_primary, Types::Bool.default(false)
+        attribute :database_priority, Types::Integer.default(100)
+        attribute :write_weight, Types::Integer.default(100)
+      end
+    end
+  end
+end

data/lib/pangea/components/multi_region_active_active/types/routing_config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Components
+    module MultiRegionActiveActive
+      # Traffic routing configuration
+      class TrafficRoutingConfig < Dry::Struct
+        transform_keys(&:to_sym)
+
+        attribute :routing_policy, Types::String.enum('latency', 'weighted', 'geolocation', 'failover').default('latency')
+        attribute :health_check_enabled, Types::Bool.default(true)
+        attribute :cross_region_latency_threshold_ms, Types::Integer.default(100)
+        attribute :sticky_sessions, Types::Bool.default(false)
+        attribute :session_affinity_ttl, Types::Integer.default(3600)
+      end
+    end
+  end
+end

data/lib/pangea/components/multi_region_active_active/types/validators.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Pangea
+  module Components
+    module MultiRegionActiveActive
+      # Validation module for MultiRegionActiveActiveAttributes
+      module Validators
+        def validate!
+          errors = []
+          errors.concat(validate_regions)
+          errors.concat(validate_consistency)
+          errors.concat(validate_failover)
+          errors.concat(validate_database)
+          errors.concat(validate_application)
+          errors.concat(validate_traffic_routing)
+          errors.concat(validate_compliance)
+          raise ArgumentError, errors.join(', ') unless errors.empty?
+
+          true
+        end
+
+        private
+
+        def validate_regions
+          errors = []
+          region_names = regions.map(&:region)
+
+          if region_names.uniq.length != region_names.length
+            errors << 'Region names must be unique'
+          end
+
+          primary_regions = regions.select(&:is_primary)
+          if primary_regions.empty?
+            errors << 'At least one region must be marked as primary'
+          elsif primary_regions.length > 1 && consistency.consistency_model == 'strong'
+            errors << 'Strong consistency requires exactly one primary region'
+          end
+
+          cidr_blocks = regions.map(&:vpc_cidr)
+          if cidr_blocks.uniq.length != cidr_blocks.length
+            errors << 'VPC CIDR blocks must not overlap across regions'
+          end
+
+          errors
+        end
+
+        def validate_consistency
+          errors = []
+
+          if consistency.write_quorum_size > regions.length
+            errors << 'Write quorum size cannot exceed number of regions'
+          end
+
+          if consistency.read_quorum_size > regions.length
+            errors << 'Read quorum size cannot exceed number of regions'
+          end
+
+          errors
+        end
+
+        def validate_failover
+          errors = []
+
+          if failover.health_check_interval < 10 || failover.health_check_interval > 300
+            errors << 'Health check interval must be between 10 and 300 seconds'
+          end
+
+          errors
+        end
+
+        def validate_database
+          errors = []
+
+          if global_database.engine == 'dynamodb' && global_database.instance_class
+            errors << 'DynamoDB does not use instance classes'
+          end
+
+          if global_database.backup_retention_days < 1 || global_database.backup_retention_days > 35
+            errors << 'Backup retention must be between 1 and 35 days'
+          end
+
+          errors
+        end
+
+        def validate_application
+          errors = []
+          return errors unless application
+
+          if application.task_cpu < 256 || application.task_cpu > 16_384
+            errors << 'Task CPU must be between 256 and 16384'
+          end
+
+          if application.task_memory < 512 || application.task_memory > 32_768
+            errors << 'Task memory must be between 512 and 32768'
+          end
+
+          errors << 'Desired count must be at least 1' if application.desired_count < 1
+
+          errors
+        end
+
+        def validate_traffic_routing
+          errors = []
+
+          if traffic_routing.cross_region_latency_threshold_ms < 1
+            errors << 'Cross-region latency threshold must be at least 1ms'
+          end
+
+          errors
+        end
+
+        def validate_compliance
+          errors = []
+          region_names = regions.map(&:region)
+
+          if compliance_regions.any? && !compliance_regions.all? { |r| region_names.include?(r) }
+            errors << 'Compliance regions must be subset of configured regions'
+          end
+
+          errors
+        end
+      end
+    end
+  end
+end

data/lib/pangea/components/multi_region_active_active/types.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Copyright 2025 The Pangea Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,236 +14,71 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 require 'dry-struct'
 require 'pangea/resources/types'
 
+require_relative 'types/region_config'
+require_relative 'types/consistency_config'
+require_relative 'types/failover_config'
+require_relative 'types/database_config'
+require_relative 'types/application_config'
+require_relative 'types/routing_config'
+require_relative 'types/monitoring_config'
+require_relative 'types/cost_config'
+require_relative 'types/validators'
+
 module Pangea
   module Components
     module MultiRegionActiveActive
-      # Region configuration for active-active deployment
-      class RegionConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :region, Types::String
-        attribute :vpc_cidr, Types::String
-        attribute :availability_zones, Types::Array.of(Types::String).constrained(min_size: 2, max_size: 6)
-        attribute :vpc_ref, Types::ResourceReference.optional
-        attribute :is_primary, Types::Bool.default(false)
-        attribute :database_priority, Types::Integer.default(100)
-        attribute :write_weight, Types::Integer.default(100)
-      end
-      
-      # Data consistency configuration
-      class ConsistencyConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :consistency_model, Types::String.enum('eventual', 'strong', 'bounded').default('eventual')
-        attribute :conflict_resolution, Types::String.enum('timestamp', 'region_priority', 'custom').default('timestamp')
-        attribute :replication_lag_threshold_ms, Types::Integer.default(100)
-        attribute :stale_read_acceptable, Types::Bool.default(false)
-        attribute :write_quorum_size, Types::Integer.default(2)
-        attribute :read_quorum_size, Types::Integer.default(1)
-      end
-      
-      # Failover configuration
-      class FailoverConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :enabled, Types::Bool.default(true)
-        attribute :health_check_interval, Types::Integer.default(30)
-        attribute :unhealthy_threshold, Types::Integer.default(3)
-        attribute :healthy_threshold, Types::Integer.default(2)
-        attribute :failover_timeout, Types::Integer.default(300)
-        attribute :auto_failback, Types::Bool.default(true)
-        attribute :notification_topic_ref, Types::ResourceReference.optional
-      end
-      
-      # Global database configuration
-      class GlobalDatabaseConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :engine, Types::String.enum('aurora-mysql', 'aurora-postgresql', 'dynamodb').default('aurora-postgresql')
-        attribute :engine_version, Types::String.optional
-        attribute :instance_class, Types::String.default('db.r5.large')
-        attribute :backup_retention_days, Types::Integer.default(7)
-        attribute :enable_global_write_forwarding, Types::Bool.default(true)
-        attribute :storage_encrypted, Types::Bool.default(true)
-        attribute :kms_key_ref, Types::ResourceReference.optional
-      end
-      
-      # Application configuration
-      class ApplicationConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :name, Types::String
-        attribute :port, Types::Integer.default(443)
-        attribute :protocol, Types::String.enum('HTTP', 'HTTPS', 'TCP').default('HTTPS')
-        attribute :health_check_path, Types::String.default('/health')
-        attribute :container_image, Types::String.optional
-        attribute :task_cpu, Types::Integer.default(256)
-        attribute :task_memory, Types::Integer.default(512)
-        attribute :desired_count, Types::Integer.default(3)
-      end
-      
-      # Traffic routing configuration
-      class TrafficRoutingConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :routing_policy, Types::String.enum('latency', 'weighted', 'geolocation', 'failover').default('latency')
-        attribute :health_check_enabled, Types::Bool.default(true)
-        attribute :cross_region_latency_threshold_ms, Types::Integer.default(100)
-        attribute :sticky_sessions, Types::Bool.default(false)
-        attribute :session_affinity_ttl, Types::Integer.default(3600)
-      end
-      
-      # Monitoring configuration
-      class MonitoringConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :enabled, Types::Bool.default(true)
-        attribute :detailed_metrics, Types::Bool.default(true)
-        attribute :cross_region_dashboard, Types::Bool.default(true)
-        attribute :synthetic_monitoring, Types::Bool.default(true)
-        attribute :distributed_tracing, Types::Bool.default(true)
-        attribute :log_aggregation, Types::Bool.default(true)
-        attribute :anomaly_detection, Types::Bool.default(true)
-      end
-      
-      # Cost optimization configuration
-      class CostOptimizationConfig < Dry::Struct
-        transform_keys(&:to_sym)
-        
-        attribute :use_regional_services, Types::Bool.default(true)
-        attribute :data_transfer_optimization, Types::Bool.default(true)
-        attribute :intelligent_tiering, Types::Bool.default(true)
-        attribute :spot_instances_enabled, Types::Bool.default(false)
-        attribute :reserved_capacity_planning, Types::Bool.default(true)
-      end
-      
-      # Main component attributes
+      # Main component attributes for multi-region active-active deployment
       class MultiRegionActiveActiveAttributes < Dry::Struct
+        include Validators
+
         transform_keys(&:to_sym)
-        
+
         # Core configuration
         attribute :deployment_name, Types::String
-        attribute :deployment_description, Types::String.default("Multi-region active-active infrastructure")
+        attribute :deployment_description, Types::String.default('Multi-region active-active infrastructure')
         attribute :domain_name, Types::String
-        
+
         # Region configurations
         attribute :regions, Types::Array.of(RegionConfig).constrained(min_size: 2)
-        
+
         # Data consistency
         attribute :consistency, ConsistencyConfig.default { ConsistencyConfig.new({}) }
-        
+
         # Failover configuration
         attribute :failover, FailoverConfig.default { FailoverConfig.new({}) }
-        
+
         # Global database
         attribute :global_database, GlobalDatabaseConfig.default { GlobalDatabaseConfig.new({}) }
-        
+
         # Application configuration
         attribute :application, ApplicationConfig.optional
-        
+
         # Traffic routing
         attribute :traffic_routing, TrafficRoutingConfig.default { TrafficRoutingConfig.new({}) }
-        
+
         # Monitoring
         attribute :monitoring, MonitoringConfig.default { MonitoringConfig.new({}) }
-        
+
         # Cost optimization
         attribute :cost_optimization, CostOptimizationConfig.default { CostOptimizationConfig.new({}) }
-        
+
         # Compliance and data residency
         attribute :data_residency_enabled, Types::Bool.default(true)
         attribute :compliance_regions, Types::Array.of(Types::String).default([].freeze)
         attribute :enable_data_localization, Types::Bool.default(false)
-        
+
         # Advanced features
         attribute :enable_global_accelerator, Types::Bool.default(true)
         attribute :enable_circuit_breaker, Types::Bool.default(true)
         attribute :enable_bulkhead_pattern, Types::Bool.default(true)
         attribute :enable_chaos_engineering, Types::Bool.default(false)
-        
+
         # Tags
         attribute :tags, Types::Hash.default({}.freeze)
-        
-        # Custom validations
-        def validate!
-          errors = []
-          
-          # Validate regions
-          region_names = regions.map(&:region)
-          if region_names.uniq.length != region_names.length
-            errors << "Region names must be unique"
-          end
-          
-          primary_regions = regions.select(&:is_primary)
-          if primary_regions.empty?
-            errors << "At least one region must be marked as primary"
-          elsif primary_regions.length > 1 && consistency.consistency_model == 'strong'
-            errors << "Strong consistency requires exactly one primary region"
-          end
-          
-          # Validate CIDR blocks don't overlap
-          cidr_blocks = regions.map(&:vpc_cidr)
-          if cidr_blocks.uniq.length != cidr_blocks.length
-            errors << "VPC CIDR blocks must not overlap across regions"
-          end
-          
-          # Validate consistency configuration
-          if consistency.write_quorum_size > regions.length
-            errors << "Write quorum size cannot exceed number of regions"
-          end
-          
-          if consistency.read_quorum_size > regions.length
-            errors << "Read quorum size cannot exceed number of regions"
-          end
-          
-          # Validate failover configuration
-          if failover.health_check_interval < 10 || failover.health_check_interval > 300
-            errors << "Health check interval must be between 10 and 300 seconds"
-          end
-          
-          # Validate global database configuration
-          if global_database.engine == 'dynamodb' && global_database.instance_class
-            errors << "DynamoDB does not use instance classes"
-          end
-          
-          if global_database.backup_retention_days < 1 || global_database.backup_retention_days > 35
-            errors << "Backup retention must be between 1 and 35 days"
-          end
-          
-          # Validate application configuration
-          if application
-            if application.task_cpu < 256 || application.task_cpu > 16384
-              errors << "Task CPU must be between 256 and 16384"
-            end
-            
-            if application.task_memory < 512 || application.task_memory > 32768
-              errors << "Task memory must be between 512 and 32768"
-            end
-            
-            if application.desired_count < 1
-              errors << "Desired count must be at least 1"
-            end
-          end
-          
-          # Validate traffic routing
-          if traffic_routing.cross_region_latency_threshold_ms < 1
-            errors << "Cross-region latency threshold must be at least 1ms"
-          end
-          
-          # Validate compliance regions
-          if compliance_regions.any? && !compliance_regions.all? { |r| region_names.include?(r) }
-            errors << "Compliance regions must be subset of configured regions"
-          end
-          
-          raise ArgumentError, errors.join(", ") unless errors.empty?
-          
-          true
-        end
       end
     end
   end
-end
+end

data/lib/pangea/components/mysql_database/component/database.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Pangea
+  module Components
+    module MySqlDatabaseComponent
+      # Database creation methods for MySQL component
+      module Database
+        # Create DB Subnet Group
+        def create_subnet_group(name, component_attrs, component_tag_set)
+          subnet_group_name = component_attrs.db_subnet_group_name || "#{name}-db-subnet-group"
+
+          aws_db_subnet_group(component_resource_name(name, :subnet_group), {
+            name: subnet_group_name,
+            description: "DB subnet group for #{name} MySQL database",
+            subnet_ids: component_attrs.subnet_refs.map(&:id),
+            tags: component_tag_set
+          })
+        end
+
+        # Create DB Parameter Group if requested
+        def create_parameter_group(name, component_attrs, component_tag_set)
+          return nil unless component_attrs.parameter_config.create_parameter_group
+
+          pg_name = component_attrs.parameter_config.parameter_group_name || "#{name}-mysql-params"
+
+          aws_db_parameter_group(component_resource_name(name, :parameter_group), {
+            name: pg_name,
+            family: component_attrs.parameter_config.parameter_group_family,
+            description: "Parameter group for #{name} MySQL database",
+            parameter: component_attrs.parameter_config.parameters.map do |param_name, param_value|
+              {
+                name: param_name,
+                value: param_value
+              }
+            end,
+            tags: component_tag_set
+          })
+        end
+
+        # Build RDS instance attributes
+        def build_rds_attributes(name, component_attrs, subnet_group_ref, parameter_group_ref, component_tag_set)
+          db_identifier = component_attrs.identifier || "#{name}-mysql-db"
+          final_snapshot_id = determine_final_snapshot_id(name, component_attrs)
+
+          rds_attrs = {
+            identifier: db_identifier,
+            engine: component_attrs.engine,
+            engine_version: component_attrs.engine_version,
+            instance_class: component_attrs.db_instance_class,
+            allocated_storage: component_attrs.allocated_storage,
+            max_allocated_storage: component_attrs.max_allocated_storage,
+            storage_type: component_attrs.storage_type,
+            iops: component_attrs.iops,
+            storage_throughput: component_attrs.storage_throughput,
+            db_name: component_attrs.db_name,
+            username: component_attrs.username,
+            manage_master_user_password: component_attrs.manage_master_user_password,
+            password: component_attrs.password,
+            kms_key_id: component_attrs.kms_key_id,
+            multi_az: component_attrs.multi_az,
+            availability_zone: component_attrs.availability_zone,
+            storage_encrypted: component_attrs.storage_encrypted,
+            publicly_accessible: component_attrs.publicly_accessible,
+            port: component_attrs.port,
+            db_subnet_group_name: subnet_group_ref.name,
+            vpc_security_group_ids: component_attrs.security_group_refs.map(&:id),
+            parameter_group_name: parameter_group_ref&.name,
+            option_group_name: component_attrs.option_group_name,
+            backup_retention_period: component_attrs.backup.backup_retention_period,
+            backup_window: component_attrs.backup.backup_window,
+            maintenance_window: component_attrs.maintenance.maintenance_window,
+            auto_minor_version_upgrade: component_attrs.maintenance.auto_minor_version_upgrade,
+            allow_major_version_upgrade: component_attrs.maintenance.allow_major_version_upgrade,
+            monitoring_interval: component_attrs.monitoring.monitoring_interval,
+            monitoring_role_arn: component_attrs.monitoring.monitoring_role_arn,
+            performance_insights_enabled: component_attrs.monitoring.performance_insights_enabled,
+            performance_insights_retention_period: component_attrs.monitoring.performance_insights_retention_period,
+            performance_insights_kms_key_id: component_attrs.monitoring.performance_insights_kms_key_id,
+            enabled_cloudwatch_logs_exports: component_attrs.enabled_cloudwatch_logs_exports,
+            copy_tags_to_snapshot: component_attrs.backup.copy_tags_to_snapshot,
+            delete_automated_backups: component_attrs.backup.delete_automated_backups,
+            skip_final_snapshot: component_attrs.backup.skip_final_snapshot,
+            final_snapshot_identifier: final_snapshot_id,
+            deletion_protection: component_attrs.deletion_protection,
+            character_set_name: component_attrs.character_set_name,
+            blue_green_update: component_attrs.blue_green_update,
+            tags: component_tag_set
+          }.compact
+
+          apply_restore_options(rds_attrs, component_attrs)
+        end
+
+        # Create read replicas if requested
+        def create_read_replicas(name, component_attrs, db_instance_ref, component_tag_set)
+          return {} unless component_attrs.create_read_replica
+
+          db_identifier = component_attrs.identifier || "#{name}-mysql-db"
+          read_replicas = {}
+
+          (1..component_attrs.read_replica_count).each do |i|
+            replica_identifier = "#{db_identifier}-replica-#{i}"
+            replica_instance_class = component_attrs.read_replica_instance_class || component_attrs.db_instance_class
+
+            replica_ref = aws_db_instance(component_resource_name(name, :read_replica, "replica#{i}".to_sym), {
+              identifier: replica_identifier,
+              replicate_source_db: db_instance_ref.identifier,
+              instance_class: replica_instance_class,
+              storage_encrypted: component_attrs.storage_encrypted,
+              kms_key_id: component_attrs.kms_key_id,
+              publicly_accessible: component_attrs.publicly_accessible,
+              monitoring_interval: component_attrs.monitoring.monitoring_interval,
+              monitoring_role_arn: component_attrs.monitoring.monitoring_role_arn,
+              performance_insights_enabled: component_attrs.monitoring.performance_insights_enabled,
+              auto_minor_version_upgrade: component_attrs.maintenance.auto_minor_version_upgrade,
+              skip_final_snapshot: true,
+              copy_tags_to_snapshot: component_attrs.backup.copy_tags_to_snapshot,
+              tags: component_tag_set.merge({
+                Name: "#{name}-mysql-replica-#{i}",
+                Role: "ReadReplica"
+              })
+            })
+            read_replicas["replica#{i}".to_sym] = replica_ref
+          end
+
+          read_replicas
+        end
+
+        private
+
+        def determine_final_snapshot_id(name, component_attrs)
+          if component_attrs.backup.skip_final_snapshot
+            nil
+          else
+            component_attrs.backup.final_snapshot_identifier || "#{name}-final-snapshot-#{Time.now.to_i}"
+          end
+        end
+
+        def apply_restore_options(rds_attrs, component_attrs)
+          if component_attrs.restore_from_snapshot && component_attrs.snapshot_identifier
+            rds_attrs[:snapshot_identifier] = component_attrs.snapshot_identifier
+            rds_attrs.delete(:db_name)
+            rds_attrs.delete(:username)
+            rds_attrs.delete(:password)
+            rds_attrs.delete(:manage_master_user_password)
+          elsif component_attrs.restore_to_point_in_time
+            rds_attrs.merge!(component_attrs.restore_to_point_in_time)
+          end
+
+          rds_attrs
+        end
+      end
+    end
+  end
+end