covalence 0.0.1 → 0.7.9.rc1

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

@@ -0,0 +1,89 @@
+require 'active_support/core_ext/hash'
+
+require_relative '../../../covalence'
+require_relative '../entities/stack'
+require_relative 'state_store_repository'
+require_relative 'input_repository'
+require_relative 'context_repository'
+
+module Covalence
+  class StackRepository
+    def self.find(data_store, environment_name, stack_name)
+      stack_scope = {
+        'environment' => environment_name,
+        'stack' => stack_name,
+      }
+      tool = lookup_tool(data_store, stack_scope)
+      return if tool.nil?
+
+      stack_data_store = data_store.initialize_scope(stack_scope)
+      stack_module = lookup_shared_namespace(stack_data_store, stack_name)
+      shared_namespace = stack_module.gsub('/', '::') unless stack_module.nil?
+
+      Stack.new(
+        type: tool,
+        name: stack_name,
+        environment_name: environment_name,
+        module_path: stack_module,
+      )
+    end
+
+    def self.populate(data_store, stack)
+      stack_scope = {
+        'environment' => stack.environment_name,
+        'stack' => stack.name,
+      }
+      stack_data_store = data_store.initialize_scope(stack_scope)
+      shared_namespace = stack.module_path.gsub('/', '::')
+
+      stack.dependencies = lookup_dependencies(stack_data_store, stack.name)
+      stack.packer_template = lookup_packer_template(stack_data_store, stack.name)
+      stack.workspace = lookup_workspace(stack_data_store, stack.name)
+      stack.state_stores = StateStoreRepository.query_by_stack_name(stack_data_store, stack.name, stack.workspace, stack.type)
+      stack.contexts = ContextRepository.query_by_namespace(stack_data_store, shared_namespace, stack.type)
+      stack.inputs = InputRepository.query_by_namespace(stack_data_store, shared_namespace, stack.type)
+      stack.args = find_args_by_namespace(stack_data_store, shared_namespace)
+    end
+
+    class << self
+      private
+      def lookup_packer_template(data_store, stack_name)
+        data_store.lookup("#{stack_name}::packer-template", nil)
+      end
+
+      def lookup_dependencies(data_store, stack_name)
+        data_store.lookup("#{stack_name}::deps", [])
+      end
+
+      def lookup_shared_namespace(data_store, stack_name)
+        data_store.lookup("#{stack_name}::module", stack_name)
+      end
+
+      def lookup_workspace(data_store, stack_name)
+        wrkspc = data_store.lookup("#{stack_name}::workspace", "")
+        wrkspc = Covalence::Helpers::ShellInterpolation.parse_shell(wrkspc) if wrkspc.to_s.include?("$(")
+        return wrkspc
+      end
+
+      # maybe arg_string instead of args
+      def find_args_by_namespace(data_store, namespace)
+        data_store.lookup("#{namespace}::args", "")
+      end
+
+      def lookup_tool(data_store, arguments)
+        if !data_store.lookup("#{arguments['stack']}::state", nil, arguments).nil?
+          return 'terraform'
+        elsif !data_store.lookup("#{arguments['stack']}::packer-template", nil, arguments).nil?
+          return 'packer'
+        else
+          logger.debug "#{arguments['environment']}:#{arguments['stack']} is neither a valid Terraform or Packer stack."
+          return nil
+        end
+      end
+
+      def logger
+        Covalence::LOGGER
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'active_support/core_ext/object/blank'
+require_relative '../entities/state_store'
+
+module Covalence
+  # todo: monitor behavior forking to determine when the split the class
+  class StateStoreRepository
+    class << self
+      def query_by_stack_name(data_store, stack_name, stack_workspace, tool)
+        if tool == 'terraform'
+          query_tool_by_stack_name(data_store, stack_name, stack_workspace)
+        else
+          return nil
+        end
+      end
+
+      private
+
+      def query_tool_by_stack_name(data_store, stack_name, stack_workspace)
+        stores = data_store.lookup("#{stack_name}::state", [])
+        raise "State store array cannot be empty" if stores.blank?
+        stores.map do |store|
+          StateStore.new(
+            backend: store.keys.first,
+            params: store.values.first,
+            workspace_enabled: !stack_workspace.empty?
+          )
+        end
+      end
+    end
+  end
+end

data/lib/covalence/core/services/hiera_syntax_service.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+
+module Covalence
+  class HieraSyntaxService
+    def self.check_yaml(filelist)
+      errors = []
+
+      [*filelist].each do |hiera_file|
+        begin
+          YAML.load_file(hiera_file)
+        rescue StandardError => error
+          errors << "ERROR: Failed to parse #{hiera_file}: #{error}"
+        end
+      end
+
+      errors.map { |error| error.to_s }
+    end
+  end
+end

data/lib/covalence/core/services/packer_stack_tasks.rb

@@ -0,0 +1,104 @@
+require 'tempfile'
+require_relative '../../../covalence'
+require_relative '../cli_wrappers/packer_cli'
+
+module Covalence
+  class PackerStackTasks
+
+    def initialize(stack)
+      @path = File.expand_path(File.join(Covalence::PACKER, stack.module_path))
+      @stack = stack
+      @template = "#{@path}/#{stack.packer_template}"
+    end
+
+    def stack_name
+      stack.name
+    end
+
+    def environment_name
+      stack.environment_name
+    end
+
+    def context_build(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          stack.materialize_cmd_inputs
+          args = collect_args(stack.args,
+                              additional_args,
+                              "-var-file=covalence-inputs.json")
+
+          call_packer_cmd("packer_build", args)
+        end
+      end
+    end
+
+    def context_inspect(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          call_packer_cmd("packer_inspect", [])
+        end
+      end
+    end
+
+    def context_validate(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          stack.materialize_cmd_inputs
+          args = collect_args(stack.args,
+                              additional_args,
+                              "-var-file=covalence-inputs.json")
+
+          call_packer_cmd("packer_validate", args)
+        end
+      end
+    end
+
+    private
+    attr_reader :template_path, :stack
+
+    def populate_workspace(workspace)
+      # Copy module to the workspace
+      FileUtils.copy_entry @path, workspace
+
+      # Copy any dependencies to the workspace
+      @stack.dependencies.each do |dep|
+        logger.info "Copying '#{dep}' dependency to #{workspace}"
+        dep_path = File.expand_path(File.join(Covalence::PACKER, dep))
+        FileUtils.cp_r dep_path, workspace
+      end
+    end
+
+    def call_packer_cmd(packer_cmd, args)
+      if template_is_yaml?(@template)
+        config = YAML.load_file(@template).to_json
+        logger.info "\nGenerated build template:\n\n#{config}"
+        File.open('covalence-packer-template.json','w') {|f| f.write(config)}
+
+        PackerCli.public_send(packer_cmd.to_sym, 'covalence-packer-template.json', args: args)
+      else
+        PackerCli.public_send(packer_cmd.to_sym, @template, args: args)
+      end
+    end
+
+    def template_is_yaml?(template)
+      %w(.yaml .yml).include?(File.extname(template))
+    end
+
+    def collect_args(*args)
+      args.flatten.compact.reject(&:empty?).map(&:strip)
+    end
+
+    def logger
+      Covalence::LOGGER
+    end
+  end
+end

data/lib/covalence/core/services/terraform_stack_tasks.rb

@@ -0,0 +1,212 @@
+require_relative '../../../covalence'
+require_relative '../cli_wrappers/terraform_cli'
+
+module Covalence
+  class TerraformStackTasks
+
+    def initialize(stack)
+      @path = File.expand_path(File.join(Covalence::TERRAFORM, stack.module_path))
+      @stack = stack
+    end
+
+    def stack_name
+      stack.name
+    end
+
+    def environment_name
+      stack.environment_name
+    end
+
+    def stack_clean
+      TerraformCli.terraform_clean(@path)
+    end
+
+    def stack_format
+      TerraformCli.terraform_fmt(@path)
+    end
+
+    # :reek:TooManyStatements
+    def stack_verify
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          stack.materialize_cmd_inputs
+          args = collect_args("-input=false",
+                              stack.args,
+                              "-var-file=covalence-inputs.tfvars")
+
+          TerraformCli.terraform_validate(args: args)
+
+          TerraformCli.terraform_plan(args: args)
+        end
+      end
+    end
+
+    # :reek:TooManyStatements
+    def stack_refresh
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_workspace(@stack.workspace) unless stack.workspace.to_s.empty?
+
+          stack.materialize_state_inputs
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          TerraformCli.terraform_refresh
+        end
+      end
+    end
+
+    # :reek:TooManyStatements
+    def stack_sync
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_workspace(@stack.workspace) unless stack.workspace.to_s.empty?
+
+          stack.materialize_state_inputs
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          stack.state_stores.drop(1).each do |store|
+            stack.materialize_state_inputs(store: store)
+            TerraformCli.terraform_init("-force-copy")
+          end
+        end
+      end
+    end
+
+    # :reek:TooManyStatements
+    def context_plan(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_workspace(@stack.workspace) unless stack.workspace.to_s.empty?
+
+          stack.materialize_state_inputs
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          stack.materialize_cmd_inputs
+          args = collect_args("-input=false",
+                              stack.args,
+                              additional_args,
+                              "-var-file=covalence-inputs.tfvars")
+
+          TerraformCli.terraform_plan(args: args)
+        end
+      end
+    end
+
+    # :reek:TooManyStatements
+    def context_plan_destroy(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_workspace(@stack.workspace) unless stack.workspace.to_s.empty?
+
+          stack.materialize_state_inputs
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          stack.materialize_cmd_inputs
+          args = collect_args("-destroy",
+                              "-input=false",
+                              stack.args,
+                              additional_args,
+                              "-var-file=covalence-inputs.tfvars")
+
+          TerraformCli.terraform_plan(args: args)
+        end
+      end
+    end
+
+    # :reek:TooManyStatements
+    def context_apply(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_workspace(@stack.workspace) unless stack.workspace.to_s.empty?
+
+          stack.materialize_state_inputs
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          stack.materialize_cmd_inputs
+          args = collect_args("-input=false",
+                              "-auto-approve=true",
+                              stack.args,
+                              additional_args,
+                              "-var-file=covalence-inputs.tfvars")
+
+          TerraformCli.terraform_apply(args: args)
+        end
+      end
+    end
+
+    # :reek:TooManyStatements
+    def context_destroy(*additional_args)
+      Dir.mktmpdir do |tmpdir|
+        populate_workspace(tmpdir)
+        Dir.chdir(tmpdir) do
+          logger.info "In #{tmpdir}:"
+
+          TerraformCli.terraform_workspace(@stack.workspace) unless stack.workspace.to_s.empty?
+
+          stack.materialize_state_inputs
+          TerraformCli.terraform_get(@path)
+          TerraformCli.terraform_init
+
+          stack.materialize_cmd_inputs
+          args = collect_args("-input=false",
+                              "-auto-approve=true",
+                              stack.args,
+                              additional_args,
+                              "-var-file=covalence-inputs.tfvars")
+
+          TerraformCli.terraform_destroy(args: args)
+        end
+      end
+    end
+
+    private
+    attr_reader :path, :stack, :store_args
+
+    def populate_workspace(workspace)
+      # Copy module to the workspace
+      FileUtils.copy_entry @path, workspace
+
+      # Copy any dependencies to the workspace
+      @stack.dependencies.each do |dep|
+        logger.info "Copying '#{dep}' dependency to #{workspace}"
+        dep_path = File.expand_path(File.join(Covalence::TERRAFORM, dep))
+        FileUtils.cp_r dep_path, workspace
+      end
+    end
+
+    def logger
+      Covalence::LOGGER
+    end
+
+    # :reek:FeatureEnvy
+    def collect_args(*args)
+      args.flatten.compact.reject(&:empty?).map(&:strip)
+    end
+  end
+end