terraforming 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc34e08ee4b6f0d0723edb9f2fc4be372b3892c2
-  data.tar.gz: c1d7da734fed9e4502ece8d0914b6283c2acc93a
+  metadata.gz: 732437685979fbd266b3f855c81ffb184be35856
+  data.tar.gz: 5f3ef26d21cab520886d5a4ebff23e2af13d5b03
 SHA512:
-  metadata.gz: e4f61751c5ff99acda6d6b64cc7f56103b37e02aa59f0d26af7a6d36a628d78fe911b9b8e1a32f5e73ec9a7d32f46cfd846e5f9a3bdfb05867ac27aa2334220f
-  data.tar.gz: b8183e1c9dd3b21454f3fd5a1d422c4985db24a57d25f71409e0a8761ba80921bcf0538daace8a8d4bd8402b16a8e887ac403f0a1cc47d2da674c433bd0a9d68
+  metadata.gz: c564d548f74b3650cf1509388cafd66bc831e705f16c881f05aa8cf5507aa93e35106f15eb5b0f74f77cbacae9f342508751417219e3ae009c94339806d6cd72
+  data.tar.gz: e451f2a2619e7cad7658fbfc33155fe948edb7e583fb2f4cb914b3b16d9a4dd6a444b98d08ec2301a56cb28bb876aebd2c454bb5797cbbfff864b9fa2e8d69f6

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [v0.1.1](https://github.com/dtan4/terraforming/releases/tag/v0.1.1) (2015-07-14)
+
+### Resource
+
+- AWS ElastiCache Cluster
+- AWS ElastiCache Subnet Group
+- AWS IAM Group Membership
+
 # [v0.1.0](https://github.com/dtan4/terraforming/releases/tag/v0.1.0) (2015-06-20)
 
 ### New feature

data/README.md

@@ -8,7 +8,22 @@
 [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
 [![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)
+Export existing AWS resources to [Terraform](https://terraform.io/) style (tf, tfstate)
+
+- [Supported version](#supported-version)
+- [Installation](#installation)
+- [Prerequisites](#prerequisites)
+- [Usage](#usage)
+  -  [Export tf](#export-tf)
+  -  [Export tfstate](#export-tfstate)
+- [Run as Docker container](#run-as-docker-container-)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Supported version
+
+Ruby 2.x
 
 ## Installation
 
@@ -31,9 +46,9 @@ Or install it yourself as:
 You need to set AWS credentials.
 
 ```bash
-AWS_ACCESS_KEY_ID=
-AWS_SECRET_ACCESS_KEY=
-AWS_REGION=
+export AWS_ACCESS_KEY_ID=XXXXXXXXXXXXXXXXXXXX
+export AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+export AWS_DEFAULT_REGION=xx-yyyy-0
 ```
 
 ## Usage
@@ -64,7 +79,9 @@ Commands:
   terraforming vpc             # VPC
 ```
 
-Output `.tf` style (e.g. S3 buckets):
+### Export tf
+
+(e.g. S3 buckets):
 
 ```bash
 $ terraforming s3
@@ -82,7 +99,9 @@ resource "aws_s3_bucket" "fuga" {
 }
 ```
 
-To output `.tfstate` style, specify `--tfstate` option (e.g. S3 buckets):
+### Export tfstate
+
+Specify `--tfstate` option (e.g. S3 buckets):
 
 ```bash
 $ terraforming s3 --tfstate
@@ -126,7 +145,142 @@ $ terraforming s3 --tfstate
 }
 ```
 
-(Probably you have to modify the output to add it to existing `terraforming.tfstate`)
+If you want to merge exported tfstate to existing `terraform.tfstate`, specify `--tfstate --merge=/path/to/terraform.tfstate` option.
+This option does NOT overwrite existing `terraform.tfstate`, but flush output to stdout like others.
+You should copy output in stdout by hand or `pbcopy` command, and paste it to existing `terraform.tfstate`.
+
+Existing `terraform.tfstate`:
+
+```bash
+# /path/to/terraform.tfstate
+
+{
+  "version": 1,
+  "serial": 88,
+  "remote": {
+    "type": "s3",
+    "config": {
+      "bucket": "terraforming-tfstate",
+      "key": "tf"
+    }
+  },
+  "modules": {
+    "path": [
+      "root"
+    ],
+    "outputs": {
+    },
+    "resources": {
+      "aws_elb.hogehoge": {
+        "type": "aws_elb",
+        "primary": {
+          "id": "hogehoge",
+          "attributes": {
+            "availability_zones.#": "2",
+            "connection_draining": "true",
+            "connection_draining_timeout": "300",
+            "cross_zone_load_balancing": "true",
+            "dns_name": "hoge-12345678.ap-northeast-1.elb.amazonaws.com",
+            "health_check.#": "1",
+            "id": "hogehoge",
+            "idle_timeout": "60",
+            "instances.#": "1",
+            "listener.#": "1",
+            "name": "hoge",
+            "security_groups.#": "2",
+            "source_security_group": "default",
+            "subnets.#": "2"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+To generate merged tfstate:
+
+```bash
+$ terraforming s3 --tfstate --merge=/path/to/tfstate
+```
+
+```json
+{
+  "version": 1,
+  "serial": 89,
+  "remote": {
+    "type": "s3",
+    "config": {
+      "bucket": "terraforming-tfstate",
+      "key": "tf"
+    }
+  },
+  "modules": {
+    "path": [
+      "root"
+    ],
+    "outputs": {
+    },
+    "resources": {
+      "aws_elb.hogehoge": {
+        "type": "aws_elb",
+        "primary": {
+          "id": "hogehoge",
+          "attributes": {
+            "availability_zones.#": "2",
+            "connection_draining": "true",
+            "connection_draining_timeout": "300",
+            "cross_zone_load_balancing": "true",
+            "dns_name": "hoge-12345678.ap-northeast-1.elb.amazonaws.com",
+            "health_check.#": "1",
+            "id": "hogehoge",
+            "idle_timeout": "60",
+            "instances.#": "1",
+            "listener.#": "1",
+            "name": "hoge",
+            "security_groups.#": "2",
+            "source_security_group": "default",
+            "subnets.#": "2"
+          }
+        }
+      },
+      "aws_s3_bucket.hoge": {
+        "type": "aws_s3_bucket",
+        "primary": {
+          "id": "hoge",
+          "attributes": {
+            "acl": "private",
+            "bucket": "hoge",
+            "id": "hoge"
+          }
+        }
+      },
+      "aws_s3_bucket.fuga": {
+        "type": "aws_s3_bucket",
+        "primary": {
+          "id": "fuga",
+          "attributes": {
+            "acl": "private",
+            "bucket": "fuga",
+            "id": "fuga"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+After writing exported tf and tfstate to files, execute `terraform plan` and check the result.
+There should be no diff.
+
+```bash
+$ terraform plan
+No changes. Infrastructure is up-to-date. This means that Terraform
+could not detect any differences between your configuration and
+the real physical resources that exist. As a result, Terraform
+doesn't need to do anything.
+```
 
 ## 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)
 
@@ -144,7 +298,6 @@ And then run Terraforming as a Docker container:
 $ 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 \
@@ -166,6 +319,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
-## LICENSE
+## License
 
 [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)

data/lib/terraforming/cli.rb

@@ -23,6 +23,16 @@ module Terraforming
       execute(Terraforming::Resource::EC2, options)
     end
 
+    desc "ecc", "ElastiCache Cluster"
+    def ecc
+      execute(Terraforming::Resource::ElastiCacheCluster, options)
+    end
+
+    desc "ecsn", "ElastiCache Subnet Group"
+    def ecsn
+      execute(Terraforming::Resource::ElastiCacheSubnetGroup, options)
+    end
+
     desc "elb", "ELB"
     def elb
       execute(Terraforming::Resource::ELB, options)
@@ -33,6 +43,11 @@ module Terraforming
       execute(Terraforming::Resource::IAMGroup, options)
     end
 
+    desc "iamgm", "IAM Group Membership"
+    def iamgm
+      execute(Terraforming::Resource::IAMGroupMembership, options)
+    end
+
     desc "iamgp", "IAM Group Policy"
     def iamgp
       execute(Terraforming::Resource::IAMGroupPolicy, options)
@@ -123,8 +138,8 @@ module Terraforming
     def tfstate(klass, tfstate_path)
       return klass.tfstate unless tfstate_path
 
-      base_tfstate = JSON.parse(open(tfstate_path).read)
-      klass.tfstate(tfstate_base: base_tfstate)
+      tfstate_base = JSON.parse(open(tfstate_path).read)
+      klass.tfstate(tfstate_base: tfstate_base)
     end
   end
 end

data/lib/terraforming/resource/elasti_cache_cluster.rb

@@ -0,0 +1,72 @@
+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, tfstate_base: nil)
+        self.new(client).tfstate(tfstate_base)
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/elasti_cache_cluster")
+      end
+
+      def tfstate(tfstate_base)
+        resources = cache_clusters.inject({}) do |result, 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,
+            "port" => "11211",
+            "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",
+          }
+          result["aws_elasticache_cluster.#{cache_cluster.cache_cluster_id}"] = {
+            "type" => "aws_elasticache_cluster",
+            "primary" => {
+              "id" => cache_cluster.cache_cluster_id,
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources, tfstate_base)
+      end
+
+      private
+
+      def cache_clusters
+        @client.describe_cache_clusters(show_cache_node_info: true).cache_clusters
+      end
+
+      def cluster_in_vpc?(cache_cluster)
+        cache_cluster.cache_security_groups.length == 0
+      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
+    end
+  end
+end

data/lib/terraforming/resource/elasti_cache_subnet_group.rb

@@ -0,0 +1,54 @@
+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, tfstate_base: nil)
+        self.new(client).tfstate(tfstate_base)
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/elasti_cache_subnet_group")
+      end
+
+      def tfstate(tfstate_base)
+        resources = cache_subnet_groups.inject({}) do |result, 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,
+          }
+          result["aws_elasticache_subnet_group.#{cache_subnet_group.cache_subnet_group_name}"] = {
+            "type" => "aws_elasticache_subnet_group",
+            "primary" => {
+              "id" => cache_subnet_group.cache_subnet_group_name,
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources, tfstate_base)
+      end
+
+      private
+
+      def cache_subnet_groups
+        @client.describe_cache_subnet_groups.cache_subnet_groups
+      end
+
+      def subnet_ids_of(cache_subnet_group)
+        cache_subnet_group.subnets.map { |sn| sn.subnet_identifier }
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_group_membership.rb

@@ -0,0 +1,61 @@
+module Terraforming
+  module Resource
+    class IAMGroupMembership
+      include Terraforming::Util
+
+      def self.tf(client: Aws::IAM::Client.new)
+        self.new(client).tf
+      end
+
+      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
+        self.new(client).tfstate(tfstate_base)
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def tf
+        apply_template(@client, "tf/iam_group_membership")
+      end
+
+      def tfstate(tfstate_base)
+        resources = iam_groups.inject({}) do |result, group|
+          membership_name = membership_name_of(group)
+
+          attributes = {
+            "group"=> group.group_name,
+            "id" => membership_name,
+            "name" => membership_name,
+            "users.#" => group_members_of(group).length.to_s,
+          }
+          result["aws_iam_group_membership.#{group.group_name}"] = {
+            "type" => "aws_iam_group_membership",
+            "primary" => {
+              "id" => membership_name,
+              "attributes" => attributes
+            }
+          }
+
+          result
+        end
+
+        generate_tfstate(resources, tfstate_base)
+      end
+
+      private
+
+      def group_members_of(group)
+        @client.get_group(group_name: group.group_name).users.map { |user| user.user_name }
+      end
+
+      def iam_groups
+        @client.list_groups.groups
+      end
+
+      def membership_name_of(group)
+        "#{group.group_name}-group-membership"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+<% cache_clusters.each do |cache_cluster| -%>
+resource "aws_elasticache_cluster" "<%= cache_cluster.cache_cluster_id %>" {
+    cluster_id           = "<%= cache_cluster.cache_cluster_id %>"
+    engine               = "<%= cache_cluster.engine %>"
+    engine_version       = "<%= cache_cluster.engine_version %>"
+    node_type            = "<%= cache_cluster.cache_node_type %>"
+    num_cache_nodes      = <%= cache_cluster.num_cache_nodes %>
+    parameter_group_name = "<%= cache_cluster.cache_parameter_group.cache_parameter_group_name %>"
+    port                 = <%= cache_cluster.configuration_endpoint.port %>
+  <%- if cluster_in_vpc?(cache_cluster) -%>
+    subnet_group_name    = "<%= cache_cluster.cache_subnet_group_name %>"
+    security_group_ids   = <%= security_group_ids_of(cache_cluster).inspect %>
+  <%- else -%>
+    security_group_names = <%= security_group_names_of(cache_cluster).inspect %>
+  <%- end -%>
+}
+
+<% end -%>

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

@@ -0,0 +1,8 @@
+<% cache_subnet_groups.each do |cache_subnet_group| -%>
+resource "aws_elasticache_subnet_group" "<%= cache_subnet_group.cache_subnet_group_name %>" {
+    name        = "<%= cache_subnet_group.cache_subnet_group_name %>"
+    description = "<%= cache_subnet_group.cache_subnet_group_description %>"
+    subnet_ids  = <%= subnet_ids_of(cache_subnet_group).inspect %>
+}
+
+<% end -%>

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

@@ -0,0 +1,8 @@
+<% iam_groups.each do |group| -%>
+resource "aws_iam_group_membership" "<%= group.group_name %>" {
+    name  = "<%= membership_name_of(group) %>"
+    users = <%= group_members_of(group).inspect %>
+    group = "<%= group.group_name %>"
+}
+
+<% end -%>

data/lib/terraforming/version.rb

@@ -1,3 +1,3 @@
 module Terraforming
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/terraforming.rb

@@ -15,8 +15,11 @@ require "terraforming/resource/db_parameter_group"
 require "terraforming/resource/db_security_group"
 require "terraforming/resource/db_subnet_group"
 require "terraforming/resource/ec2"
+require "terraforming/resource/elasti_cache_cluster"
+require "terraforming/resource/elasti_cache_subnet_group"
 require "terraforming/resource/elb"
 require "terraforming/resource/iam_group"
+require "terraforming/resource/iam_group_membership"
 require "terraforming/resource/iam_group_policy"
 require "terraforming/resource/iam_instance_profile"
 require "terraforming/resource/iam_policy"

data/terraforming.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Daisuke Fujita"]
   spec.email         = ["dtanshi45@gmail.com"]
 
-  spec.summary       = %q{Import existing AWS resources into Terraform style (tf, tfstate)}
-  spec.description   = %q{Import existing AWS resources into Terraform style (tf, tfstate)}
+  spec.summary       = %q{Export existing AWS resources to Terraform style (tf, tfstate)}
+  spec.description   = %q{Export existing AWS resources to Terraform style (tf, tfstate)}
   spec.homepage      = "https://github.com/dtan4/terraforming"
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terraforming
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Daisuke Fujita
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-19 00:00:00.000000000 Z
+date: 2015-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -164,7 +164,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Import existing AWS resources into Terraform style (tf, tfstate)
+description: Export existing AWS resources to Terraform style (tf, tfstate)
 email:
 - dtanshi45@gmail.com
 executables:
@@ -189,8 +189,11 @@ files:
 - lib/terraforming/resource/db_security_group.rb
 - lib/terraforming/resource/db_subnet_group.rb
 - lib/terraforming/resource/ec2.rb
+- lib/terraforming/resource/elasti_cache_cluster.rb
+- lib/terraforming/resource/elasti_cache_subnet_group.rb
 - lib/terraforming/resource/elb.rb
 - lib/terraforming/resource/iam_group.rb
+- lib/terraforming/resource/iam_group_membership.rb
 - lib/terraforming/resource/iam_group_policy.rb
 - lib/terraforming/resource/iam_instance_profile.rb
 - lib/terraforming/resource/iam_policy.rb
@@ -210,8 +213,11 @@ files:
 - lib/terraforming/template/tf/db_security_group.erb
 - lib/terraforming/template/tf/db_subnet_group.erb
 - lib/terraforming/template/tf/ec2.erb
+- lib/terraforming/template/tf/elasti_cache_cluster.erb
+- lib/terraforming/template/tf/elasti_cache_subnet_group.erb
 - lib/terraforming/template/tf/elb.erb
 - lib/terraforming/template/tf/iam_group.erb
+- lib/terraforming/template/tf/iam_group_membership.erb
 - lib/terraforming/template/tf/iam_group_policy.erb
 - lib/terraforming/template/tf/iam_instance_profile.erb
 - lib/terraforming/template/tf/iam_policy.erb
@@ -252,8 +258,9 @@ 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)
+summary: Export existing AWS resources to Terraform style (tf, tfstate)
 test_files: []
+has_rdoc: