ConfigLMM 0.1.0

data/lib/ConfigLMM/Framework/plugins/plugin.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'store'
+require 'http'
+require 'fileutils'
+
+module ConfigLMM
+    module Framework
+
+        class Plugin
+
+
+            def self.inherited(plugin)
+                Store.registerPlugin(plugin)
+            end
+
+            def self.id
+                @ID ||= self.normalizeId(self.className.to_s)
+            end
+
+            def self.addMeta(*fields)
+                fields.each do |field|
+                    self.define_singleton_method(field) do |value|
+                        @Meta ||= {}
+                        @Meta[field] = value
+                    end
+                end
+            end
+
+            def self.persistBuildDir
+                @PersistBuildDir = true
+            end
+
+            def self.persistBuildDir?
+                @PersistBuildDir == true
+            end
+
+            class << self
+                alias :className :name
+            end
+
+            addMeta :name, :description
+
+            def initialize(logger, prompt, plugins)
+                @Logger = logger
+                @Prompt = prompt
+                @Plugins = plugins
+                @Diff = {}
+            end
+
+            def id
+                self.class.id
+            end
+
+            def self.actionMethod(type, action)
+                name = type.to_s
+                name[0] = name[0].upcase
+                ('action' + name + action.to_s.capitalize).to_sym
+            end
+
+            def hasAction?(type, action)
+                self.methods.include?(self.class.actionMethod(type, action))
+            end
+
+            def diff
+                @Diff
+            end
+
+            def cleanup(configs, state, context, options)
+                # Do nothing
+            end
+
+            protected
+
+            def logger
+                @Logger
+            end
+
+            def prompt
+                @Prompt
+            end
+
+            def plugins
+                @Plugins
+            end
+
+            def shouldMatch(id, targetKey, stateKey, target, activeState)
+                if target[targetKey] != activeState[stateKey]
+                    @Diff.update({targetKey => [target[targetKey], activeState[stateKey]]})
+                end
+            end
+
+            def fileWrite(target, data, dry)
+                if dry
+                    prompt.say('Would write file ' + target)
+                else
+                    File.write(target, data)
+                end
+            end
+
+            def copy(source, target, dry)
+                if dry
+                    prompt.say('Would copy ' + source + ' to ' + target)
+                else
+                    FileUtils.cp_r(source, target, noop: dry)
+                end
+            end
+
+            def copyNotPresent(source, target, dry)
+                if !File.exist?(target + File.basename(source))
+                    if dry
+                        prompt.say('Would copy ' + source + ' to ' + target)
+                    else
+                        FileUtils.cp_r(source, target, noop: dry)
+                    end
+                end
+            end
+
+            def rm(path, dry)
+                if dry
+                    prompt.say('Would remove ' + path)
+                else
+                    FileUtils.rm_r(path, noop: dry)
+                end
+            end
+
+            def mkdir(target, dry)
+                if dry
+                    prompt.say('Would create ' + target)
+                else
+                    FileUtils.mkdir_p(target)
+                end
+            end
+
+            def chown(user, group, target, dry)
+                if dry
+                    prompt.say("Would chown #{target} as #{user}:#{group}")
+                else
+                    FileUtils.chown_R(user, group, target)
+                end
+            end
+
+            def renderTemplate(template, target, outputPath, options)
+                variables = {
+                    config: target,
+                }
+                result = template.result_with_hash(variables)
+                mkdir(File.dirname(outputPath), options['dry'])
+                if options['dry']
+                    prompt.say('Would write to ' + outputPath)
+                else
+                    File.write(outputPath, result)
+                end
+            end
+
+            def self.normalizeId(id)
+                id = id.split('::').last
+                if id.downcase.end_with?('plugin')
+                    id = id[0...-6]
+                end
+                id.to_sym
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/Framework/plugins/ssh.rb

@@ -0,0 +1,37 @@
+
+# frozen_string_literal: true
+
+require_relative 'plugin'
+require_relative 'errors'
+require 'net/ssh'
+
+module ConfigLMM
+    module Framework
+
+        class SSH < Framework::Plugin
+
+            def parseLocation(location)
+                  user, hostname = location.split('@')
+                  if hostname.nil?
+                      hostname = user
+                      user = nil
+                  end
+                  hostname, port = hostname.split(':')
+                  port = 22 unless port
+                  {
+                      hostname: hostname,
+                      user: user,
+                      port: port
+                  }
+            end
+
+            def checkSSHAuth!(location, password)
+                creds = parseLocation(location)
+                Net::SSH.start(creds[:hostname], creds[:user], password: password, port: creds[:port]) do |ssh|
+                    # All good if we got here
+                end
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/Framework/plugins/store.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module ConfigLMM
+    module Framework
+        class Store
+
+            @@AvailablePlugins = {}
+
+            def self.registerPlugin(plugin)
+                @@AvailablePlugins[plugin.id] = plugin
+            end
+
+            def self.plugins
+                @@AvailablePlugins.values
+            end
+
+            def self.countPlugins
+                @@AvailablePlugins.length
+            end
+
+            def self.plugin(pluginId)
+                raise PluginMissingError.new("Couldn't find plugin '#{pluginId}'") unless @@AvailablePlugins.key?(pluginId)
+                @@AvailablePlugins[pluginId]
+            end
+
+            def self.leafPlugins
+                nonLeaves = Set.new
+                @@AvailablePlugins.each do |id, plugin|
+                    plugin.ancestors.each do |ancestor|
+                        nonLeaves << ancestor if ancestor != plugin
+                    end
+                end
+                @@AvailablePlugins.reject do |id, plugin|
+                    nonLeaves.include?(plugin)
+                end
+            end
+
+            def self.boot(logger, prompt, plugins)
+                leafPlugins.each do |id, plugin|
+                    self.initPlugin(id, logger, prompt, plugins)
+                rescue PluginLoadError => error
+                    logger.warn("Plugin '#{id}' failed to load!\n#{error.message}" + (error.cause ? '  - ' : ''), error.cause)
+                end
+                true
+            end
+
+            def self.initPlugin(pluginId, logger, prompt, plugins)
+                pluginId = pluginId.to_sym
+                raise 'Recursive/cyclic plugin' if plugins.key?(pluginId)
+                plugins[pluginId] = @@AvailablePlugins[pluginId].new(logger, prompt, plugins)
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/Framework/plugins.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'plugins/dns'
+require_relative 'plugins/nginxApp'
+require_relative 'plugins/ssh'

data/lib/ConfigLMM/Framework/registrator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ConfigLMM
+    module Framework
+        module Registrator
+
+            @BasePaths = []
+
+            def self.addPath(basePath)
+                @BasePaths << basePath
+            end
+
+            def self.registerAll(logger)
+                @BasePaths.each do |basePath|
+                    self.register(basePath, logger)
+                end
+            end
+
+            protected
+
+            def self.register(basePath, logger)
+                Dir.glob(basePath + 'Plugins/**/**.lmm.rb').each do |file|
+                    require file
+                rescue ScriptError => error
+                    logger.error("Failed to load #{File.realdirpath(file)}\n", error)
+                    raise error
+                end
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/Framework.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ConfigLMM
+    module Framework
+    end
+end
+
+require_relative 'Framework/registrator'
+require_relative 'Framework/plugins'

data/lib/ConfigLMM/LMM/plugins.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../Framework/registrator'
+
+ConfigLMM::Framework::Registrator.addPath(__dir__ + '/../../../')

data/lib/ConfigLMM/LMM.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ConfigLMM
+    module LMM
+    end
+end
+
+require_relative 'LMM/plugins'

data/lib/ConfigLMM/cli.rb

@@ -0,0 +1,161 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'LMM'
+
+module ConfigLMM
+    # Handle the application command line parsing
+    # and the dispatch to various command objects
+    #
+    # @api public
+    class CLI < Thor
+        ArgumentError = Class.new(RuntimeError)
+        MissingArgument = Class.new(ArgumentError)
+        InvalidOption = Class.new(ArgumentError)
+
+        #class_option :locations, type: :string, default: '', group: :configs, desc: 'Filter by config file locations'
+        #class_option :things, type: :string, default: '', group: :configs, desc: 'Filter things to use'
+        class_option :level, type: :string, enum: ['debug', 'info', 'warn', 'error'], default: 'info', desc: 'Logging level to use'
+        class_option :dry,  aliases: '-n', type: :boolean, desc: 'Only show actions without performing'
+
+        desc 'version', 'Show program\'s version'
+        def version
+            require_relative 'version'
+            puts "v" + ConfigLMM::VERSION
+        end
+        map %w[--version -v] => :version
+
+
+        desc 'list [CONFIGS...]', 'List things'
+        method_option :help,  aliases: '-h', type: :boolean,
+                              desc: 'Display usage information'
+        def list(*configPaths)
+            handleCommand(:list, configPaths, options)
+        end
+
+
+        desc 'validate [CONFIGS...]', 'Check whether the configuration is valid'
+        method_option :help, aliases: '-h', type: :boolean,
+                             desc: 'Display usage information'
+        def validate(*configPaths)
+            handleCommand(:validate, configPaths, options)
+        end
+
+        desc 'refresh [CONFIGS...]', 'Update local state to match deployed things'
+        method_option :help,    aliases: '-h', type: :boolean,
+                                desc: 'Display usage information'
+        method_option :state,   aliases: '-s', type: :string,
+                                desc: 'Path to the state file'
+        method_option :context, aliases: '-c', type: :string,
+                                desc: 'Path to context file'
+        def refresh(*configPaths)
+            handleCommand(:refresh, configPaths, options)
+        end
+
+
+        desc 'diff [CONFIGS...]', 'Show changes that will be applied with next deploy'
+        method_option :help,    aliases: '-h', type: :boolean,
+                                desc: 'Display usage information'
+        method_option :state,   aliases: '-s', type: :string,
+                                desc: 'Path to the state file'
+        method_option :context, aliases: '-c', type: :string,
+                                desc: 'Path to context file'
+        def diff(*configPaths)
+            handleCommand(:diff, configPaths, options)
+        end
+
+
+        desc 'build [CONFIGS...]', 'Build configuration in deployable form'
+        method_option :help,    aliases: '-h', type: :boolean,
+                                desc: 'Display usage information'
+        method_option :context, aliases: '-c', type: :string,
+                                desc: 'Path to context file'
+        method_option :output,  aliases: '-o', type: :string,
+                                default: './build',
+                                desc: 'Output folder'
+        def build(*configPaths)
+            handleCommand(:build, configPaths, options)
+        end
+
+
+        desc 'deploy [CONFIGS...]', 'Deploy configuration'
+        method_option :help,    aliases: '-h', type: :boolean,
+                                desc: 'Display usage information'
+        method_option :state,   aliases: '-s', type: :string,
+                                desc: 'Path to the state file'
+        method_option :context, aliases: '-c', type: :string,
+                                desc: 'Path to context file'
+        method_option :output,  aliases: '-o', type: :string,
+                                default: '/tmp or ./build',
+                                desc: 'Output folder'
+        def deploy(*configPaths)
+            handleCommand(:deploy, configPaths, options)
+        end
+
+
+        desc 'cleanup [CONFIGS...]', 'In deployed infrastructure cleanup/delete unused things (eg. deployment leftover junk) (note this can be risky due to mistakes)'
+        method_option :help,  aliases: '-h', type: :boolean,
+                              desc: 'Display usage information'
+        method_option :state, aliases: '-s', type: :string,
+                              desc: 'Path to the state file'
+        def cleanup(*configPaths)
+            handleCommand(:cleanup, configPaths, options)
+        end
+
+        desc 'types', 'List available types/plugins'
+        method_option :help,  aliases: '-h', type: :boolean,
+                              desc: 'Display usage information'
+        def types
+            handleCommand(:types, options)
+        end
+
+=begin
+        # TODO
+        desc 'test [CONFIGS...]', 'Test whether deployed things work as expected'
+        method_option :help,      aliases: '-h', type: :boolean,
+                                  desc: 'Display usage information'
+        method_option :load,      aliases: '-l', type: :boolean,
+                                  desc: 'Run performance/load tests (might be dangerous as it can affect live users)'
+        method_option :chaos,     aliases: '-c', type: :boolean,
+                                  desc: 'Test whether systems keep working while random things die (might be dangerous as it can affect live users due to injecting real faults)'
+        method_option :alerts,    aliases: '-a', type: :boolean,
+                                  desc: 'Test failure conditions and whether alerts work (might be dangerous as it can affect live users due to injecting real faults)'
+        method_option :tools,     aliases: '-t', type: :string, desc: 'Filter tools to use for testing'
+
+        def test(*configPaths)
+            handleCommand(:test, configPaths, options)
+        end
+
+        desc 'compare [CONFIGS...]', 'Show changes between local state and deployed things'
+        method_option :help,  aliases: '-h', type: :boolean,
+                              desc: 'Display usage information'
+        method_option :state, aliases: '-s', type: :string,
+                              desc: 'Path to state file'
+        def compare(*configPaths)
+            handleCommand(:compare, configPaths, options)
+        end
+
+=end
+
+        private
+
+        def handleCommand(name, *params)
+            if options[:help]
+                invoke :help, [name.to_s]
+            else
+                require_relative('commands/' + name.to_s)
+                Object.const_get('ConfigLMM::Commands::' + name.to_s.capitalize).new(*params).execute
+            end
+        rescue ArgumentError => e
+            $stderr.puts(e)
+            invoke :help, [name.to_s]
+            exit 1
+        end
+
+
+        def self.exit_on_failure?
+            true
+        end
+    end
+end

data/lib/ConfigLMM/command.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ConfigLMM
+  class Command
+    # Execute this command
+    #
+    # @api public
+    def execute(*)
+        raise(NotImplementedError, "#{self.class}##{__method__} must be implemented")
+    end
+
+    # A readable, structured and beautiful logging for the terminal
+    #
+    # @see http://www.rubydoc.info/gems/tty-logger
+    #
+    # @api public
+    def logger
+        if @Logger.nil?
+            require 'tty-logger'
+            @Logger = TTY::Logger.new do |config|
+                yield(config)
+            end
+        end
+        @Logger
+    end
+
+    # The external commands runner
+    #
+    # @see http://www.rubydoc.info/gems/tty-command
+    #
+    # @api public
+    def command(**options)
+        if @Command.nil?
+            require 'tty-command'
+            @Command = TTY::Command.new(options)
+        end
+        @Command
+    end
+
+    # The interactive prompt
+    #
+    # @see http://www.rubydoc.info/gems/tty-prompt
+    #
+    # @api public
+    def prompt
+        if @Prompt.nil?
+            require 'tty-prompt'
+            @Prompt = TTY::Prompt.new
+        end
+        @Prompt
+    end
+  end
+end

data/lib/ConfigLMM/commands/build.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class Build < ConfigsCommand
+            def processConfig(config, options)
+
+                config.each do |id, target|
+
+                    target['Resources'].to_h.each do |id, target|
+                        IO::ConfigList.processConfig(id, target, target[:Parent])
+                        processBuild(IO::ConfigList.normalizeId(id), target, options)
+                    end
+
+                    processBuild(id, target, options)
+                end
+                prompt.ok('Build successful, artifacts are in ' + options['output'])
+            end
+
+            def processBuild(id, target, options)
+                providers = []
+                self.plugins.each do |pluginId, plugin|
+                    if plugin.hasAction?(target['Type'], :build)
+                        providers << plugin
+                    end
+                end
+
+                if providers.empty?
+                    logger.debug("Skipping ID=#{id} - Type=#{target['Type']}")
+                    return
+                end
+
+                bestProvider = self.findBestProvider(providers)
+                invokeBuildAction(id, bestProvider, target, options)
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/commands/cleanup.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class Cleanup < ConfigsCommand
+
+            def processConfig(config, options)
+                plugins.each do |pluginId, plugin|
+                    configs = {}
+                    loadConfigs(plugin, config, configs)
+                    plugin.cleanup(configs, state, context, options)
+                end
+                prompt.ok('Cleanup successful!')
+            end
+
+            def loadConfigs(plugin, config, configs)
+                config.each do |id, target|
+                    loadConfigs(plugin, target['Resources'], configs) if target['Resources']
+                    if plugin.hasAction?(target['Type'], :deploy)
+                        configs[id] = target
+                    end
+                end
+                configs
+            end
+
+        end
+    end
+end