prometheus-splash 0.4.5 → 0.6.1

data/lib/splash/backends/redis.rb

@@ -1,57 +1,100 @@
 # coding: utf-8
+
+# base Splash Module
 module Splash
+
+  # generic backends module
   module Backends
+
+    # Redis backend definition
     class Redis
       include Splash::Config
+
+      # Constructor
+      # @param [Symbol] store name in [:execution_trace] actually (see config and constants )
+      # @return [Splash::Backends::Redis] a Redis backend
       def initialize(store)
         @hostname = Socket.gethostname
         @config = get_config[:backends][:stores][store]
         conf = { :host => @config[:host], :port => @config[:port], :db => @config[:base].to_i}
         conf[:password] = @config[:auth] if @config[:auth]
         @store = ::Redis.new conf
-        @redis_cli_cmd = `which redis-cli`
+        #@redis_cli_cmd = `which redis-cli`
         @store.auth(@config[:auth]) if @config[:auth]
       end
 
+      # return the list of find records in backend for a specific pattern
+      # @param [String] hostname optionnal (default : local hostname)
+      # @param [String] pattern shell regexp
+      # @return [Array] list of record (for all hostname if hostname is specified)
       def list(pattern='*', hostname = @hostname)
          return @store.keys("#{hostname}##{pattern}").map{|item| item = remove_hostname(item)}
       end
 
+      # return the list of find records in backend for a specific pattern, without hostname Checking
+      # Redis Backend specific method
+      # @param [String] pattern shell regexp
+      # @return [Array] list of record (for all hostname if hostname is specified)
       def listall(pattern='*')
          return @store.keys(pattern)
       end
 
+      # return value of queried record
+      # @param [Hash] options
+      # @option options [Symbol] :key the name of the record
+      # @return [String] content value of record
       def get(options)
         hostname = (options[:hostname])? options[:hostname] : @hostname
         return @store.get(prefix_hostname(options[:key],hostname))
       end
 
+      # defined and store value for specified key
+      # @param [Hash] options
+      # @option options [Symbol] :key the name of the record
+      # @option options [Symbol] :value the content value of the record
+      # @return [String] content value of record
       def put(options)
         hostname = (options[:hostname])? options[:hostname] : @hostname
         @store.set prefix_hostname(options[:key],hostname), options[:value]
       end
 
+      # delete a specific record
+      # @param [Hash] options
+      # @option options [Symbol] :key the name of the record
+      # @return [Boolean] status of the operation
       def del(options)
         hostname = (options[:hostname])? options[:hostname] : @hostname
         @store.del prefix_hostname(options[:key],hostname)
       end
 
+      # flush all records in backend
       def flush
-        `#{@redis_cli_cmd} -n 3 flushdb`
-        # @@store.flushdb
+        #`#{@redis_cli_cmd} -n #{@config[:base]} flushdb`
+        @store.flushdb
       end
 
+      # verifiy a specific record existance
+      # @param [Hash] options
+      # @option options [Symbol] :key the name of the record
+      # @return [Boolean] presence of the record
       def exist?(options)
         hostname = (options[:hostname])? options[:hostname] : @hostname
         return ( not @store.get(prefix_hostname(options[:key],hostname)).nil?)
       end
 
       private
+
+      # Redis backend specific method for prefix record name with hostname
+      # @param [String] key
+      # @param [String] hostname
+      # @return [String] prefixed string
       def prefix_hostname(key,hostname)
         return "#{hostname}##{key}"
       end
 
-
+      # Redis backend specific method for removing hostname of record
+      # @param [String] astring
+      # @return [String] cleaned string
       def remove_hostname(astring)
         result = astring.split("#")
         result.shift

data/lib/splash/cli.rb

@@ -1,20 +1,48 @@
 # coding: utf-8
 Dir[File.dirname(__FILE__) + '/cli/*.rb'].each {|file| require file  }
 
+# The CLI Command structure for Thor
 class CLI < Thor
+
+  # callback for managing ARGV errors
   def self.exit_on_failure?
     true
   end
 
+  # Constructor override to manage debug, colors and emoji options for logger
+  def initialize(*args)
+    super
+    log = get_logger
+    options[:colors.to_s]
+    log.level = :debug if options[:debug]
+    log.emoji  = options[:emoji.to_s]
+    log.color  = options[:colors.to_s]
+    log.debug  "DEBUG activated" if options[:debug]
+  end
+
+  class_option :quiet, :desc => "Quiet mode, limit output to :fatal", :aliases => "-q", :type => :boolean
+  class_option :emoji, :desc => "Display Emoji", :type => :boolean, :default => true
+  class_option :colors, :desc => "Display colors", :type => :boolean, :default => true
+  class_option :debug, :desc => "Set log level to :debug", :aliases => "-d", :type => :boolean
+
+
   include CLISplash
-  desc "commands SUBCOMMAND ...ARGS", "Managing commands/batchs supervision"
+  desc "commands SUBCOMMAND ...ARGS", "Managing commands/batchs supervision & orchestration"
   subcommand "commands", Commands
+  desc "sequences SUBCOMMAND ...ARGS", "Managing Sequences of commands"
+  subcommand "sequences", Sequences
   desc "logs SUBCOMMAND ...ARGS", "Managing Files/Logs supervision"
   subcommand "logs", Logs
-  desc "daemon SUBCOMMAND ...ARGS", "Logs monitor daemon contoller"
+  desc "processes SUBCOMMAND ...ARGS", "Managing processes supervision"
+  subcommand "processes", Processes
+  desc "daemon SUBCOMMAND ...ARGS", "Splash daemon controller"
   subcommand "daemon", CLIController
-  desc "config SUBCOMMAND ...ARGS", "config tools for Splash"
+  desc "config SUBCOMMAND ...ARGS", "Config tools for Splash"
   subcommand "config", Config
   desc "documentation SUBCOMMAND ...ARGS", "Documentation for Splash"
   subcommand "documentation", Documentation
+  desc "webadmin SUBCOMMAND ...ARGS", "Splash Webadmin daemon controller"
+  subcommand "webadmin", WebAdmin
+
+
 end

data/lib/splash/cli/commands.rb

@@ -1,7 +1,9 @@
 # coding: utf-8
-module CLISplash
 
+# module for all Thor subcommands
+module CLISplash
 
+  # Thor inherited class for commands management
   class Commands < Thor
     include Splash::Config
     include Splash::Backends
@@ -9,7 +11,10 @@ module CLISplash
     include Splash::Transports
     include Splash::Templates
     include Splash::Loggers
+    include Splash::Commands
 
+
+    # Thor method : execution of command
     desc "execute NAME", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
     execute command or sequence or ack result\n
@@ -21,14 +26,16 @@ module CLISplash
     with --hostname, execute on an other Splash daemon node
     LONGDESC
     option :trace, :type => :boolean, :default => true
-    option :ack, :type => :boolean, negate: false
+    option :ack, :type => :boolean, negate: false,  :aliases => "-a"
     option :notify, :type => :boolean, :default => true
     option :callback, :type => :boolean, :default => true
-    option :hostname, :type => :string
+    option :hostname, :type => :string,  :aliases => "-H"
     def execute(name)
       log = get_logger
+      log.level = :fatal if options[:quiet]
       if is_root? then
         if options[:hostname] then
+          options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
           splash_exit({ :case => :options_incompatibility, :more => '--hostname forbidden with delagate commands'}) if get_config.commands[name.to_sym][:delegate_to]
           log.info "Remote Splash configured commands on #{options[:hostname]}:"
           log.info "ctrl+c for interrupt"
@@ -49,15 +56,16 @@ module CLISplash
                                     payload: {:name => name},
                                     :return_to => "splash.#{Socket.gethostname}.returncli",
                                     :queue => "splash.#{options[:hostname]}.input" })
-                res[:more] = "Remote command : :execute_command Scheduled"
-                splash_exit res
               end
             end
           rescue Interrupt
             splash_exit case: :interrupt, more: "Remote command exection"
           end
+          log.receive "Command execute confirmation"
+          res[:more] = "Remote command : :execute_command Scheduled"
+          splash_exit res
         else
-          command =  Splash::CommandWrapper::new(name)
+          command =  CommandWrapper::new(name)
           if options[:ack] then
             splash_exit command.ack
           end
@@ -70,6 +78,7 @@ module CLISplash
     end
 
 
+    # Thor method : scheduling commands
     desc "schedule NAME", "Schedule excution of command on Splash daemon"
     long_desc <<-LONGDESC
     Schedule excution of command on Splash daemon\n
@@ -80,11 +89,12 @@ module CLISplash
     WARNING : scheduling by CLI are not percisted, so use it only for specifics cases.\n
     NOTES : Scheduling, force trace, notifying and callback.
     LONGDESC
-    option :hostname, :type => :string
+    option :hostname, :type => :string, :default => Socket.gethostname,  :aliases => "-H"
     option :at, :type => :string
     option :in, :type => :string
     def schedule(name)
       log = get_logger
+      log.level = :fatal if options[:quiet]
       hostname = (options[:hostname])? options[:hostname] : Socket.gethostname
       splash_exit({ :case => :options_incompatibility, :more => '--at or --in is required'}) unless options[:at] or options[:in]
       splash_exit({ :case => :options_incompatibility, :more => '--at an --in'}) if options[:at] and options[:in]
@@ -101,47 +111,78 @@ module CLISplash
                                   payload: {:name => name, :schedule => schedule},
                                   :return_to => "splash.#{Socket.gethostname}.returncli",
                                   :queue => "splash.#{hostname}.input" })
-          log.receive "Execute command sheduled confirmed"
-          res[:more] = "Remote command : :execute_command with schedule"
-          splash_exit res
         end
       rescue Interrupt
         splash_exit case: :interrupt, more: "Remote command exection"
       end
+      log.receive "Execute command sheduled confirmed"
+      res[:more] = "Remote command : :execute_command with schedule"
+      splash_exit res
 
     end
 
-
+    # Thor method : getting a treeview of sequence of commands
     desc "treeview", "Show commands sequence tree"
-    def treeview(command, depht = 0)
+    long_desc <<-LONGDESC
+    Show commands sequence tree\n
+    with --hostname, ask other Splash daemon via transport\n
+    LONGDESC
+    option :hostname, :type => :string,  :aliases => "-H"
+    def treeview(command)
+      depht = 0
       log  = get_logger
-      log.info "Command : #{command.to_s}" if depht == 0
-      cmd  = get_config.commands[command.to_sym]
-      if cmd[:on_failure] then
-        spacer=  " " * depht + " "
-        log.flat "#{spacer}* on failure => #{cmd[:on_failure]}"
-        treeview(cmd[:on_failure], depht+2)
+      if options[:hostname] then
+        options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
+        log.info "Remote Splash treeview command on #{options[:hostname]}:"
+        log.info "ctrl+c for interrupt"
+        begin
+          transport = get_default_client
+          if transport.class == Hash  and transport.include? :case then
+            splash_exit transport
+          else
+            commands = transport.execute({ :verb => :list_commands,
+                                  :return_to => "splash.#{Socket.gethostname}.returncli",
+                                  :queue => "splash.#{options[:hostname]}.input" })
+          end
+        rescue Interrupt
+          splash_exit case: :interrupt, more: "Remote command exection"
+        end
+        log.receive "Receving list of commands from #{options[:hostname]}"
+      else
+        commands  = get_config.commands
       end
-      if cmd[:on_success] then
-        spacer = " " * depht + " "
-        log.flat "#{spacer}* on success => #{cmd[:on_success]}"
-        treeview(cmd[:on_success],depht+2)
+      log.info "Command : #{command.to_s}" if depht == 0
+      aproc = Proc::new do |command,depht|
+        cmd  = commands[command.to_sym]
+        if cmd[:on_failure] then
+          spacer=  " " * depht + " "
+          log.flat "#{spacer}* on failure => #{cmd[:on_failure]}"
+          aproc.call(cmd[:on_failure], depht+2)
+        end
+        if cmd[:on_success] then
+          spacer = " " * depht + " "
+          log.flat "#{spacer}* on success => #{cmd[:on_success]}"
+          aproc.call(cmd[:on_success],depht+2)
+        end
       end
+      aproc.call(command,depht)
     end
 
 
+    # Thor method : getting the list of available commands in splash config
     desc "list", "Show configured commands"
     long_desc <<-LONGDESC
     Show configured commands\n
     with --detail, show command details\n
     with --hostname, ask other Splash daemon via transport\n
     LONGDESC
-    option :detail, :type => :boolean
-    option :hostname, :type => :string
+    option :detail, :type => :boolean,  :aliases => "-D"
+    option :hostname, :type => :string,  :aliases => "-H"
     def list
       log = get_logger
       list = {}
       if options[:hostname] then
+        options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
         log.info "Remote Splash configured commands on #{options[:hostname]}:"
         log.info  "ctrl+c for interrupt"
         begin
@@ -156,10 +197,11 @@ module CLISplash
         rescue Interrupt
           splash_exit case: :interrupt, more: "remote list Command"
         end
+        log.receive "Receving list of commands from #{options[:hostname]}"
       else
-        log.info "Splash configured commands :"
         list = get_config.commands
       end
+      log.info "Splash configured commands :"
       log.ko 'No configured commands found' if list.keys.empty?
       list.keys.each do |command|
         log.item "#{command.to_s}"
@@ -177,17 +219,18 @@ module CLISplash
       splash_exit case: :quiet_exit
     end
 
-
+    # Thor method: getting informations about a specific splash configuration defined command
     desc "show COMMAND", "Show specific configured command COMMAND"
     long_desc <<-LONGDESC
     Show specific configured command COMMAND\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
     LONGDESC
-    option :hostname, :type => :string
+    option :hostname, :type => :string,  :aliases => "-H"
     def show(command)
       log = get_logger
       list = {}
       if options[:hostname] then
+        options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
         log.info "Remote Splash configured commands on #{options[:hostname]}:"
         log.info "ctrl+c for interrupt"
         begin
@@ -202,6 +245,7 @@ module CLISplash
         rescue Interrupt
           splash_exit case: :interrupt, more: "remote list Command"
         end
+        log.receive "Receving list of commands from #{options[:hostname]}"
       else
         list = get_config.commands
       end
@@ -221,13 +265,13 @@ module CLISplash
       end
     end
 
-
+    # Thor method : getting information on the last execution of a command
     desc "lastrun COMMAND", "Show last running result for specific configured command COMMAND"
     long_desc <<-LONGDESC
     Show last running result for specific configured command COMMAND\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
     LONGDESC
-    option :hostname, :type => :string
+    option :hostname, :type => :string,  :aliases => "-H"
     def lastrun(command)
       log = get_logger
       backend = get_backend :execution_trace
@@ -235,8 +279,10 @@ module CLISplash
       if not redis and options[:hostname] then
         splash_exit case: :specific_config_required, :more => "Redis backend is requiered for Remote execution report request"
       end
+      splash_exit case: :not_root if not is_root? and not redis
       list = get_config.commands.keys
       if options[:hostname] then
+        options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
         list = backend.list("*", options[:hostname]).map(&:to_sym)
       end
       if list.include? command.to_sym then
@@ -259,6 +305,7 @@ module CLISplash
       end
     end
 
+    # Thor method : getting the list of avaibles executions reports
     desc "getreportlist", "list all executions report results "
     long_desc <<-LONGDESC
     list all executions report results\n
@@ -268,12 +315,13 @@ module CLISplash
     with --detail, get major informations of each reports\n
     --all and --hostname are exclusives
     LONGDESC
-    option :pattern, :type => :string
-    option :hostname, :type => :string
-    option :all, :type => :boolean, :negate => false
-    option :detail, :type => :boolean
+    option :pattern, :type => :string, :aliases => "-p"
+    option :hostname, :type => :string,  :aliases => "-H"
+    option :all, :type => :boolean, :negate => false,  :aliases => "-A"
+    option :detail, :type => :boolean,  :aliases => "-D"
     def getreportlist
       log = get_logger
+      options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
       if options[:hostname] and options[:all] then
         splash_exit case: :options_incompatibility, more: "--all, --hostname"
       end
@@ -282,6 +330,7 @@ module CLISplash
       if not redis and (options[:hostname] or options[:all]) then
         splash_exit case: :specific_config_required, more: "Redis Backend requiered for Remote execution report Request"
       end
+      splash_exit case: :not_root if not is_root? and not redis
       pattern = (options[:pattern])? options[:pattern] : '*'
       if options[:all] then
         res = backend.listall pattern

data/lib/splash/cli/config.rb

@@ -1,39 +1,60 @@
 # coding: utf-8
+
+# module for all Thor subcommands
 module CLISplash
 
+  # Thor inherited class for configuration management
   class Config < Thor
     include Splash::ConfigUtilities
     include Splash::Helpers
     include Splash::Exiter
     include Splash::Loggers
 
-
+    # Thor method : running of Splash setup
     desc "setup", "Setup installation fo Splash"
     long_desc <<-LONGDESC
     Setup installation fo Splash\n
     with --preserve, preserve from reinstallation of the config
     LONGDESC
-    option :preserve, :type => :boolean
+    option :preserve, :type => :boolean,  :aliases => "-P"
     def setup
       acase = run_as_root :setupsplash, options
       splash_exit acase
     end
 
+    # Thor method : running of Splash sanitycheck
     desc "sanitycheck", "Verify installation fo Splash"
     def sanitycheck
       acase = run_as_root :checkconfig
       splash_exit acase
     end
 
-    desc "version", "display current Splash version"
+    # Thor method : Getting the current Splash version
+    desc "version", "Display current Splash version"
     def version
       log = get_logger
       config = get_config
       log.info "Splash version : #{config.version}, Author : #{config.author}"
-      log_info config.copyright
+      log.info config.copyright
       splash_exit case: :quiet_exit
     end
 
+    # Thor method : Installing Splashd Systemd service file
+    desc "service", "Install Splashd Systemd service"
+    def service
+      acase = run_as_root :addservice
+      splash_exit acase
+    end
+
+
+    # Thor method : flushing configured backend
+    desc "flushbackend", "Flush configured backend"
+    def flushbackend
+      acase = run_as_root :flush_backend
+      splash_exit acase
+    end
+
+
   end
 
 end