terraforming 0.0.1

data/lib/terraforming/resource/db_subnet_group.rb

@@ -0,0 +1,52 @@
+module Terraforming::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
+      resources = db_subnet_groups.inject({}) do |result, 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
+        }
+        result["aws_db_subnet_group.#{module_name_of(subnet_group)}"] = {
+          "type" => "aws_db_subnet_group",
+          "primary" => {
+            "id" => subnet_group.db_subnet_group_name,
+            "attributes" => attributes
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def db_subnet_groups
+      @client.describe_db_subnet_groups.db_subnet_groups
+    end
+
+    def module_name_of(subnet_group)
+      normalize_module_name(subnet_group.db_subnet_group_name)
+    end
+  end
+end

data/lib/terraforming/resource/ec2.rb

@@ -0,0 +1,69 @@
+module Terraforming::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
+      resources = instances.inject({}) do |result, instance|
+        attributes = {
+          "ami"=> instance.image_id,
+          "associate_public_ip_address"=> "true",
+          "availability_zone"=> instance.placement.availability_zone,
+          "ebs_block_device.#"=> instance.block_device_mappings.length.to_s,
+          "ebs_optimized"=> instance.ebs_optimized.to_s,
+          "ephemeral_block_device.#"=> "0",
+          "id"=> instance.instance_id,
+          "instance_type"=> instance.instance_type,
+          "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.#"=> instance.root_device_name ? "1" : "0",
+          "security_groups.#"=> instance.security_groups.length.to_s,
+          "source_dest_check"=> instance.source_dest_check.to_s,
+          "subnet_id"=> instance.subnet_id,
+          "tenancy"=> instance.placement.tenancy
+        }
+        result["aws_instance.#{module_name_of(instance)}"] = {
+          "type" => "aws_instance",
+          "primary" => {
+            "id" => instance.instance_id,
+            "attributes" => attributes,
+            "meta" => {
+              "schema_version" => "1"
+            }
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def instances
+      @client.describe_instances.reservations.map(&:instances).flatten
+    end
+
+    def module_name_of(instance)
+      normalize_module_name(name_from_tag(instance, instance.instance_id))
+    end
+  end
+end

data/lib/terraforming/resource/elb.rb

@@ -0,0 +1,56 @@
+module Terraforming::Resource
+  class ELB
+    include Terraforming::Util
+
+    def self.tf(client = Aws::ElasticLoadBalancing::Client.new)
+      self.new(client).tf
+    end
+
+    def self.tfstate(client = Aws::ElasticLoadBalancing::Client.new)
+      self.new(client).tfstate
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    def tf
+      apply_template(@client, "tf/elb")
+    end
+
+    def tfstate
+      resources = load_balancers.inject({}) do |result, load_balancer|
+        attributes = {
+          "availability_zones.#" => load_balancer.availability_zones.length.to_s,
+          "dns_name" => load_balancer.dns_name,
+          "health_check.#" => "1",
+          "id" => load_balancer.load_balancer_name,
+          "instances.#" => load_balancer.instances.length.to_s,
+          "listener.#" => load_balancer.listener_descriptions.length.to_s,
+          "name" => load_balancer.load_balancer_name,
+          "security_groups.#" => load_balancer.security_groups.length.to_s,
+          "subnets.#" => load_balancer.subnets.length.to_s,
+        }
+        result["aws_elb.#{module_name_of(load_balancer)}"] = {
+          "type" => "aws_elb",
+          "primary" => {
+            "id" => load_balancer.load_balancer_name,
+            "attributes" => attributes
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    def load_balancers
+      @client.describe_load_balancers.load_balancer_descriptions
+    end
+
+    def module_name_of(load_balancer)
+      normalize_module_name(load_balancer.load_balancer_name)
+    end
+  end
+end

data/lib/terraforming/resource/rds.rb

@@ -0,0 +1,74 @@
+module Terraforming::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
+      resources = db_instances.inject({}) do |result, 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,
+        }
+        result["aws_db_instance.#{module_name_of(instance)}"] = {
+          "type" => "aws_db_instance",
+          "primary" => {
+            "id" => instance.db_instance_identifier,
+            "attributes" => attributes
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def db_instances
+      @client.describe_db_instances.db_instances
+    end
+
+    def module_name_of(instance)
+      normalize_module_name(instance.db_instance_identifier)
+    end
+  end
+end

data/lib/terraforming/resource/s3.rb

@@ -0,0 +1,51 @@
+module Terraforming::Resource
+  class S3
+    include Terraforming::Util
+
+    def self.tf(client = Aws::S3::Client.new)
+      self.new(client).tf
+    end
+
+    def self.tfstate(client = Aws::S3::Client.new)
+      self.new(client).tfstate
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    def tf
+      apply_template(@client, "tf/s3")
+    end
+
+    def tfstate
+      resources = buckets.inject({}) do |result, bucket|
+        result["aws_s3_bucket.#{module_name_of(bucket)}"] = {
+          "type" => "aws_s3_bucket",
+          "primary" => {
+            "id" => bucket.name,
+            "attributes" => {
+              "acl" => "private",
+              "bucket" => bucket.name,
+              "id" => bucket.name
+            }
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def buckets
+      @client.list_buckets.buckets
+    end
+
+    def module_name_of(bucket)
+      normalize_module_name(bucket.name)
+    end
+  end
+end

data/lib/terraforming/resource/security_group.rb

@@ -0,0 +1,56 @@
+module Terraforming::Resource
+  class SecurityGroup
+    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/security_group")
+    end
+
+    def tfstate
+      resources = security_groups.inject({}) do |result, security_group|
+        attributes = {
+          "description" => security_group.description,
+          "egress.#" => security_group.ip_permissions_egress.length.to_s,
+          "id" => security_group.group_id,
+          "ingress.#" => security_group.ip_permissions.length.to_s,
+          "name" => security_group.group_name,
+          "owner_id" => security_group.owner_id,
+          "vpc_id" => security_group.vpc_id || "",
+        }
+        result["aws_security_group.#{module_name_of(security_group)}"] = {
+          "type" => "aws_security_group",
+          "primary" => {
+            "id" => security_group.group_id,
+            "attributes" => attributes
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def module_name_of(security_group)
+      normalize_module_name(security_group.group_name)
+    end
+
+    def security_groups
+      @client.describe_security_groups.security_groups
+    end
+  end
+end

data/lib/terraforming/resource/subnet.rb

@@ -0,0 +1,55 @@
+module Terraforming::Resource
+  class Subnet
+    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/subnet")
+    end
+
+    def tfstate
+      resources = subnets.inject({}) do |result, subnet|
+        attributes = {
+          "availability_zone" => subnet.availability_zone,
+          "cidr_block" => subnet.cidr_block,
+          "id" => subnet.subnet_id,
+          "map_public_ip_on_launch" => subnet.map_public_ip_on_launch.to_s,
+          "tags.#" => subnet.tags.length.to_s,
+          "vpc_id" => subnet.vpc_id,
+        }
+        result["aws_subnet.#{module_name_of(subnet)}"] = {
+          "type" => "aws_subnet",
+          "primary" => {
+            "id" => subnet.subnet_id,
+            "attributes" => attributes
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def subnets
+      @client.describe_subnets.subnets
+    end
+
+    def module_name_of(subnet)
+      normalize_module_name(name_from_tag(subnet, subnet.subnet_id))
+    end
+  end
+end

data/lib/terraforming/resource/vpc.rb

@@ -0,0 +1,67 @@
+module Terraforming::Resource
+  class VPC
+    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/vpc")
+    end
+
+    def tfstate
+      resources = vpcs.inject({}) do |result, vpc|
+        attributes = {
+          "cidr_block" => vpc.cidr_block,
+          "enable_dns_hostnames" => enable_dns_hostnames?(vpc).to_s,
+          "enable_dns_support" => enable_dns_support?(vpc).to_s,
+          "id" => vpc.vpc_id,
+          "instance_tenancy" => vpc.instance_tenancy,
+          "tags.#" => vpc.tags.length.to_s,
+        }
+        result["aws_vpc.#{module_name_of(vpc)}"] = {
+          "type" => "aws_vpc",
+          "primary" => {
+            "id" => vpc.vpc_id,
+            "attributes" => attributes
+          }
+        }
+
+        result
+      end
+
+      generate_tfstate(resources)
+    end
+
+    private
+
+    def enable_dns_hostnames?(vpc)
+      vpc_attribute(vpc, :enableDnsHostnames).enable_dns_hostnames.value
+    end
+
+    def enable_dns_support?(vpc)
+      vpc_attribute(vpc, :enableDnsSupport).enable_dns_support.value
+    end
+
+    def module_name_of(vpc)
+      normalize_module_name(name_from_tag(vpc, vpc.vpc_id))
+    end
+
+    def vpcs
+      @client.describe_vpcs.vpcs
+    end
+
+    def vpc_attribute(vpc, attribute)
+      @client.describe_vpc_attribute(vpc_id: vpc.vpc_id, attribute: attribute)
+    end
+  end
+end