pangea-aws 0.1.0

data/lib/pangea/resources/aws_batch_compute_environment/types/templates.rb

@@ -0,0 +1,153 @@
+# 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 Types
+        # Configuration templates for BatchComputeEnvironmentAttributes
+        module BatchComputeEnvironmentTemplates
+          def ec2_managed_environment(name, vpc_config, options = {})
+            {
+              compute_environment_name: name,
+              type: "MANAGED",
+              state: "ENABLED",
+              compute_resources: {
+                type: "EC2",
+                allocation_strategy: "BEST_FIT_PROGRESSIVE",
+                min_vcpus: options[:min_vcpus] || 0,
+                max_vcpus: options[:max_vcpus] || 100,
+                desired_vcpus: options[:desired_vcpus] || 0,
+                instance_types: options[:instance_types] || ["optimal"],
+                subnets: vpc_config[:subnets],
+                security_group_ids: vpc_config[:security_group_ids],
+                instance_role: options[:instance_role],
+                tags: options[:tags] || {}
+              }
+            }
+          end
+
+          def spot_managed_environment(name, vpc_config, options = {})
+            {
+              compute_environment_name: name,
+              type: "MANAGED",
+              state: "ENABLED",
+              compute_resources: {
+                type: "SPOT",
+                allocation_strategy: "SPOT_CAPACITY_OPTIMIZED",
+                min_vcpus: options[:min_vcpus] || 0,
+                max_vcpus: options[:max_vcpus] || 100,
+                desired_vcpus: options[:desired_vcpus] || 0,
+                instance_types: options[:instance_types] || ["optimal"],
+                spot_iam_fleet_request_role: options[:spot_iam_fleet_request_role],
+                bid_percentage: options[:bid_percentage] || 50,
+                subnets: vpc_config[:subnets],
+                security_group_ids: vpc_config[:security_group_ids],
+                instance_role: options[:instance_role],
+                tags: options[:tags] || {}
+              }
+            }
+          end
+
+          def fargate_managed_environment(name, vpc_config, options = {})
+            {
+              compute_environment_name: name,
+              type: "MANAGED",
+              state: "ENABLED",
+              compute_resources: {
+                type: "FARGATE",
+                max_vcpus: options[:max_vcpus] || 100,
+                subnets: vpc_config[:subnets],
+                security_group_ids: vpc_config[:security_group_ids],
+                platform_capabilities: ["FARGATE"],
+                tags: options[:tags] || {}
+              }
+            }
+          end
+
+          def fargate_spot_managed_environment(name, vpc_config, options = {})
+            {
+              compute_environment_name: name,
+              type: "MANAGED",
+              state: "ENABLED",
+              compute_resources: {
+                type: "FARGATE_SPOT",
+                max_vcpus: options[:max_vcpus] || 100,
+                subnets: vpc_config[:subnets],
+                security_group_ids: vpc_config[:security_group_ids],
+                platform_capabilities: ["FARGATE"],
+                tags: options[:tags] || {}
+              }
+            }
+          end
+
+          def unmanaged_environment(name, options = {})
+            {
+              compute_environment_name: name,
+              type: "UNMANAGED",
+              state: options[:state] || "ENABLED",
+              service_role: options[:service_role],
+              tags: options[:tags] || {}
+            }
+          end
+        end
+
+        # Common EC2 instance type groups for AWS Batch
+        module BatchInstanceTypes
+          def compute_optimized_instances
+            %w[
+              c4.large c4.xlarge c4.2xlarge c4.4xlarge c4.8xlarge
+              c5.large c5.xlarge c5.2xlarge c5.4xlarge c5.9xlarge c5.12xlarge c5.18xlarge c5.24xlarge
+              c5n.large c5n.xlarge c5n.2xlarge c5n.4xlarge c5n.9xlarge c5n.18xlarge
+              c6i.large c6i.xlarge c6i.2xlarge c6i.4xlarge c6i.8xlarge c6i.12xlarge c6i.16xlarge
+              c6i.24xlarge c6i.32xlarge
+            ]
+          end
+
+          def memory_optimized_instances
+            %w[
+              r4.large r4.xlarge r4.2xlarge r4.4xlarge r4.8xlarge r4.16xlarge
+              r5.large r5.xlarge r5.2xlarge r5.4xlarge r5.8xlarge r5.12xlarge r5.16xlarge r5.24xlarge
+              r5a.large r5a.xlarge r5a.2xlarge r5a.4xlarge r5a.8xlarge r5a.12xlarge r5a.16xlarge r5a.24xlarge
+              r6i.large r6i.xlarge r6i.2xlarge r6i.4xlarge r6i.8xlarge r6i.12xlarge r6i.16xlarge
+              r6i.24xlarge r6i.32xlarge
+            ]
+          end
+
+          def general_purpose_instances
+            %w[
+              m4.large m4.xlarge m4.2xlarge m4.4xlarge m4.10xlarge m4.16xlarge
+              m5.large m5.xlarge m5.2xlarge m5.4xlarge m5.8xlarge m5.12xlarge m5.16xlarge m5.24xlarge
+              m5a.large m5a.xlarge m5a.2xlarge m5a.4xlarge m5a.8xlarge m5a.12xlarge m5a.16xlarge m5a.24xlarge
+              m6i.large m6i.xlarge m6i.2xlarge m6i.4xlarge m6i.8xlarge m6i.12xlarge m6i.16xlarge
+              m6i.24xlarge m6i.32xlarge
+            ]
+          end
+
+          def gpu_instances
+            %w[
+              p2.xlarge p2.8xlarge p2.16xlarge
+              p3.2xlarge p3.8xlarge p3.16xlarge
+              p3dn.24xlarge
+              g3.4xlarge g3.8xlarge g3.16xlarge
+              g4dn.xlarge g4dn.2xlarge g4dn.4xlarge g4dn.8xlarge g4dn.12xlarge g4dn.16xlarge
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_batch_compute_environment/types/validators.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.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Validation methods for BatchComputeEnvironmentAttributes
+        module BatchComputeEnvironmentValidators
+          def self.validate_compute_environment_name(name)
+            if name.length < 1 || name.length > 128
+              raise Dry::Struct::Error, "Compute environment name must be between 1 and 128 characters"
+            end
+
+            unless name.match?(/^[a-zA-Z0-9\-_]+$/)
+              raise Dry::Struct::Error,
+                    "Compute environment name can only contain letters, numbers, hyphens, and underscores"
+            end
+
+            true
+          end
+
+          def self.validate_compute_resources(resources)
+            unless resources.is_a?(::Hash)
+              raise Dry::Struct::Error, "Compute resources must be a hash"
+            end
+
+            if resources[:type] && !%w[EC2 SPOT FARGATE FARGATE_SPOT].include?(resources[:type])
+              raise Dry::Struct::Error, "Compute resource type must be one of: EC2, SPOT, FARGATE, FARGATE_SPOT"
+            end
+
+            validate_allocation_strategy(resources)
+            validate_vcpu_settings(resources)
+            validate_instance_types(resources[:instance_types]) if resources[:instance_types]
+            validate_spot_configuration(resources)
+            validate_fargate_configuration(resources)
+
+            true
+          end
+
+          def self.validate_allocation_strategy(resources)
+            return unless resources[:allocation_strategy]
+
+            valid_strategies = case resources[:type]
+                               when "EC2", "SPOT"
+                                 %w[BEST_FIT BEST_FIT_PROGRESSIVE SPOT_CAPACITY_OPTIMIZED]
+                               when "FARGATE", "FARGATE_SPOT"
+                                 ["SPOT_CAPACITY_OPTIMIZED"]
+                               else
+                                 []
+                               end
+
+            unless valid_strategies.include?(resources[:allocation_strategy])
+              raise Dry::Struct::Error,
+                    "Invalid allocation strategy '#{resources[:allocation_strategy]}' for type '#{resources[:type]}'"
+            end
+          end
+
+          def self.validate_vcpu_settings(resources)
+            if resources[:min_vcpus] && resources[:min_vcpus] < 0
+              raise Dry::Struct::Error, "min_vcpus must be non-negative"
+            end
+
+            if resources[:max_vcpus] && resources[:max_vcpus] < 0
+              raise Dry::Struct::Error, "max_vcpus must be non-negative"
+            end
+
+            if resources[:desired_vcpus] && resources[:desired_vcpus] < 0
+              raise Dry::Struct::Error, "desired_vcpus must be non-negative"
+            end
+
+            if resources[:min_vcpus] && resources[:max_vcpus] && resources[:min_vcpus] > resources[:max_vcpus]
+              raise Dry::Struct::Error, "min_vcpus cannot be greater than max_vcpus"
+            end
+
+            if resources[:desired_vcpus] && resources[:max_vcpus] && resources[:desired_vcpus] > resources[:max_vcpus]
+              raise Dry::Struct::Error, "desired_vcpus cannot be greater than max_vcpus"
+            end
+          end
+
+          def self.validate_instance_types(instance_types)
+            return true if instance_types == ["optimal"]
+
+            unless instance_types.is_a?(Array) && instance_types.all? { |type| type.is_a?(String) }
+              raise Dry::Struct::Error, "Instance types must be an array of strings"
+            end
+
+            instance_types.each do |type|
+              unless type.match?(/^[a-z0-9]+\.[a-z0-9]+$/) || type == "optimal"
+                raise Dry::Struct::Error, "Invalid instance type format: #{type}"
+              end
+            end
+
+            true
+          end
+
+          def self.validate_spot_configuration(resources)
+            if resources[:type] == "SPOT" && resources[:spot_iam_fleet_request_role].nil?
+              raise Dry::Struct::Error, "SPOT compute resources require spot_iam_fleet_request_role"
+            end
+          end
+
+          def self.validate_fargate_configuration(resources)
+            return unless %w[FARGATE FARGATE_SPOT].include?(resources[:type])
+
+            if resources[:platform_capabilities] && !resources[:platform_capabilities].include?("FARGATE")
+              raise Dry::Struct::Error, "Fargate compute resources must include FARGATE platform capability"
+            end
+          end
+
+          def self.validate_vpc_configuration(vpc_config)
+            unless vpc_config.is_a?(::Hash)
+              raise Dry::Struct::Error, "VPC configuration must be a hash"
+            end
+
+            unless vpc_config[:subnets] && vpc_config[:subnets].is_a?(Array) && !vpc_config[:subnets].empty?
+              raise Dry::Struct::Error, "VPC configuration must include non-empty subnets array"
+            end
+
+            unless vpc_config[:security_group_ids] && vpc_config[:security_group_ids].is_a?(Array) &&
+                   !vpc_config[:security_group_ids].empty?
+              raise Dry::Struct::Error, "VPC configuration must include non-empty security_group_ids array"
+            end
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# 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'
+
+require_relative 'types/validators'
+require_relative 'types/helpers'
+require_relative 'types/templates'
+require_relative 'types/attributes'

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

@@ -0,0 +1,68 @@
+# 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_relative 'types'
+require_relative 'synthesis/synthesizer'
+
+module Pangea
+  module Resources
+    module AWS
+      # AWS Batch Job Definition implementation
+      # Provides type-safe function for creating job definitions
+      def aws_batch_job_definition(name, attributes = {})
+        validated_attrs = Types::BatchJobDefinitionAttributes.new(attributes)
+
+        ref = ResourceReference.new(
+          type: 'aws_batch_job_definition',
+          name: name,
+          resource_attributes: validated_attrs.to_h,
+          outputs: {
+            id: "${aws_batch_job_definition.#{name}.id}",
+            arn: "${aws_batch_job_definition.#{name}.arn}",
+            name: "${aws_batch_job_definition.#{name}.name}",
+            revision: "${aws_batch_job_definition.#{name}.revision}",
+            tags_all: "${aws_batch_job_definition.#{name}.tags_all}"
+          }
+        )
+
+        attrs = validated_attrs.to_h
+
+        resource :aws_batch_job_definition, name do
+          job_definition_name attrs[:job_definition_name]
+          type attrs[:type]
+
+          container_properties(attrs[:container_properties]) if attrs[:container_properties]
+          node_properties(attrs[:node_properties]) if attrs[:node_properties]
+
+          if attrs[:retry_strategy]
+            retry_strategy(attrs[:retry_strategy])
+          end
+
+          if attrs[:timeout]
+            timeout(attrs[:timeout])
+          end
+
+          platform_capabilities attrs[:platform_capabilities] if attrs[:platform_capabilities]
+          propagate_tags attrs[:propagate_tags] unless attrs[:propagate_tags].nil?
+          tags attrs[:tags] if attrs[:tags]
+        end
+
+        ref
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_batch_job_definition/synthesis/synthesizer.rb

@@ -0,0 +1,159 @@
+# 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
+      # Synthesizer class to handle complex nested block synthesis for Batch Job Definition
+      class BatchJobDefinitionSynthesizer
+        class << self
+          def synthesize_container(ctx, props)
+            ctx.image props[:image]
+            ctx.vcpus props[:vcpus] if props[:vcpus]
+            ctx.memory props[:memory] if props[:memory]
+            ctx.job_role_arn props[:job_role_arn] if props[:job_role_arn]
+            ctx.execution_role_arn props[:execution_role_arn] if props[:execution_role_arn]
+            ctx.command props[:command] if props[:command]
+            ctx.user props[:user] if props[:user]
+            ctx.instance_type props[:instance_type] if props[:instance_type]
+            ctx.privileged props[:privileged] if props[:privileged]
+            ctx.readonly_root_filesystem props[:readonly_root_filesystem] if props[:readonly_root_filesystem]
+
+            synthesize_environment(ctx, props[:environment])
+            synthesize_mount_points(ctx, props[:mount_points])
+            synthesize_volumes(ctx, props[:volumes])
+            synthesize_resource_requirements(ctx, props[:resource_requirements])
+            synthesize_network_config(ctx, props[:network_configuration])
+            synthesize_fargate_config(ctx, props[:fargate_platform_configuration])
+          end
+
+          def synthesize_nodes(ctx, props)
+            ctx.main_node props[:main_node]
+            ctx.num_nodes props[:num_nodes]
+
+            props[:node_range_properties]&.each do |node_range|
+              ctx.node_range_properties do |nr|
+                nr.target_nodes node_range[:target_nodes]
+                synthesize_node_container(nr, node_range[:container]) if node_range[:container]
+              end
+            end
+          end
+
+          private
+
+          def synthesize_environment(ctx, env_vars)
+            return unless env_vars
+
+            env_vars.each do |env|
+              ctx.environment do |e|
+                e.name env[:name]
+                e.value env[:value]
+              end
+            end
+          end
+
+          def synthesize_mount_points(ctx, mounts)
+            return unless mounts
+
+            mounts.each do |mp|
+              ctx.mount_points do |m|
+                m.source_volume mp[:source_volume]
+                m.container_path mp[:container_path]
+                m.read_only mp[:read_only] if mp.key?(:read_only)
+              end
+            end
+          end
+
+          def synthesize_volumes(ctx, volumes)
+            return unless volumes
+
+            volumes.each { |vol| synthesize_single_volume(ctx, vol) }
+          end
+
+          def synthesize_single_volume(ctx, vol)
+            ctx.volumes do |v|
+              v.name vol[:name]
+              synthesize_host_config(v, vol[:host]) if vol[:host]
+              synthesize_efs_config(v, vol[:efs_volume_configuration]) if vol[:efs_volume_configuration]
+            end
+          end
+
+          def synthesize_host_config(ctx, host)
+            ctx.host do |h|
+              h.source_path host[:source_path] if host[:source_path]
+            end
+          end
+
+          def synthesize_efs_config(ctx, efs)
+            ctx.efs_volume_configuration do |e|
+              e.file_system_id efs[:file_system_id]
+              e.root_directory efs[:root_directory] if efs[:root_directory]
+              e.transit_encryption efs[:transit_encryption] if efs[:transit_encryption]
+              if efs[:authorization_config]
+                e.authorization_config do |a|
+                  a.access_point_id efs[:authorization_config][:access_point_id]
+                  a.iam efs[:authorization_config][:iam] if efs[:authorization_config][:iam]
+                end
+              end
+            end
+          end
+
+          def synthesize_resource_requirements(ctx, reqs)
+            return unless reqs
+
+            reqs.each do |req|
+              ctx.resource_requirements do |r|
+                r.type req[:type]
+                r.value req[:value]
+              end
+            end
+          end
+
+          def synthesize_network_config(ctx, config)
+            return unless config
+
+            ctx.network_configuration do |n|
+              n.assign_public_ip config[:assign_public_ip]
+            end
+          end
+
+          def synthesize_fargate_config(ctx, config)
+            return unless config
+
+            ctx.fargate_platform_configuration do |f|
+              f.platform_version config[:platform_version]
+            end
+          end
+
+          def synthesize_node_container(ctx, container)
+            ctx.container do |c|
+              c.image container[:image]
+              c.vcpus container[:vcpus] if container[:vcpus]
+              c.memory container[:memory] if container[:memory]
+              c.job_role_arn container[:job_role_arn] if container[:job_role_arn]
+              container[:environment]&.each do |env|
+                c.environment do |e|
+                  e.name env[:name]
+                  e.value env[:value]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_batch_job_definition/types/computed.rb

@@ -0,0 +1,64 @@
+# 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 Types
+        class BatchJobDefinitionAttributes
+          # Computed properties for batch job definitions
+          module Computed
+            def container_job?
+              self[:type] == 'container'
+            end
+
+            alias is_container_job? container_job?
+
+            def multinode_job?
+              self[:type] == 'multinode'
+            end
+
+            alias is_multinode_job? multinode_job?
+
+            def supports_ec2?
+              platform_capabilities.nil? || platform_capabilities.include?('EC2')
+            end
+
+            def supports_fargate?
+              platform_capabilities&.include?('FARGATE') || false
+            end
+
+            def has_retry_strategy?
+              !retry_strategy.nil?
+            end
+
+            def has_timeout?
+              !timeout.nil?
+            end
+
+            def estimated_memory_mb
+              container_properties&.dig(:memory)
+            end
+
+            def estimated_vcpus
+              container_properties&.dig(:vcpus)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_batch_job_definition/types/configurations.rb

@@ -0,0 +1,75 @@
+# 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 Types
+        class BatchJobDefinitionAttributes
+          # Common container configurations
+          module Configurations
+            def standard_environment_variables(options = {})
+              base_vars = [
+                { name: 'AWS_DEFAULT_REGION', value: options[:region] || 'us-east-1' },
+                { name: 'BATCH_JOB_ID', value: '${AWS_BATCH_JOB_ID}' },
+                { name: 'BATCH_JOB_ATTEMPT', value: '${AWS_BATCH_JOB_ATTEMPT}' }
+              ]
+
+              base_vars.concat(options[:custom_vars]) if options[:custom_vars]
+
+              base_vars
+            end
+
+            def common_resource_requirements(gpu_count = nil)
+              requirements = []
+
+              requirements << { type: 'GPU', value: gpu_count.to_s } if gpu_count
+
+              requirements
+            end
+
+            def efs_volume(volume_name, file_system_id, options = {})
+              {
+                name: volume_name,
+                efs_volume_configuration: {
+                  file_system_id: file_system_id,
+                  root_directory: options[:root_directory] || '/',
+                  transit_encryption: options[:transit_encryption] || 'ENABLED',
+                  authorization_config: options[:authorization_config]
+                }.compact
+              }
+            end
+
+            def host_volume(volume_name, host_path)
+              {
+                name: volume_name,
+                host: { source_path: host_path }
+              }
+            end
+
+            def standard_mount_point(volume_name, container_path, read_only = false)
+              {
+                source_volume: volume_name,
+                container_path: container_path,
+                read_only: read_only
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end