geoengineer 0.1.4 → 0.1.5

data/lib/geoengineer/resources/aws_route53_zone.rb

@@ -7,15 +7,42 @@ 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 } }
+  after :initialize, -> { _geo_id -> { "#{self._public_or_private}-#{self.name}." } }
+
+  def _public_or_private
+    self.vpc_id.nil? ? 'public' : self.vpc_id
+  end
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'name' => name,
+      'vpc_id' => vpc_id,
+      'force_destroy' => (force_destroy || 'false')
+    }
+    tfstate
+  end
 
   def self._fetch_remote_resources(provider)
-    hosted_zones = AwsClients.route53(provider).list_hosted_zones.hosted_zones.map(&:to_h)
+    _fetch_zones(provider).map { |zone| _generate_remote_zone(provider, zone) }
+  end
+
+  def self._fetch_zones(provider)
+    AwsClients.route53(provider).list_hosted_zones.hosted_zones.map(&:to_h)
+  end
+
+  def self._generate_remote_zone(provider, zone)
+    is_private_zone = zone.dig(:config, :private_zone) || false
+
+    zone[:id] = zone[:id].gsub(%r{^/hostedzone/}, '')
+    zone[:zone_id]       = zone[:id]
+    zone[:_terraform_id] = zone[:id]
+    zone[:vpc_id]        = _get_zone_vpc_id(provider, zone[:id]) if is_private_zone
+    zone[:_geo_id]       = "#{is_private_zone ? zone[:vpc_id] : 'public'}-#{zone[:name]}"
+    zone
+  end
 
-    hosted_zones.map do |zone|
-      zone[:_terraform_id] = zone[:id]
-      zone[:_geo_id]       = zone[:name]
-      zone
-    end
+  def self._get_zone_vpc_id(provider, zone_id)
+    AwsClients.route53(provider).get_hosted_zone({ id: zone_id }).to_h[:vp_cs].first[:vpc_id]
   end
 end

data/lib/geoengineer/resources/aws_route_table.rb

@@ -7,7 +7,7 @@ class GeoEngineer::Resources::AwsRouteTable < GeoEngineer::Resource
   validate -> { validate_required_attributes([:vpc_id]) }
   validate -> { validate_has_tag(:Name) }
   validate -> {
-    validate_subresource_required_attributes(:route, [:cider_block]) unless self.all_route.empty?
+    validate_subresource_required_attributes(:route, [:cidr_block]) unless self.all_route.empty?
   }
 
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }

data/lib/geoengineer/resources/aws_s3_bucket_object.rb

@@ -0,0 +1,24 @@
+########################################################################
+# AwsS3Bucket is the +aws_s3_bucket_object+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/s3_bucket_object.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsS3BucketObject < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:bucket]) }
+
+  after :initialize, -> { _terraform_id -> { bucket } }
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'bucket' => bucket,
+      'key'    => key,
+      'source' => source
+    }
+    tfstate
+  end
+
+  def short_type
+    's3_object'
+  end
+end

data/lib/geoengineer/resources/aws_vpn_connection.rb

@@ -10,15 +10,23 @@ class GeoEngineer::Resources::AwsVpnConnection < GeoEngineer::Resource
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { NullObject.maybe(tags)[:Name] } }
 
+  def vpn_type(val = nil)
+    val ? self["type"] = val : self["type"]
+  end
+
   def self._fetch_remote_resources(provider)
-    AwsClients.ec2(provider)
-              .describe_vpn_connections['vpn_connections'].map(&:to_h).map do |connection|
-      connection.merge(
-        {
-          _terraform_id: connection[:vpn_connection_id],
-          _geo_id: connection[:tags].find { |tag| tag[:key] == "Name" }&.dig(:value)
-        }
-      )
-    end
+    AwsClients
+      .ec2(provider)
+      .describe_vpn_connections['vpn_connections']
+      .reject { |connection| connection['state'] == 'deleted' } # Necessary for development
+      .map(&:to_h)
+      .map do |connection|
+        connection.merge(
+          {
+            _terraform_id: connection[:vpn_connection_id],
+            _geo_id: connection[:tags].find { |tag| tag[:key] == "Name" }&.dig(:value)
+          }
+        )
+      end
   end
 end

data/lib/geoengineer/resources/aws_vpn_connection_route.rb

@@ -6,30 +6,66 @@
 class GeoEngineer::Resources::AwsVpnConnectionRoute < GeoEngineer::Resource
   validate -> { validate_required_attributes([:destination_cidr_block, :vpn_connection_id]) }
 
-  after :initialize, -> { _terraform_id -> { "#{destination_cidr_block}:#{vpn_connection_id}" } }
+  after :initialize, -> {
+    _terraform_id -> {
+      connection_route_id unless terraform_ref?
+    }
+  }
+
+  after :initialize, -> {
+    _geo_id -> {
+      connection_route_id
+    }
+  }
+
+  # Is the VPN connection id a terraform ref or an id
+  def terraform_ref?
+    /^\${[a-zA-Z0-9\._-]+}$/.match(vpn_connection_id)
+  end
+
+  def to_terraform_state
+    tfstate = super
+
+    tfstate[:primary][:attributes] = {
+      'destination_cidr_block' => destination_cidr_block,
+      'vpn_connection_id' => vpn_connection_id
+    }
+
+    tfstate
+  end
+
+  def connection_route_id
+    self.class.build_connection_route_id(
+      destination_cidr_block,
+      vpn_connection_id
+    )
+  end
+
+  def self.build_connection_route_id(cidr, connection_id)
+    "#{cidr}:#{connection_id}"
+  end
 
   def support_tags?
     false
   end
 
   def self._fetch_remote_resources(provider)
-    AwsClients
-      .ec2(provider)
-      .describe_vpn_connections['vpn_connections']
-      .map(&:to_h)
-      .select { |connection| !connection[:routes].empty? }
-      .map { |connection| _generate_routes(connection) }
-      .flatten
+    AwsClients.ec2(provider)
+              .describe_vpn_connections['vpn_connections']
+              .map(&:to_h)
+              .select { |connection| !connection[:routes].empty? }
+              .map { |connection| _generate_routes(connection) }
+              .flatten
   end
 
   def self._generate_routes(connection)
     connection[:routes].map do |route|
-      route.merge(
-        {
-          _terraform_id: "#{route[:destination_cidr_block]}:#{connection[:vpn_connection_id]}",
-          vpn_connection_id: connection[:vpn_connection_id]
-        }
-      )
+      cidr = route[:destination_cidr_block]
+      connection_id = connection[:vpn_connection_id]
+
+      id = build_connection_route_id(cidr, connection_id)
+
+      route.merge({ _terraform_id: id, _geo_id: id })
     end
   end
 end

data/lib/geoengineer/resources/aws_waf_ipset.rb

@@ -0,0 +1,35 @@
+########################################################################
+# AwsWafIpset is the +aws_waf_ipset+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/waf_ipset.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsWafIpset < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name]) }
+  validate :validate_correct_cidr_blocks
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { name } }
+
+  def self._fetch_remote_resources(provider)
+    AwsClients.waf(provider).list_ip_sets['ip_sets'].map(&:to_h).map do |s|
+      s.merge(
+        {
+          _terraform_id: s[:ip_set_id],
+          _geo_id: s[:name]
+        }
+      )
+      s
+    end
+  end
+
+  def validate_correct_cidr_blocks
+    errors = []
+    error = validate_cidr_block(self.ip_set_descriptors&.value)
+    errors << error unless error.nil?
+    errors
+  end
+
+  def support_tags?
+    false
+  end
+end

data/lib/geoengineer/resources/aws_waf_rule.rb

@@ -0,0 +1,26 @@
+########################################################################
+# AwsWafRule is the +aws_waf_rule+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/waf_rule.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsWafRule < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:metric_name, :name]) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { name } }
+
+  def self._fetch_remote_resources(provider)
+    AwsClients.waf(provider).list_rules['rules'].map(&:to_h).map do |s|
+      s.merge(
+        {
+          _terraform_id: s[:rule_id],
+          _geo_id: s[:name]
+        }
+      )
+    end
+  end
+
+  def support_tags?
+    false
+  end
+end

data/lib/geoengineer/resources/aws_waf_web_acl.rb

@@ -0,0 +1,26 @@
+########################################################################
+# AwsWafWebAcl is the +aws_waf_web_acl+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/waf_web_acl.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsWafWebAcl < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:metric_name, :default_action, :name, :rules]) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { name } }
+
+  def self._fetch_remote_resources(provider)
+    AwsClients.waf(provider).list_web_acls['web_acls'].map(&:to_h).map do |acl|
+      acl.merge(
+        {
+          _terraform_id: acl[:web_acl_id],
+          _geo_id: acl[:name]
+        }
+      )
+    end
+  end
+
+  def support_tags?
+    false
+  end
+end

data/lib/geoengineer/utils/aws_clients.rb

@@ -14,6 +14,7 @@ class AwsClients
   def self.client_params(provider = nil)
     client_params = { stub_responses: stubbed? }
     client_params[:region] = provider.region if provider
+    client_params[:retry_limit] = Integer(ENV['AWS_RETRY_LIMIT']) if ENV['AWS_RETRY_LIMIT']
     client_params
   end
 
@@ -178,4 +179,18 @@ class AwsClients
       Aws::KMS::Client
     )
   end
+
+  def self.waf(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::WAF::Client
+    )
+  end
+
+  def self.emr(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::EMR::Client
+    )
+  end
 end

data/lib/geoengineer/utils/has_validations.rb

@@ -51,6 +51,7 @@ module HasValidations
   # Validates CIDR block format
   # Returns error when argument fails validation
   def validate_cidr_block(cidr_block)
+    return "Empty cidr block" if cidr_block.nil? || cidr_block.empty?
     return if NetAddr::CIDR.create(cidr_block)
   rescue NetAddr::ValidationError
     return "Bad cidr block \"#{cidr_block}\" #{for_resource}"

data/lib/geoengineer/version.rb

@@ -1,3 +1,3 @@
 module GeoEngineer
-  VERSION = '0.1.4'.freeze
+  VERSION = '0.1.5'.freeze
 end

data/spec/resource_spec.rb

@@ -325,6 +325,62 @@ describe GeoEngineer::Resource do
     end
   end
 
+  describe '#duplicate' do
+    let!(:project) do
+      GeoEngineer::Project.new('org', 'project_name', nil) {
+        tags {
+          a  '1'
+        }
+      }
+    end
+    let!(:resource_class) do
+      class GeoEngineer::Resources::Derp < GeoEngineer::Resource
+        validate -> { validate_has_tag(:Name) }
+        after :initialize, -> {
+          _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id }
+        }
+        after :initialize, -> { _geo_id       -> { NullObject.maybe(tags)[:Name] } }
+        after :initialize, -> { _number       -> { NullObject.maybe(_geo_id)[-1] } }
+
+        def self._fetch_remote_resources(provider)
+          [
+            { _geo_id: "geo_id1", _terraform_id: "t1 baby!" },
+            { _geo_id: "geo_id2", _terraform_id: "t who?" }
+          ]
+        end
+      end
+    end
+
+    let(:subject) do
+      project.resource('derp', 'id') {
+        tags {
+          Name "geo_id1"
+        }
+      }
+    end
+
+    it 'copies over attributes and subresources' do
+      copy = subject.duplicate('duplicate')
+      # We haven't changed anything, so it should all match
+      expect(copy.type).to eq(subject.type)
+      expect(copy._geo_id).to eq(subject._geo_id)
+      expect(copy._terraform_id).to eq(subject._terraform_id)
+      expect(copy._number).to eq(subject._number)
+      expect(copy.tags["Name"]).to eq(subject.tags["Name"])
+    end
+
+    it 'handles procs appropriately' do
+      copy = subject.duplicate('duplicate')
+      copy.tags["Name"] = "geo_id2"
+
+      expect(copy.type).to eq(subject.type)
+      expect(copy._geo_id).to_not eq(subject._geo_id)
+      expect(copy._terraform_id).to_not eq(subject._terraform_id)
+      expect(copy._number).to_not eq(subject._number)
+      expect(copy._number).to eq("2")
+    end
+  end
+
   describe 'class method' do
     describe('#type_from_class_name') do
       it 'should return resource' do

data/spec/resources/aws_alb_listener_spec.rb

@@ -12,7 +12,12 @@ describe GeoEngineer::Resources::AwsAlbListener do
       alb_client.stub_responses(
         :describe_load_balancers,
         {
-          load_balancers: [{ load_balancer_arn: "foo/bar-baz" }]
+          load_balancers: [
+            {
+              load_balancer_arn: "foo/bar-baz",
+              load_balancer_name: "foo-bar-baz"
+            }
+          ]
         }
       )
       alb_client.stub_responses(

data/spec/resources/aws_alb_spec.rb

@@ -29,5 +29,12 @@ describe GeoEngineer::Resources::AwsAlb do
       remote_resources = GeoEngineer::Resources::AwsAlb._fetch_remote_resources(nil)
       expect(remote_resources.length).to eq 1
     end
+
+    it "should work if no ALB's exist" do
+      alb_client.stub_responses(:describe_load_balancers, { load_balancers: [] })
+
+      remote_resources = GeoEngineer::Resources::AwsAlb._fetch_remote_resources(nil)
+      expect(remote_resources.length).to eq 0
+    end
   end
 end

data/spec/resources/aws_alb_target_group_spec.rb

@@ -28,8 +28,30 @@ describe GeoEngineer::Resources::AwsAlbTargetGroup do
           ]
         }
       )
+      alb_client.stub_responses(
+        :describe_tags,
+        {
+          tag_descriptions: [
+            {
+              resource_arn: "targetgroup/foo/bar-baz",
+              tags: [{ key: "Name", value: "foo/bar-baz" }]
+            },
+            {
+              resource_arn: "targetgroup/foo/test-test",
+              tags: [{ key: "Name", value: "foo/test-test" }]
+            }
+          ]
+        }
+      )
       remote_resources = GeoEngineer::Resources::AwsAlbTargetGroup._fetch_remote_resources(nil)
       expect(remote_resources.length).to eq 2
     end
+
+    it "should work if no ALB's exist" do
+      alb_client.stub_responses(:describe_target_groups, { target_groups: [] })
+
+      remote_resources = GeoEngineer::Resources::AwsAlbTargetGroup._fetch_remote_resources(nil)
+      expect(remote_resources.length).to eq 0
+    end
   end
 end