aws-insight 0.14.0

data/lib/terraforming/resource/alb.rb

@@ -0,0 +1,98 @@
+module Terraforming
+  module Resource
+    class ALB
+      include Terraforming::Util
+
+      def self.tf(client: Aws::ElasticLoadBalancingV2::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::ElasticLoadBalancingV2::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/alb")
+      end
+
+      def tfstate
+        load_balancers.inject({}) do |resources, load_balancer|
+          load_balancer_attributes = load_balancer_attributes_of(load_balancer)
+          attributes = {
+            "dns_name" => load_balancer.dns_name,
+            "enable_deletion_protection" => load_balancer_attributes["deletion_protection.enabled"].to_s,
+            "id" => load_balancer.load_balancer_arn,
+            "idle_timeout" => load_balancer_attributes["idle_timeout.timeout_seconds"].to_s,
+            "internal" => internal?(load_balancer).to_s,
+            "name" => load_balancer.load_balancer_name,
+            "security_groups.#" => load_balancer.security_groups.length.to_s,
+            "subnets.#" => load_balancer.availability_zones.length.to_s,
+            "zone_id" => load_balancer.canonical_hosted_zone_id,
+          }
+
+          attributes.merge!(access_logs_attributes_of(load_balancer_attributes))
+          attributes.merge!(tag_attributes_of(load_balancer))
+
+          resources["aws_alb.#{module_name_of(load_balancer)}"] = {
+            "type" => "aws_alb",
+            "primary" => {
+              "id" => load_balancer.load_balancer_arn,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def access_logs_attributes_of(load_balancer_attributes)
+        {
+          "access_logs.#" => "1",
+          "access_logs.0.bucket" => load_balancer_attributes["access_logs.s3.bucket"],
+          "access_logs.0.enabled" => load_balancer_attributes["access_logs.s3.enabled"].to_s,
+          "access_logs.0.prefix" => load_balancer_attributes["access_logs.s3.prefix"],
+        }
+      end
+
+      def internal?(load_balancer)
+        load_balancer.scheme == "internal"
+      end
+
+      def load_balancers
+        @client.describe_load_balancers.load_balancers
+      end
+
+      def load_balancer_attributes_of(load_balancer)
+        @client.describe_load_balancer_attributes(load_balancer_arn: load_balancer.load_balancer_arn).attributes.inject({}) do |result, attribute|
+          result[attribute.key] = attribute.value
+          result
+        end
+      end
+
+      def module_name_of(load_balancer)
+        normalize_module_name(load_balancer.load_balancer_name)
+      end
+
+      def tag_attributes_of(load_balancer)
+        tags = tags_of(load_balancer)
+        attributes = { "tags.%" => tags.length.to_s }
+
+        tags.each do |tag|
+          attributes["tags.#{tag.key}"] = tag.value
+        end
+
+        attributes
+      end
+
+      def tags_of(load_balancer)
+        @client.describe_tags(resource_arns: [load_balancer.load_balancer_arn]).tag_descriptions.first.tags
+      end
+    end
+  end
+end

data/lib/terraforming/resource/auto_scaling_group.rb

@@ -0,0 +1,90 @@
+module Terraforming
+  module Resource
+    class AutoScalingGroup
+      include Terraforming::Util
+
+      def self.tf(client: Aws::AutoScaling::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::AutoScaling::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/auto_scaling_group")
+      end
+
+      def tfstate
+        auto_scaling_groups.inject({}) do |resources, group|
+          vpc_zone_specified = vpc_zone_specified?(group)
+
+          attributes = {
+            "availability_zones.#" => vpc_zone_specified ? "0" : group.availability_zones.length.to_s,
+            "default_cooldown" => "300",
+            "desired_capacity" => group.desired_capacity.to_s,
+            "health_check_grace_period" => group.health_check_grace_period.to_s,
+            "health_check_type" => group.health_check_type,
+            "id" => group.auto_scaling_group_name,
+            "launch_configuration" => group.launch_configuration_name,
+            "load_balancers.#" => "0",
+            "max_size" => group.max_size.to_s,
+            "min_size" => group.min_size.to_s,
+            "name" => group.auto_scaling_group_name,
+            "tag.#" => group.tags.length.to_s,
+            "termination_policies.#" => "0",
+            "vpc_zone_identifier.#" => vpc_zone_specified ? vpc_zone_identifier_of(group).length.to_s : "0",
+          }
+
+          group.tags.each do |tag|
+            hashcode = tag_hashcode_of(tag)
+            attributes.merge!({
+              "tag.#{hashcode}.key" => tag.key,
+              "tag.#{hashcode}.propagate_at_launch" => tag.propagate_at_launch.to_s,
+              "tag.#{hashcode}.value" => tag.value,
+            })
+          end
+
+          resources["aws_autoscaling_group.#{module_name_of(group)}"] = {
+            "type" => "aws_autoscaling_group",
+            "primary" => {
+              "id" => group.auto_scaling_group_name,
+              "attributes" => attributes,
+              "meta" => {
+                "schema_version" => "1"
+              }
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def auto_scaling_groups
+        @client.describe_auto_scaling_groups.map(&:auto_scaling_groups).flatten
+      end
+
+      def module_name_of(group)
+        normalize_module_name(group.auto_scaling_group_name)
+      end
+
+      def tag_hashcode_of(tag)
+        Zlib.crc32("#{tag.key}-#{tag.value}-#{tag.propagate_at_launch}-")
+      end
+
+      def vpc_zone_identifier_of(group)
+        group.vpc_zone_identifier.split(",")
+      end
+
+      def vpc_zone_specified?(group)
+        group.vpc_zone_identifier && !vpc_zone_identifier_of(group).empty?
+      end
+    end
+  end
+end

data/lib/terraforming/resource/cloud_watch_alarm.rb

@@ -0,0 +1,87 @@
+module Terraforming
+  module Resource
+    class CloudWatchAlarm
+      include Terraforming::Util
+
+      def self.tf(client: Aws::CloudWatch::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::CloudWatch::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/cloud_watch_alarm")
+      end
+
+      def tfstate
+        alarms.inject({}) do |resources, alarm|
+          resources["aws_cloudwatch_metric_alarm.#{module_name_of(alarm)}"] = {
+            "type" => "aws_cloudwatch_metric_alarm",
+            "primary" => {
+              "id" => alarm.alarm_name,
+              "attributes" => alarm_attributes(alarm)
+            }
+          }
+          resources
+        end
+      end
+
+      private
+
+      def alarm_attributes(alarm)
+        attributes = {
+          "actions_enabled" => alarm.actions_enabled.to_s,
+          "alarm_description" => sanitize(alarm.alarm_description),
+          "alarm_name" => alarm.alarm_name,
+          "comparison_operator" => alarm.comparison_operator,
+          "evaluation_periods" => alarm.evaluation_periods.to_s,
+          "id" => alarm.alarm_name,
+          "metric_name" => alarm.metric_name,
+          "namespace" => alarm.namespace,
+          "period" => alarm.period.to_s,
+          "statistic" => alarm.statistic,
+          "threshold" => alarm.threshold.to_s,
+          "unit" => sanitize(alarm.unit)
+        }
+        add_checksummed_attributes(attributes, alarm)
+      end
+
+      def alarms
+        @client.describe_alarms.map(&:metric_alarms).flatten
+      end
+
+      def module_name_of(alarm)
+        normalize_module_name(alarm.alarm_name)
+      end
+
+      def sanitize(argument)
+        argument.nil? ? "" : argument
+      end
+
+      def add_checksummed_attributes(attributes, alarm)
+        %w(insufficient_data_actions alarm_actions ok_actions dimensions).each do |action|
+          attribute = alarm.send(action.to_sym)
+          attributes["#{action}.#"] = attribute.size.to_s
+          attribute.each do |attr|
+            if attr.is_a? String
+              checksum = Zlib.crc32(attr)
+              value = attr
+            else
+              checksum = attr.name
+              value = attr.value
+            end
+            attributes["#{action}.#{checksum}"] = value
+          end
+        end
+
+        attributes
+      end
+    end
+  end
+end

data/lib/terraforming/resource/config.rb

@@ -0,0 +1,98 @@
+module Terraforming
+  module Resource
+    class Config
+      include Terraforming::Util
+
+      def self.tf(client: Aws::ElasticLoadBalancingV2::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::ElasticLoadBalancingV2::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/alb")
+      end
+
+      def tfstate
+        load_balancers.inject({}) do |resources, load_balancer|
+          load_balancer_attributes = load_balancer_attributes_of(load_balancer)
+          attributes = {
+            "dns_name" => load_balancer.dns_name,
+            "enable_deletion_protection" => load_balancer_attributes["deletion_protection.enabled"].to_s,
+            "id" => load_balancer.load_balancer_arn,
+            "idle_timeout" => load_balancer_attributes["idle_timeout.timeout_seconds"].to_s,
+            "internal" => internal?(load_balancer).to_s,
+            "name" => load_balancer.load_balancer_name,
+            "security_groups.#" => load_balancer.security_groups.length.to_s,
+            "subnets.#" => load_balancer.availability_zones.length.to_s,
+            "zone_id" => load_balancer.canonical_hosted_zone_id,
+          }
+
+          attributes.merge!(access_logs_attributes_of(load_balancer_attributes))
+          attributes.merge!(tag_attributes_of(load_balancer))
+
+          resources["aws_alb.#{module_name_of(load_balancer)}"] = {
+            "type" => "aws_alb",
+            "primary" => {
+              "id" => load_balancer.load_balancer_arn,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def access_logs_attributes_of(load_balancer_attributes)
+        {
+          "access_logs.#" => "1",
+          "access_logs.0.bucket" => load_balancer_attributes["access_logs.s3.bucket"],
+          "access_logs.0.enabled" => load_balancer_attributes["access_logs.s3.enabled"].to_s,
+          "access_logs.0.prefix" => load_balancer_attributes["access_logs.s3.prefix"],
+        }
+      end
+
+      def internal?(load_balancer)
+        load_balancer.scheme == "internal"
+      end
+
+      def load_balancers
+        @client.describe_load_balancers.load_balancers
+      end
+
+      def load_balancer_attributes_of(load_balancer)
+        @client.describe_load_balancer_attributes(load_balancer_arn: load_balancer.load_balancer_arn).attributes.inject({}) do |result, attribute|
+          result[attribute.key] = attribute.value
+          result
+        end
+      end
+
+      def module_name_of(load_balancer)
+        normalize_module_name(load_balancer.load_balancer_name)
+      end
+
+      def tag_attributes_of(load_balancer)
+        tags = tags_of(load_balancer)
+        attributes = { "tags.%" => tags.length.to_s }
+
+        tags.each do |tag|
+          attributes["tags.#{tag.key}"] = tag.value
+        end
+
+        attributes
+      end
+
+      def tags_of(load_balancer)
+        @client.describe_tags(resource_arns: [load_balancer.load_balancer_arn]).tag_descriptions.first.tags
+      end
+    end
+  end
+end

data/lib/terraforming/resource/db_parameter_group.rb

@@ -0,0 +1,58 @@
+module Terraforming
+  module Resource
+    class DBParameterGroup
+      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_parameter_group")
+      end
+
+      def tfstate
+        db_parameter_groups.inject({}) do |resources, parameter_group|
+          attributes = {
+            "description" => parameter_group.description,
+            "family" => parameter_group.db_parameter_group_family,
+            "id" => parameter_group.db_parameter_group_name,
+            "name" => parameter_group.db_parameter_group_name,
+            "parameter.#" => db_parameters_in(parameter_group).length.to_s
+          }
+          resources["aws_db_parameter_group.#{module_name_of(parameter_group)}"] = {
+            "type" => "aws_db_parameter_group",
+            "primary" => {
+              "id" => parameter_group.db_parameter_group_name,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def db_parameter_groups
+        @client.describe_db_parameter_groups.map(&:db_parameter_groups).flatten
+      end
+
+      def db_parameters_in(parameter_group)
+        @client.describe_db_parameters(db_parameter_group_name: parameter_group.db_parameter_group_name).map(&:parameters).flatten
+      end
+
+      def module_name_of(parameter_group)
+        normalize_module_name(parameter_group.db_parameter_group_name)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/db_security_group.rb

@@ -0,0 +1,57 @@
+module Terraforming
+  module Resource
+    class DBSecurityGroup
+      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_security_group")
+      end
+
+      def tfstate
+        db_security_groups.inject({}) do |resources, security_group|
+          attributes = {
+            "db_subnet_group_name" => security_group.db_security_group_name,
+            "id" => security_group.db_security_group_name,
+            "ingress.#" => ingresses_of(security_group).length.to_s,
+            "name" => security_group.db_security_group_name,
+          }
+          resources["aws_db_security_group.#{module_name_of(security_group)}"] = {
+            "type" => "aws_db_security_group",
+            "primary" => {
+              "id" => security_group.db_security_group_name,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def ingresses_of(security_group)
+        security_group.ec2_security_groups + security_group.ip_ranges
+      end
+
+      def db_security_groups
+        @client.describe_db_security_groups.map(&:db_security_groups).flatten.select { |sg| !ingresses_of(sg).empty? }
+      end
+
+      def module_name_of(security_group)
+        normalize_module_name(security_group.db_security_group_name)
+      end
+    end
+  end
+end