aws-insight 0.14.0

data/lib/terraforming/resource/iam_policy.rb

@@ -0,0 +1,63 @@
+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
+        iam_policies.inject({}) do |resources, policy|
+          version = iam_policy_version_of(policy)
+          attributes = {
+            "id" => policy.arn,
+            "name" => policy.policy_name,
+            "path" => policy.path,
+            "description" => iam_policy_description(policy),
+            "policy" => prettify_policy(version.document, breakline: true, unescape: true),
+          }
+          resources["aws_iam_policy.#{module_name_of(policy)}"] = {
+            "type" => "aws_iam_policy",
+            "primary" => {
+              "id" => policy.arn,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def iam_policies
+        @client.list_policies(scope: "Local").map(&:policies).flatten
+      end
+
+      def iam_policy_description(policy)
+        @client.get_policy(policy_arn: policy.arn).policy.description
+      end
+
+      def iam_policy_version_of(policy)
+        @client.get_policy_version(policy_arn: policy.arn, version_id: policy.default_version_id).policy_version
+      end
+
+      def module_name_of(policy)
+        normalize_module_name(policy.policy_name)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_policy_attachment.rb

@@ -0,0 +1,86 @@
+module Terraforming
+  module Resource
+    class IAMPolicyAttachment
+      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_attachment")
+      end
+
+      def tfstate
+        iam_policy_attachments.inject({}) do |resources, policy_attachment|
+          attributes = {
+            "id" => policy_attachment[:name],
+            "name" => policy_attachment[:name],
+            "policy_arn" => policy_attachment[:arn],
+            "groups.#" => policy_attachment[:entities].policy_groups.length.to_s,
+            "users.#" => policy_attachment[:entities].policy_users.length.to_s,
+            "roles.#" => policy_attachment[:entities].policy_roles.length.to_s,
+          }
+          resources["aws_iam_policy_attachment.#{module_name_of(policy_attachment)}"] = {
+            "type" => "aws_iam_policy_attachment",
+            "primary" => {
+              "id" => policy_attachment[:name],
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def attachment_name_from(policy)
+        "#{policy.policy_name}-policy-attachment"
+      end
+
+      def entities_for_policy(policy)
+        # list_entities_for_policy is a weird one: the response class
+        # has three different member variables that we need to
+        # paginate through altogether.
+        result = Aws::IAM::Types::ListEntitiesForPolicyResponse.new
+        result.policy_groups = []
+        result.policy_users = []
+        result.policy_roles = []
+        @client.list_entities_for_policy(policy_arn: policy.arn).each do |resp|
+          result.policy_groups += resp.policy_groups
+          result.policy_users += resp.policy_users
+          result.policy_roles += resp.policy_roles
+        end
+
+        result
+      end
+
+      def iam_policies
+        @client.list_policies(scope: "All", only_attached: true).map(&:policies).flatten
+      end
+
+      def iam_policy_attachments
+        iam_policies.map do |policy|
+          {
+            arn: policy.arn,
+            entities: entities_for_policy(policy),
+            name: attachment_name_from(policy),
+          }
+        end
+      end
+
+      def module_name_of(policy_attachment)
+        normalize_module_name(policy_attachment[:name])
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_role.rb

@@ -0,0 +1,56 @@
+module Terraforming
+  module Resource
+    class IAMRole
+      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_role")
+      end
+
+      def tfstate
+        iam_roles.inject({}) do |resources, role|
+          attributes = {
+            "arn" => role.arn,
+            "assume_role_policy" =>
+              prettify_policy(role.assume_role_policy_document, breakline: true, unescape: true),
+            "id" => role.role_name,
+            "name" => role.role_name,
+            "path" => role.path,
+            "unique_id" => role.role_id,
+          }
+          resources["aws_iam_role.#{module_name_of(role)}"] = {
+            "type" => "aws_iam_role",
+            "primary" => {
+              "id" => role.role_name,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def iam_roles
+        @client.list_roles.map(&:roles).flatten
+      end
+
+      def module_name_of(role)
+        normalize_module_name(role.role_name)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_role_policy.rb

@@ -0,0 +1,71 @@
+module Terraforming
+  module Resource
+    class IAMRolePolicy
+      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_role_policy")
+      end
+
+      def tfstate
+        iam_role_policies.inject({}) do |resources, policy|
+          attributes = {
+            "id" => iam_role_policy_id_of(policy),
+            "name" => policy.policy_name,
+            "policy" => prettify_policy(policy.policy_document, breakline: true, unescape: true),
+            "role" => policy.role_name,
+          }
+          resources["aws_iam_role_policy.#{unique_name(policy)}"] = {
+            "type" => "aws_iam_role_policy",
+            "primary" => {
+              "id" => iam_role_policy_id_of(policy),
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def unique_name(policy)
+        "#{normalize_module_name(policy.role_name)}_#{normalize_module_name(policy.policy_name)}"
+      end
+
+      def iam_role_policy_id_of(policy)
+        "#{policy.role_name}:#{policy.policy_name}"
+      end
+
+      def iam_roles
+        @client.list_roles.map(&:roles).flatten
+      end
+
+      def iam_role_policy_names_in(role)
+        @client.list_role_policies(role_name: role.role_name).policy_names
+      end
+
+      def iam_role_policy_of(role, policy_name)
+        @client.get_role_policy(role_name: role.role_name, policy_name: policy_name)
+      end
+
+      def iam_role_policies
+        iam_roles.map do |role|
+          iam_role_policy_names_in(role).map { |policy_name| iam_role_policy_of(role, policy_name) }
+        end.flatten
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_user.rb

@@ -0,0 +1,55 @@
+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
+        iam_users.inject({}) do |resources, user|
+          attributes = {
+            "arn" => user.arn,
+            "id" => user.user_name,
+            "name" => user.user_name,
+            "path" => user.path,
+            "unique_id" => user.user_id,
+            "force_destroy" => "false",
+          }
+          resources["aws_iam_user.#{module_name_of(user)}"] = {
+            "type" => "aws_iam_user",
+            "primary" => {
+              "id" => user.user_name,
+              "attributes" => attributes,
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def iam_users
+        @client.list_users.map(&:users).flatten
+      end
+
+      def module_name_of(user)
+        normalize_module_name(user.user_name)
+      end
+    end
+  end
+end

data/lib/terraforming/resource/iam_user_policy.rb

@@ -0,0 +1,71 @@
+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
+        iam_user_policies.inject({}) do |resources, policy|
+          attributes = {
+            "id" => iam_user_policy_id_of(policy),
+            "name" => policy.policy_name,
+            "policy" => prettify_policy(policy.policy_document, breakline: true, unescape: true),
+            "user" => policy.user_name,
+          }
+          resources["aws_iam_user_policy.#{unique_name(policy)}"] = {
+            "type" => "aws_iam_user_policy",
+            "primary" => {
+              "id" => iam_user_policy_id_of(policy),
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def unique_name(policy)
+        "#{normalize_module_name(policy.user_name)}_#{normalize_module_name(policy.policy_name)}"
+      end
+
+      def iam_user_policy_id_of(policy)
+        "#{policy.user_name}:#{policy.policy_name}"
+      end
+
+      def iam_users
+        @client.list_users.map(&:users).flatten
+      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/internet_gateway.rb

@@ -0,0 +1,54 @@
+module Terraforming
+  module Resource
+    class InternetGateway
+      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/internet_gateway")
+      end
+
+      def tfstate
+        internet_gateways.inject({}) do |resources, internet_gateway|
+          next resources if internet_gateway.attachments.empty?
+
+          attributes = {
+            "id"     => internet_gateway.internet_gateway_id,
+            "vpc_id" => internet_gateway.attachments[0].vpc_id,
+            "tags.#" => internet_gateway.tags.length.to_s,
+          }
+          resources["aws_internet_gateway.#{module_name_of(internet_gateway)}"] = {
+            "type" => "aws_internet_gateway",
+            "primary" => {
+              "id"         => internet_gateway.internet_gateway_id,
+              "attributes" => attributes
+            }
+          }
+
+          resources
+        end
+      end
+
+      private
+
+      def internet_gateways
+        @client.describe_internet_gateways.map(&:internet_gateways).flatten
+      end
+
+      def module_name_of(internet_gateway)
+        normalize_module_name(name_from_tag(internet_gateway, internet_gateway.internet_gateway_id))
+      end
+    end
+  end
+end