dh-proteus 0.1.3

data/lib/proteus/helpers/string_helpers.rb

@@ -0,0 +1,13 @@
+module Proteus
+  module Helpers
+    module StringHelpers
+      def camel_case(input)
+        input.split('_').collect(&:capitalize).join
+      end
+
+      def _(input)
+        input.gsub('-', '_')
+      end
+    end
+  end
+end

data/lib/proteus/init.rb

@@ -0,0 +1,16 @@
+require 'proteus/generators/init'
+
+module Proteus
+  class Init < Thor
+    include Thor::Actions
+    include Helpers
+
+    def self.source_root
+      File.expand_path(File.join(File.dirname(__FILE__), 'generators', 'templates'))
+    end
+
+    include Generators::Init
+
+    default_task :init
+  end
+end

data/lib/proteus/modules/manager.rb

@@ -0,0 +1,53 @@
+require 'proteus/helpers/path_helpers'
+require 'proteus/modules/terraform_module'
+require 'proteus/backend/backend'
+
+module Proteus
+  module Modules
+
+    class Manager
+      include Thor::Shell
+      include Proteus::Helpers::PathHelpers
+
+      def initialize(context:, environment:)
+        @context = context
+        @environment = environment
+        initialize_modules
+      end
+
+      def render_modules
+        @modules.map(&:process)
+      end
+
+      def clean
+        @modules.map(&:clean)
+      end
+
+      private
+
+      def initialize_modules
+        say "Initializing modules", :green
+
+        tfvars_content = File.read(File.join(environments_path(@context), "terraform.#{@environment}.tfvars"))
+
+        if tfvars_content.empty?
+          terraform_variables = []
+        else
+          terraform_variables = HCL::Checker.parse(tfvars_content).with_indifferent_access
+        end
+
+        @modules = []
+
+        Dir.glob("#{modules_path(@context)}/*").each do |directory|
+          @modules << TerraformModule.new(
+            name: File.basename(directory),
+            context: @context,
+            environment: @environment,
+            terraform_variables: terraform_variables
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/proteus/modules/terraform_module.rb

@@ -0,0 +1,184 @@
+require 'proteus/helpers/path_helpers'
+require 'proteus/helpers/string_helpers'
+require 'hcl/checker'
+require 'yaml'
+
+module Proteus
+  module Modules
+    class TerraformModule
+      @@hooks = {}
+
+      include Thor::Shell
+      extend Thor::Shell
+      include Proteus::Helpers::PathHelpers
+      extend Proteus::Helpers::PathHelpers
+      include Proteus::Helpers::StringHelpers
+
+      attr_reader :name
+
+      def initialize(name:, context:, environment:, terraform_variables:)
+        @name = name
+        @context = context
+        @environment = environment
+        @terraform_variables = terraform_variables
+        @hook_variables = {}
+      end
+
+      def process
+        clean
+        run_hooks
+        load_data
+        return if !data?
+        validate
+        render
+      end
+
+      def clean
+        File.file?(manifest) ? FileUtils.rm(manifest) : nil
+      end
+
+      def self.register_hook(module_name, hook)
+        @@hooks[module_name] ||= Array.new
+        @@hooks[module_name] << hook
+      end
+
+      def run_hooks
+        Dir.glob(File.join(module_hooks_path(@context, @name), '*')).each do |file|
+          require file
+        end
+
+        hooks_module = "Proteus::Modules::#{camel_case(@name)}::Hooks"
+        if Kernel.const_defined?(hooks_module)
+          say "Hooks present for module #{@name}", :green
+          Kernel.const_get(hooks_module).constants.each do |constant|
+            say "Found hook: #{constant}", :green
+            self.class.include(Kernel.const_get("#{hooks_module}::#{constant}"))
+          end
+        end
+
+        if @@hooks.key?(@name)
+          @@hooks[@name].each do |hook|
+            hook_result = hook.call(@environment, @context, @name)
+
+            if hook_result.is_a?(Hash)
+              @hook_variables.merge!(hook_result)
+            end
+
+            @@hooks[@name].delete(hook)
+          end
+        end
+      end
+
+      private
+
+
+      def load_data
+        @data = {}
+
+        if File.file?(config_file)
+          @data = YAML.load_file(config_file, {}).with_indifferent_access
+        end
+      end
+
+      def data?
+        return false unless @data
+        @data.any?
+      end
+
+      def validate
+        if data? && File.file?(validator_file)
+          require validator_file
+
+          begin
+            validator_class = "Proteus::Validators::#{camel_case(@name)}Validator"
+
+            Kernel.const_get(validator_class).new(@data, @environment)
+
+            say "Ran #{camel_case(@name)}Validator for environment #{@environment} #{"\u2714".encode('utf-8')}", :green
+          rescue Proteus::Validators::ValidationError => validation_error
+            say "#{validator_class}: #{validation_error.message} [modules/#{@name}/config/#{@environment}.yaml] #{"\u2718".encode('utf-8')}", :red
+            exit 1
+          end
+        else
+          say "Module #{@name} has no validator.", :magenta
+        end
+      end
+
+      def render
+        File.open(manifest, "w") do |manifest|
+          manifest << global_resources
+
+          @data.fetch('template_data', {}).each do |template, data|
+            manifest << render_template(File.join(module_templates_path(@context, @name), "#{template}.tf.erb"), data)
+          end
+        end
+      end
+
+      def render_template(template_file, data)
+        if File.file?(template_file)
+          template = File.read(template_file)
+          begin
+            return "#{Erubis::Eruby.new(template).result(template_binding(data).get_binding)}\n\n"
+          rescue Exception => e
+            say "Error in template: #{template_file}", :magenta
+            e.backtrace.each { |line| say line, :magenta }
+            say e.message, :magenta
+            exit 1
+          end
+        end
+      end
+
+      def template_binding(data)
+        binding = Proteus::Templates::TemplateBinding.new(
+          context: @context,
+          environment: @environment,
+          module_name: @name,
+          data: data,
+          defaults: parse_defaults
+        )
+
+        binding.set(:terraform_variables, @terraform_variables)
+
+        @hook_variables.each do |key, value|
+          binding.set(key, value)
+        end
+
+        binding
+      end
+
+      def parse_defaults
+        defaults = []
+
+        return defaults unless File.file?(File.join(module_path(@context, @name), 'io.tf'))
+        HCL::Checker.parse(File.read(File.join(module_path(@context, @name), 'io.tf')))['variable'].each do |variable, values|
+          if values
+            defaults.push(variable) if values.has_key?('default')
+          end
+        end
+        return defaults
+      end
+
+      def global_resources
+        Dir.glob(File.join(module_config_path(@context, @name), 'global_resources/*')).inject("") do |memo, resource_file|
+					if resource_file =~ /tf\.erb/
+						"#{memo}\n#{render_template(resource_file, @data.dig('global_resources', File.basename(resource_file, '.tf.erb')))}"
+					else
+          "#{memo}#{File.read(resource_file)}\n"
+					end
+        end
+      end
+
+      def config_file
+        File.join(module_config_path(@context, @name), "#{@environment}.yaml")
+      end
+
+      def validator_file
+        File.join(module_config_path(@context, @name), 'validator.rb')
+      end
+
+      def manifest
+        File.join(context_root_path(@context), "#{@name}.tf")
+      end
+    end
+  end
+end

data/lib/proteus/templates/partial.rb

@@ -0,0 +1,123 @@
+require 'hcl/checker'
+
+module Proteus
+  module Templates
+    class Partial < TemplateBinding
+
+      include Proteus::Helpers::PathHelpers
+      include Thor::Shell
+
+      def initialize(name:, context:, environment:, module_name:, data:, data_context: nil, force_rendering: true, deep_merge: false, terraform_variables:, scope_resources: nil)
+        @name = name
+        @context = context
+        @environment = environment
+        @module_name = module_name
+        @data = data
+        @data_context = data_context
+        @force_rendering = force_rendering
+        @deep_merge = deep_merge
+        @terraform_variables = terraform_variables
+        @scope_resources = scope_resources
+
+        @defaults = {}
+        set(@name.split('/').last, {})
+
+        if data.dig('partials', @name)
+          @partial_data_present = true
+
+          @data['partials'][@name].delete('render')
+
+          set(@name, @data['partials'][@name])
+        end
+
+      end
+
+      def render
+        if partial_data? || @force_rendering
+          defaults_file = File.join(module_templates_path(@context, @module_name), 'defaults', "#{@name}.yaml")
+
+          default_partial_path = File.join(module_templates_path(@context, @module_name), "_#{@name}.tf.erb")
+          sub_directory_partial_path = File.join(module_templates_path(@context, @module_name), "#{@name}.tf.erb")
+
+          if File.file?(default_partial_path)
+            partial_file = default_partial_path
+          else
+            partial_file = sub_directory_partial_path
+          end
+
+
+          if File.file?(partial_file)
+            partial_template = File.read(partial_file)
+
+            if File.file?(defaults_file)
+              @defaults = YAML.load_file(defaults_file, {}).with_indifferent_access
+
+              partial_data = instance_variable_get("@#{@name}")
+
+              if @deep_merge == false
+                @defaults.each do |key, value|
+                  if !partial_data.key?(key)
+                    partial_data[key] = value
+                  end
+                end
+              elsif @deep_merge == :each
+                merged_data = []
+
+                partial_data.each do |item|
+                  merged_data << @defaults.deep_merge(item)
+                end
+
+                instance_variable_set("@#{@name.split('/').last}", merged_data)
+              else
+                instance_variable_set("@#{@name.split('/').last}", @defaults.deep_merge(partial_data))
+              end
+
+            end
+
+            begin
+              if @scope_resources
+                return scope_resources(manifest: Erubis::Eruby.new(partial_template).result(get_binding), scope: @scope_resources)
+              else
+                return Erubis::Eruby.new(partial_template).result(get_binding)
+              end
+            rescue Exception => e
+              say "Error in partial: #{partial_file}", :magenta
+              e.backtrace.each { |line| say line, :magenta }
+              say e.message, :magenta
+              exit 1
+            end
+          end
+        end
+      end
+
+      def partial_data?
+        @partial_data_present
+      end
+
+      def scope_resources(manifest:, scope:)
+        scoped = []
+        manifest.each_line do |line|
+          if matches = line.match(/resource( +)"(?<resource_type>[a-z0-9_]+)"( +)"(?<resource_name>[a-zA-Z0-9_\-]+)"( +)(\{)/)
+            say "MATCHED RESOURCE: #{line}", :green
+            matches = matches.named_captures.with_indifferent_access
+            scoped << "resource \"#{matches[:resource_type]}\" \"#{scope}_#{matches[:resource_name]}\" {"
+            say "CHANGED TO:       #{scoped.last}", :green
+          elsif matches = line.match(/(?<pre>.*(\{|\())(?<data>data\.)?(?<resource_type>(?<provider>aws|kubernetes|helm|tls_private_key|null_resource)[a-z_0-9]*)\.(?<resource_name>[a-z0-9_]+)(?<attribute>(?<wildcard>.\*)?\.[a-z_]+)?(?<post>.*)?/)
+            matches = matches.named_captures.with_indifferent_access
+
+            if !matches[:data]
+              say "MATCHED REFERENCE: #{line}", :green
+              scoped << "#{matches[:pre]}#{matches[:resource_type]}.#{scope}_#{matches[:resource_name]}#{matches[:attribute]}#{matches[:post]}"
+              say "CHANGED TO:        #{scoped.last}", :green
+            else
+              scoped << line
+            end
+          else
+            scoped << line
+          end
+        end
+        scoped.map!(&:chomp).join("\n")
+      end
+    end
+  end
+end

data/lib/proteus/templates/template_binding.rb

@@ -0,0 +1,62 @@
+module Proteus
+  module Templates
+    class TemplateBinding
+
+      include Proteus::Helpers::PathHelpers
+      include Proteus::Helpers::StringHelpers
+
+      def initialize(context:, environment:, module_name:, data: {}, defaults:  [])
+        @context = context
+        @environment = environment
+        @module_name = module_name
+
+        data.each do |key, value|
+          set(key, value)
+        end
+        @defaults = defaults
+      end
+
+      def set(name, value)
+        instance_variable_set("@#{name}", value)
+      end
+
+      def get_binding
+        binding
+      end
+
+      def render_defaults(context, demo: false)
+        @defaults.inject("") do |memo, default|
+          if context.has_key?(default)
+            memo << "#{demo ? "# " : ""}#{default} = \"#{context[default]}\"\n"
+          else
+            memo
+          end
+        end
+      end
+
+      # return output of partial template
+      # name: symbol (template_name)
+      def render_partial(name:, data:, data_context: nil, force_rendering: true, deep_merge: false, scope_resources: nil)
+        partial = Partial.new(
+          name: name.to_s,
+          context: @context,
+          environment: @environment,
+          module_name: @module_name,
+          data: data,
+          data_context: data_context,
+          force_rendering: force_rendering,
+          deep_merge: deep_merge,
+          terraform_variables: @terraform_variables,
+          scope_resources: scope_resources
+        )
+
+        partial.render
+      end
+
+      def default_true(context, key)
+        return context.has_key?(key) ? context[key] : true
+      end
+    end
+  end
+end
+