yle_tf 0.1.0

data/lib/yle_tf/logger.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+require 'logger'
+require 'rubygems'
+
+class YleTf
+  # Logger for debug, error, etc. outputs.
+  # Prints to STDERR, so it does not mess with e.g. `terraform output`.
+  module Logger
+    class << self
+      extend Forwardable
+      def_delegators :logger, :debug, :info, :warn, :error, :fatal
+      def_delegators :logger, :debug?
+    end
+
+    def self.logger
+      @logger ||= ::Logger.new(STDERR).tap do |logger|
+        patch_for_old_ruby(logger)
+        logger.level = log_level
+        logger.formatter = log_formatter
+      end
+    end
+
+    def self.log_level
+      (ENV['TF_DEBUG'] && 'DEBUG') || \
+        ENV['TF_LOG'] || \
+        'INFO'
+    end
+
+    def self.log_formatter
+      proc do |severity, _datetime, progname, msg|
+        if progname
+          "[#{progname}] #{severity}: #{msg}\n"
+        else
+          "#{severity}: #{msg}\n"
+        end
+      end
+    end
+
+    # Patches the `::Logger` in older Ruby versions to
+    # accept log level as a `String`
+    def self.patch_for_old_ruby(logger)
+      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+        require_relative '../../vendor/logger_level_patch'
+        logger.extend(LoggerLevelPatch)
+      end
+    end
+  end
+end

data/lib/yle_tf/plugin.rb

@@ -0,0 +1,55 @@
+class YleTf
+  class Plugin
+    autoload :ActionHook, 'yle_tf/plugin/action_hook'
+    autoload :Loader, 'yle_tf/plugin/loader'
+    autoload :Manager, 'yle_tf/plugin/manager'
+
+    DEFAULT_COMMAND = Object.new.freeze
+
+    def self.manager
+      @manager ||= Manager.new
+    end
+
+    def self.register
+      Plugin.manager.register(self)
+    end
+
+    def self.action_hooks
+      @action_hooks ||= []
+    end
+
+    def self.action_hook(&block)
+      action_hooks << block
+    end
+
+    def self.commands
+      @commands ||= {}
+    end
+
+    def self.command(name, synopsis, &block)
+      name = name.to_s if name.is_a?(Symbol)
+      commands[name] = {
+        synopsis: synopsis,
+        proc: block
+      }
+    end
+
+    def self.default_config(config = nil)
+      @default_config = config if config
+      @default_config || {}
+    end
+
+    def self.config_context(context = nil)
+      @config_context = context if context
+      @config_context || {}
+    end
+
+    def self.backends
+      @backends ||= {}
+    end
+
+    def self.backend(type, &block)
+      backends[type.to_sym] = block
+    end
+  end
+end

data/lib/yle_tf/plugin/action_hook.rb

@@ -0,0 +1,23 @@
+class YleTf
+  class Plugin
+    class ActionHook
+      attr_reader :actions
+
+      def initialize(actions)
+        @actions = actions
+      end
+
+      def before(existing, new, *args, &block)
+        if actions.include?(existing)
+          actions.insert_before(existing, new, *args, &block)
+        end
+      end
+
+      def after(existing, new, *args, &block)
+        if actions.include?(existing)
+          actions.insert_after(existing, new, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/plugin/loader.rb

@@ -0,0 +1,59 @@
+require 'yle_tf/logger'
+
+class YleTf
+  class Plugin
+    module Loader
+      BUNDLER_PLUGIN_GROUP = :tf_plugins
+
+      def self.load_plugins
+        load_core_plugins
+        load_bundler_plugins
+        load_user_plugins
+      end
+
+      def self.load_core_plugins
+        core_plugins.each do |plugin_file|
+          Logger.debug("Loading core plugin: #{File.basename(plugin_file, '.rb')}")
+          load(plugin_file)
+        end
+      end
+
+      def self.load_bundler_plugins
+        if defined?(Bundler)
+          print_bundler_plugin_list if Logger.debug?
+          Bundler.require(BUNDLER_PLUGIN_GROUP)
+        end
+      end
+
+      def self.load_user_plugins
+        user_plugins.each do |plugin|
+          Logger.debug("Loading user plugin: #{plugin}")
+          require(plugin)
+        end
+      end
+
+      def self.core_plugins
+        Dir.glob(File.expand_path('../../../yle_tf_plugins/**/plugin.rb', __FILE__))
+      end
+
+      def self.bundler_plugins
+        plugins = Bundler.definition.current_dependencies.select do |dep|
+          dep.groups.include?(BUNDLER_PLUGIN_GROUP)
+        end
+        plugins.map { |dep| Bundler.definition.specs[dep].first }
+      end
+
+      def self.user_plugins
+        ENV.fetch('TF_PLUGINS', '').split(/[ ,]+/)
+      end
+
+      def self.print_bundler_plugin_list
+        plugins = bundler_plugins
+        if !plugins.empty?
+          Logger.debug('Loading plugins via Bundler:')
+          plugins.each { |spec| Logger.debug("  - #{spec.name} = #{spec.version}") }
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/plugin/manager.rb

@@ -0,0 +1,49 @@
+require 'yle_tf/logger'
+
+class YleTf
+  class Plugin
+    class Manager
+      attr_reader :registered
+
+      def initialize
+        @registered = []
+      end
+
+      def register(plugin)
+        if !registered.include?(plugin)
+          Logger.debug("Registered plugin: #{plugin}")
+          @registered << plugin
+        end
+      end
+
+      def action_hooks
+        registered.map(&:action_hooks).flatten
+      end
+
+      def commands
+        {}.tap do |commands|
+          registered.each do |plugin|
+            commands.merge!(plugin.commands)
+          end
+          commands.default = commands.delete(DEFAULT_COMMAND)
+        end
+      end
+
+      def config_contexts
+        registered.map(&:config_context)
+      end
+
+      def default_configs
+        registered.map(&:default_config)
+      end
+
+      def backends
+        {}.tap do |backends|
+          registered.each do |plugin|
+            backends.merge!(plugin.backends)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/system.rb

@@ -0,0 +1,22 @@
+require 'shellwords'
+
+require 'yle_tf/error'
+require 'yle_tf/logger'
+
+class YleTf
+  # Helpers to execute system commands with error handling
+  #
+  # TODO: Add way to wrap stdout of the commands and direct it to `Logger`
+  class System
+    ExecuteError = Class.new(YleTf::Error)
+
+    def self.cmd(*args, **opts)
+      env = opts[:env]
+      YleTf::Logger.debug { "Calling `#{args.shelljoin}`#{" with env '#{env}'" if env}" }
+
+      system(env || {}, *args) ||
+        raise(ExecuteError,
+              "Failed to execute `#{args.shelljoin}`#{" with env '#{env}'" if env}")
+    end
+  end
+end

data/lib/yle_tf/tf_hook.rb

@@ -0,0 +1,90 @@
+require 'fileutils'
+require 'tmpdir'
+
+require 'yle_tf/error'
+require 'yle_tf/logger'
+require 'yle_tf/system'
+
+class YleTf
+  class TfHook
+    autoload :Runner, 'yle_tf/tf_hook/runner'
+
+    # Returns a `TfHook` instance from configuration hash
+    def self.from_config(config, tf_env)
+      TfHook.new(
+        description: config['description'],
+        source: config['source'],
+        vars: merge_vars(config['vars'], tf_env)
+      )
+    end
+
+    # Returns a `Hook` instance from a local file path
+    def self.from_file(path)
+      TfHook.new(
+        description: File.basename(path),
+        path: path
+      )
+    end
+
+    attr_reader :description, :source, :path, :vars
+
+    def initialize(opts = {})
+      @description = opts[:description]
+      @source = opts[:source]
+      @path = opts[:path]
+      @vars = opts[:vars] || {}
+      @tmpdir = nil
+    end
+
+    def run(tf_vars)
+      fetch if !path
+
+      Logger.info("Running hook '#{description}'...")
+      YleTf::System.cmd(path, env: vars.merge(tf_vars))
+    ensure
+      delete_tmpdir
+    end
+
+    def parse_source_config
+      m = %r{^(?<uri>.+)//(?<path>[^?]+)(\?ref=(?<ref>.*))?$}.match(source)
+      raise Error, "Invalid or missing `source` for hook '#{description}'" if !m
+
+      {
+        uri: m[:uri],
+        path: m[:path],
+        ref: m[:ref] || 'master'
+      }
+    end
+
+    def fetch
+      source_config = parse_source_config
+      source_config[:dir] = create_tmpdir
+      clone_git_repo(source_config)
+      @path = File.join(source_config[:dir], source_config[:path])
+    end
+
+    def clone_git_repo(config)
+      Logger.info("Cloning hook '#{description}' from #{config[:uri]} (#{config[:ref]})")
+      YleTf::System.cmd(
+        'git', 'clone', '--no-progress', '--depth=1', '--branch', config[:ref],
+        '--', config[:uri], config[:dir]
+      )
+    end
+
+    def create_tmpdir
+      @tmpdir = Dir.mktmpdir('tf_hook_')
+    end
+
+    def delete_tmpdir
+      FileUtils.rm_r(@tmpdir) if @tmpdir
+      @tmpdir = nil
+    end
+
+    # Returns a hash with env specific vars merged into the default ones
+    def self.merge_vars(vars, tf_env)
+      vars ||= {}
+      defaults = vars['defaults'] || {}
+      defaults.merge(vars[tf_env] || {})
+    end
+  end
+end

data/lib/yle_tf/tf_hook/runner.rb

@@ -0,0 +1,48 @@
+require 'yle_tf/logger'
+require 'yle_tf/tf_hook'
+
+class YleTf
+  class TfHook
+    class Runner
+      attr_reader :config, :hook_env
+
+      def initialize(config, hook_env)
+        @config = config
+        @hook_env = hook_env
+      end
+
+      def tf_env
+        @tf_env ||= config.tf_env
+      end
+
+      def run(hook_type)
+        Logger.debug("Running #{hook_type} hooks")
+        hooks(hook_type).each do |hook|
+          hook.run(hook_env)
+        end
+      end
+
+      def hooks(hook_type)
+        hook_confs(hook_type).map { |conf| TfHook.from_config(conf, tf_env) } +
+          hook_files(hook_type).map { |file| TfHook.from_file(file) }
+      end
+
+      def hook_confs(hook_type)
+        config.fetch('hooks', hook_type).select do |hook|
+          if hook['envs'] && !hook['envs'].include?(tf_env)
+            Logger.debug("Skipping hook '#{hook['description']}' in env '#{tf_env}'")
+            false
+          else
+            true
+          end
+        end
+      end
+
+      def hook_files(hook_type)
+        Dir.glob("tf_hooks/#{hook_type}/*").select do |file|
+          File.executable?(file) && !File.directory?(file)
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/vars_file.rb

@@ -0,0 +1,42 @@
+class YleTf
+  class VarsFile
+    # Returns the env specific tfvars file path if it exists
+    def self.find_env_vars_file(config)
+      path = "#{config.module_dir}/envs/#{config.tf_env}.tfvars"
+      VarsFile.new(path) if File.exist?(path)
+    end
+
+    # Returns all envs that have tfvars files
+    def self.list_all_envs(config)
+      Dir.glob("#{config.module_dir}/envs/*.tfvars").map do |path|
+        File.basename(path, '.tfvars')
+      end
+    end
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def read
+      IO.read(path)
+    end
+
+    def append_file(vars_file)
+      File.open(path, 'a') do |file|
+        file.puts # ensure we don't append to an existing line
+        file.puts(vars_file.read)
+      end
+    end
+
+    def append_vars(vars)
+      File.open(path, 'a') do |file|
+        file.puts # ensure we don't append to an existing line
+        vars.each do |key, value|
+          file.puts %(#{key} = "#{value}")
+        end
+      end
+    end
+  end
+end