geoengineer 0.1.0

data/lib/geoengineer/utils/has_lifecycle.rb

@@ -0,0 +1,54 @@
+########################################################################
+# HasLifecycle provides methods to enable lifecycle hooks
+########################################################################
+module HasLifecycle
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # ClassMethods
+  module ClassMethods
+    def _init_validation_hash
+      {
+        after: {},
+        before: {}
+      }
+    end
+
+    def lifecycle_actions(stage, step)
+      all = []
+      # inherit lifecycle_actions
+      sclazz = self.superclass
+      all.concat(sclazz.lifecycle_actions(stage, step)) if sclazz.respond_to?(:lifecycle_actions)
+
+      # Add this lifecycle actions
+      la_exists = @_actions && @_actions[stage] && @_actions[stage][step]
+      all.concat(@_actions[stage][step]) if la_exists
+      all
+    end
+
+    # Currently only supporting after(:initialize)
+    def after(lifecycle_step, method_name_or_proc)
+      @_actions = _init_validation_hash unless @_actions
+      @_actions[:after][lifecycle_step] = [] unless @_actions[:after][lifecycle_step]
+      @_actions[:after][lifecycle_step] << method_name_or_proc
+    end
+
+    def before(lifecycle_step, method_name_or_proc)
+      @_actions = _init_validation_hash unless @_actions
+      @_actions[:before][lifecycle_step] = [] unless @_actions[:before][lifecycle_step]
+      @_actions[:before][lifecycle_step] << method_name_or_proc
+    end
+  end
+
+  # This method will return a list of errors if not valid, or nil
+  def execute_lifecycle(stage, step)
+    self.class.lifecycle_actions(stage, step).each do |actions|
+      if actions.is_a? Proc
+        self.instance_exec(&actions)
+      else
+        self.send(actions)
+      end
+    end
+  end
+end

data/lib/geoengineer/utils/has_resources.rb

@@ -0,0 +1,63 @@
+########################################################################
+# HasResources provides methods for a class to contain and query a set of resources
+########################################################################
+module HasResources
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # ClassMethods
+  module ClassMethods
+    def get_resource_class_from_type(type)
+      c_name = type.split('_').collect(&:capitalize).join
+      c_name = "GeoEngineer::Resources::#{c_name}"
+      clazz = Object.const_defined?(c_name) ? Object.const_get(c_name) : GeoEngineer::Resource
+      clazz
+    end
+  end
+
+  def resources
+    @_resources = [] unless @_resources
+    @_resources
+  end
+
+  # Overridden By Project and Environment
+  def all_resources
+    resources
+  end
+
+  def find_resource(type, id)
+    all_resources.select { |r| r.type == type && r.id == id }.first
+  end
+
+  def find_resource_by_ref(ref)
+    return nil unless ref.start_with?("${")
+    ref = ref.delete('${').delete('}')
+    type, name = ref.split('.')
+    find_resource(type, name)
+  end
+
+  def resources_grouped_by
+    all_resources.each_with_object({}) do |r, c|
+      value = yield r
+      c[value] ||= []
+      c[value] << r
+      c
+    end
+  end
+
+  def resources_of_type(type)
+    all_resources.select { |r| r.type == type }
+  end
+
+  # Factory to create resource and attach
+  def create_resource(type, id, &block)
+    # This will look for a class that is defined by the type so it can override functionality
+    # For example, if `type='aws_security_group'` then the class would be `AwsSecurityGroup`
+    clazz = self.class.get_resource_class_from_type(type)
+
+    res = clazz.new(type, id, &block)
+    resources << res # Add the resource
+    res
+  end
+end

data/lib/geoengineer/utils/has_sub_resources.rb

@@ -0,0 +1,43 @@
+########################################################################
+# HasSubResources provides methods for a object to contain subresources
+########################################################################
+module HasSubResources
+  # This overrides assign_block from HasAttributes
+  # when a block is passed to an attribute it becomes a SubResource
+  def assign_block(name, *args, &block)
+    sr = GeoEngineer::SubResource.new(self, name, &block)
+    subresources << sr
+    sr
+  end
+
+  def attribute_missing(name)
+    all = false
+    if name.start_with?('all_')
+      name = name[4..-1]
+      all = true
+    end
+    srl = subresources.select { |s| s.type == name.to_s }
+
+    if srl.empty?
+      return [] if all
+      return nil
+    else
+      return srl if all
+      return srl.first
+    end
+  end
+
+  def subresources
+    @_subresources = [] unless @_subresources
+    @_subresources
+  end
+
+  def delete_subresources_where(&block)
+    # Only leave sub resources that dont
+    @_subresources = subresources.reject(&block)
+  end
+
+  def delete_all_subresources(type)
+    @_subresources = subresources.select { |s| s.type != type.to_s }
+  end
+end

data/lib/geoengineer/utils/has_validations.rb

@@ -0,0 +1,57 @@
+require 'netaddr'
+
+########################################################################
+# HasValidations provides methods to enable validations
+########################################################################
+module HasValidations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # ClassMethods
+  module ClassMethods
+    def validations
+      all_validations = []
+      all_validations.concat(@_validations) if @_validations
+      # inherit validations
+      sclazz = self.superclass
+      all_validations.concat(sclazz.validations) if sclazz.respond_to?(:validations)
+      all_validations
+    end
+
+    def validate(method_name_or_proc)
+      @_validations = [] unless @_validations
+      @_validations << method_name_or_proc
+    end
+  end
+
+  # This method will return a list of errors if not valid, or nil
+  def errors
+    execute_lifecycle(:before, :validation) if self.respond_to? :execute_lifecycle
+    errs = []
+    self.class.validations.each do |validation|
+      errs << (validation.is_a?(Proc) ? self.instance_exec(&validation) : self.send(validation))
+    end
+    # remove nils
+    errs = errs.flatten.select { |x| !x.nil? }
+    errs
+  end
+
+  # Validation Helper Methods
+  def validate_required_attributes(keys)
+    errs = []
+    keys.each do |key|
+      errs << "#{key} attribute nil for #{self}" if self[key].nil?
+    end
+    errs
+  end
+
+  # Validates CIDR block format
+  # Returns error when argument fails validation
+  def validate_cidr_block(cidr_block)
+    parsed_cidr = NetAddr::CIDR.create(cidr_block)
+    return [parsed_cidr, nil]
+  rescue NetAddr::ValidationError
+    return [nil, "Bad cidr block \"#{cidr_block}\" #{for_resource}"]
+  end
+end

data/lib/geoengineer/utils/null_object.rb

@@ -0,0 +1,17 @@
+########################################################################
+# NullObject and NullObject.maybe provide the NullObject pattern
+# as defined {http://devblog.avdi.org/2011/05/30/null-objects-and-falsiness/ here}
+#
+########################################################################
+class NullObject
+  def method_missing(name, *args, &block)
+    nil
+  end
+
+  def self.maybe(value)
+    case value
+    when nil then NullObject.new
+    else value
+    end
+  end
+end

data/lib/geoengineer/version.rb

@@ -0,0 +1,3 @@
+module GeoEngineer
+  VERSION = '0.1.0'.freeze
+end

data/spec/environment_spec.rb

@@ -0,0 +1,140 @@
+require_relative './spec_helper'
+
+describe("GeoEngineer::Environment") do
+  describe 'validations' do
+    it 'should have unique terrform id' do
+      env = GeoEngineer::Environment.new("test") {
+        region "us-west-1"
+        account_id 1
+      }
+      env.resource('type', 'id1') {
+        _terraform_id "tid"
+        _geo_id 'gid1'
+      }
+      env.resource('type', 'id2') {
+        _terraform_id "tid"
+        _geo_id 'gid2'
+      }
+      expect(env.all_resources.length).to eq 2
+      expect(env.errors.length).to eq 1
+    end
+
+    it 'should have unique geo_id' do
+      env = GeoEngineer::Environment.new("test") {
+        region "us-west-1"
+        account_id 1
+      }
+      env.resource('type', 'id1') {
+        _terraform_id "tid1"
+        _geo_id 'gid'
+      }
+      env.resource('type', 'id2') {
+        _terraform_id "tid2"
+        _geo_id 'gid'
+      }
+      expect(env.all_resources.length).to eq 2
+      expect(env.errors.length).to eq 1
+    end
+
+    it 'should have unique type and ids' do
+      env = GeoEngineer::Environment.new("test") {
+        region "us-west-1"
+        account_id 1
+      }
+      env.resource('type', 'id1') {
+        _terraform_id "tid1"
+        _geo_id 'gid1'
+      }
+      env.resource('type', 'id1') {
+        _terraform_id "tid2"
+        _geo_id 'gid2'
+      }
+      expect(env.all_resources.length).to eq 2
+      expect(env.errors.length).to eq 1
+    end
+  end
+
+  describe '#codifies_resources' do
+    it 'should return both codified and uncodified resources' do
+      class GeoEngineer::Resources::CodifiedResource < GeoEngineer::Resource
+        def self._fetch_remote_resources
+          [{ _geo_id: "geo_id1" }, { _geo_id: "geo_id2" }]
+        end
+      end
+
+      env = GeoEngineer::Environment.new("test")
+      env.resource('codified_resource', 'id1') {
+        _terraform_id "geo_id1"
+      }
+      expect(env.codified_resources('codified_resource').length).to eq 1
+      expect(env.uncodified_resources('codified_resource').length).to eq 1
+    end
+  end
+
+  describe '#to_terraform_state' do
+    it 'should return state of resources' do
+      env = GeoEngineer::Environment.new("test")
+      env.resource('type', 'id1') {
+        _terraform_id "tid"
+        _geo_id 'gid1'
+      }
+      tfstate = env.to_terraform_state
+      expect(tfstate[:modules].first[:resources].length).to eq 1
+    end
+  end
+
+  describe '#to_terraform_json' do
+    it 'should return terraform of all resources' do
+      env = GeoEngineer::Environment.new("test")
+      env.resource('type', 'id1') {
+        _terraform_id "tid"
+        _geo_id 'gid1'
+      }
+      tfjson = env.to_terraform_json
+      expect(tfjson[:resource].length).to eq 1
+    end
+  end
+
+  describe '#project' do
+    it 'should create a project with this as environment' do
+      env = GeoEngineer::Environment.new("test")
+      env.project("org", "name") {
+        environments 'test'
+      }
+      expect(env.projects.length).to eq 1
+    end
+
+    it 'should only load projects in the environment' do
+      env = GeoEngineer::Environment.new("test")
+      p0 = env.project("org", "0") {
+        environments 'test'
+      }
+
+      p1 = env.project("org", "1") {
+        environments 'nottest'
+      }
+
+      expect(p0.class).to eq GeoEngineer::Project
+      expect(p1.class).to eq NullObject
+    end
+  end
+
+  describe '#all_resources' do
+    it 'should include local and project resources (if project in env)' do
+      env = GeoEngineer::Environment.new("test")
+      env.resource('type', 'id0') { x 2 }
+
+      p0 = env.project("org", "0") {
+        environments 'test'
+      }
+      p0.resource('type', 'id1') { x 2 }
+
+      p1 = env.project("org", "1") {
+        environments 'nottest'
+      }
+      p1.resource('type', 'id2') { x 2 }
+
+      expect(env.all_resources.length).to eq 2
+    end
+  end
+end

data/spec/output_spec.rb

@@ -0,0 +1,3 @@
+require_relative './spec_helper'
+
+describe("GeoEngineer::Output")

data/spec/project_spec.rb

@@ -0,0 +1,79 @@
+require_relative './spec_helper'
+
+describe("GeoEngineer::Project") do
+  class OutModuleTemplate < GeoEngineer::Template
+    attr_reader :res1, :res2
+
+    def initialize(name, project, parameters)
+      super(name, project, parameters)
+
+      res1 = resource('type', '1') {
+        name "Resource1"
+        param parameters[:res1]
+      }
+
+      res2 = resource('type', '2') {
+        name "Resource2"
+        rel  res1
+      }
+
+      @res1 = res1
+      @res2 = res2
+    end
+
+    def template_resources
+      [@res1, @res2]
+    end
+  end
+
+  class GeoEngineer::Templates::InModuleTemplate < GeoEngineer::Template
+  end
+
+  describe 'validations' do
+    it 'should validate its resources' do
+      project = GeoEngineer::Project.new('org', "project_name", nil)
+      project.environments = 'test'
+      project.resource('res', 'id') {
+        x 10
+      }
+      expect(project.errors.length).to eq 1 # geo_id nil
+    end
+
+    it 'should validate it has an environmnet' do
+      project = GeoEngineer::Project.new('org', "project_name", nil)
+      expect(project.errors.length).to eq 1
+    end
+  end
+
+  describe '#from_template' do
+    it 'should create a template from a class' do
+      project = GeoEngineer::Project.new('org', "project_name", nil)
+      temp1 = project.from_template('in_module_template', 'in')
+      temp2 = project.from_template('out_module_template', 'out')
+      expect(temp1.template_resources.length).to eq 0
+      expect(temp2.template_resources.length).to eq 2
+    end
+
+    it 'should error if the template is not found' do
+      project = GeoEngineer::Project.new('org', "project_name", nil)
+      expect { project.from_template('not_a_template') }.to raise_error(StandardError)
+    end
+  end
+
+  describe '#all_resources' do
+    it 'should return all resources created in templates and directly' do
+      project = GeoEngineer::Project.new('org', "project_name", nil)
+      project.resource('res', 'id') { x 10 }
+      project.from_template('out_module_template', 'out')
+      expect(project.all_resources.length).to eq 3
+    end
+  end
+
+  describe '#resource' do
+    it 'should create a resource and assign itself as project' do
+      project = GeoEngineer::Project.new('org', "project_name", nil)
+      res = project.resource('res', 'id') { x 10 }
+      expect(res.project).to eq project
+    end
+  end
+end