covalence 0.0.1 → 0.7.9.rc1

data/lib/covalence/core/entities/environment.rb

@@ -0,0 +1,24 @@
+require 'virtus'
+require 'active_model'
+
+require_relative 'stack'
+
+module Covalence
+  class Environment
+    include Virtus.model
+    include ActiveModel::Validations
+
+    attribute :name, String
+    attribute :stacks, Array[Stack]
+
+    validates! :name, format: {
+      without: /\s+/,
+      message: "Environment %{attribute}: \"%{value}\" cannot contain spaces"
+    }
+
+    def initialize(attributes = {}, *args)
+      super
+      self.valid?
+    end
+  end
+end

data/lib/covalence/core/entities/input.rb

@@ -0,0 +1,112 @@
+require 'virtus'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash'
+require 'active_model'
+
+require_relative '../../helpers/shell_interpolation'
+
+module Covalence
+  class Input
+    include Virtus.model
+    include ActiveModel::Validations
+
+    attribute :name, String
+    # unprocessed value, could be remote
+    attribute :raw_value, Object
+
+    def initialize(attributes = {}, *args)
+      super
+      self.valid?
+    end
+
+    def value
+      return raw_value if !raw_value.is_a?(Hash)
+      get_value(raw_value)
+    end
+
+    def to_command_option
+      "#{name} = #{parse_input(value())}"
+    end
+
+    private
+
+    def get_value(input)
+      backend, type = parse_type(input)
+
+      if backend != "local"
+        remote_value = backend::lookup(type, input)
+        if remote_value.is_a?(Hash)
+          get_value(remote_value)
+        else
+          remote_value
+        end
+      elsif input.stringify_keys.has_key?('value')
+        input.stringify_keys.fetch('value')
+      else
+        input
+      end
+    end
+
+    def parse_array(input)
+      config = "[\n"
+      input.each do |v|
+        config += "  #{parse_input(v)},\n"
+      end
+      config += "]"
+    end
+
+    def parse_hash(input)
+      config = "{\n"
+      input.each do |k,v|
+        config += "  \"#{k}\" = #{parse_input(v)}\n"
+      end
+      config += "}"
+    end
+
+    def parse_input(input)
+      if input.nil?
+        "\"\""
+
+      elsif input.is_a?(Hash)
+        parse_hash(input)
+
+      elsif input.is_a?(Array)
+        parse_array(input)
+
+      elsif input.to_s.include?("$(")
+        "\"#{Covalence::Helpers::ShellInterpolation.parse_shell(input)}\""
+
+      else
+        "\"#{input}\""
+      end
+    end
+
+    # :reek:FeatureEnvy
+    def parse_type(input)
+      if input.stringify_keys.has_key?('type')
+        type = input.stringify_keys.fetch('type')
+
+        local_types = %w(
+          list
+          map
+          string
+        )
+
+        if local_types.any? {|local_type| type == local_type }
+          return [ "local", type ]
+        elsif type.include?('.')
+          pieces = type.split('.', 2)
+          return [ "Covalence::#{pieces.first.camelize}".constantize,
+                   pieces[1] ]
+        else
+          errors.add(:base,
+                     "invalid input type specified: #{type}",
+                     strict: true)
+        end
+      else
+        return [ "local", "map" ]
+      end
+    end
+
+  end
+end

data/lib/covalence/core/entities/stack.rb

@@ -0,0 +1,74 @@
+require 'virtus'
+require 'active_model'
+require 'semantic'
+
+require_relative '../../../covalence'
+require_relative 'state_store'
+require_relative 'input'
+require_relative 'context'
+
+module Covalence
+  class Stack
+    include Virtus.model
+    include ActiveModel::Validations
+
+    attribute :type, String
+    attribute :name, String
+    attribute :environment_name, String
+    attribute :module_path, String
+    attribute :dependencies, Array[String]
+    attribute :packer_template, String
+    attribute :state_stores, Array[StateStore]
+    attribute :contexts, Array[Context]
+    attribute :inputs, Hash[String => Input]
+    attribute :args, String
+    attribute :workspace, String
+
+    validates! :type, inclusion: {
+      in: %w(terraform packer)
+    }
+    validates! :name, format: {
+      without: /\s+/,
+      message: "Stack %{attribute}: \"%{value}\" cannot contain spaces"
+    }
+
+    def initialize(attributes = {}, *arguments)
+      super
+      self.valid?
+    end
+
+    def full_name
+      "#{environment_name}-#{name}"
+    end
+
+    def materialize_cmd_inputs
+      if type == "terraform"
+        config = ""
+        inputs.values.map(&:to_command_option).each do |input|
+          config += input + "\n"
+        end
+        logger.info "\nStack inputs:\n\n#{config}"
+        File.open('covalence-inputs.tfvars','w') {|f| f.write(config)}
+      elsif type == "packer"
+        config = Hash.new
+        inputs.each do |name, input|
+          config[name] = input.value
+        end
+        config_json = JSON.generate(config)
+        logger.info "\nStack inputs:\n\n#{config_json}"
+        File.open('covalence-inputs.json','w') {|f| f.write(config_json)}
+      end
+    end
+
+    def materialize_state_inputs(store: state_stores.first)
+      config = store.get_config
+      logger.info "\nState store configuration:\n\n#{config}"
+      File.open('covalence-state.tf','w') {|f| f.write(config)}
+    end
+
+    def logger
+      Covalence::LOGGER
+    end
+
+  end
+end

data/lib/covalence/core/entities/state_store.rb

@@ -0,0 +1,65 @@
+require 'virtus'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash'
+require 'active_model'
+
+# check to see how this works with plugins
+Dir[File.expand_path('../state_stores/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
+module Covalence
+  class StateStore
+    include Virtus.model
+    include ActiveModel::Validations
+
+    attribute :params, Hash, :writer => :private
+    attribute :backend, Object, :writer => :private
+    attribute :workspace_enabled, Boolean
+
+    validate :validate_params_has_name,
+      :backend_has_state_store
+
+    def initialize(attributes = {}, *args)
+      super
+      self.valid?
+    end
+
+    def name
+      params.fetch('name')
+    end
+
+    # :reek:FeatureEnvy
+    def params=(params)
+      super(params.stringify_keys)
+    end
+
+    #TODO: prep different backend for plugins
+    # :reek:FeatureEnvy
+    def backend=(backend_name)
+      super("Covalence::#{backend_name.camelize}".constantize)
+    end
+
+    def get_config
+      backend::get_state_store(@params, @workspace_enabled)
+    end
+
+    private
+    def validate_params_has_name
+      if !params.has_key?('name')
+        errors.add(:base,
+                   "Params #{params} missing 'name' parameter for the #{backend} state store",
+                   strict: true)
+      end
+    end
+
+    def backend_has_state_store
+      backend_has_no_state_store = !backend.has_state_store? rescue true
+      if backend_has_no_state_store
+        errors.add(:base,
+                   "#{backend} backend module does not support state storage",
+                   strict: true)
+      end
+    end
+  end
+end

data/lib/covalence/core/repositories/context_repository.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext/object/blank'
+require_relative '../entities/context'
+
+module Covalence
+  class ContextRepository
+    class << self
+      def query_by_namespace(data_store, namespace, tool)
+        if tool == 'terraform'
+          query_tool_by_namespace(data_store, namespace)
+        else
+          Array.new(1, Context.new())
+        end
+      end
+
+      private
+
+      def query_tool_by_namespace(data_store, namespace)
+        targets = data_store.hash_lookup("#{namespace}::targets", {})
+        contexts = targets.map do |name, values|
+          next if name.blank?
+          Context.new(name: name, values: values)
+        end
+        contexts.compact!
+        # always append blank context at the end.
+        contexts << Context.new()
+        contexts
+      end
+    end
+  end
+end

data/lib/covalence/core/repositories/environment_repository.rb

@@ -0,0 +1,92 @@
+require_relative '../../../covalence'
+require_relative '../data_stores/hiera'
+require_relative '../entities/environment'
+require_relative 'stack_repository'
+
+module Covalence
+  class EnvironmentRepository
+    class << self
+      def find_all(data_store = HieraDB::Client.new(Covalence::CONFIG))
+        environments_hash = lookup_environments(data_store)
+
+        environments_hash.map do |environment_name, stack_names|
+          stacks = stack_names.map do |stack_name|
+            StackRepository.find(data_store, environment_name, stack_name)
+          end.compact
+
+          check_all_stacks_valid!(environment_name,
+                                  stack_names,
+                                  stacks)
+
+          Environment.new(name: environment_name,
+                          stacks: stacks)
+        end
+      end
+
+      def find_filtered(task, data_store = HieraDB::Client.new(Covalence::CONFIG))
+        environments_hash = lookup_environments(data_store)
+        env_request = task['environment']
+        stk_request = task['stack']
+
+        if (env_request.nil? || !environments_hash.has_key?(env_request))
+          if RESERVED_NS.include?(env_request)
+            return Array.new(1, Environment.new(name: env_request,
+                                     stacks: stk_request))
+          else
+            raise "'#{env_request}' not found in environments"
+          end
+        end
+
+        stacks = nil
+        if (!stk_request.nil? && environments_hash[env_request].include?(stk_request))
+          stack_list = Array.new(1, stk_request)
+          stacks = Array.new(1, StackRepository.find(data_store, env_request, stk_request))
+        else
+          stack_list = environments_hash[env_request]
+          stacks = stack_list.map do |stack_name|
+            StackRepository.find(data_store, env_request, stack_name)
+          end.compact
+        end
+
+        check_all_stacks_valid!(env_request,
+                                stack_list,
+                                stacks)
+
+        Array.new(1, Environment.new(name: env_request,
+                                     stacks: stacks))
+      end
+
+      def populate_stack(stack, data_store = HieraDB::Client.new(Covalence::CONFIG))
+        StackRepository.populate(data_store, stack)
+      end
+
+      private
+
+      def lookup_environments(data_store)
+        environments_hash = data_store.hash_lookup('environments')
+        raise "Missing 'environments' configuration hash" if environments_hash.empty?
+        environments_hash
+      end
+
+      # Stacks are valid if they map to at least one tool (packer or terraform)
+      def check_all_stacks_valid!(environment_name, stack_list, stacks)
+        stack_names = stacks.map(&:name)
+        logger.debug("All stacks: #{stack_list}")
+        logger.debug("Targeted stacks: #{stack_names}")
+
+        invalid_stacks = stack_list - stack_names
+
+        if invalid_stacks.size > 0
+          error_string = <<-eos
+          Invalid stack(s) #{invalid_stacks} for environment #{environment_name}.
+          eos
+          raise error_string.strip
+        end
+      end
+
+      def logger
+        Covalence::LOGGER
+      end
+    end
+  end
+end

data/lib/covalence/core/repositories/input_repository.rb

@@ -0,0 +1,56 @@
+require 'json'
+require 'yaml'
+require_relative '../../../covalence'
+require_relative '../entities/input'
+
+module Covalence
+  class InputRepository
+    class << self
+      def query_by_namespace(data_store, namespace, tool)
+        results = Hash.new
+        if tool == 'terraform'
+          results = parse_var_file('terraform', data_store, namespace)
+        else
+          results = parse_var_file('packer', data_store, namespace)
+        end
+
+        results.merge(query_tool_by_namespace(data_store, namespace))
+      end
+
+      private
+
+      #TODO: refactor nested conditional
+      def parse_var_file(tool, data_store, namespace)
+        yaml_ext = %w(yaml yml)
+        json_ext = %w(json)
+
+        varfile = data_store.lookup("#{namespace}::vars-file", nil)
+        return {} unless varfile
+        tool_module_path ="Covalence::#{tool.upcase}".constantize
+        varfile = File.expand_path(File.join(tool_module_path, varfile.to_s))
+        if (File.file?(varfile) &&
+            (yaml_ext + json_ext).include?(File.extname(varfile)[1..-1]))
+          if json_ext.include?(File.extname(varfile)[1..-1])
+            tmp_hash = JSON.parse(File.read(varfile))
+          else
+            tmp_hash = YAML.load_file(varfile)
+          end
+
+          tmp_hash = tmp_hash.map do |name, raw_value|
+            [ name, Input.new(name: name, raw_value: raw_value) ]
+          end
+          Hash[*tmp_hash.flatten]
+        else
+          raise ArgumentError, "cannot parse non-yaml or non-json file: #{varfile}"
+        end
+      end
+
+      def query_tool_by_namespace(data_store, namespace)
+        tmp_hash = data_store.hash_lookup("#{namespace}::vars", {}).map do |name, raw_value|
+          [ name, Input.new(name: name, raw_value: raw_value) ]
+        end
+        Hash[*tmp_hash.flatten]
+      end
+    end
+  end
+end