aws-insight 0.14.0

data/lib/terraforming/resource/db_subnet_group.rb

@@ -0,0 +1,52 @@
+module Terraforming
+  module Resource
+    class DBSubnetGroup
+      include Terraforming::Util
+
+      def self.tf(client: Aws::RDS::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::RDS::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/db_subnet_group")
+      end
+
+      def tfstate
+        db_subnet_groups.inject({}) do |resources, subnet_group|
+          attributes = {
+            "description" => subnet_group.db_subnet_group_description,
+            "name" => subnet_group.db_subnet_group_name,
+            "subnet_ids.#" => subnet_group.subnets.length.to_s
+          }
+          resources["aws_db_subnet_group.#{module_name_of(subnet_group)}"] = {
+            "type" => "aws_db_subnet_group",
+            "primary" => {
+              "id" => subnet_group.db_subnet_group_name,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def db_subnet_groups
+        @client.describe_db_subnet_groups.map(&:db_subnet_groups).flatten
+      end
+
+      def module_name_of(subnet_group)
+        normalize_module_name(subnet_group.db_subnet_group_name)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/ec2.rb

@@ -0,0 +1,130 @@
+module Terraforming
+  module Resource
+    class EC2
+      include Terraforming::Util
+
+      def self.tf(client: Aws::EC2::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/ec2")
+      end
+
+      def tfstate
+        instances.inject({}) do |resources, instance|
+          in_vpc = in_vpc?(instance)
+          block_devices = block_devices_of(instance)
+
+          attributes = {
+            "ami" => instance.image_id,
+            "associate_public_ip_address" => associate_public_ip?(instance).to_s,
+            "availability_zone" => instance.placement.availability_zone,
+            "ebs_block_device.#" => ebs_block_devices_in(block_devices, instance).length.to_s,
+            "ebs_optimized" => instance.ebs_optimized.to_s,
+            "ephemeral_block_device.#" => "0", # Terraform 0.6.1 cannot fetch this field from AWS
+            "id" => instance.instance_id,
+            "instance_type" => instance.instance_type,
+            "monitoring" => monitoring_state(instance).to_s,
+            "private_dns" => instance.private_dns_name,
+            "private_ip" => instance.private_ip_address,
+            "public_dns" => instance.public_dns_name,
+            "public_ip" => instance.public_ip_address,
+            "root_block_device.#" => root_block_devices_in(block_devices, instance).length.to_s,
+            "security_groups.#" => in_vpc ? "0" : instance.security_groups.length.to_s,
+            "source_dest_check" => instance.source_dest_check.to_s,
+            "tenancy" => instance.placement.tenancy,
+            "vpc_security_group_ids.#" => in_vpc ? instance.security_groups.length.to_s : "0",
+          }
+
+          placement_group = instance.placement.group_name
+          attributes["placement_group"] = placement_group unless placement_group.empty?
+
+          attributes["subnet_id"] = instance.subnet_id if in_vpc?(instance)
+
+          resources["aws_instance.#{module_name_of(instance)}"] = {
+            "type" => "aws_instance",
+            "primary" => {
+              "id" => instance.instance_id,
+              "attributes" => attributes,
+              "meta" => {
+                "schema_version" => "1"
+              }
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def block_device_ids_of(instance)
+        instance.block_device_mappings.map { |bdm| bdm.ebs.volume_id }
+      end
+
+      def block_devices_of(instance)
+        return [] if instance.block_device_mappings.empty?
+        @client.describe_volumes(volume_ids: block_device_ids_of(instance)).map(&:volumes).flatten
+      end
+
+      def block_device_mapping_of(instance, volume_id)
+        instance.block_device_mappings.select { |bdm| bdm.ebs.volume_id == volume_id }[0]
+      end
+
+      def ebs_block_devices_in(block_devices, instance)
+        block_devices.reject do |bd|
+          root_block_device?(block_device_mapping_of(instance, bd.volume_id), instance)
+        end
+      end
+
+      #
+      # NOTE(dtan4):
+      #   Original logic is here:
+      #     https://github.com/hashicorp/terraform/blob/281e4d3e67f66daab9cdb1f7c8b6f602d949e5ee/builtin/providers/aws/resource_aws_instance.go#L481-L501
+      #
+      def in_vpc?(instance)
+        !vpc_security_groups_of(instance).empty? ||
+          (instance.subnet_id && instance.subnet_id != "" && instance.security_groups.empty?)
+      end
+
+      def associate_public_ip?(instance)
+        !instance.public_ip_address.to_s.empty?
+      end
+
+      def monitoring_state(instance)
+        %w(enabled pending).include?(instance.monitoring.state)
+      end
+
+      def instances
+        @client.describe_instances.map(&:reservations).flatten.map(&:instances).flatten.reject do |instance|
+          instance.state.name == "terminated"
+        end
+      end
+
+      def module_name_of(instance)
+        normalize_module_name(name_from_tag(instance, instance.instance_id))
+      end
+
+      def root_block_device?(block_device_mapping, instance)
+        block_device_mapping.device_name == instance.root_device_name
+      end
+
+      def root_block_devices_in(block_devices, instance)
+        block_devices.select { |bd| root_block_device?(block_device_mapping_of(instance, bd.volume_id), instance) }
+      end
+
+      def vpc_security_groups_of(instance)
+        instance.security_groups.select { |security_group| /\Asg-/ =~ security_group.group_id }
+      end
+    end
+  end
+end

data/lib/terraforming/resource/efs_file_system.rb

@@ -0,0 +1,60 @@
+module Terraforming
+  module Resource
+    class EFSFileSystem
+      include Terraforming::Util
+
+      def self.tf(client: Aws::EFS::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::EFS::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/elastic_filesystem")
+      end
+
+      def tfstate
+        file_systems.inject({}) do |resources, efs|
+          attributes = {
+            "creation_token" => efs.creation_token,
+            "id" => efs.file_system_id,
+            "performance_mode" => efs.performance_mode,
+            "tags.%" => "1",
+            "tags.Name" => efs.name,
+          }
+
+          resources["aws_efs_file_system.#{module_name_of(efs)}"] = {
+            "type" => "aws_efs_file_system",
+            "depends_on" => [],
+            "primary" => {
+              "id" => efs.file_system_id,
+              "attributes" => attributes,
+              "meta" => {},
+              "tainted" => false,
+            },
+            "deposed" => [],
+            "provider" => "aws",
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def file_systems
+        @client.describe_file_systems.data.file_systems.flatten
+      end
+
+      def module_name_of(efs)
+        normalize_module_name(efs.file_system_id)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/eip.rb

@@ -0,0 +1,66 @@
+module Terraforming
+  module Resource
+    class EIP
+      include Terraforming::Util
+
+      def self.tf(client: Aws::EC2::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/eip")
+      end
+
+      def tfstate
+        eips.inject({}) do |resources, addr|
+          attributes = {
+            "association_id" => addr.association_id,
+            "domain" => addr.domain,
+            "id" => vpc?(addr) ? addr.allocation_id : addr.public_ip,
+            "instance" => addr.instance_id,
+            "network_interface" => addr.network_interface_id,
+            "private_ip" => addr.private_ip_address,
+            "public_ip" => addr.public_ip,
+            "vpc" => vpc?(addr).to_s,
+          }
+          attributes.delete_if { |_k, v| v.nil? }
+          resources["aws_eip.#{module_name_of(addr)}"] = {
+            "type" => "aws_eip",
+            "primary" => {
+              "id" => vpc?(addr) ? addr.allocation_id : addr.public_ip,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def eips
+        @client.describe_addresses.map(&:addresses).flatten
+      end
+
+      def vpc?(addr)
+        addr.domain.eql?("vpc")
+      end
+
+      def module_name_of(addr)
+        if vpc?(addr)
+          normalize_module_name(addr.allocation_id)
+        else
+          normalize_module_name(addr.public_ip)
+        end
+      end
+    end
+  end
+end

data/lib/terraforming/resource/elasti_cache_cluster.rb

@@ -0,0 +1,80 @@
+module Terraforming
+  module Resource
+    class ElastiCacheCluster
+      include Terraforming::Util
+
+      def self.tf(client: Aws::ElastiCache::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::ElastiCache::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/elasti_cache_cluster")
+      end
+
+      def tfstate
+        cache_clusters.inject({}) do |resources, cache_cluster|
+          attributes = {
+            "cache_nodes.#" => cache_cluster.cache_nodes.length.to_s,
+            "cluster_id" => cache_cluster.cache_cluster_id,
+            "engine" => cache_cluster.engine,
+            "engine_version" => cache_cluster.engine_version,
+            "id" => cache_cluster.cache_cluster_id,
+            "node_type" => cache_cluster.cache_node_type,
+            "num_cache_nodes" => "1",
+            "parameter_group_name" => cache_cluster.cache_parameter_group.cache_parameter_group_name,
+            "security_group_ids.#" => security_group_ids_of(cache_cluster).length.to_s,
+            "security_group_names.#" => security_group_names_of(cache_cluster).length.to_s,
+            "subnet_group_name" => cache_cluster.cache_subnet_group_name,
+            "tags.#" => "0",
+          }
+
+          attributes["port"] = if cache_cluster.configuration_endpoint
+                                 cache_cluster.configuration_endpoint.port.to_s
+                               else
+                                 cache_cluster.cache_nodes[0].endpoint.port.to_s
+                               end
+
+          resources["aws_elasticache_cluster.#{module_name_of(cache_cluster)}"] = {
+            "type" => "aws_elasticache_cluster",
+            "primary" => {
+              "id" => cache_cluster.cache_cluster_id,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def cache_clusters
+        @client.describe_cache_clusters(show_cache_node_info: true).map(&:cache_clusters).flatten
+      end
+
+      def cluster_in_vpc?(cache_cluster)
+        cache_cluster.cache_security_groups.empty?
+      end
+
+      def security_group_ids_of(cache_cluster)
+        cache_cluster.security_groups.map { |sg| sg.security_group_id }
+      end
+
+      def security_group_names_of(cache_cluster)
+        cache_cluster.cache_security_groups.map { |sg| sg.cache_security_group_name }
+      end
+
+      def module_name_of(cache_cluster)
+        normalize_module_name(cache_cluster.cache_cluster_id)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/elasti_cache_subnet_group.rb

@@ -0,0 +1,56 @@
+module Terraforming
+  module Resource
+    class ElastiCacheSubnetGroup
+      include Terraforming::Util
+
+      def self.tf(client: Aws::ElastiCache::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::ElastiCache::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/elasti_cache_subnet_group")
+      end
+
+      def tfstate
+        cache_subnet_groups.inject({}) do |resources, cache_subnet_group|
+          attributes = {
+            "description" => cache_subnet_group.cache_subnet_group_description,
+            "name" => cache_subnet_group.cache_subnet_group_name,
+            "subnet_ids.#" => subnet_ids_of(cache_subnet_group).length.to_s,
+          }
+          resources["aws_elasticache_subnet_group.#{module_name_of(cache_subnet_group)}"] = {
+            "type" => "aws_elasticache_subnet_group",
+            "primary" => {
+              "id" => cache_subnet_group.cache_subnet_group_name,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def cache_subnet_groups
+        @client.describe_cache_subnet_groups.map(&:cache_subnet_groups).flatten
+      end
+
+      def subnet_ids_of(cache_subnet_group)
+        cache_subnet_group.subnets.map { |sn| sn.subnet_identifier }
+      end
+
+      def module_name_of(cache_subnet_group)
+        normalize_module_name(cache_subnet_group.cache_subnet_group_name)
+      end
+    end
+  end
+end