geoengineer 0.1.0

data/lib/geoengineer/resources/aws_elasticache_replication_group.rb

@@ -0,0 +1,44 @@
+###############################################################################################
+# AwsElasticacheReplicationGroup is the +aws_elasticache_replication_group+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/elasticache_replication_group.html Terraform Docs}
+##################################################################################################
+class GeoEngineer::Resources::AwsElasticacheReplicationGroup < GeoEngineer::Resource
+  validate -> {
+    validate_required_attributes(
+      [
+        :replication_group_id,
+        :replication_group_description,
+        :number_cache_clusters,
+        :node_type,
+        :port
+      ]
+    )
+  }
+
+  after :initialize, -> { _terraform_id -> { replication_group_id } }
+
+  def to_terraform_state
+    tfstate = super
+
+    attributes = {}
+
+    # Workaround for availability zones
+    availability_zones.each_with_index do |az, i|
+      attributes["availability_zones.#{i}"] = az
+    end
+    attributes['availability_zones.#'] = availability_zones.count.to_s
+
+    tfstate[:primary][:attributes] = attributes
+    tfstate
+  end
+
+  def self._fetch_remote_resources
+    ec = AwsClients.elasticache
+    ec.describe_replication_groups['replication_groups'].map(&:to_h).map do |rg|
+      rg[:_terraform_id] = rg[:replication_group_id]
+      rg[:_geo_id] = rg[:replication_group_id]
+      rg
+    end
+  end
+end

data/lib/geoengineer/resources/aws_elasticache_subnet_group.rb

@@ -0,0 +1,25 @@
+###############################################################################################
+# AwsElasticacheSubnetGroup is the +aws_elasticache_subnet_group+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/elasticache_subnet_group.html Terraform Docs}
+##################################################################################################
+class GeoEngineer::Resources::AwsElasticacheSubnetGroup < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name, :subnet_ids]) }
+
+  after :initialize, -> { _terraform_id -> { name } }
+
+  def support_tags?
+    false
+  end
+
+  def self._fetch_remote_resources
+    cache_subnet_groups = AwsClients.elasticache.describe_cache_subnet_groups
+
+    cache_subnet_groups['cache_subnet_groups'].map(&:to_h).map do |csg|
+      csg[:name] = csg[:cache_subnet_group_name]
+      csg[:_terraform_id] = csg[:cache_subnet_group_name]
+      csg[:_geo_id] = csg[:cache_subnet_group_name]
+      csg
+    end
+  end
+end

data/lib/geoengineer/resources/aws_elasticsearch_domain.rb

@@ -0,0 +1,35 @@
+########################################################################
+# AwsElasticsearchDomain is the +aws_elasticsearch_domain+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/elasticsearch_domain.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsElasticsearchDomain < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:domain_name]) }
+
+  after :initialize, -> {
+    _terraform_id -> {
+      "arn:aws:es:#{environment.region}:#{environment.account_id}:domain/#{self.domain_name}"
+    }
+  }
+  after :initialize, -> { _geo_id -> { domain_name } }
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'domain_name' => domain_name,
+      'access_policies' => access_policies
+    }
+    tfstate
+  end
+
+  def short_type
+    "es"
+  end
+
+  def self._fetch_remote_resources
+    AwsClients.elasticsearch.list_domain_names['domain_names'].map(&:to_h).map do |esd|
+      esd[:_geo_id] = esd[:domain_name]
+      esd
+    end
+  end
+end

data/lib/geoengineer/resources/aws_elb.rb

@@ -0,0 +1,57 @@
+########################################################################
+# AwsElb is the +aws_elb+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/elb.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsElb < GeoEngineer::Resource
+  validate :validate_unique_lb_ports
+  validate -> { validate_required_attributes([:name]) }
+  validate -> { validate_subresource_required_attributes(:access_logs, [:bucket]) }
+  validate -> {
+    validate_subresource_required_attributes(
+      :listener,
+      [
+        :instance_port,
+        :instance_protocol,
+        :lb_port,
+        :lb_protocol
+      ]
+    )
+  }
+  validate -> {
+    validate_subresource_required_attributes(
+      :health_check,
+      [
+        :healthy_threshold, :unhealthy_threshold, :target, :interval, :timeout
+      ]
+    )
+  }
+  validate -> { validate_required_subresource(:listener) }
+
+  after :initialize, -> { _terraform_id -> { name } }
+
+  def validate_unique_lb_ports
+    errors = []
+    ports = []
+    self.all_listener.each do |listener|
+      if ports.include? listener.lb_port
+        errors << "AwsElb non-unique listener lb_port #{for_resource}"
+      end
+      ports << listener.lb_port
+    end
+    errors
+  end
+
+  def short_type
+    "elb"
+  end
+
+  def self._fetch_remote_resources
+    AwsClients.elb.describe_load_balancers['load_balancer_descriptions'].map(&:to_h).map do |elb|
+      elb[:_terraform_id] = elb[:load_balancer_name]
+      elb[:_geo_id] = elb[:load_balancer_name]
+      elb[:name] = elb[:load_balancer_name]
+      elb
+    end
+  end
+end

data/lib/geoengineer/resources/aws_iam_policy.rb

@@ -0,0 +1,53 @@
+########################################################################
+# AwsIamPolicy +aws_iam_policy+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/iam_policy.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsIamPolicy < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name, :policy]) }
+
+  after :initialize, -> {
+    _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id }
+  }
+  after :initialize, -> {
+    _geo_id -> { name.to_s }
+  }
+
+  def to_terraform_state
+    arn = NullObject.maybe(remote_resource).arn
+    default_version_id = NullObject.maybe(remote_resource).default_version_id
+    policy = _get_policy_document(arn, default_version_id)
+
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'policy' => policy
+    }
+    tfstate
+  end
+
+  def support_tags?
+    false
+  end
+
+  def _get_policy_document(arn, version_id)
+    response = AwsClients.iam.get_policy_version({ policy_arn: arn,
+                                                   version_id: version_id })
+    URI.decode(response.policy_version.document)
+  end
+
+  def self._all_remote_policies
+    AwsClients.iam.list_policies.each.map(&:policies).flatten.map(&:to_h)
+  end
+
+  def self._fetch_remote_resources
+    _all_remote_policies.map(&:to_h).map do |policy|
+      {
+        '_terraform_id' => policy[:arn],
+        '_geo_id' => policy[:policy_name],
+        'arn' => policy[:arn],
+        'default_version_id' => policy[:default_version_id],
+        'name' => policy[:policy_name]
+      }
+    end
+  end
+end

data/lib/geoengineer/resources/aws_iam_user.rb

@@ -0,0 +1,42 @@
+########################################################################
+# AwsIamUser +aws_iam_user+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/iam_user.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsIamUser < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name]) }
+
+  after :initialize, -> {
+    _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id }
+  }
+  after :initialize, -> {
+    _geo_id -> { name.to_s }
+  }
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'name' => name,
+      'force_destroy' => (force_destroy || 'false')
+    }
+    tfstate
+  end
+
+  def support_tags?
+    false
+  end
+
+  def self._all_remote_users
+    AwsClients.iam.list_users.each.map(&:users).flatten.map(&:to_h)
+  end
+
+  def self._fetch_remote_resources
+    _all_remote_users.map do |user|
+      {
+        '_terraform_id' => user[:user_name],
+        '_geo_id' => user[:user_name],
+        'name' => user[:user_name]
+      }
+    end
+  end
+end

data/lib/geoengineer/resources/aws_instance.rb

@@ -0,0 +1,24 @@
+########################################################################
+# AwsInstance is the +aws_db_parameter_group+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/db_parameter_group.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsInstance < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:ami, :instance_type]) }
+  validate -> { validate_has_tag(:Name) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { NullObject.maybe(tags)[:Name] } }
+
+  def self._all_remote_instances
+    AwsClients.ec2.describe_instances.reservations.map(&:instances).flatten.map(&:to_h)
+  end
+
+  def self._fetch_remote_resources
+    _all_remote_instances.map do |i|
+      i[:_terraform_id] = i[:instance_id]
+      i[:_geo_id] = i[:tags] ? i[:tags].select { |x| x[:key] == "Name" }.first[:value] : nil
+      i
+    end
+  end
+end

data/lib/geoengineer/resources/aws_proxy_protocol_policy.rb

@@ -0,0 +1,39 @@
+########################################################################
+# AwsProxyProtocolPolicy is the +aws_proxy_protocol_policy+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/proxy_protocol_policy.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsProxyProtocolPolicy < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:load_balancer, :instance_ports]) }
+
+  # _terraform_id is the ELB, and the name of the policy, i.e. "TFEnableProxyProtocol"
+  after :initialize, -> {
+    _terraform_id -> { "#{NullObject.maybe(load_balancer)._terraform_id}:TFEnableProxyProtocol" }
+  }
+
+  # The loadbalancer and the instance ports are necessary in the terraform state for the policy
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'load_balancer' => load_balancer._terraform_id,
+      'instance_ports.#' => instance_ports.length.to_s
+    }
+    instance_ports.each_with_index { |ip, i|
+      tfstate[:primary][:attributes]["instance_ports.#{i}"] = ip
+    }
+    tfstate
+  end
+
+  def support_tags?
+    false
+  end
+
+  def short_type
+    "elbppp"
+  end
+
+  # This is a weird resource and it is not listed
+  def self._fetch_remote_resources
+    []
+  end
+end

data/lib/geoengineer/resources/aws_redshift_cluster.rb

@@ -0,0 +1,23 @@
+########################################################################
+# AwsRedshiftCluster is the +aws_redshift_cluster+ terrform resource,
+#
+# Terraform Docs
+# {https://www.terraform.io/docs/providers/aws/r/redshift_cluster.html#cluster_version}
+########################################################################
+class GeoEngineer::Resources::AwsRedshiftCluster < GeoEngineer::Resource
+  validate -> {
+    validate_required_attributes(
+      [:cluster_identifier, :node_type, :master_password, :master_username]
+    )
+  }
+  validate -> {
+    validate_required_attributes([:number_of_nodes]) if self.cluster_type == 'multi-node'
+  }
+  validate -> { validate_required_attributes([:bucket_name]) if self.enable_logging }
+
+  after :initialize, -> { _terraform_id -> { cluster_identifier } }
+
+  def self._fetch_remote_resources
+    AwsClients.redshift.describe_clusters.clusters.map(&:to_h)
+  end
+end

data/lib/geoengineer/resources/aws_route53_record.rb

@@ -0,0 +1,32 @@
+########################################################################
+# AwsRoute53Record is the +aws_route53_record+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/route53_record.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsRoute53Record < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:zone_id, :name, :type]) }
+  validate -> { validate_required_attributes([:ttl, :records]) unless self.alias }
+
+  validate -> {
+    if self.alias
+      validate_subresource_required_attributes(:alias, [:name, :zone_id, :evaluate_target_health])
+    end
+  }
+
+  after :initialize, -> { _terraform_id -> { "#{zone_id}_#{name}_#{type}" } }
+
+  def self._fetch_remote_resources
+    _fetch_zones.map { |zone| _fetch_records_for_zone(zone) }.flatten.compact
+  end
+
+  def self._fetch_zones
+    AwsClients.route53.list_hosted_zones.hosted_zones.map(&:to_h)
+  end
+
+  def self._fetch_records_for_zone(zone)
+    records = AwsClients.route53.list_resource_record_sets({ hosted_zone_id: zone[:id] })
+    records.resource_record_sets.map(&:to_h).map do |record|
+      record.merge({ _terraform_id: "#{record[:zone_id]}_#{record[:name]}_#{record[:type]}" })
+    end
+  end
+end

data/lib/geoengineer/resources/aws_route53_zone.rb

@@ -0,0 +1,21 @@
+########################################################################
+# AwsRoute53Zone is the +aws_route53_zone+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/route53_zone.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsRoute53Zone < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name]) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { self.name } }
+
+  def self._fetch_remote_resources
+    hosted_zones = AwsClients.route53.list_hosted_zones.hosted_zones.map(&:to_h)
+
+    hosted_zones.map do |zone|
+      zone[:_terraform_id] = zone[:id]
+      zone[:_geo_id]       = zone[:name]
+      zone
+    end
+  end
+end

data/lib/geoengineer/resources/aws_s3_bucket.rb

@@ -0,0 +1,54 @@
+########################################################################
+# AwsS3Bucket is the +aws_s3_bucket+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/s3_bucket.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsS3Bucket < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:bucket]) }
+  validate :validate_policy_json
+
+  after  :initialize, -> { _terraform_id -> { bucket } }
+  before :validation, -> {
+    # AWS/Terraform reorganises and adds information to the policy that affects it
+    # This adds that information to ensure unnecessary change
+    if policy && validate_policy_json.nil?
+      old_policy = self.policy
+      policy_hash = JSON.parse(old_policy)
+      # First each statement must have Sid
+      (policy_hash["Statement"] || []).each { |s| s["Sid"] = s["Sid"] || "" }
+
+      self.policy = policy_hash.to_json
+    end
+  }
+
+  def validate_policy_json
+    return unless policy
+    JSON.parse(policy)
+    return nil
+  rescue JSON::ParserError
+    return "Error: policy #{for_resource} invalid JSON"
+  end
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'acl' => (acl || 'private'),
+      'force_destroy' => (force_destroy || 'false'),
+      'policy' => policy
+    }
+    tfstate
+  end
+
+  def short_type
+    "s3"
+  end
+
+  def self._fetch_remote_resources
+    AwsClients.s3.list_buckets[:buckets].map(&:to_h).map do |s3b|
+      s3b[:_terraform_id] = s3b[:name]
+      s3b[:_geo_id] = s3b[:name]
+      s3b[:bucket]  = s3b[:name]
+      s3b
+    end
+  end
+end