aws-insight 0.14.0

data/lib/terraforming/resource/rds.rb

@@ -0,0 +1,74 @@
+module Terraforming
+  module Resource
+    class RDS
+      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/rds")
+      end
+
+      def tfstate
+        db_instances.inject({}) do |resources, instance|
+          attributes = {
+            "address" => instance.endpoint.address,
+            "allocated_storage" => instance.allocated_storage.to_s,
+            "availability_zone" => instance.availability_zone,
+            "backup_retention_period" => instance.backup_retention_period.to_s,
+            "backup_window" => instance.preferred_backup_window,
+            "db_subnet_group_name" => instance.db_subnet_group ? instance.db_subnet_group.db_subnet_group_name : "",
+            "endpoint" => instance.endpoint.address,
+            "engine" => instance.engine,
+            "engine_version" => instance.engine_version,
+            "final_snapshot_identifier" => "#{instance.db_instance_identifier}-final",
+            "id" => instance.db_instance_identifier,
+            "identifier" => instance.db_instance_identifier,
+            "instance_class" => instance.db_instance_class,
+            "maintenance_window" => instance.preferred_maintenance_window,
+            "multi_az" => instance.multi_az.to_s,
+            "name" => instance.db_name,
+            "parameter_group_name" => instance.db_parameter_groups[0].db_parameter_group_name,
+            "password" => "xxxxxxxx",
+            "port" => instance.endpoint.port.to_s,
+            "publicly_accessible" => instance.publicly_accessible.to_s,
+            "security_group_names.#" => instance.db_security_groups.length.to_s,
+            "status" => instance.db_instance_status,
+            "storage_type" => instance.storage_type,
+            "username" => instance.master_username,
+            "vpc_security_group_ids.#" => instance.vpc_security_groups.length.to_s,
+          }
+          resources["aws_db_instance.#{module_name_of(instance)}"] = {
+            "type" => "aws_db_instance",
+            "primary" => {
+              "id" => instance.db_instance_identifier,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def db_instances
+        @client.describe_db_instances.map(&:db_instances).flatten
+      end
+
+      def module_name_of(instance)
+        normalize_module_name(instance.db_instance_identifier)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/redshift.rb

@@ -0,0 +1,67 @@
+module Terraforming
+  module Resource
+    class Redshift
+      include Terraforming::Util
+
+      def self.tf(client: Aws::Redshift::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::Redshift::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/redshift")
+      end
+
+      def tfstate
+        clusters.inject({}) do |resources, cluster|
+          attributes = {
+            "cluster_identifier"                  => cluster.cluster_identifier,
+            "cluster_type"                        => cluster.number_of_nodes == 1 ? "single-node" : "multi-node",
+            "node_type"                           => cluster.node_type,
+            "master_password"                     => "xxxxxxxx",
+            "master_username"                     => cluster.master_username,
+            "availability_zone"                   => cluster.availability_zone,
+            "preferred_maintenance_window"        => cluster.preferred_maintenance_window,
+            "cluster_parameter_group_name"        => cluster.cluster_parameter_groups[0].parameter_group_name,
+            "automated_snapshot_retention_period" => cluster.automated_snapshot_retention_period.to_s,
+            "port"                                => cluster.endpoint.port.to_s,
+            "cluster_version"                     => cluster.cluster_version,
+            "allow_version_upgrade"               => cluster.allow_version_upgrade.to_s,
+            "number_of_nodes"                     => cluster.number_of_nodes.to_s,
+            "publicly_accessible"                 => cluster.publicly_accessible.to_s,
+            "encrypted"                           => cluster.encrypted.to_s,
+            "skip_final_snapshot"                 => "true",
+          }
+          attributes["database_name"] = cluster.db_name if cluster.db_name
+
+          resources["aws_redshift_cluster.#{module_name_of(cluster)}"] = {
+            "type" => "aws_redshift_cluster",
+            "primary" => {
+              "id" => cluster.cluster_identifier,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def clusters
+        @client.describe_clusters.map(&:clusters).flatten
+      end
+
+      def module_name_of(cluster)
+        normalize_module_name(cluster.cluster_identifier)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/route53_record.rb

@@ -0,0 +1,106 @@
+module Terraforming
+  module Resource
+    class Route53Record
+      include Terraforming::Util
+
+      def self.tf(client: Aws::Route53::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::Route53::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/route53_record")
+      end
+
+      def tfstate
+        records.inject({}) do |resources, r|
+          record, zone_id = r[:record], r[:zone_id]
+          counter = r[:counter]
+          record_id = record_id_of(record, zone_id)
+
+          attributes = {
+            "id" => record_id,
+            "name" => name_of(record.name.gsub(/\\052/, '*')),
+            "type" => record.type,
+            "zone_id" => zone_id,
+          }
+
+          attributes["alias.#"] = "1" if record.alias_target
+          attributes["records.#"] = record.resource_records.length.to_s unless record.resource_records.empty?
+          attributes["ttl"] = record.ttl.to_s if record.ttl
+          attributes["weight"] = record.weight ? record.weight.to_s : "-1"
+          attributes["region"] = record.region if record.region
+
+          if record.geo_location
+            attributes["continent"] = record.geo_location.continent_code if record.geo_location.continent_code
+            attributes["country"] = record.geo_location.country_code if record.geo_location.country_code
+            attributes["subdivision"] = record.geo_location.subdivision_code if record.geo_location.subdivision_code
+          end
+
+          attributes["set_identifier"] = record.set_identifier if record.set_identifier
+
+          resources["aws_route53_record.#{module_name_of(record, counter)}"] = {
+            "type" => "aws_route53_record",
+            "primary" => {
+              "id" => record_id,
+              "attributes" => attributes,
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def hosted_zones
+        @client.list_hosted_zones.map(&:hosted_zones).flatten
+      end
+
+      def record_id_of(record, zone_id)
+        "#{zone_id}_#{name_of(record.name.gsub(/\\052/, '*'))}_#{record.type}"
+      end
+
+      def record_sets_of(hosted_zone)
+        @client.list_resource_record_sets(hosted_zone_id: zone_id_of(hosted_zone)).map do |response|
+          response.data.resource_record_sets
+        end.flatten
+      end
+
+      def records
+        to_return = hosted_zones.map do |hosted_zone|
+          record_sets_of(hosted_zone).map { |record| { record: record, zone_id: zone_id_of(hosted_zone) } }
+        end.flatten
+        count = {}
+        dups = to_return.group_by { |record| module_name_of(record[:record], nil) }.select { |_, v| v.size > 1 }.map(&:first)
+        to_return.each do |r|
+          module_name = module_name_of(r[:record], nil)
+          next unless dups.include?(module_name)
+          count[module_name] = count[module_name] ? count[module_name] + 1 : 0
+          r[:counter] = count[module_name]
+        end
+        to_return
+      end
+
+      # TODO(dtan4): change method name...
+      def name_of(dns_name)
+        dns_name.gsub(/\.\z/, "")
+      end
+
+      def module_name_of(record, counter)
+        normalize_module_name(name_of(record.name.gsub(/\\052/, 'wildcard')) + "-" + record.type + (!counter.nil? ? "-" + counter.to_s : ""))
+      end
+
+      def zone_id_of(hosted_zone)
+        hosted_zone.id.gsub(%r{\A/hostedzone/}, "")
+      end
+    end
+  end
+end

data/lib/terraforming/resource/route53_zone.rb

@@ -0,0 +1,89 @@
+module Terraforming
+  module Resource
+    class Route53Zone
+      include Terraforming::Util
+
+      def self.tf(client: Aws::Route53::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::Route53::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/route53_zone")
+      end
+
+      def tfstate
+        hosted_zones.inject({}) do |resources, hosted_zone|
+          zone_id = zone_id_of(hosted_zone)
+          vpc = vpc_of(hosted_zone)
+
+          attributes = {
+            "comment" => comment_of(hosted_zone),
+            "id" => zone_id,
+            "name" => name_of(hosted_zone),
+            "name_servers.#" => name_servers_of(hosted_zone).length.to_s,
+            "tags.#" => tags_of(hosted_zone).length.to_s,
+            "vpc_id" => vpc ? vpc.vpc_id : "",
+            "vpc_region" => vpc ? vpc.vpc_region : "",
+            "zone_id" => zone_id,
+          }
+          resources["aws_route53_zone.#{module_name_of(hosted_zone)}"] = {
+            "type" => "aws_route53_zone",
+            "primary" => {
+              "id" => zone_id,
+              "attributes" => attributes,
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def hosted_zones
+        @client.list_hosted_zones.map(&:hosted_zones).flatten.map { |hosted_zone| @client.get_hosted_zone(id: hosted_zone.id) }
+      end
+
+      def tags_of(hosted_zone)
+        @client.list_tags_for_resource(resource_type: "hostedzone", resource_id: zone_id_of(hosted_zone)).resource_tag_set.tags
+      end
+
+      def comment_of(hosted_zone)
+        hosted_zone.hosted_zone.config.comment
+      end
+
+      def name_of(hosted_zone)
+        hosted_zone.hosted_zone.name.gsub(/\.\z/, "")
+      end
+
+      def name_servers_of(hosted_zone)
+        delegation_set = hosted_zone.delegation_set
+        delegation_set ? delegation_set.name_servers : []
+      end
+
+      def module_name_of(hosted_zone)
+        normalize_module_name(name_of(hosted_zone)) << "-#{private_hosted_zone?(hosted_zone) ? 'private' : 'public'}"
+      end
+
+      def private_hosted_zone?(hosted_zone)
+        hosted_zone.hosted_zone.config.private_zone
+      end
+
+      def vpc_of(hosted_zone)
+        hosted_zone.vp_cs[0]
+      end
+
+      def zone_id_of(hosted_zone)
+        hosted_zone.hosted_zone.id.gsub(%r{\A/hostedzone/}, "")
+      end
+    end
+  end
+end

data/lib/terraforming/resource/route_table.rb

@@ -0,0 +1,122 @@
+module Terraforming
+  module Resource
+    class RouteTable
+      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/route_table")
+      end
+
+      def tfstate
+        route_tables.inject({}) do |resources, route_table|
+          attributes = {
+            "id" => route_table.route_table_id,
+            "vpc_id" => route_table.vpc_id,
+          }
+
+          attributes.merge!(tags_attributes_of(route_table))
+          attributes.merge!(routes_attributes_of(route_table))
+          attributes.merge!(propagating_vgws_attributes_of(route_table))
+
+          resources["aws_route_table.#{module_name_of(route_table)}"] = {
+            "type" => "aws_route_table",
+            "primary" => {
+              "id" => route_table.route_table_id,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def routes_of(route_table)
+        route_table.routes.reject do |route|
+          route.gateway_id.to_s == 'local' ||
+            route.origin.to_s == 'EnableVgwRoutePropagation' ||
+            route.destination_prefix_list_id
+        end
+      end
+
+      def module_name_of(route_table)
+        normalize_module_name(name_from_tag(route_table, route_table.route_table_id))
+      end
+
+      def route_tables
+        @client.describe_route_tables.map(&:route_tables).flatten
+      end
+
+      def routes_attributes_of(route_table)
+        routes = routes_of(route_table)
+        attributes = { "route.#" => routes.length.to_s }
+
+        routes.each do |route|
+          attributes.merge!(route_attributes_of(route))
+        end
+
+        attributes
+      end
+
+      def route_attributes_of(route)
+        hashcode = route_hashcode_of(route)
+        attributes = {
+          "route.#{hashcode}.cidr_block" => route.destination_cidr_block.to_s,
+          "route.#{hashcode}.gateway_id" => route.gateway_id.to_s,
+          "route.#{hashcode}.instance_id" => route.instance_id.to_s,
+          "route.#{hashcode}.network_interface_id" => route.network_interface_id.to_s,
+          "route.#{hashcode}.vpc_peering_connection_id" => route.vpc_peering_connection_id.to_s
+        }
+
+        attributes
+      end
+
+      def route_hashcode_of(route)
+        string = "#{route.destination_cidr_block}-#{route.gateway_id}-"
+        instance_set = !route.instance_id.nil? && route.instance_id != ''
+
+        string << route.instance_id.to_s if instance_set
+        string << route.vpc_peering_connection_id.to_s
+        string << route.network_interface_id.to_s unless instance_set
+
+        Zlib.crc32(string)
+      end
+
+      def propagaving_vgws_of(route_table)
+        route_table.propagating_vgws.map(&:gateway_id).map(&:to_s)
+      end
+
+      def propagating_vgws_attributes_of(route_table)
+        vgws = propagaving_vgws_of(route_table)
+        attributes = { "propagating_vgws.#" => vgws.length.to_s }
+
+        vgws.each do |gateway_id|
+          hashcode = Zlib.crc32(gateway_id)
+          attributes["propagating_vgws.#{hashcode}"] = gateway_id
+        end
+
+        attributes
+      end
+
+      def tags_attributes_of(route_table)
+        tags = route_table.tags
+        attributes = { "tags.#" => tags.length.to_s }
+        tags.each { |tag| attributes["tags.#{tag.key}"] = tag.value }
+        attributes
+      end
+    end
+  end
+end