geoengineer 0.1.0

data/lib/geoengineer/output.rb

@@ -0,0 +1,27 @@
+########################################################################
+# Outputs are mapped 1:1 to terraform outputs
+#
+# {https://www.terraform.io/docs/configuration/outputs.html Terraform Docs}
+########################################################################
+class GeoEngineer::Output
+  attr_reader :id, :value
+
+  def initialize(id, value, &block)
+    @id    = id
+    @value = value
+  end
+
+  def to_terraform_json
+    { id: { value: value } }
+  end
+
+  def to_terraform
+    sb = ""
+    sb += "output #{@id.inspect} { "
+    sb += "\n"
+    sb += "  value = #{@value.inspect}"
+    sb += "\n"
+    sb += " }"
+    sb
+  end
+end

data/lib/geoengineer/project.rb

@@ -0,0 +1,79 @@
+########################################################################
+# Projects are groups of resources used to organize and validate.
+#
+# A Project contains resources, has arbitrary attributes and validation rules
+########################################################################
+class GeoEngineer::Project
+  include HasAttributes
+  include HasResources
+  include HasValidations
+
+  attr_accessor :org, :name
+  attr_reader :templates
+  attr_reader :environment
+
+  validate -> { environments.nil? ? "Project #{full_name} must have an environment" : nil }
+  validate -> { all_resources.map(&:errors).flatten }
+
+  def initialize(org, name, environment, &block)
+    @org = org
+    @name = name
+    @environment = environment
+    @templates = {}
+    instance_exec(self, &block) if block_given?
+  end
+
+  def full_id_name
+    "#{org}_#{name}".tr('-', '_')
+  end
+
+  def full_name
+    "#{org}/#{name}"
+  end
+
+  def resource(type, id, &block)
+    return find_resource(type, id) unless block_given?
+    resource = create_resource(type, id, &block)
+    resource.project = self
+    resource.environment = @environment
+    resource
+  end
+
+  def all_resources
+    reses = resources
+    @templates.each { |name, template| reses += template.all_resources }
+    reses
+  end
+
+  def find_template(type)
+    clazz_name = type.split('_').collect(&:capitalize).join
+    return Object.const_get(clazz_name) if Object.const_defined? clazz_name
+
+    module_clazz = "GeoEngineer::Templates::#{clazz_name}"
+    return Object.const_get(module_clazz) if Object.const_defined? module_clazz
+
+    throw "undefined template '#{type}' for '#{clazz_name}' or 'GeoEngineer::#{clazz_name}'"
+  end
+
+  def from_template(type, name, parameters = {}, &block)
+    throw "Template '#{name}' already defined for project #{full_name}" if @templates[name]
+    clazz = find_template(type)
+    template = clazz.new(name, self, parameters)
+    @templates[name] = template
+    template.instance_exec(*template.template_resources, &block) if block_given?
+    template
+  end
+
+  # dot method
+  def to_dot
+    str = ["  subgraph \"cluster_#{full_id_name}\" {"]
+    str << "    style = filled; color = lightgrey;"
+    str << "    label = <<B><FONT POINT-SIZE=\"24.0\">#{full_name}</FONT></B>>"
+    nodes = all_resources.map do |res|
+      "    node [label=#{res.short_name.inspect}, shape=\"box\"] #{res.to_ref.inspect};"
+    end
+    str << nodes
+    str << "  }"
+    str.join(" // #{full_name} \n")
+  end
+end

data/lib/geoengineer/resource.rb

@@ -0,0 +1,200 @@
+########################################################################
+# Resources are the core of GeoEngineer and are mapped 1:1 to terraform resources
+#
+# {https://www.terraform.io/docs/configuration/resources.html Terraform Docs}
+#
+# For example, +aws_security_group+ is a resource
+#
+# A Resource can have arbitrary attributes, validation rules and lifecycle hooks
+########################################################################
+class GeoEngineer::Resource
+  include HasAttributes
+  include HasSubResources
+  include HasValidations
+  include HasLifecycle
+
+  attr_accessor :environment, :project, :template
+
+  attr_reader :type, :id
+
+  validate -> { validate_required_attributes([:_geo_id]) }
+
+  def initialize(type, id, &block)
+    @type = type
+    @id = id
+
+    # Remembering parents, grand parents ...
+    @environment = nil
+    @project = nil
+    @template = nil
+
+    # Most resources will have the same _geo_id and _terraform_id
+    # Each resource must define _terraform_id
+    _geo_id -> { _terraform_id }
+    instance_exec(self, &block) if block_given?
+    execute_lifecycle(:after, :initialize)
+  end
+
+  def remote_resource
+    return @_remote if @_remote_searched
+    @_remote = _find_remote_resource
+    @_remote_searched = true
+    @_remote&.local_resource = self
+    @_remote
+  end
+
+  # Look up the resource remotly to see if it exists
+  # This method will not work within a resource definition
+  def new?
+    !remote_resource
+  end
+
+  ## Terraform methods
+  def to_terraform
+    sb = ["resource #{@type.inspect} #{@id.inspect} { "]
+
+    sb.concat terraform_attributes.map { |k, v|
+      "  #{k.to_s.inspect} = #{v.inspect}"
+    }
+
+    sb.concat subresources.map(&:to_terraform)
+    sb << " }"
+    sb.join("\n")
+  end
+
+  def to_terraform_json
+    json = terraform_attributes
+    subresources.map(&:to_terraform_json).each do |k, v|
+      json[k] ||= []
+      json[k] << v
+    end
+    json
+  end
+
+  def to_terraform_state
+    {
+      type: @type,
+      primary: {
+        id: _terraform_id
+      }
+    }
+  end
+
+  def terraform_name
+    "#{type}.#{id}"
+  end
+
+  # Override to_s
+  def to_s
+    terraform_name
+  end
+
+  def to_ref(attribute = "id")
+    "${#{terraform_name}.#{attribute}}"
+  end
+
+  # REMOTE METHODS
+
+  # This method will fetch the remote resource that has the same _geo_id as the codified resource.
+  # This method will:
+  # 1. return nil if no resource is found
+  # 2. return an instance of Resource with the remote attributes
+  # 3. throw an error if more than one resource has the same _geo_id
+  def _find_remote_resource
+    aws_resources = self.class.fetch_remote_resources()
+    matches = aws_resources.select { |r| r._geo_id == self._geo_id }
+
+    return matches.first if matches.length == 1
+    return nil if matches.empty?
+
+    throw "ERROR:\"#{self.type}.#{self.id}\" has #{matches.length} remote resources"
+  end
+
+  def self.fetch_remote_resources
+    return @_rr_cache if @_rr_cache
+    @_rr_cache = []
+    resource_hashes = _fetch_remote_resources()
+
+    resource_hashes.each do |res_hash|
+      @_rr_cache << GeoEngineer::Resource.new(self.type_from_class_name, res_hash['_geo_id']) {
+        # add attributes to the resource
+        res_hash.each do |k, v|
+          self[k] = v
+        end
+      }
+    end
+
+    @_rr_cache
+  end
+
+  def self.clear_remote_resource_cache
+    @_rr_cache = nil
+  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
+    throw "NOT IMPLEMENTED ERROR for #{self.name}"
+  end
+
+  # VIEW METHODS
+  def short_type
+    type
+  end
+
+  # strip project information if project
+  def short_id
+    si = id.to_s.tr('-', "_")
+    si = si.gsub(project.full_id_name, '') if project
+    si = si.gsub('__', '_').gsub(/^_|_$/, '')
+    si
+  end
+
+  def short_name
+    "#{short_type}.#{short_id}"
+  end
+
+  def in_project
+    project.nil? ? "" : "in project \"#{project.full_name}\""
+  end
+
+  def for_resource
+    "for resource \"#{type}.#{id}\" #{in_project}"
+  end
+
+  # VALIDATION METHODS
+  def support_tags?
+    true
+  end
+
+  def validate_required_subresource(subresource)
+    "Subresource '#{subresource}'' required #{for_resource}" if self.send(subresource.to_sym).nil?
+  end
+
+  def validate_subresource_required_attributes(subresource, keys)
+    errs = []
+    self.send("all_#{subresource}".to_sym).each do |sr|
+      keys.each do |key|
+        errs << "#{key} attribute on subresource #{subresource} nil #{for_resource}" if sr[key].nil?
+      end
+    end
+    errs
+  end
+
+  def validate_has_tag(tag)
+    errs = []
+    errs << validate_required_subresource(:tags)
+    errs.concat(validate_subresource_required_attributes(:tags, [tag]))
+    errs
+  end
+
+  # CLASS METHODS
+  def self.type_from_class_name
+    # from http://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    self.name.split('::').last
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+  end
+end

data/lib/geoengineer/resources/aws_db_instance.rb

@@ -0,0 +1,46 @@
+########################################################################
+# AwsDbInstance is the +aws_db_instance+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/db_instance.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsDbInstance < GeoEngineer::Resource
+  validate -> {
+    unless replicate_source_db
+      validate_required_attributes(
+        [
+          :allocated_storage,
+          :engine
+        ]
+      )
+    end
+  }
+  validate -> { validate_required_attributes([:password, :username, :name]) if new? }
+  validate -> { validate_required_attributes([:instance_class, :engine]) }
+  validate -> { validate_subresource_required_attributes(:access_logs, [:bucket]) }
+
+  after :initialize, -> { final_snapshot_identifier -> { "#{identifier}-final" } }
+  after :initialize, -> { _terraform_id -> { identifier } }
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'identifier' => _terraform_id,
+      'final_snapshot_identifier' => final_snapshot_identifier,
+      'skip_final_snapshot' => 'true'
+    }
+    tfstate
+  end
+
+  def short_type
+    "db"
+  end
+
+  def self._fetch_remote_resources
+    AwsClients.rds.describe_db_instances['db_instances'].map(&:to_h).map do |rds|
+      rds[:_terraform_id] = rds[:db_instance_identifier]
+      rds[:_geo_id]       = rds[:db_instance_identifier]
+      rds[:identifier]    = rds[:db_instance_identifier]
+      rds
+    end
+  end
+end

data/lib/geoengineer/resources/aws_db_parameter_group.rb

@@ -0,0 +1,25 @@
+########################################################################
+# AwsDbParameterGroup 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::AwsDbParameterGroup < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name, :family, :description]) }
+  validate -> { validate_subresource_required_attributes(:parameter, [:name, :value]) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { name } }
+
+  def short_type
+    "dbpg"
+  end
+
+  def self._fetch_remote_resources
+    AwsClients.rds.describe_db_parameter_groups['db_parameter_groups'].map(&:to_h).map do |pg|
+      pg[:_terraform_id] = pg[:db_parameter_group_name]
+      pg[:_geo_id] = pg[:db_parameter_group_name]
+      pg[:name] = pg[:db_parameter_group_name]
+      pg
+    end
+  end
+end

data/lib/geoengineer/resources/aws_elasticache_cluster.rb

@@ -0,0 +1,50 @@
+########################################################################
+# AwsElasticacheCluster is the +aws_elasticache_cluster+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/elasticache_cluster.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsElasticacheCluster < GeoEngineer::Resource
+  validate -> {
+    validate_required_attributes(
+      [
+        :cluster_id,
+        :engine,
+        :node_type,
+        :num_cache_nodes,
+        :parameter_group_name,
+        :port
+      ]
+    )
+  }
+
+  after :initialize, -> { _terraform_id -> { cluster_id } }
+
+  def to_terraform_state
+    tfstate = super
+    attributes = {
+      'port' => port.to_s,
+      'parameter_group_name' => parameter_group_name
+    }
+
+    # Security groups workaround
+    security_group_ids.each_with_index do |sg, i|
+      attributes["security_group_ids.#{i}"] = sg._terraform_id
+    end
+    attributes['security_group_ids.#'] = security_group_ids.count.to_s
+
+    tfstate[:primary][:attributes] = attributes
+    tfstate
+  end
+
+  def short_type
+    "ec"
+  end
+
+  def self._fetch_remote_resources
+    AwsClients.elasticache.describe_cache_clusters['cache_clusters'].map(&:to_h).map do |ec|
+      ec[:_geo_id] = ec[:cache_cluster_id]
+      ec[:_terraform_id] = ec[:cache_cluster_id]
+      ec
+    end
+  end
+end

data/lib/geoengineer/resources/aws_elasticache_parameter_group.rb

@@ -0,0 +1,30 @@
+########################################################################
+# AwsElasticacheParameterGroup is the +aws_elasticache_parameter_group+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/elasticache_parameter_group.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsElasticacheParameterGroup < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name, :family, :description]) }
+  validate -> { validate_subresource_required_attributes(:parameter, [:name, :value]) }
+
+  after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
+  after :initialize, -> { _geo_id -> { name } }
+
+  def support_tags?
+    false
+  end
+
+  def short_type
+    "ecpg"
+  end
+
+  def self._fetch_remote_resources
+    ec = AwsClients.elasticache
+    ec.describe_cache_parameter_groups['cache_parameter_groups'].map(&:to_h).map do |pg|
+      pg[:_terraform_id] = pg[:cache_parameter_group_name]
+      pg[:_geo_id] = pg[:cache_parameter_group_name]
+      pg[:name] = pg[:cache_parameter_group_name]
+      pg
+    end
+  end
+end