pangea-aws 0.1.0

data/lib/pangea/resources/aws_eks_fargate_profile/types.rb

@@ -0,0 +1,144 @@
+# 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 Resources
+    module AWS
+      module Types
+        # Fargate profile selector for pod matching
+        class FargateSelector < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          attribute? :namespace, Resources::Types::String.optional
+          attribute :labels, Resources::Types::Hash.default({}.freeze)
+          
+          # Validate namespace format
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            
+            # Validate namespace is not empty
+            if attrs[:namespace] && attrs[:namespace].strip.empty?
+              raise Dry::Struct::Error, "Namespace cannot be empty"
+            end
+            
+            # Validate label keys and values
+            if attrs[:labels]
+              attrs[:labels].each do |key, value|
+                if key.to_s.empty? || value.to_s.empty?
+                  raise Dry::Struct::Error, "Label keys and values cannot be empty"
+                end
+                
+                # Kubernetes label key validation
+                unless key.to_s.match?(/\A[a-zA-Z]([a-zA-Z0-9\-_.]*[a-zA-Z0-9])?\z/)
+                  raise Dry::Struct::Error, "Invalid label key format: #{key}"
+                end
+              end
+            end
+            
+            super(attrs)
+          end
+          
+          def to_h
+            hash = { namespace: namespace }
+            hash[:labels] = labels if labels.any?
+            hash
+          end
+        end
+        
+        # EKS Fargate profile attributes with validation
+        class EksFargateProfileAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          # Required attributes
+          attribute? :cluster_name, Resources::Types::String.optional
+          attribute :fargate_profile_name, Resources::Types::String.optional.default(nil)
+          attribute? :pod_execution_role_arn, Resources::Types::String.constrained(
+            format: /\Aarn:aws:iam::\d{12}:role\/.+\z/
+          )
+          attribute? :selectors, Resources::Types::Array.of(FargateSelector).constrained(
+            min_size: 1,
+            max_size: 5
+          )
+          
+          # Optional attributes
+          attribute :subnet_ids, Resources::Types::Array.of(Resources::Types::String).optional.default(nil)
+          attribute :tags, Resources::Types::Hash.default({}.freeze)
+          
+          # Validate selectors
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            
+            # Convert raw selector hashes to FargateSelector objects if needed
+            if attrs[:selectors] && attrs[:selectors].is_a?(Array)
+              attrs[:selectors] = attrs[:selectors].map do |selector|
+                selector.is_a?(FargateSelector) ? selector : FargateSelector.new(selector)
+              end
+            end
+            
+            # Validate selector count
+            if attrs[:selectors] && attrs[:selectors].size > 5
+              raise Dry::Struct::Error, "Fargate profile can have a maximum of 5 selectors"
+            end
+            
+            # Validate unique namespaces when no labels
+            if attrs[:selectors]
+              namespace_only_selectors = attrs[:selectors].select { |s| s.labels.empty? }
+              namespaces = namespace_only_selectors.map(&:namespace)
+              if namespaces.size != namespaces.uniq.size
+                raise Dry::Struct::Error, "Duplicate namespace selectors without labels are not allowed"
+              end
+            end
+            
+            super(attrs)
+          end
+          
+          # Computed properties
+          def namespaces
+            selectors.map(&:namespace).uniq
+          end
+          
+          def has_labels?
+            selectors.any? { |s| s.labels.any? }
+          end
+          
+          def selector_count
+            selectors.size
+          end
+          
+          def covers_namespace?(namespace)
+            selectors.any? { |s| s.namespace == namespace }
+          end
+          
+          def to_h
+            hash = {
+              cluster_name: cluster_name,
+              pod_execution_role_arn: pod_execution_role_arn,
+              selectors: selectors.map(&:to_h)
+            }
+            
+            hash[:fargate_profile_name] = fargate_profile_name if fargate_profile_name
+            hash[:subnet_ids] = subnet_ids if subnet_ids
+            hash[:tags] = tags if tags.any?
+            
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_eks_node_group/builders/dsl_builder.rb

@@ -0,0 +1,107 @@
+# 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 Resources
+    module AWS
+      module EksNodeGroup
+        # Builds Terraform DSL for EKS node group resources
+        module DslBuilder
+          module_function
+
+          def build_resource(context, attrs)
+            build_required_attributes(context, attrs)
+            build_scaling_config(context, attrs.scaling_config)
+            build_update_config(context, attrs.update_config) if attrs.update_config
+            build_instance_config(context, attrs)
+            build_version_info(context, attrs)
+            build_remote_access(context, attrs.remote_access) if attrs.remote_access
+            build_launch_template(context, attrs.launch_template) if attrs.launch_template
+            build_kubernetes_config(context, attrs)
+          end
+
+          def build_required_attributes(context, attrs)
+            context.cluster_name attrs.cluster_name
+            context.node_role_arn attrs.node_role_arn
+            context.subnet_ids attrs.subnet_ids
+            context.node_group_name attrs.node_group_name if attrs.node_group_name
+          end
+
+          def build_scaling_config(context, scaling_config)
+            context.scaling_config do
+              context.desired_size scaling_config.desired_size
+              context.max_size scaling_config.max_size
+              context.min_size scaling_config.min_size
+            end
+          end
+
+          def build_update_config(context, update_config)
+            context.update_config do
+              if update_config.max_unavailable
+                context.max_unavailable update_config.max_unavailable
+              elsif update_config.max_unavailable_percentage
+                context.max_unavailable_percentage update_config.max_unavailable_percentage
+              end
+            end
+          end
+
+          def build_instance_config(context, attrs)
+            context.instance_types attrs.instance_types
+            context.capacity_type attrs.capacity_type
+            context.ami_type attrs.ami_type
+            context.disk_size attrs.disk_size
+          end
+
+          def build_version_info(context, attrs)
+            context.release_version attrs.release_version if attrs.release_version
+            context.version attrs.version if attrs.version
+            context.force_update_version attrs.force_update_version if attrs.force_update_version
+          end
+
+          def build_remote_access(context, remote_access)
+            context.remote_access do
+              context.ec2_ssh_key remote_access.ec2_ssh_key if remote_access.ec2_ssh_key
+              context.source_security_group_ids remote_access.source_security_group_ids if remote_access.source_security_group_ids.any?
+            end
+          end
+
+          def build_launch_template(context, launch_template)
+            context.launch_template do
+              context.id launch_template.id if launch_template.id
+              context.__send__(:name, launch_template.name) if launch_template.name
+              context.version launch_template.version if launch_template.version
+            end
+          end
+
+          def build_kubernetes_config(context, attrs)
+            context.labels attrs.labels if attrs.labels.any?
+            build_taints(context, attrs.taints) if attrs.taints.any?
+            context.tags attrs.tags if attrs.tags.any?
+          end
+
+          def build_taints(context, taints)
+            taint_array = taints.map do |taint_config|
+              taint_hash = { key: taint_config.key, effect: taint_config.effect }
+              taint_hash[:value] = taint_config.value if taint_config.value
+              taint_hash
+            end
+            context.taint taint_array
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_eks_node_group/builders/reference_builder.rb

@@ -0,0 +1,76 @@
+# 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 Resources
+    module AWS
+      module EksNodeGroup
+        # Builds resource references for EKS node groups
+        module ReferenceBuilder
+          TERRAFORM_OUTPUTS = %i[
+            id arn cluster_name node_group_name node_role_arn subnet_ids status
+            capacity_type instance_types disk_size remote_access scaling_config
+            update_config launch_template version release_version resources tags_all
+          ].freeze
+
+          COMPUTED_PROPERTIES = %i[
+            spot_instances? custom_ami? has_remote_access? has_taints? has_labels?
+          ].freeze
+
+          DELEGATED_ATTRIBUTES = %i[ami_type].freeze
+
+          module_function
+
+          def build_reference(name, node_group_attrs)
+            ref = ResourceReference.new(
+              type: 'aws_eks_node_group',
+              name: name,
+              resource_attributes: node_group_attrs.to_h,
+              outputs: build_outputs(name)
+            )
+
+            add_computed_properties(ref, node_group_attrs)
+            add_delegated_attributes(ref, node_group_attrs)
+            add_desired_size_method(ref, node_group_attrs)
+            ref
+          end
+
+          def build_outputs(name)
+            TERRAFORM_OUTPUTS.each_with_object({}) do |output, hash|
+              hash[output] = "${aws_eks_node_group.#{name}.#{output}}"
+            end
+          end
+
+          def add_computed_properties(ref, node_group_attrs)
+            COMPUTED_PROPERTIES.each do |prop|
+              ref.define_singleton_method(prop) { node_group_attrs.public_send(prop) }
+            end
+          end
+
+          def add_delegated_attributes(ref, node_group_attrs)
+            DELEGATED_ATTRIBUTES.each do |attr|
+              ref.define_singleton_method(attr) { node_group_attrs.public_send(attr) }
+            end
+          end
+
+          def add_desired_size_method(ref, node_group_attrs)
+            ref.define_singleton_method(:desired_size) { node_group_attrs.scaling_config.desired_size }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_eks_node_group/resource.rb

@@ -0,0 +1,114 @@
+# 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 'pangea/resources/base'
+require 'pangea/resources/reference'
+require 'pangea/resources/aws_eks_node_group/types'
+require 'pangea/resource_registry'
+require_relative 'builders/dsl_builder'
+require_relative 'builders/reference_builder'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS EKS Node Group with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] EKS node group attributes
+      # @option attributes [String] :cluster_name EKS cluster name (required)
+      # @option attributes [String] :node_role_arn IAM role ARN for nodes (required)
+      # @option attributes [Array<String>] :subnet_ids Subnet IDs for nodes (required)
+      # @option attributes [String] :node_group_name Custom node group name
+      # @option attributes [Hash] :scaling_config Scaling configuration
+      # @option attributes [Hash] :update_config Update configuration
+      # @option attributes [Array<String>] :instance_types EC2 instance types
+      # @option attributes [String] :capacity_type ON_DEMAND or SPOT
+      # @option attributes [String] :ami_type AMI type for nodes
+      # @option attributes [String] :release_version AMI release version
+      # @option attributes [Integer] :disk_size Root device disk size in GB
+      # @option attributes [Hash] :remote_access SSH access configuration
+      # @option attributes [Hash] :launch_template Custom launch template
+      # @option attributes [Hash] :labels Kubernetes labels
+      # @option attributes [Array<Hash>] :taints Kubernetes taints
+      # @option attributes [Hash] :tags Resource tags
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      #
+      # @example Basic node group
+      #   node_group = aws_eks_node_group(:workers, {
+      #     cluster_name: cluster.name,
+      #     node_role_arn: node_role.arn,
+      #     subnet_ids: private_subnet_ids,
+      #     scaling_config: {
+      #       desired_size: 3,
+      #       min_size: 2,
+      #       max_size: 5
+      #     }
+      #   })
+      #
+      # @example Spot instance node group with labels and taints
+      #   spot_nodes = aws_eks_node_group(:spot_workers, {
+      #     cluster_name: cluster.name,
+      #     node_role_arn: node_role.arn,
+      #     subnet_ids: private_subnet_ids,
+      #     capacity_type: "SPOT",
+      #     instance_types: ["t3.large", "t3a.large", "t3.xlarge"],
+      #     scaling_config: {
+      #       desired_size: 5,
+      #       min_size: 3,
+      #       max_size: 10
+      #     },
+      #     labels: {
+      #       workload: "batch",
+      #       lifecycle: "spot"
+      #     },
+      #     taints: [{
+      #       key: "spot",
+      #       value: "true",
+      #       effect: "NO_SCHEDULE"
+      #     }],
+      #     tags: {
+      #       CostCenter: "engineering",
+      #       Type: "spot-compute"
+      #     }
+      #   })
+      #
+      # @example GPU node group for ML workloads
+      #   gpu_nodes = aws_eks_node_group(:gpu_workers, {
+      #     cluster_name: cluster.name,
+      #     node_role_arn: node_role.arn,
+      #     subnet_ids: private_subnet_ids,
+      #     ami_type: "AL2_x86_64_GPU",
+      #     instance_types: ["g4dn.xlarge", "g4dn.2xlarge"],
+      #     scaling_config: { desired_size: 2, min_size: 1, max_size: 4 },
+      #     disk_size: 100,
+      #     labels: { workload: "ml", gpu: "nvidia" },
+      #     taints: [{
+      #       key: "nvidia.com/gpu",
+      #       effect: "NO_SCHEDULE"
+      #     }]
+      #   })
+      def aws_eks_node_group(name, attributes = {})
+        node_group_attrs = Types::EksNodeGroupAttributes.new(attributes)
+
+        resource(:aws_eks_node_group, name) do
+          EksNodeGroup::DslBuilder.build_resource(self, node_group_attrs)
+        end
+
+        EksNodeGroup::ReferenceBuilder.build_reference(name, node_group_attrs)
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_eks_node_group/types/eks_node_group_attributes.rb

@@ -0,0 +1,132 @@
+# 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 Resources
+    module AWS
+      module Types
+        # EKS node group attributes with validation
+        class EksNodeGroupAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          AMI_TYPES = %w[
+            AL2_x86_64 AL2_x86_64_GPU AL2_ARM_64
+            BOTTLEROCKET_ARM_64 BOTTLEROCKET_x86_64
+            BOTTLEROCKET_ARM_64_NVIDIA BOTTLEROCKET_x86_64_NVIDIA
+            CUSTOM
+          ].freeze
+
+          CAPACITY_TYPES = %w[ON_DEMAND SPOT].freeze
+
+          # Required attributes
+          attribute? :cluster_name, Pangea::Resources::Types::String.optional
+          attribute? :node_role_arn, Pangea::Resources::Types::String.constrained(
+            format: /\Aarn:aws:iam::\d{12}:role\/.+\z/
+          )
+          attribute? :subnet_ids, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).constrained(min_size: 1).optional
+
+          # Optional attributes
+          attribute :node_group_name, Pangea::Resources::Types::String.optional.default(nil)
+          attribute :scaling_config, ScalingConfig.default(ScalingConfig.new({}))
+          attribute :update_config, UpdateConfig.optional.default(nil)
+          attribute :instance_types, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).default(['t3.medium'].freeze)
+          attribute :capacity_type, Pangea::Resources::Types::String.constrained(included_in: CAPACITY_TYPES).default('ON_DEMAND')
+          attribute :ami_type, Pangea::Resources::Types::String.constrained(included_in: AMI_TYPES).default('AL2_x86_64')
+          attribute :release_version, Pangea::Resources::Types::String.optional.default(nil)
+          attribute :version, Pangea::Resources::Types::String.optional.default(nil)
+          attribute :disk_size, Pangea::Resources::Types::Integer.default(20).constrained(gteq: 20, lteq: 1000)
+          attribute :remote_access, RemoteAccess.optional.default(nil)
+          attribute :launch_template, LaunchTemplate.optional.default(nil)
+          attribute :labels, Pangea::Resources::Types::Hash.default({}.freeze)
+          attribute :taints, Pangea::Resources::Types::Array.of(Taint).default([].freeze)
+          attribute :tags, Pangea::Resources::Types::Hash.default({}.freeze)
+          attribute :force_update_version, Pangea::Resources::Types::Bool.default(false)
+
+          # Validate instance types match AMI type
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            # Validate ARM instance types with ARM AMIs
+            if attrs[:ami_type] && attrs[:instance_types]
+              ami_type = attrs[:ami_type]
+              instance_types = attrs[:instance_types]
+
+              if ami_type.include?('ARM') && instance_types.any? { |t| !t.include?('g') && !t.include?('a1') }
+                raise Dry::Struct::Error, 'ARM AMI types require ARM-compatible instance types'
+              end
+
+              if ami_type.include?('GPU') && instance_types.none? { |t| t.include?('p') || t.include?('g4') }
+                raise Dry::Struct::Error, 'GPU AMI types require GPU instance types'
+              end
+            end
+
+            super(attrs)
+          end
+
+          # Computed properties
+          def spot_instances?
+            capacity_type == 'SPOT'
+          end
+
+          def custom_ami?
+            ami_type == 'CUSTOM'
+          end
+
+          def has_remote_access?
+            !remote_access.nil?
+          end
+
+          def has_taints?
+            taints.any?
+          end
+
+          def has_labels?
+            labels.any?
+          end
+
+          def to_h
+            hash = {
+              cluster_name: cluster_name,
+              node_role_arn: node_role_arn,
+              subnet_ids: subnet_ids,
+              scaling_config: scaling_config.to_h,
+              instance_types: instance_types,
+              capacity_type: capacity_type,
+              ami_type: ami_type,
+              disk_size: disk_size,
+              force_update_version: force_update_version
+            }
+
+            hash[:node_group_name] = node_group_name if node_group_name
+            hash[:update_config] = update_config.to_h if update_config && !update_config.to_h.empty?
+            hash[:release_version] = release_version if release_version
+            hash[:version] = version if version
+            hash[:remote_access] = remote_access.to_h if remote_access && !remote_access.to_h.empty?
+            hash[:launch_template] = launch_template.to_h if launch_template
+            hash[:labels] = labels if labels.any?
+            hash[:taints] = taints.map(&:to_h) if taints.any?
+            hash[:tags] = tags if tags.any?
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_eks_node_group/types/launch_template.rb

@@ -0,0 +1,58 @@
+# 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 Resources
+    module AWS
+      module Types
+        # Launch template specification
+        class LaunchTemplate < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute :id, Pangea::Resources::Types::String.optional.default(nil)
+          attribute :name, Pangea::Resources::Types::String.optional.default(nil)
+          attribute :version, Pangea::Resources::Types::String.optional.default(nil)
+
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            # Validate that either id or name is specified
+            unless attrs[:id] || attrs[:name]
+              raise Dry::Struct::Error, "Launch template must specify either 'id' or 'name'"
+            end
+
+            if attrs[:id] && attrs[:name]
+              raise Dry::Struct::Error, "Launch template cannot specify both 'id' and 'name'"
+            end
+
+            super(attrs)
+          end
+
+          def to_h
+            hash = {}
+            hash[:id] = id if id
+            hash[:name] = name if name
+            hash[:version] = version if version
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_eks_node_group/types/remote_access.rb

@@ -0,0 +1,41 @@
+# 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 Resources
+    module AWS
+      module Types
+        # Remote access configuration
+        class RemoteAccess < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute :ec2_ssh_key, Pangea::Resources::Types::String.optional.default(nil)
+          attribute :source_security_group_ids, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).default([].freeze)
+
+          def to_h
+            hash = {}
+            hash[:ec2_ssh_key] = ec2_ssh_key if ec2_ssh_key
+            hash[:source_security_group_ids] = source_security_group_ids if source_security_group_ids.any?
+            hash
+          end
+        end
+      end
+    end
+  end
+end