geoengineer 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10a3ba58afd64f71c7acc870e588f452f26f544a
-  data.tar.gz: 50072402a6cd1b74baa75df96161f2a7d98d56b7
+  metadata.gz: ebcdcd4573207cc095eeb99bcc20771ddae9f2fa
+  data.tar.gz: d34079a107d98e72ebb3206395d6982a63238efc
 SHA512:
-  metadata.gz: 9999badc1ff21e9043a4f753e62a271ab98a6d09c137b948ced6802c61c32b7e68a2321aa95d65c2ab2c77f0d6d44b103df6a13567c13a0599a66dbee34db97d
-  data.tar.gz: e5e1b196d5582b70dc792c1a163ea0bf451285048c62f5a7df8de50ddab2c9e0326e7bd47106f347057396212bdb613ab9d7e14e41dc7029919400dc41d059c3
+  metadata.gz: '0092827fe84c1e9325ec4511133f7d80299bbd9d67a96e47ac62c84c11fc7e5c792e298ecbc78442d9ab219c9d5168a16eb12b2b162b2df53f138e28bc308e55'
+  data.tar.gz: ddd2677004c40b506e3336fa0882236a8c231181aa1f9ce405816b8de95ec446a02eee7e687c5ab2dec3dc741bc9bc4c9b8f8a72655103bf3764b1155ad54918

data/README.md

@@ -275,12 +275,14 @@ class GeoEngineer::Resources::AwsSecurityGroup < GeoEngineer::Resource
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { NullObject.maybe(tags)[:Name] } }
 
-  def self._fetch_remote_resources
-    AwsClients.ec2.describe_security_groups['security_groups'].map(&:to_h).map do |sg|
-      sg[:name] = sg[:group_name]
-      sg[:_terraform_id] = sg[:group_id]
-      sg[:_geo_id] = sg[:tags] ? sg[:tags].select { |x| x[:key] == "Name" }.first[:value] : nil
-      sg
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider)
+      .describe_security_groups['security_groups']
+      .map(&:to_h).map do |sg|
+        sg[:name] = sg[:group_name]
+        sg[:_terraform_id] = sg[:group_id]
+        sg[:_geo_id] = sg[:tags] ? sg[:tags].select { |x| x[:key] == "Name" }.first[:value] : nil
+        sg
     end
   end
 end

data/lib/geoengineer.rb

@@ -27,3 +27,5 @@ Dir["#{File.dirname(__FILE__)}/geoengineer/utils/**/*.rb"].each { |f| require f
 Dir["#{File.dirname(__FILE__)}/geoengineer/*.rb"].each { |f| require f }
 
 Dir["#{File.dirname(__FILE__)}/geoengineer/resources/**/*.rb"].each { |f| require f }
+
+Dir["#{File.dirname(__FILE__)}/geoengineer/templates/**/*.rb"].each { |f| require f }

data/lib/geoengineer/cli/geo_cli.rb

@@ -206,10 +206,7 @@ class GeoCLI
     global_options
 
     # Require any patches to the way geo works
-    if File.file?("#{Dir.pwd}/.geo.rb")
-      require_from_pwd '.geo'
-      puts "Loaded patches from .geo.rb" if @verbose
-    end
+    require_from_pwd '.geo' if File.file?("#{Dir.pwd}/.geo.rb")
 
     # Add commands
     add_commands

data/lib/geoengineer/cli/terraform_commands.rb

@@ -22,9 +22,11 @@ module GeoCLI::TerraformCommands
   def terraform_plan
     plan_commands = [
       "cd #{@tmpdir}",
-      "terraform plan -parallelism=#{terraform_parallelism}" \
+      "terraform refresh",
+      "terraform plan --refresh=false -parallelism=#{terraform_parallelism}" \
       " -state=#{@terraform_state_file} -out=#{@plan_file} #{@no_color}"
     ]
+
     shell_exec(plan_commands.join(" && "), true)
   end
 
@@ -32,7 +34,7 @@ module GeoCLI::TerraformCommands
     apply_commands = [
       "cd #{@tmpdir}",
       "terraform apply -parallelism=#{terraform_parallelism}" \
-      " -state=#{@terraform_state_file} #{@plan_file} #{@no_color}"
+      " #{@plan_file} #{@no_color}"
     ]
     shell_exec(apply_commands.join(" && "), true)
   end

data/lib/geoengineer/environment.rb

@@ -56,6 +56,7 @@ class GeoEngineer::Environment
   def initialize(name, &block)
     @name = name
     @outputs = []
+    @providers = []
     self.send("#{name}?=", true) # e.g. staging?
     instance_exec(self, &block) if block_given?
   end
@@ -76,6 +77,16 @@ class GeoEngineer::Environment
     resource
   end
 
+  def provider(id, &block)
+    provider = GeoEngineer::Provider.new(id, &block)
+    @providers << provider
+    provider
+  end
+
+  def find_provider(id_alias)
+    @providers.find { |p| p.terraform_id == id_alias }
+  end
+
   def output(id, value, &block)
     output = GeoEngineer::Output.new(id, value, &block)
     @outputs << output
@@ -131,6 +142,7 @@ class GeoEngineer::Environment
     end
 
     tf_resources = all_resources.map(&:to_terraform)
+    tf_resources += @providers.compact.map(&:to_terraform)
     tf_resources += @outputs.compact.map(&:to_terraform)
     tf_resources.join("\n\n")
   end
@@ -145,6 +157,7 @@ class GeoEngineer::Environment
 
     h = { resource: json_resources }
     h[:output] = @outputs.map(&:to_terraform_json) unless @outputs.empty?
+    h[:provider] = @providers.map(&:to_terraform_json) unless @providers.empty?
     h
   end
 
@@ -186,7 +199,7 @@ class GeoEngineer::Environment
   def uncodified_resources(type)
     # unmanaged resources have a remote resource without local_resource
     clazz = self.class.get_resource_class_from_type(type)
-    res = clazz.fetch_remote_resources.select { |r| r.local_resource.nil? }
+    res = clazz.fetch_remote_resources(nil).select { |r| r.local_resource.nil? }
     res.sort_by(&:terraform_name)
   end
 end

data/lib/geoengineer/provider.rb

@@ -0,0 +1,38 @@
+########################################################################
+# Outputs are mapped 1:1 to terraform outputs
+#
+# {https://www.terraform.io/docs/providers/aws/ Terraform Docs}
+########################################################################
+class GeoEngineer::Provider
+  attr_reader :id
+  include HasAttributes
+
+  def initialize(id, &block)
+    @id = id
+    instance_exec(self, &block) if block_given?
+  end
+
+  def terraform_id
+    if self.alias
+      "#{id}.#{self.alias}"
+    else
+      id
+    end
+  end
+
+  ## Terraform methods
+  def to_terraform
+    sb = ["provider #{@id.inspect} { "]
+
+    sb.concat terraform_attributes.map { |k, v|
+      "  #{k.to_s.inspect} = #{v.inspect}"
+    }
+
+    sb << " }"
+    sb.join("\n")
+  end
+
+  def to_terraform_json
+    { id.to_s => terraform_attributes }
+  end
+end

data/lib/geoengineer/resource.rb

@@ -8,6 +8,8 @@
 # A Resource can have arbitrary attributes, validation rules and lifecycle hooks
 ########################################################################
 class GeoEngineer::Resource
+  DEFAULT_PROVIDER = "default_provider".freeze
+
   include HasAttributes
   include HasSubResources
   include HasValidations
@@ -45,6 +47,11 @@ class GeoEngineer::Resource
     @_remote
   end
 
+  def depends_on(list_or_item)
+    self[:depends_on] ||= []
+    self[:depends_on].concat([list_or_item].flatten.compact)
+  end
+
   # Look up the resource remotly to see if it exists
   # This method will not work within a resource definition
   def new?
@@ -111,10 +118,10 @@ class GeoEngineer::Resource
     raise "file #{path} not found" unless File.file?(path)
 
     raw = File.open(path, "rb").read
-    interpolated = ERB.new(raw).result(binding_obj)
-    escaped = interpolated.gsub("$", "$$")
+    interpolated = ERB.new(raw).result(binding_obj).to_s
+
     # normalize JSON to prevent terraform from e.g. newlines as legitimate changes
-    normalized = _normalize_json(escaped)
+    normalized = _normalize_json(interpolated)
 
     send(attribute, normalized)
   end
@@ -155,19 +162,29 @@ class GeoEngineer::Resource
   end
 
   def matched_remote_resource
-    self.class.fetch_remote_resources.select { |r| r._geo_id == _geo_id }
+    self.class.fetch_remote_resources(fetch_provider).select { |r| r._geo_id == _geo_id }
+  end
+
+  # There are two types of provider, the string given to a resource, and the object with attributes
+  # this method takes the string on the resource and returns the object
+  def fetch_provider
+    environment&.find_provider(provider)
   end
 
-  def self.fetch_remote_resources
-    return @_rr_cache if @_rr_cache
-    @_rr_cache = _fetch_remote_resources
-                 .reject { |resource| _ignore_remote_resource?(resource) }
-                 .map { |resource| GeoEngineer::Resource.build(resource) }
+  def self.fetch_remote_resources(provider)
+    # The cache key is the provider
+    # no provider no resource
+    provider_id = provider&.terraform_id || DEFAULT_PROVIDER
+    @_rr_cache ||= {}
+    return @_rr_cache[provider_id] if @_rr_cache[provider_id]
+    @_rr_cache[provider_id] = _fetch_remote_resources(provider)
+                              .reject { |resource| _ignore_remote_resource?(resource) }
+                              .map { |resource| GeoEngineer::Resource.build(resource) }
   end
 
   # This method must be implemented for each resource type
   # it must return a list of hashes with at least the key
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     throw "NOT IMPLEMENTED ERROR for #{name}"
   end
 
@@ -246,11 +263,8 @@ class GeoEngineer::Resource
   def merge_tags(source)
     setup_tags_if_needed
 
-    send(source)
-      .all_tags
-      .map(&:attributes)
-      .reduce({}, :merge)
-      .each { |key, value| tags.attributes[key] ||= value }
+    send(source).all_tags.map(&:attributes).reduce({}, :merge)
+                .each { |key, value| tags.attributes[key] ||= value }
   end
 
   # VALIDATION METHODS

data/lib/geoengineer/resources/api_gateway/helpers.rb

@@ -0,0 +1,107 @@
+########################################################################
+# GeoEngineer::ApiGatewayHelpers Utility methods for ApiGateway resources
+#
+########################################################################
+module GeoEngineer::ApiGatewayHelpers
+  def self._rest_api_cache
+    @_rest_api_cache ||= {}
+    @_rest_api_cache
+  end
+
+  def self._rest_api_resource_cache
+    @_rest_api_resource_cache ||= {}
+    @_rest_api_resource_cache
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Class Methods
+  module ClassMethods
+    # Helper Client
+    def _client(provider)
+      AwsClients.api_gateway(provider)
+    end
+
+    # Rest API
+    def _fetch_remote_rest_apis(provider)
+      cache = GeoEngineer::ApiGatewayHelpers._rest_api_cache
+      return cache[provider] if cache[provider]
+
+      ret = _client(provider).get_rest_apis['items'].map(&:to_h).map do |rr|
+        rr[:_terraform_id]    = rr[:id]
+        rr[:_geo_id]          = rr[:name]
+        rr[:root_resource_id] = _root_resource_id(provider, rr)
+        rr
+      end.compact
+      cache[provider] = ret
+      ret
+    end
+
+    def _root_resource_id(provider, rr)
+      _client(provider).get_resources({ rest_api_id: rr[:id] })['items'].map do |res|
+        return res.id if res.path == '/'
+      end
+      nil
+    end
+
+    def __fetch_remote_rest_api_resources_for_rest_api(provider, rr)
+      _client(provider).get_resources({
+                                        rest_api_id: rr[:_terraform_id]
+                                      })['items'].map(&:to_h).map do |res|
+        next nil unless res[:path_part] # default resource has no path_part
+        res[:_terraform_id] = res[:id]
+        res[:_geo_id]       = "#{rr[:_geo_id]}::#{res[:path_part]}"
+        res
+      end.compact
+    end
+
+    # Resources
+    def _fetch_remote_rest_api_resources_for_rest_api(provider, rr)
+      cache = GeoEngineer::ApiGatewayHelpers._rest_api_resource_cache[provider] ||= {}
+      return cache[rr[:_terraform_id]] if cache[rr[:_terraform_id]]
+
+      cache[rr[:_terraform_id]] = __fetch_remote_rest_api_resources_for_rest_api(provider, rr)
+    end
+
+    # Combination Methods
+    def _remote_rest_api_resource(provider)
+      _fetch_remote_rest_apis(provider).map do |rr|
+        _fetch_remote_rest_api_resources_for_rest_api(provider, rr).map do |res|
+          yield rr, res
+        end
+      end
+    end
+
+    def _remote_rest_api_resource_method(provider)
+      _remote_rest_api_resource(provider) do |rr, res|
+        (res[:resource_methods] || {}).keys.map do |meth|
+          yield rr, res, meth
+        end
+      end
+    end
+
+    # Integration
+    def _fetch_integration(provider, rr, res, meth)
+      return _client(provider).get_integration({
+                                                 rest_api_id: rr[:_terraform_id],
+                                                 resource_id: res[:_terraform_id],
+                                                 http_method: meth
+                                               }).to_h
+    rescue Aws::APIGateway::Errors::NotFoundException
+      return nil
+    end
+
+    # Method
+    def _fetch_method(provider, rr, res, meth)
+      return _client(provider).get_method({
+                                            rest_api_id: rr[:_terraform_id],
+                                            resource_id: res[:_terraform_id],
+                                            http_method: meth
+                                          }).to_h
+    rescue Aws::APIGateway::Errors::NotFoundException
+      return nil
+    end
+  end
+end

data/lib/geoengineer/resources/aws_alb.rb

@@ -0,0 +1,39 @@
+########################################################################
+# AwsAlb is the +aws_alb+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/alb.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsAlb < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:subnets]) }
+  validate -> { validate_subresource_required_attributes(:access_logs, [:bucket]) }
+  validate -> { validate_has_tag(:Name) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id       -> { NullObject.maybe(tags)[:Name] } }
+
+  def short_type
+    "alb"
+  end
+
+  def self._merge_attributes(albs, tags)
+    albs.map do |alb|
+      alb_tags = tags.find { |desc| desc[:resource_arn] == alb[:load_balancer_arn] }
+      alb.merge(
+        {
+          _terraform_id: alb[:load_balancer_arn],
+          _geo_id: alb_tags[:tags]&.find { |tag| tag[:key] == "Name" }.dig(:value)
+        }
+      )
+    end
+  end
+
+  def self._fetch_remote_resources(provider)
+    albs = AwsClients.alb(provider).describe_load_balancers['load_balancers'].map(&:to_h)
+    tags = AwsClients.alb(provider)
+                     .describe_tags({ resource_arns: albs.map { |alb| alb[:load_balancer_arn] } })
+                     .tag_descriptions
+                     .map(&:to_h)
+
+    _merge_attributes(albs, tags)
+  end
+end

data/lib/geoengineer/resources/aws_alb_listener.rb

@@ -0,0 +1,39 @@
+########################################################################
+# AwsAlbListener is the +aws_alb_listener+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/alb_listener.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsAlbListener < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:load_balancer_arn, :port, :default_action]) }
+  validate -> {
+    validate_subresource_required_attributes(:default_action, [:target_group_arn, :type])
+  }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id       -> { "#{load_balancer_arn}::#{port}" } }
+
+  def short_type
+    "alb_listener"
+  end
+
+  def self._merge_attributes(listener)
+    listener.merge(
+      {
+        _geo_id: "#{listener[:load_balancer_arn]}::#{listener[:port]}",
+        _terraform_id: listener[:listener_arn]
+      }
+    )
+  end
+
+  def self._fetch_remote_resources(provider)
+    albs = AwsClients.alb(provider).describe_load_balancers['load_balancers'].map(&:to_h)
+    albs.map do |alb|
+      AwsClients
+        .alb(provider)
+        .describe_listeners({ load_balancer_arn: alb[:load_balancer_arn] })
+        .listeners
+        .map(&:to_h)
+        .map { |listener| _merge_attributes(listener) }
+    end.flatten.compact
+  end
+end

data/lib/geoengineer/resources/aws_alb_listener_rule.rb

@@ -0,0 +1,42 @@
+########################################################################
+# AwsAlbListenerRule is the +aws_alb_listener_rule+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/alb_listener_rule.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsAlbListenerRule < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:listener_arn, :priority, :action, :condition]) }
+  validate -> {
+    validate_subresource_required_attributes(:action, [:target_group_arn, :type])
+  }
+  validate -> {
+    validate_subresource_required_attributes(:condition, [:field, :values])
+  }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id       -> { "#{listener_arn}::#{priority}" } }
+
+  def short_type
+    "alb_listener_rule"
+  end
+
+  def self._merge_attributes(rule, listener)
+    rule.merge(
+      {
+        _geo_id: "#{listener[:listener_arn]}::#{rule[:priority]}",
+        _terraform_id: rule[:rule_arn]
+      }
+    )
+  end
+
+  def self._fetch_remote_resources(provider)
+    listeners = GeoEngineer::Resources::AwsAlbListener._fetch_remote_resources(provider)
+    listeners.map do |listener|
+      AwsClients
+        .alb(provider)
+        .describe_rules({ listener_arn: listener[:listener_arn] })
+        .rules
+        .map(&:to_h)
+        .map { |rule| _merge_attributes(rule, listener) }
+    end.flatten.compact
+  end
+end