configmonkey_cli 1.0.0

data/lib/configmonkey_cli/application/core.rb

@@ -0,0 +1,78 @@
+module ConfigmonkeyCli
+  class Application
+    module Core
+      # ===================
+      # = Signal trapping =
+      # ===================
+      def trap_signals
+        debug "Trapping INT signal..."
+        $interruptable_threads = []
+        Signal.trap("INT") do
+          $cm_runtime_exiting = true
+          $interruptable_threads.each{|thr| thr.raise(Interrupt) if thr.alive? }
+          Kernel.puts "Interrupting..."
+        end
+        # Signal.trap("TERM") do
+        #   $cm_runtime_exiting = true
+        #   Kernel.puts "Terminating..."
+        # end
+      end
+
+      def release_signals
+        debug "Releasing INT signal..."
+        Signal.trap("INT", "DEFAULT")
+        # Signal.trap("TERM", "DEFAULT")
+      end
+
+      def haltpoint thr = Thread.current
+        thr.raise Interrupt if $cm_runtime_exiting
+      end
+
+      def interruptable &block
+        Thread.new do
+          begin
+            thr = Thread.current
+            $interruptable_threads << Thread.current
+            thr[:return_value] = block.call(thr)
+          ensure
+            $interruptable_threads.delete(Thread.current)
+          end
+        end.join[:return_value]
+      end
+
+
+      # ==========
+      # = Events =
+      # ==========
+      def hook *which, &hook_block
+        which.each do |w|
+          @hooks[w.to_sym] ||= []
+          @hooks[w.to_sym] << hook_block
+        end
+      end
+
+      def fire which, *args
+        return if @disable_event_firing
+        sync { debug "[Event] Firing #{which} (#{@hooks[which].try(:length) || 0} handlers) #{args.map(&:class)}", 99 }
+        @hooks[which] && @hooks[which].each{|h| h.call(*args) }
+      end
+
+
+      # ==========
+      # = Logger =
+      # ==========
+      def logger_filename
+        "#{cm_cfg_path}/logs/configmonkey.log"
+      end
+
+      def logger
+        sync do
+          @logger ||= begin
+            FileUtils.mkdir_p(File.dirname(@opts[:logfile]))
+            Logger.new(@opts[:logfile], 10, 1024000)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/configmonkey_cli/application/dispatch.rb

@@ -0,0 +1,81 @@
+module ConfigmonkeyCli
+  class Application
+    module Dispatch
+      def dispatch action = (@opts[:dispatch] || :help)
+        if respond_to?("dispatch_#{action}")
+          send("dispatch_#{action}")
+        else
+          abort("unknown action #{action}", 1)
+        end
+      end
+
+      def dispatch_help
+        puts @optparse.to_s
+      end
+
+      def dispatch_generate_manifest
+        puts c("Not implemented", :red)
+        # puts c("Generating example config `#{cfg_name}'")
+        # if File.exist?(cfg_file)
+        #   abort "Conflict, file already exists: #{cfg_file}", 1
+        # else
+        #   generate_config(cfg_name)
+        #   puts c("Writing #{cfg_file}...", :green)
+        # end
+      end
+
+      def dispatch_index
+        Thread.abort_on_exception = true
+        trap_signals
+
+        @running = true
+        load_and_execute_manifest
+      rescue Manifest::ExecutionError => ex
+        error "\nTraceback (most recent call last):"
+        ex.backtrace.reverse.each_with_index {|l, i| error "\t#{"#{ex.backtrace.length - i}:".rjust(4)} #{l}" }
+        error "\n" << "[#{ex.class}] #{ex.message}".strip
+      ensure
+        @running = false
+        release_signals
+      end
+
+      def dispatch_info
+        your_version = Gem::Version.new(ConfigmonkeyCli::VERSION)
+        puts c ""
+        puts c("     Your version: ", :yellow) << c("#{your_version}", :magenta)
+
+        print c("  Current version: ", :yellow)
+        if @opts[:check_for_updates]
+          require "net/http"
+          print c("checking...", :blue)
+
+          begin
+            current_version = Gem::Version.new Net::HTTP.get_response(URI.parse(ConfigmonkeyCli::UPDATE_URL)).body.strip
+
+            if current_version > your_version
+              status = c("#{current_version} (consider update)", :red)
+            elsif current_version < your_version
+              status = c("#{current_version} (ahead, beta)", :green)
+            else
+              status = c("#{current_version} (up2date)", :green)
+            end
+          rescue
+            status = c("failed (#{$!.message})", :red)
+          end
+
+          print "#{"\b" * 11}#{" " * 11}#{"\b" * 11}" # reset line
+          puts status
+        else
+          puts c("check disabled", :red)
+        end
+
+        # more info
+        puts c ""
+        puts c "  Configmonkey CLI is brought to you by #{c "bmonkeys.net", :green}"
+        puts c "  Contribute @ #{c "github.com/2called-chaos/configmonkey_cli", :cyan}"
+        puts c "  Eat bananas every day!"
+        puts c ""
+      end
+    end
+  end
+end

data/lib/configmonkey_cli/application/manifest.rb

@@ -0,0 +1,316 @@
+module ConfigmonkeyCli
+  class Application
+    class Manifest
+      MANIFEST_ACTIONS = [:chmod, :copy, :custom, :inplace, :invoke, :link, :mkdir, :rsync, :remove, :rtfm, :sync_links, :template]
+
+      class ExecutionError < ::RuntimeError
+        def initialize file, original_exception
+          @file = file
+          @original_exception = original_exception
+        end
+
+        def message
+          ln = ex.message[@file] && ex.message.match(/#{Regexp.escape(@file)}:([0-9]+)/)&.to_a&.second
+          ln ||= backtrace.reverse.detect{|l| l[@file] }&.split(":")&.second
+          "#{@file}#{":#{ln}" if ln}\n --- #{ex.message.gsub(@file, "<manifest>")}"
+        end
+
+        def backtrace
+          ex.backtrace
+        end
+
+        def original_exception
+          @original_exception
+        end
+        alias_method :ex, :original_exception
+      end
+
+      class Invalid < ExecutionError
+      end
+
+      class ThorHelperApp < Thor
+        include Thor::Actions
+      end
+
+      attr_reader :app, :directory, :manifest_file, :actions, :thor, :padding
+
+      def initialize app, directory, manifest_file = "manifest.rb"
+        @app = app
+        @directory = directory
+        init_thor!
+        @padding = 26
+        @manifest_file = File.join(directory, manifest_file || "manifest.rb")
+        @actions = []
+        @host_constraint = []
+        @target_directory = app.opts[:target_directory]
+        all do
+          begin
+            eval File.read(@manifest_file, encoding: "utf-8"), binding, @manifest_file
+          rescue Exception => ex
+            raise Invalid.new(@manifest_file, ex)
+          end
+        end
+        app.debug "§constraint-final:#{@host_constraint}", 120
+      end
+
+      def checksum *args
+        opts = args.extract_options!
+        if opts[:soft]
+          @_checksum_soft ||= begin
+            to_c = args.map(&:to_s)
+            to_c.unshift @manifest_file
+            Digest::SHA1.hexdigest(to_c.to_s)
+          end
+        else
+          @_checksum_hard ||= begin
+            to_c = args.map(&:to_s)
+            to_c.unshift Digest::SHA1.file(@manifest_file)
+            Digest::SHA1.hexdigest(to_c.to_s)
+          end
+        end
+      end
+
+      def to_s
+        "#<…::Manifest @directory=#{@directory} @actions=#{@actions.length}>"
+      end
+
+      def init_thor!
+        ThorHelperApp.source_root(directory)
+        @thor = ThorHelperApp.new([], { pretend: app.opts[:simulation] })
+
+        @thor.shell.class_eval do
+          def say_status(status, message, log_status = true)
+            return if quiet? || log_status == false
+            spaces = "  " * (padding + 1)
+            color  = log_status.is_a?(Symbol) ? log_status : :green
+
+            status = status.to_s.rjust(12)
+            status = set_color status, color, true if color
+
+            if($cm_current_action_name)
+              cm_action = $cm_current_action_name.to_s.rjust(12)
+              cm_action = set_color cm_action, $cm_current_action_color, true if $cm_current_action_color
+            end
+
+            buffer = "#{cm_action}#{status}#{spaces}#{message}"
+            buffer = "#{buffer}\n" unless buffer.end_with?("\n")
+
+            stdout.print(buffer)
+            stdout.flush
+          end
+
+          def ask q, *args, &block
+            ConfigmonkeyCli::Application.instance_method(:interruptable).bind(Object.new).call do
+              begin
+                q = "\a" << q if ENV["THOR_ASK_BELL"]
+                super(q, *args, &block)
+              rescue Interrupt => ex
+                Thread.main.raise(ex)
+              end
+            end
+          end
+        end
+      end
+
+      def _dump!
+        @actions.each do |constraint, action, instance|
+          begin
+            $cm_current_action_name = action
+            $cm_current_action_color = :magenta
+            thor.say_status :dump, instance, :black
+          ensure
+            $cm_current_action_name = $cm_current_action_color = nil
+          end
+        end
+      end
+
+      def _simulate!
+        _execute!(true)
+      end
+
+      def _execute! simulate = false
+        set_destination_root(@target_directory, false)
+
+        if simulate
+          thor.say_status :info, thor.set_color("---> !!! SIMULATION ONLY !!! <---", :green), :cyan
+        else
+          thor.say_status :info, thor.set_color("---> !!! HOT HOT HOT !!! <---", :red), :cyan
+        end
+        thor.say_status :info, (thor.set_color("Source Dir: ", :magenta) << thor.set_color(directory, :blue)), :cyan
+        thor.say_status :info, (thor.set_color(" Dest Root: ", :magenta) << thor.set_color(thor.destination_root, :blue)), :cyan
+        @actions.each_with_index do |(constraint, action, instance), index|
+          begin
+            $cm_current_action_index = index
+            $cm_current_action_name = action
+            $cm_current_action_color = :magenta
+            instance.prepare
+            simulate ? instance.simulate : instance.destructive
+          ensure
+            $cm_current_action_index = $cm_current_action_name = $cm_current_action_color = nil
+            app.haltpoint
+          end
+        end
+      rescue Interrupt, SystemExit
+        raise
+      rescue Exception => ex
+        raise(ExecutionError.new(@manifest_file, ex))
+      end
+
+      def _with_constraint *constraint
+        if @host_constraint.last == constraint
+          return yield if block_given?
+        end
+        if _breached_constraint?(constraint)
+          app.debug "§constraint-ignore:#{constraint}", 119
+          return
+        end
+        begin
+          @host_constraint << constraint
+          app.debug "§constraint-push:#{constraint}", 120
+          app.debug "§constraint-now:#{@host_constraint}", 121
+          yield if block_given?
+        ensure
+          app.debug "§constraint-pop:#{@host_constraint.pop}", 120
+          app.debug "§constraint-now:#{@host_constraint}", 121
+        end
+      end
+
+      def _breached_constraint? constraint = nil
+        in_constraint = catch :return_value do
+          [@host_constraint, [constraint || []]].each do |list|
+            list.each do |act, args|
+              case act
+              when :any then next
+              when :on
+                args.include?(app.opts[:hostname]) ? next : throw(:return_value, false)
+              when :not_on
+                args.include?(app.opts[:hostname]) ? throw(:return_value, false) : next
+              end
+            end
+          end
+          true
+        end
+        !in_constraint
+      end
+
+      def push_action *args
+        if $cm_current_action_index
+          @actions.insert $cm_current_action_index + 1, [@host_constraint.dup] + args
+        else
+          @actions.push [@host_constraint.dup] + args
+        end
+      end
+
+      def set_destination_root drpath, from_manifest = true
+        if from_manifest
+          base = File.realpath(File.expand_path(@directory))
+          xpath = File.expand_path(drpath[0] == "/" ? drpath : File.join(base, drpath))
+          if app.opts[:target_directory] != "/"
+            thor.say_status :warn, (thor.set_color(" Dest Root: ", :magenta) << thor.set_color(xpath, :blue) << thor.set_color(" IGNORED! -o parameter will take precedence", :red)), :red
+          else
+            @target_directory = xpath
+          end
+        else
+          thor.destination_root = File.realpath(File.expand_path(drpath))
+        end
+      end
+
+
+      # =======
+      # = DSL =
+      # =======
+
+      def padded str, *color
+        "".rjust(padding, " ") << (color.any? ? c(str.to_s, *color) : str.to_s)
+      end
+
+      def c str, *color
+        thor.set_color(str, *color)
+      end
+
+      def say str, *color
+        thor.say((color.any? ? c(str.to_s, *color) : str.to_s))
+      end
+
+      # do block no matter the `hostname`
+      def all &block
+        _with_constraint(:any, &block)
+      end
+
+      # do block only if `hostname` is in *hosts
+      def on *hosts, &block
+        _with_constraint(:on, hosts.flatten.map(&:to_s), &block)
+      end
+
+      # do block except if `hostname` is in *hosts
+      def not_on *hosts, &block
+        _with_constraint(:not_on, hosts.flatten.map(&:to_s), &block)
+      end
+
+      MANIFEST_ACTIONS.each do |meth|
+        define_method(meth) do |*args, &block|
+          push_action(meth, "ConfigmonkeyCli::Application::ManifestAction::#{meth.to_s.camelize}".constantize.new(app, self, *args, &block))
+          app.haltpoint
+        end
+      end
+
+      def ask question, opts = {}
+        if opts[:use_thread] != false
+          return app.interruptable { ask(question, opts.merge(use_thread: false)) }
+        end
+        opts[:limited_to] = opts.delete(:choose) if opts[:choose]
+        opts[:add_to_history] = true unless opts.key?(:add_to_history)
+        color = opts.delete(:color)
+        spaces = "".ljust(opts[:padding]) if opts[:padding]
+        begin
+          @thor.ask("#{spaces}#{question}", color, opts).presence
+        rescue Interrupt
+          app.haltpoint(Thread.main)
+        end
+      end
+
+      def yes? question, opts = {}
+        opts[:quit] = true unless opts.key?(:quit)
+        opts[:default] = true unless opts.key?(:default)
+        opts[:padding] = @padding unless opts.key?(:padding)
+        return true if app.opts[:default_yes]
+        return opts[:default] if app.opts[:default_accept]
+        o = "#{opts[:default] ? :Yn : :yN}"
+        o << "h" if opts[:help]
+        o << "q" if opts[:quit]
+        q = "#{question} [#{o}]"
+        c = opts[:color].presence || (opts[:default] ? :red : :yellow)
+        askopts = opts.slice(:padding, :limited_to, :choose, :add_to_history).merge(color: c, use_thread: false)
+        if askopts[:padding] && askopts[:padding] > 10
+          qq = thor.set_color(q, askopts[:color]) if askopts[:color]
+          q = "#{thor.set_color("?", :red)}  #{qq || q}"
+          askopts[:padding] -= 3
+        end
+
+        app.interruptable do
+          catch :return_value do
+            loop {
+              x = (ask(q, askopts) || (opts[:default] ? :y : :n)).to_s.downcase.strip
+
+              if ["y", "yes", "1", "t", "true"].include?(x)
+                throw :return_value, true
+              elsif ["n", "no", "0", "f", "false"].include?(x)
+                throw :return_value, false
+              elsif ["h", "help", "?"].include?(x)
+                @thor.say_status :help, "#{opts[:help]}", :cyan
+              elsif ["q", "quit", "exit"].include?(x)
+                raise SystemExit
+              else
+                @thor.say_status :warn, "choose one of y|yes|1|t|true|n|no|0|f|false#{"|q|quit|exit" if opts[:quit]}#{"|?|h|help" if opts[:help]}", :red
+              end
+            }
+          end
+        end
+      end
+
+      def no? question, opts = {}
+        !yes?(question, opts.merge(default: false))
+      end
+    end
+  end
+end