terraforming 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98a4283e9ec68191bb76845061e9d990c8265684
-  data.tar.gz: 849118d11012f17491c2b88460b57b2f40fa6a8a
+  metadata.gz: d57472a2d8992db0599ae5a1111b1c648f76f8e5
+  data.tar.gz: c50702794d78467502ff68dab56f2e0749bb57de
 SHA512:
-  metadata.gz: 8ab684ad1cc0796cc085d97de0c8319261742edf6bc2d66f9e9e99d4e64d47834214499c98cadeb09e583481cceb57077da23709844fb9ed25c73427b84ed8f0
-  data.tar.gz: 6ae32eb13bfe952a9b3853940f4bc01e9b1016474ec7e134d1d5395059c84c6ebccdf5aeef16ce800bc5729e0195408860d768da9ecc55c3f42c166ca3cd9d26
+  metadata.gz: 3082ae845101d88a318b4b926013b9035c4e5732cbcbfadb88c7a5c8115cba2ae0b53845b67e5be8fe7afb276a6289243b2a8273dbd4368281b9190ff4151f75
+  data.tar.gz: 2c55b45bee3f6ede00e547862e440d1baf23443de54d0fd3de39524f1a349873a25579e4fa18da37da044f49957d5696010897c52a9739793ea88ca9a7266ddc

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# [v0.0.3](https://github.com/dtan4/terraforming/releases/tag/v0.0.3) (2015-05-26)
+
+### Fixed
+
+- Include AWS ELB additional attributes #39
+
+### Resource
+
+- AWS IAM group
+- AWS IAM group policy
+- AWS IAM policy
+- AWS IAM user
+- AWS IAM user policy
+- AWS Route53 hosted zone
+- AWS Route53 record
+
+# [v0.0.2](https://github.com/dtan4/terraforming/releases/tag/v0.0.2) (2015-05-09)
+
+### Fixed
+
+- Nested module declation #35
+  - raised NameError exception #34
+
+### Resource
+
+- AWS Network ACL
+
+# [v0.0.1](https://github.com/dtan4/terraforming/releases/tag/v0.0.1) (2015-04-23)
+
+Initial release.
+
+### Resource
+
+- AWS Database Parameter Group
+- AWS Database Security Group
+- AWS Subnet Group
+- AWS EC2 instances
+- AWS ELB
+- AWS RDS instances
+- AWS S3 buckets
+- AWS SecurityGroup
+- AWS Subnet
+- AWS VPC

data/README.md

@@ -4,6 +4,7 @@
 [![Code Climate](https://codeclimate.com/github/dtan4/terraforming/badges/gpa.svg)](https://codeclimate.com/github/dtan4/terraforming)
 [![Test Coverage](https://codeclimate.com/github/dtan4/terraforming/badges/coverage.svg)](https://codeclimate.com/github/dtan4/terraforming)
 [![Gem Version](https://badge.fury.io/rb/terraforming.svg)](http://badge.fury.io/rb/terraforming)
+[![Docker Repository on Quay.io](https://quay.io/repository/dtan4/terraforming/status "Docker Repository on Quay.io")](https://quay.io/repository/dtan4/terraforming)
 
 Import existing AWS resources into [Terraform](https://terraform.io/) style (tf, tfstate)
 
@@ -116,9 +117,33 @@ $ terraforming s3 --tfstate
 
 (Probably you have to modify the output to add it to existing `terraforming.tfstate`)
 
+## Run as Docker container [![Docker Repository on Quay.io](https://quay.io/repository/dtan4/terraforming/status "Docker Repository on Quay.io")](https://quay.io/repository/dtan4/terraforming)
+
+Terraforming Docker Image is available at [quay.io/dtan4/terraforming](https://quay.io/repository/dtan4/terraforming) and developed at [dtan4/dockerfile-terraforming](https://github.com/dtan4/dockerfile-terraforming).
+
+Pull the Docker image:
+
+```bash
+$ docker pull quay.io/dtan4/terraforming:latest
+```
+
+And then run Terraforming as a Docker container:
+
+```bash
+$ docker run \
+    --rm \
+    --name terraforming \
+    -v /path/to/tf-files-dir:/app \
+    -e AWS_ACCESS_KEY_ID=XXXXXXXXXXXXXXXXXXXX \
+    -e AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
+    -e AWS_DEFAULT_REGION=xx-yyyy-0 \
+    quay.io/dtan4/terraforming:latest \
+    terraforming s3
+```
+
 ## Development
 
-After checking out the repo, run `scripts/setup` to install dependencies. Then, run `scripts/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `script/setup` to install dependencies. Then, run `script/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/lib/terraforming.rb

@@ -15,8 +15,15 @@ require "terraforming/resource/db_security_group"
 require "terraforming/resource/db_subnet_group"
 require "terraforming/resource/ec2"
 require "terraforming/resource/elb"
+require "terraforming/resource/iam_group"
+require "terraforming/resource/iam_group_policy"
+require "terraforming/resource/iam_policy"
+require "terraforming/resource/iam_user"
+require "terraforming/resource/iam_user_policy"
 require "terraforming/resource/network_acl"
 require "terraforming/resource/rds"
+require "terraforming/resource/route53_record"
+require "terraforming/resource/route53_zone"
 require "terraforming/resource/s3"
 require "terraforming/resource/security_group"
 require "terraforming/resource/subnet"

data/lib/terraforming/cli.rb

@@ -30,12 +30,54 @@ module Terraforming
       execute(Terraforming::Resource::ELB, options)
     end
 
+    desc "iamg", "IAM Group"
+    option :tfstate, type: :boolean
+    def iamg
+      execute(Terraforming::Resource::IAMGroup, options)
+    end
+
+    desc "iamgp", "IAM Group Policy"
+    option :tfstate, type: :boolean
+    def iamgp
+      execute(Terraforming::Resource::IAMGroupPolicy, options)
+    end
+
+    desc "iamp", "IAM Policy"
+    option :tfstate, type: :boolean
+    def iamp
+      execute(Terraforming::Resource::IAMPolicy, options)
+    end
+
+    desc "iamu", "IAM User"
+    option :tfstate, type: :boolean
+    def iamu
+      execute(Terraforming::Resource::IAMUser, options)
+    end
+
+    desc "iamup", "IAM User Policy"
+    option :tfstate, type: :boolean
+    def iamup
+      execute(Terraforming::Resource::IAMUserPolicy, options)
+    end
+
     desc "nacl", "Network ACL"
     option :tfstate, type: :boolean
     def nacl
       execute(Terraforming::Resource::NetworkACL, options)
     end
 
+    desc "r53r", "Route53 Record"
+    option :tfstate, type: :boolean
+    def r53r
+      execute(Terraforming::Resource::Route53Record, options)
+    end
+
+    desc "r53z", "Route53 Hosted Zone"
+    option :tfstate, type: :boolean
+    def r53z
+      execute(Terraforming::Resource::Route53Zone, options)
+    end
+
     desc "rds", "RDS"
     option :tfstate, type: :boolean
     def rds

data/lib/terraforming/resource/elb.rb

@@ -21,15 +21,21 @@ module Terraforming
 
       def tfstate
         resources = load_balancers.inject({}) do |result, load_balancer|
+          load_balancer_attributes = load_balancer_attributes_of(load_balancer)
           attributes = {
             "availability_zones.#" => load_balancer.availability_zones.length.to_s,
+            "connection_draining" => load_balancer_attributes.connection_draining.enabled.to_s,
+            "connection_draining_timeout" => load_balancer_attributes.connection_draining.timeout.to_s,
+            "cross_zone_load_balancing" => load_balancer_attributes.cross_zone_load_balancing.enabled.to_s,
             "dns_name" => load_balancer.dns_name,
             "health_check.#" => "1",
             "id" => load_balancer.load_balancer_name,
+            "idle_timeout" => load_balancer_attributes.connection_settings.idle_timeout.to_s,
             "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,
+            "source_security_group" => load_balancer.source_security_group.group_name,
             "subnets.#" => load_balancer.subnets.length.to_s,
           }
           result["aws_elb.#{module_name_of(load_balancer)}"] = {
@@ -50,6 +56,10 @@ module Terraforming
         @client.describe_load_balancers.load_balancer_descriptions
       end
 
+      def load_balancer_attributes_of(load_balancer)
+        @client.describe_load_balancer_attributes(load_balancer_name: load_balancer.load_balancer_name).load_balancer_attributes
+      end
+
       def module_name_of(load_balancer)
         normalize_module_name(load_balancer.load_balancer_name)
       end

data/lib/terraforming/resource/iam_group.rb

@@ -0,0 +1,52 @@
+module Terraforming
+  module Resource
+    class IAMGroup
+      include Terraforming::Util
+
+      def self.tf(client = Aws::IAM::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client = Aws::IAM::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/iam_group")
+      end
+
+      def tfstate
+        resources = iam_groups.inject({}) do |result, group|
+          attributes = {
+            "arn"=> group.arn,
+            "id" => group.group_name,
+            "name" => group.group_name,
+            "path" => group.path,
+            "unique_id" => group.group_id,
+          }
+          result["aws_iam_group.#{group.group_name}"] = {
+            "type" => "aws_iam_group",
+            "primary" => {
+              "id" => group.group_name,
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def iam_groups
+        @client.list_groups.groups
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_group_policy.rb

@@ -0,0 +1,69 @@
+module Terraforming
+  module Resource
+    class IAMGroupPolicy
+      include Terraforming::Util
+
+      def self.tf(client = Aws::IAM::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client = Aws::IAM::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/iam_group_policy")
+      end
+
+      def tfstate
+        resources = iam_group_policies.inject({}) do |result, policy|
+          attributes = {
+            "group" => policy.group_name,
+            "id" => iam_group_policy_id_of(policy),
+            "name" => policy.policy_name,
+            "policy" => CGI.unescape(policy.policy_document)
+          }
+          result["aws_iam_group_policy.#{policy.policy_name}"] = {
+            "type" => "aws_iam_group_policy",
+            "primary" => {
+              "id" => iam_group_policy_id_of(policy),
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def iam_groups
+        @client.list_groups.groups
+      end
+
+      def iam_group_policy_id_of(policy)
+        "#{policy.group_name}:#{policy.policy_name}"
+      end
+
+      def iam_group_policy_names_in(group)
+        @client.list_group_policies(group_name: group.group_name).policy_names
+      end
+
+      def iam_group_policy_of(group, policy_name)
+        @client.get_group_policy(group_name: group.group_name, policy_name: policy_name)
+      end
+
+      def iam_group_policies
+        iam_groups.map do |group|
+          iam_group_policy_names_in(group).map { |policy_name| iam_group_policy_of(group, policy_name) }
+        end.flatten
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_policy.rb

@@ -0,0 +1,56 @@
+module Terraforming
+  module Resource
+    class IAMPolicy
+      include Terraforming::Util
+
+      def self.tf(client = Aws::IAM::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client = Aws::IAM::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/iam_policy")
+      end
+
+      def tfstate
+        resources = iam_policies.inject({}) do |result, policy|
+          version = iam_policy_version_of(policy)
+          attributes = {
+            "id" => policy.arn,
+            "name" => policy.policy_name,
+            "path" => policy.path,
+            "policy" => CGI.unescape(version.document),
+          }
+          result["aws_iam_policy.#{policy.policy_name}"] = {
+            "type" => "aws_iam_policy",
+            "primary" => {
+              "id" => policy.arn,
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def iam_policies
+        @client.list_policies(scope: "Local").policies
+      end
+
+      def iam_policy_version_of(policy)
+        @client.get_policy_version(policy_arn: policy.arn, version_id: policy.default_version_id).policy_version
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_user.rb

@@ -0,0 +1,52 @@
+module Terraforming
+  module Resource
+    class IAMUser
+      include Terraforming::Util
+
+      def self.tf(client = Aws::IAM::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client = Aws::IAM::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/iam_user")
+      end
+
+      def tfstate
+        resources = iam_users.inject({}) do |result, user|
+          attributes = {
+            "arn"=> user.arn,
+            "id" => user.user_name,
+            "name" => user.user_name,
+            "path" => user.path,
+            "unique_id" => user.user_id,
+          }
+          result["aws_iam_user.#{user.user_name}"] = {
+            "type" => "aws_iam_user",
+            "primary" => {
+              "id" => user.user_name,
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def iam_users
+        @client.list_users.users
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_user_policy.rb

@@ -0,0 +1,69 @@
+module Terraforming
+  module Resource
+    class IAMUserPolicy
+      include Terraforming::Util
+
+      def self.tf(client = Aws::IAM::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client = Aws::IAM::Client.new)
+        self.new(client).tfstate
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/iam_user_policy")
+      end
+
+      def tfstate
+        resources = iam_user_policies.inject({}) do |result, policy|
+          attributes = {
+            "id" => iam_user_policy_id_of(policy),
+            "name" => policy.policy_name,
+            "policy" => CGI.unescape(policy.policy_document),
+            "user" => policy.user_name,
+          }
+          result["aws_iam_user_policy.#{policy.policy_name}"] = {
+            "type" => "aws_iam_user_policy",
+            "primary" => {
+              "id" => iam_user_policy_id_of(policy),
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def iam_users
+        @client.list_users.users
+      end
+
+      def iam_user_policy_id_of(policy)
+        "#{policy.user_name}:#{policy.policy_name}"
+      end
+
+      def iam_user_policy_names_in(user)
+        @client.list_user_policies(user_name: user.user_name).policy_names
+      end
+
+      def iam_user_policy_of(user, policy_name)
+        @client.get_user_policy(user_name: user.user_name, policy_name: policy_name)
+      end
+
+      def iam_user_policies
+        iam_users.map do |user|
+          iam_user_policy_names_in(user).map { |policy_name| iam_user_policy_of(user, policy_name) }
+        end.flatten
+      end
+    end
+  end
+end

data/lib/terraforming/resource/network_acl.rb

@@ -44,8 +44,16 @@ module Terraforming
 
       private
 
+      def default_entry?(entry)
+        entry.rule_number == default_rule_number
+      end
+
+      def default_rule_number
+        32767
+      end
+
       def egresses_of(network_acl)
-        network_acl.entries.select { |entry| entry.egress }
+        network_acl.entries.select { |entry| entry.egress && !default_entry?(entry) }
       end
 
       def from_port_of(entry)
@@ -53,7 +61,7 @@ module Terraforming
       end
 
       def ingresses_of(network_acl)
-        network_acl.entries.select { |entry| !entry.egress }
+        network_acl.entries.select { |entry| !entry.egress && !default_entry?(entry) }
       end
 
       def module_name_of(network_acl)
@@ -65,7 +73,7 @@ module Terraforming
       end
 
       def to_port_of(entry)
-        entry.port_range ? entry.port_range.to : 65535
+        entry.port_range ? entry.port_range.to : 0
       end
     end
   end

data/lib/terraforming/resource/route53_record.rb

@@ -0,0 +1,88 @@
+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
+        resources = records.inject({}) do |result, r|
+          record, zone_id = r[:record], r[:zone_id]
+          record_id = record_id_of(record, zone_id)
+
+          attributes = {
+            "id"=> record_id,
+            "name"=> name_of(record.name),
+            "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.to_s if record.weight
+          attributes["set_identifier"] = record.set_identifier if record.set_identifier
+
+          result["aws_route53_record.#{module_name_of(record)}"] = {
+            "type" => "aws_route53_record",
+            "primary" => {
+              "id" => record_id,
+              "attributes" => attributes,
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def hosted_zones
+        @client.list_hosted_zones.hosted_zones
+      end
+
+      def record_id_of(record, zone_id)
+        "#{zone_id}_#{name_of(record.name)}_#{record.type}"
+      end
+
+      def record_sets_of(hosted_zone)
+        @client.list_resource_record_sets(hosted_zone_id: zone_id_of(hosted_zone)).resource_record_sets
+      end
+
+      def records
+        hosted_zones.map do |hosted_zone|
+          record_sets_of(hosted_zone).map { |record| { record: record, zone_id: zone_id_of(hosted_zone) } }
+        end.flatten
+      end
+
+      # TODO(dtan4): change method name...
+      def name_of(dns_name)
+        dns_name.gsub(/\.\z/, "")
+      end
+
+      def module_name_of(record)
+        normalize_module_name(name_of(record.name))
+      end
+
+      def zone_id_of(hosted_zone)
+        hosted_zone.id.gsub(/\A\/hostedzone\//, "")
+      end
+    end
+  end
+end

data/lib/terraforming/resource/route53_zone.rb

@@ -0,0 +1,74 @@
+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
+        resources = hosted_zones.inject({}) do |result, hosted_zone|
+          zone_id = zone_id_of(hosted_zone)
+
+          attributes = {
+            "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,
+            "zone_id" => zone_id,
+          }
+          result["aws_route53_zone.#{module_name_of(hosted_zone)}"] = {
+            "type" => "aws_route53_zone",
+            "primary" => {
+              "id" => zone_id,
+              "attributes" => attributes,
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources)
+      end
+
+      private
+
+      def hosted_zones
+        @client.list_hosted_zones.hosted_zones
+      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 name_of(hosted_zone)
+        hosted_zone.name.gsub(/\.\z/, "")
+      end
+
+      def name_servers_of(hosted_zone)
+        @client.get_hosted_zone(id: hosted_zone.id).delegation_set.name_servers
+      end
+
+      def module_name_of(hosted_zone)
+        normalize_module_name(name_of(hosted_zone))
+      end
+
+      def zone_id_of(hosted_zone)
+        hosted_zone.id.gsub(/\A\/hostedzone\//, "")
+      end
+    end
+  end
+end

data/lib/terraforming/template/tf/elb.erb

@@ -1,10 +1,15 @@
 <% load_balancers.each do |load_balancer| -%>
+  <%- load_balancer_attributes = load_balancer_attributes_of(load_balancer) -%>
 resource "aws_elb" "<%= module_name_of(load_balancer) %>" {
-    name               = "<%= load_balancer.load_balancer_name %>"
-    availability_zones = <%= load_balancer.availability_zones.inspect %>
-    subnets            = <%= load_balancer.subnets.inspect %>
-    security_groups    = <%= load_balancer.security_groups.inspect %>
-    instances          = <%= load_balancer.instances.map { |instance| instance.instance_id }.inspect %>
+    name                        = "<%= load_balancer.load_balancer_name %>"
+    availability_zones          = <%= load_balancer.availability_zones.inspect %>
+    subnets                     = <%= load_balancer.subnets.inspect %>
+    security_groups             = <%= load_balancer.security_groups.inspect %>
+    instances                   = <%= load_balancer.instances.map { |instance| instance.instance_id }.inspect %>
+    cross_zone_load_balancing   = <%= load_balancer_attributes.cross_zone_load_balancing.enabled %>
+    idle_timeout                = <%= load_balancer_attributes.connection_settings.idle_timeout %>
+    connection_draining         = <%= load_balancer_attributes.connection_draining.enabled %>
+    connection_draining_timeout = <%= load_balancer_attributes.connection_draining.timeout %>
 
 <% load_balancer.listener_descriptions.map { |ld| ld.listener }.map do |listener| -%>
     listener {

data/lib/terraforming/template/tf/iam_group.erb

@@ -0,0 +1,7 @@
+<% iam_groups.each do |group| -%>
+resource "aws_iam_group" "<%= group.group_name %>" {
+    name = "<%= group.group_name %>"
+    path = "<%= group.path %>"
+}
+
+<% end -%>

data/lib/terraforming/template/tf/iam_group_policy.erb

@@ -0,0 +1,10 @@
+<% iam_group_policies.each do |policy| -%>
+resource "aws_iam_group_policy" "<%= policy.policy_name %>" {
+    name   = "<%= policy.policy_name %>"
+    group  = "<%= policy.group_name %>"
+    policy = <<POLICY
+<%= CGI.unescape(policy.policy_document).strip %>
+POLICY
+}
+
+<% end -%>

data/lib/terraforming/template/tf/iam_policy.erb

@@ -0,0 +1,11 @@
+<% iam_policies.each do |policy| -%>
+  <%- version = iam_policy_version_of(policy) -%>
+resource "aws_iam_policy" "<%= policy.policy_name %>" {
+    name   = "<%= policy.policy_name %>"
+    path   = "<%= policy.path %>"
+    policy = <<POLICY
+<%= CGI.unescape(version.document).strip %>
+POLICY
+}
+
+<% end -%>

data/lib/terraforming/template/tf/iam_user.erb

@@ -0,0 +1,7 @@
+<% iam_users.each do |user| -%>
+resource "aws_iam_user" "<%= user.user_name %>" {
+    name = "<%= user.user_name %>"
+    path = "<%= user.path %>"
+}
+
+<% end -%>

data/lib/terraforming/template/tf/iam_user_policy.erb

@@ -0,0 +1,10 @@
+<% iam_user_policies.each do |policy| -%>
+resource "aws_iam_user_policy" "<%= policy.policy_name %>" {
+    name   = "<%= policy.policy_name %>"
+    user   = "<%= policy.user_name %>"
+    policy = <<POLICY
+<%= CGI.unescape(policy.policy_document).strip %>
+POLICY
+}
+
+<% end -%>

data/lib/terraforming/template/tf/route53_record.erb

@@ -0,0 +1,30 @@
+<% records.each do |r| -%>
+  <%- record, zone_id = r[:record], r[:zone_id] -%>
+resource "aws_route53_record" "<%= module_name_of(record) %>" {
+    zone_id = "<%= zone_id %>"
+    name    = "<%= name_of(record.name) %>"
+    type    = "<%= record.type %>"
+<%- unless record.resource_records.empty? -%>
+    records = <%= record.resource_records.map(&:value).to_s %>
+<%- end -%>
+<%- if record.ttl -%>
+    ttl     = "<%= record.ttl %>"
+<%- end -%>
+<%- if record.weight -%>
+    weight  = <%= record.weight %>
+<%- end -%>
+<%- if record.set_identifier -%>
+    set_identifier = "<%= record.set_identifier %>"
+<%- end -%>
+
+    <%- if record.alias_target -%>
+    alias {
+        name    = "<%= name_of(record.alias_target.dns_name)
+ %>"
+        zone_id = "<%= record.alias_target.hosted_zone_id %>"
+        evaluate_target_health = <%= record.alias_target.evaluate_target_health %>
+    }
+    <%- end -%>
+}
+
+<% end -%>

data/lib/terraforming/template/tf/route53_zone.erb

@@ -0,0 +1,12 @@
+<% hosted_zones.each do |hosted_zone| -%>
+resource "aws_route53_zone" "<%= module_name_of(hosted_zone) %>" {
+    name = "<%= name_of(hosted_zone) %>"
+
+    tags {
+<% tags_of(hosted_zone).each do |tag| -%>
+        <%= tag.key %> = "<%= tag.value %>"
+<% end -%>
+    }
+}
+
+<% end -%>

data/lib/terraforming/version.rb

@@ -1,3 +1,3 @@
 module Terraforming
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terraforming
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Daisuke Fujita
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-09 00:00:00.000000000 Z
+date: 2015-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -181,6 +181,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Guardfile
@@ -195,8 +196,15 @@ files:
 - lib/terraforming/resource/db_subnet_group.rb
 - lib/terraforming/resource/ec2.rb
 - lib/terraforming/resource/elb.rb
+- lib/terraforming/resource/iam_group.rb
+- lib/terraforming/resource/iam_group_policy.rb
+- lib/terraforming/resource/iam_policy.rb
+- lib/terraforming/resource/iam_user.rb
+- lib/terraforming/resource/iam_user_policy.rb
 - lib/terraforming/resource/network_acl.rb
 - lib/terraforming/resource/rds.rb
+- lib/terraforming/resource/route53_record.rb
+- lib/terraforming/resource/route53_zone.rb
 - lib/terraforming/resource/s3.rb
 - lib/terraforming/resource/security_group.rb
 - lib/terraforming/resource/subnet.rb
@@ -206,16 +214,23 @@ files:
 - lib/terraforming/template/tf/db_subnet_group.erb
 - lib/terraforming/template/tf/ec2.erb
 - lib/terraforming/template/tf/elb.erb
+- lib/terraforming/template/tf/iam_group.erb
+- lib/terraforming/template/tf/iam_group_policy.erb
+- lib/terraforming/template/tf/iam_policy.erb
+- lib/terraforming/template/tf/iam_user.erb
+- lib/terraforming/template/tf/iam_user_policy.erb
 - lib/terraforming/template/tf/network_acl.erb
 - lib/terraforming/template/tf/rds.erb
+- lib/terraforming/template/tf/route53_record.erb
+- lib/terraforming/template/tf/route53_zone.erb
 - lib/terraforming/template/tf/s3.erb
 - lib/terraforming/template/tf/security_group.erb
 - lib/terraforming/template/tf/subnet.erb
 - lib/terraforming/template/tf/vpc.erb
 - lib/terraforming/util.rb
 - lib/terraforming/version.rb
-- scripts/console
-- scripts/setup
+- script/console
+- script/setup
 - terraforming.gemspec
 homepage: https://github.com/dtan4/terraforming
 licenses:
@@ -237,7 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Import existing AWS resources into Terraform style (tf, tfstate)