ConfigLMM 0.1.0

data/lib/ConfigLMM/commands/configsCommand.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative '../utils/filters'
+require_relative '../io/configList'
+require_relative '../context'
+require_relative '../state'
+require_relative '../Framework'
+require_relative '../LMM'
+require 'xdg'
+require 'tmpdir'
+
+module ConfigLMM
+    module Commands
+        class ConfigsCommand < ConfigLMM::Command
+
+            def initialize(configPaths, options)
+                @ConfigPaths = configPaths
+                @Options = options
+                @Plugins = {}
+
+                logger do |config|
+                    config.level = @Options[:level]
+                end
+
+                @Context = Context.new(logger, prompt, ::XDG.new, @Options[:context])
+                @State = State.new(logger, prompt)
+                @Diff = {}
+
+                # Load all Plugin files
+                Framework::Registrator.registerAll(logger)
+
+                # Create Plugin instances
+                Framework::Store.boot(logger, prompt, @Plugins)
+            end
+
+            def execute
+                raise ConfigLMM::CLI::MissingArgument.new("ERROR: No configs specified!\n\n") if @ConfigPaths.empty?
+
+                options = @Options.dup
+                options.delete(:locations)
+                options.delete(:things)
+                #options[:locationFilter] = Utils::Filters.parseLocationsOption(@Options[:locations], logger)
+                #options[:thingFilter] = Utils::Filters.parseThingsOption(@Options[:things], logger)
+
+                configList = IO::ConfigList.create(@ConfigPaths, logger)
+                configList.expand!(options[:locationFilter])
+
+                @State.load!(configList, options)
+
+                self.processConfig(configList.toConfig(@Context), options)
+            end
+
+            def plugins
+                @Plugins
+            end
+
+            def state
+                @State
+            end
+
+            def context
+                @Context
+            end
+
+            def findBestProvider(plugins)
+                raise 'No providers!' if plugins.empty?
+                # TODO FIXME
+                # In case of multiple providers that match
+                # We should chose best one and save it in state
+                plugins.first
+            end
+
+            protected
+
+            def invokeValidateAction(id, plugin, singleTarget, options)
+                actionMethod = plugin.class.actionMethod(singleTarget['Type'], 'Validate')
+                plugin.send(actionMethod, id, singleTarget, state, context, options)
+            end
+
+            def invokeRefreshAction(id, plugin, singleTarget, options)
+                state.create!
+                activeState = state.item(id)
+                if activeState[:Type].nil?
+                    activeState[:Type] = singleTarget['Type'].to_s
+                elsif activeState[:Type] != singleTarget['Type'].to_s
+                    raise Framework::PluginError.new("Unexpected Type #{activeState[:Type].inspect}! Wanted #{singleTarget['Type']}")
+                end
+                actionMethod = plugin.class.actionMethod(singleTarget['Type'], 'Refresh')
+                if plugin.methods.include?(:authenticate)
+                    result = plugin.authenticate(actionMethod, singleTarget, state, context, options)
+                    raise Framework::PluginAuthError.new('Failed to authenticate!') unless result
+                end
+                plugin.send(actionMethod, id, singleTarget, activeState, context, options)
+                state.save
+            end
+
+            def invokeDiffAction(id, plugin, singleTarget, options)
+                state.create!
+                activeState = state.item(id)
+                if activeState[:Type].nil?
+                    activeState[:Type] = singleTarget['Type'].to_s
+                elsif activeState[:Type] != singleTarget['Type'].to_s
+                    raise Framework::PluginError.new("Unexpected Type #{activeState[:Type].inspect}! Wanted #{singleTarget['Type']}")
+                end
+                actionMethod = plugin.class.actionMethod(singleTarget['Type'], 'Diff')
+                plugin.send(actionMethod, id, singleTarget, activeState, context, options)
+            end
+
+            def invokeBuildAction(id, plugin, singleTarget, options)
+                actionMethod = plugin.class.actionMethod(singleTarget['Type'], 'Build')
+                plugin.send(actionMethod, id, singleTarget, state, context, options)
+            end
+
+            def invokeDeployAction(id, plugin, singleTarget, options)
+                prompt.warn("Deploying #{singleTarget['ID']}: #{singleTarget['Type'].to_s}")
+                state.create!
+                activeState = state.item(id)
+                if activeState[:Type].nil?
+                    activeState[:Type] = singleTarget['Type'].to_s
+                elsif activeState[:Type] != singleTarget['Type'].to_s
+                    raise Framework::PluginError.new("Unexpected Type #{activeState[:Type].inspect}! Wanted #{singleTarget['Type']}")
+                end
+                actionMethod = plugin.class.actionMethod(singleTarget['Type'], 'Deploy')
+                if plugin.methods.include?(:authenticate)
+                    result = plugin.authenticate(actionMethod, singleTarget, state, context, options)
+                    raise Framework::PluginAuthError.new('Failed to authenticate!') unless result
+                end
+
+                Dir.mktmpdir do |outputDir|
+
+                    if plugin.class.persistBuildDir?
+                        if options['output'] == '/tmp or ./build'
+                            options = options.dup
+                            options['output'] = './build'
+                            if !options['dry']
+                                FileUtils.mkdir_p(options['output'])
+                            end
+                        end
+                    else
+                        options = options.dup
+                        options['output'] = outputDir
+                    end
+
+                    if !options['dry']
+                     # Prevent others accessing it
+                        FileUtils.chmod(0750, options['output'])
+                    end
+
+                    if plugin.hasAction?(singleTarget['Type'], :build)
+                        invokeBuildAction(id, plugin, singleTarget, options)
+                    end
+
+                    plugin.send(actionMethod, id, singleTarget, activeState, context, options)
+                end
+                state.save
+            end
+
+
+            def checkDiff(id, targetName, stateName, target, activeState)
+                if target[targetName] != activeState[stateName]
+                    @Diff[id] = target
+                end
+            end
+        end
+    end
+end

data/lib/ConfigLMM/commands/deploy.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class Deploy < ConfigsCommand
+            def processConfig(config, options)
+                config.each do |id, target|
+
+                    target['Resources'].to_h.each do |id, config|
+                        IO::ConfigList.processConfig(id, config, target[:Parent])
+                        processDeploy(IO::ConfigList.normalizeId(id), config, options)
+                    end
+
+                    processDeploy(id, target, options)
+                end
+                prompt.ok('Deploy successful!')
+            end
+
+            def processDeploy(id, target, options)
+                providers = []
+                self.plugins.each do |pluginId, plugin|
+                    if plugin.hasAction?(target['Type'], :deploy)
+                        providers << plugin
+                    end
+                end
+                message = "Couldn't find action Build for #{target['Type']}"
+                if providers.empty?
+                    logger.debug(message)
+                    return
+                end
+
+                bestProvider = self.findBestProvider(providers)
+                invokeDeployAction(id, bestProvider, target, options)
+            end
+        end
+    end
+end

data/lib/ConfigLMM/commands/diff.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class Diff < ConfigsCommand
+            def processConfig(config, options)
+                configDiffs = {}
+                config.each do |id, data|
+                    found = false
+                    plugins.each do |pluginId, plugin|
+                        if plugin.hasAction?(data['Type'], :diff)
+                            invokeDiffAction(id, plugin, data, options)
+                            configDiffs[id] = plugin.diff unless plugin.diff.empty?
+                            found = true
+                        end
+                    end
+                    logger.debug("Couldn't find action Diff for type #{data['Type']}") unless found
+                end
+                showDiff(configDiffs)
+            end
+
+            def showDiff(configDiffs)
+                configDiffs.each do |id, diffs|
+                    prompt.say(' ' + id + ':')
+                    diffs.each do |name, diff|
+                        if diff.first.is_a?(Hash)
+                            prompt.say('     ' + name + ':')
+                            diff.first.each do |name, value|
+                                prompt.say('-      ' + name + ': ' + value, :color => :red)
+                            end
+                            diff.last.each do |name, value|
+                                prompt.say('+      ' + name + ': ' + value, :color => :green)
+                            end
+                        else
+                            prompt.say('-    ' + name + ': ' + diff.first, :color => :red)
+                            prompt.say('+    ' + name + ': ' + diff.last, :color => :green)
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/ConfigLMM/commands/list.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class List < ConfigsCommand
+            def processConfig(config, options)
+                config.each do |id, data|
+                    prompt.say("#{data['Name']}: #{data['Type']}")
+                end
+            end
+        end
+    end
+end

data/lib/ConfigLMM/commands/refresh.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class Refresh < ConfigsCommand
+            def processConfig(config, options)
+                errors = 0
+                config.each do |id, target|
+
+                    target['Resources'].to_h.each do |id, target|
+                        IO::ConfigList.processConfig(id, target, target[:Parent])
+                        processRefresh(IO::ConfigList.normalizeId(id), target, options)
+                    end
+
+                    errors += processRefresh(id, target, options)
+                end
+                if errors.zero?
+                    prompt.ok('Refresh successful!')
+                else
+                    prompt.error('Encountered issue while refreshing state!')
+                end
+            end
+
+            def processRefresh(id, target, options)
+                errors = 0
+                found = false
+                self.plugins.each do |pluginId, plugin|
+                    if plugin.hasAction?(target['Type'], :refresh)
+                        begin
+                            invokeRefreshAction(id, plugin, target, options)
+                        rescue Framework::PluginError => e
+                            logger.error(e)
+                            errors += 1
+                        end
+                        found = true
+                    end
+                end
+                # We allow plugins without refresh action
+                logger.debug("Couldn't find action Refresh for type #{target['Type']}") unless found
+                errors
+            end
+        end
+    end
+end

data/lib/ConfigLMM/commands/types.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative '../Framework'
+require 'set'
+require 'yaml'
+
+module ConfigLMM
+    module Commands
+        class Types < ConfigLMM::Command
+              def initialize(options)
+                logger do |config|
+                    config.level = options[:level]
+                end
+
+                # Load all Plugin files
+                Framework::Registrator.registerAll(logger)
+            end
+
+            def execute
+                types = {}
+                Framework::Store.plugins.each do |plugin|
+                    plugin.instance_methods.each do |method|
+                        if match = method.match('^action(\w+)(Validate|Build|Refresh|Diff|Deploy)$')
+                            type = match[1]
+                            types[type] ||= []
+                            types[type] << match[2]
+                        end
+                    end
+                end
+                prompt.say(YAML.dump({ 'Types' => types.sort.to_h }))
+            end
+        end
+    end
+end

data/lib/ConfigLMM/commands/validate.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'configsCommand'
+
+module ConfigLMM
+    module Commands
+        class Validate < ConfigsCommand
+            def processConfig(config, options)
+
+                errors = 0
+                config.each do |id, target|
+                    target['Resources'].to_h.each do |id, target|
+                        IO::ConfigList.processConfig(id, target, target[:Parent])
+                        processValidate(IO::ConfigList.normalizeId(id), target, options)
+                    end
+
+                    errors += 1 unless processValidate(id, target, options)
+                end
+                if errors.zero?
+                    prompt.ok('Validation successful, no issues were found!')
+                else
+                    prompt.error('Validation failed, we found some issues!')
+                end
+            end
+
+            def processValidate(id, target, options)
+                providers = []
+                self.plugins.each do |pluginId, plugin|
+                    if plugin.hasAction?(target['Type'], :validate)
+                        providers << plugin
+                    end
+                end
+                if providers.empty?
+                    # We allow for validation function to not exist
+                    true
+                else
+                    errors = []
+                    providers.each do |provider|
+                        errors += invokeValidateAction(id, provider, target, options)
+                    end
+                    errors.each do |error|
+                        prompt.error(error)
+                    end
+                    errors.empty?
+                end
+            end
+        end
+    end
+end

data/lib/ConfigLMM/context.rb

@@ -0,0 +1,52 @@
+
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'yaml'
+
+module ConfigLMM
+    class Context
+        CONTEXT_FILE = 'configlmm/context.yaml'
+
+        def initialize(logger, prompt, xdg, contextFile)
+            @Logger = logger
+            @Prompt = prompt
+            load!(xdg.config_home, contextFile)
+        end
+
+        def likes?(name)
+            @Context['Likes'].include?(name)
+        end
+
+        def dislikes?(name)
+            @Context['Dislikes'].include?(name)
+        end
+
+        def add(context)
+            return unless context
+            context['Likes'] ||= []
+            context['Dislikes'] ||= []
+            @Context['Likes'] += context['Likes']
+            @Context['Dislikes'] += context['Dislikes']
+        end
+
+        private
+
+        def load!(configHome, contextFile)
+            @Context = {}
+            if (contextFile && !File.exist?(contextFile))
+                @Logger.error("Provided Context file doesn't exist: #{contextFile}")
+                raise 'Missing Context!'
+            end
+            if !contextFile
+                contextFile = configHome / CONTEXT_FILE
+            end
+            if (File.exist?(contextFile))
+                @Context = YAML.safe_load_file(contextFile, permitted_classes: [Symbol])
+            end
+            @Context['Likes'] ||= []
+            @Context['Dislikes'] ||= []
+        end
+
+    end
+end

data/lib/ConfigLMM/io/configList.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'path'
+require 'find'
+require 'yaml'
+
+module ConfigLMM
+    module IO
+        class ConfigList
+            ConfigError = Class.new(RuntimeError)
+
+            def self.create(targets, logger)
+                targets = targets.uniq.select do |target|
+                    exist = File.exist?(target)
+                    logger.warn("'#{path}' doesn't exist, ignoring!") unless exist
+                    exist
+                end
+                self.new(targets)
+            end
+
+            def initialize(targets)
+                @Sources = targets.map do |target|
+                    Path.new(target)
+                end
+            end
+
+            def expand!(locationFilter)
+                sources = []
+                @Sources.each do |source|
+                    basePath = source.to_s
+                    if File.file?(basePath)
+                        parent = Path.new(File.dirname(File.expand_path(basePath)))
+                        sources << Path.new(basePath, parent)
+                    else
+                        parent = source
+                        ::Find.find(basePath) do |path|
+                            next unless Path.isConfig?(path)
+                            parent = parent.lookupParent(path)
+                            if File.directory?(path)
+                                parent = Path.new(path, parent)
+                                next
+                            end
+                            path = Path.new(path, parent)
+                            sources << path if Utils::Filters.includePath?(path, locationFilter)
+                        end
+                    end
+                end
+                @Sources = sources
+            end
+
+            def self.normalizeId(id)
+                # Remove all non-letters but allow Unicode
+                id.gsub(/[[:space:]]/, '').upcase
+            end
+
+            def self.processConfig(id, data, parent)
+                data['ID'] = id
+                if data['Type'].nil?
+                    raise ConfigError.new("Missing 'Type' field: #{id}!")
+                end
+                data['Name'] = id unless data.has_key?('Name')
+                data['Type'] = data['Type'].to_sym
+                data[:Parent] = parent
+                data
+            end
+
+            def toConfig(context)
+                config = {}
+                @Sources.each do |source|
+                    YAML.safe_load_file(source.to_s, permitted_classes: [Symbol]).each do |id, data|
+                        normalizedId = self.class.normalizeId(id)
+                        if id == '_CONTEXT_'
+                            context.add(data)
+                            next
+                        end
+
+                        self.class.processConfig(id, data, source.parent)
+
+                        # TODO FIXME we should deep merge them instead
+                        raise ConfigError.new("Duplicate ID: #{id} (#{normalizedId}) - #{source}") if config.has_key?(normalizedId)
+                        config[normalizedId] = data
+                    end
+                #rescue YAML::SyntaxError => error
+                #    raise ConfigError.new(error)
+                end
+                config
+            end
+
+            def count
+                @Sources.length
+            end
+
+            def to_a
+                @Sources
+            end
+        end
+    end
+end

data/lib/ConfigLMM/io/path.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative 'source'
+
+module ConfigLMM
+    module IO
+        class Path < Source
+            def initialize(path, parent = nil)
+                @Path = path.is_a?(Pathname) ? path : Pathname.new(path)
+                super(parent)
+            end
+
+            def name
+                @Path.basename.to_s
+            end
+
+            def basename
+                @Path.basename(@Path.extname).to_s
+            end
+
+            def dirname
+                parent.basename unless parent.nil?
+            end
+
+            def self.isConfig?(path)
+                return false unless File.extname(path) == '.yaml'
+                File.basename(path, '.yaml').end_with?('.mm')
+            end
+
+            def to_s
+                @Path.to_s
+            end
+
+            def ==(other)
+                self.to_s == other.to_s
+            end
+
+            def lookupParent(path)
+                if path.start_with?(self.to_s)
+                    self
+                else
+                    parent&.lookupParent(path) or raise "Didn't find parent for #{path}"
+                end
+            end
+        end
+    end
+end

data/lib/ConfigLMM/io/source.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ConfigLMM
+    module IO
+        class Source
+
+            def initialize(parent = nil)
+                unless parent.nil? || parent.is_a?(Source)
+                    raise "Invalid parent! Must be instance of Source! Got #{parent.inspect}"
+                end
+                @ID = false
+                @Parent = parent
+                @Childs = {}
+                @Parent.addChild(self) if @Parent.is_a?(Source)
+            end
+
+            def id
+                return @ID unless @ID == false
+                if @Parent.is_a?(Source)
+                    @ID = self.name
+                    @ID = @Parent.id + '/' + @ID if @Parent.id
+                else
+                    @ID = nil
+                end
+                @ID
+            end
+
+            def parent
+                @Parent
+            end
+
+            def [](name)
+                raise "Didn't find #{name} in #{self.inspect}" unless @Childs.key?(name)
+                @Childs[name]
+            end
+
+            protected
+
+            def addChild(child)
+                raise "Invalid child! Must be instance of Source! Got #{child.inspect}" unless child.is_a?(Source)
+                return if @Childs.key?(child.name)
+                @Childs[child.name] = child
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/io.rb

@@ -0,0 +1,2 @@
+
+require_relative 'io/configList'