prometheus-splash 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62507dbefc8ccad97a7388a4527a79991b7224e5d6181d8edc06fcd6299c6791
-  data.tar.gz: 62fa6ab6b86cd2442a9f3d6e2a4bf3e073f3a2d0a51154dba4fa64590c4b5f54
+  metadata.gz: 7065fa547ec467bcde47fcb52c57a05fa0abc5e902e3ce1f9ed3c1ac0f64b0d6
+  data.tar.gz: 73cb3e469d7c32adaeebf39987c8c767e2579889bcea5101cdf1492101ffffe6
 SHA512:
-  metadata.gz: f651a3c3a6c758ce7939403d16c48d4b8f3666e30ad378c9de2db38a3e5ff7bfaf5565a0ffedf971781305a3098b15e9d5111efa1b4be6db16db8642b43ddbfc
-  data.tar.gz: fe6b45de95e4ecde64eb7361d4edc6da5268bfebabd312617b44983612155f02a7bc20c6297adf85797abe069350f81bf9cc46ec43ebb3fc493fcdd115306280
+  metadata.gz: c390147005809aa6d3fe5aa9975e4f8ca4787fb1a3c359c53e33d21cb50d9329aae48946fcbb8168ee5fbadeba05cf43ca4b2d761435a9b50e60098f30debd2a
+  data.tar.gz: e241c29c18a58c9dbd095323b2d2600fe9e30aacd20096e276d508920124b0419c5e7ee24a0bca5b6f34e5eb8424f79739f57443f980972d7e67e94a75e41b88

data/README.md

@@ -75,6 +75,11 @@ With :
 - SERVER : IP or fqdn of the Gateway.
 - PORT : the specific TCP port of the Gateway.
 
+If you have already setup, you could use --preserve option to keep your active configuration and report file on place
+This is usefull for automatique Idempotent installation like with Ansible :
+
+    # splash conf set --preserve
+
 
 ### Sanitycheck
 
@@ -475,7 +480,7 @@ If you want to prevent callback execution, as root :
 
 #### Display the last execution trace for a command
 
-If you want to view the last execution trace for  commande, (run with --trace : default)
+If you want to view the last execution trace for  commande, (only if executed with --trace : default)
 
     # splash com lastrun
     Splash command pwd previous execution report:
@@ -500,6 +505,11 @@ If you want to view the last execution trace for  commande, (run with --trace :
 
     STDERR:
     -------
+
+
+Lastrun could receive the --hostname option to get the execution report of command
+
+
 ### Advanced  Configuration
 
 #### Backend configuration

data/config/splash.yml

@@ -20,6 +20,8 @@
     :active: :rabbitmq
     :rabbitmq:
       :url: amqp://127.0.0.1
+      :port: 5672
+      :host: "localhost"
   :daemon:
     :logmon_scheduling:
       :every: 20s

data/lib/splash/backends.rb

@@ -4,9 +4,16 @@ Dir[File.dirname(__FILE__) + '/backends/*.rb'].each {|file| require file  }
 module Splash
   module Backends
     include Splash::Config
+    include Splash::Constants
+
     def get_backend(store)
-      aclass = "Splash::Backends::#{get_config[:backends][:stores][store][:type].to_s.capitalize}"
-      return Kernel.const_get(aclass)::new(store)
+      backend = get_config[:backends][:stores][store][:type].to_s
+      aclass = "Splash::Backends::#{backend.capitalize}"
+      begin
+        return Kernel.const_get(aclass)::new(store)
+      rescue
+        splash_exit case: :configuration_error, more: "Backend specified for store #{store} inexistant : #{backend}"
+      end
     end
 
   end

data/lib/splash/cli/commands.rb

@@ -6,28 +6,61 @@ module CLISplash
     include Splash::Config
     include Splash::Backends
     include Splash::Exiter
+    include Splash::Transports
+    include Splash::Templates
 
     desc "execute NAME", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
-    execute command or sequence or ack result
-    with --no-trace prevent storing execution trace in configured backend (see config file)
-    with --ack, notify errorcode=0 to Prometheus PushGateway
-    with --no-notify, bypass Prometheus notification
-    with --no-callback, never execute callback (:on_failure, :on_success)
+    execute command or sequence or ack result\n
+    with --no-trace prevent storing execution trace in configured backend (see config file)\n
+    with --ack, notify errorcode=0 to Prometheus PushGateway\n
+    with --no-notify, bypass Prometheus notification\n
+    with --no-callback, never execute callback (:on_failure, :on_success)\n
                         never follow sequences
+    with --hostname, execute on an other Splash daemon node
     LONGDESC
     option :trace, :type => :boolean, :default => true
     option :ack, :type => :boolean, negate: false
     option :notify, :type => :boolean, :default => true
     option :callback, :type => :boolean, :default => true
+    option :hostname, :type => :string
     def execute(name)
       if is_root? then
-        command =  Splash::CommandWrapper::new(name)
-        if options[:ack] then
-          splash_exit command.ack
+        if options[:hostname] then
+          puts "Remote Splash configured commands on #{options[:hostname]}:"
+          puts "ctrl+c for interrupt"
+          begin
+            transport = get_default_client
+            if transport.class == Hash  and transport.include? :case then
+              splash_exit transport
+            else
+              if options[:ack] then
+                res = transport.execute({ :verb => :ack_command,
+                                      payload: {:name => name},
+                                      :return_to => "splash.#{Socket.gethostname}.returncli",
+                                      :queue => "splash.#{options[:hostname]}.input" })
+                res[:more] = "Remote command : :ack_command OK"
+                splash_exit res
+              else
+                res = transport.execute({ :verb => :execute_command,
+                                    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
+        else
+          command =  Splash::CommandWrapper::new(name)
+          if options[:ack] then
+            splash_exit command.ack
+          end
+          acase = command.call_and_notify trace: options[:trace], notify: options[:notify], callback: options[:callback]
+          splash_exit acase
         end
-        acase = command.call_and_notify trace: options[:trace], notify: options[:notify], callback: options[:callback]
-        splash_exit acase
       else
         splash_exit case: :not_root, :more => "Command execution"
       end
@@ -56,11 +89,31 @@ module CLISplash
     long_desc <<-LONGDESC
     Show configured commands
     with --detail, show command details
+    with --hostname, ask other splash daemon via transport
     LONGDESC
     option :detail, :type => :boolean
+    option :hostname, :type => :string
     def list
-      puts "Splash configured commands :"
-      list = get_config.commands
+      list = {}
+      if options[:hostname] then
+        puts "Remote Splash configured commands on #{options[:hostname]}:"
+        puts "ctrl+c for interrupt"
+        begin
+          transport = get_default_client
+          if transport.class == Hash  and transport.include? :case then
+            splash_exit transport
+          else
+            list = 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 list Command"
+        end
+      else
+        puts "Splash configured commands :"
+        list = get_config.commands
+      end
       puts 'No configured commands found' if list.keys.empty?
       list.keys.each do |command|
         puts " * #{command.to_s}"
@@ -103,19 +156,27 @@ 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
-      list = get_config.commands
-      if list.keys.include? command.to_sym then
+      list = get_config.commands.keys
+      if options[:hostname] then
+        list = backend.list("*", options[:hostname]).map(&:to_sym)
+      end
+      if list.include? command.to_sym then
         print "Splash command #{command} previous execution report:\n\n"
         req  = { :key => command}
         req[:hostname] = options[:hostname] if options[:hostname]
         if backend.exist? req then
-          print backend.get req
+          res = backend.get req
+          tp = Template::new(
+              list_token: get_config.execution_template_tokens,
+              template_file: get_config.execution_template_path)
+          tp.map YAML::load(res)
+          print tp.output
         else
           puts "Command not already runned."
         end
         splash_exit case: :quiet_exit
       else
-        splash_exit case: :command_not_configured
+        splash_exit case: :not_found, :more => "Command report never runned remotly" if options[:hostname]
       end
     end
 
@@ -125,11 +186,13 @@ module CLISplash
     with --pattern <SEARCH>, search type string, wilcard * (group) ? (char)\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)\n
     with --all, get all execution report for all servers (only with Redis backend configured)\n
+    with --detail, get major informations of each reports
     --all and --hostname are exclusives
     LONGDESC
     option :pattern, :type => :string
     option :hostname, :type => :string
     option :all, :type => :boolean, :negate => false
+    option :detail, :type => :boolean
     def getreportlist
       if options[:hostname] and options[:all] then
         splash_exit case: :options_incompatibility, more: "--all, --hostname"
@@ -137,7 +200,7 @@ module CLISplash
       backend = get_backend :execution_trace
       redis = (backend.class == Splash::Backends::Redis)? true : false
       if not redis and (options[:hostname] or options[:all]) then
-        splash_exit case: :redis_back_required, more: "Remote execution report Request"
+        splash_exit case: :specific_config_required, more: "Redis Backend requiered for Remote execution report Request"
       end
       pattern = (options[:pattern])? options[:pattern] : '*'
       if options[:all] then
@@ -150,11 +213,23 @@ module CLISplash
       print "List of Executions reports :\n\n"
       puts "Not reports found" if res.empty?
       res.each do |item|
+        host = ""
+        command = ""
         if options[:all]
           host,command = item.split('#')
           puts " * Command : #{command} @ host : #{host}"
         else
-          puts " * Command : #{item}"
+          command = item
+          puts " * Command : #{command}"
+        end
+        if options[:detail] then
+          req = { :key => command }
+          req[:hostname] = host if options[:all]
+          res = YAML::load(backend.get(req))
+          puts "   - Status : #{res[:status]}"
+          puts "   - Start date : #{res[:start_date]}"
+          puts "   - End date : #{res[:end_date]}"
+          puts "   - Execution time : #{res[:exec_time]}"
         end
       end
       splash_exit case: :quiet_exit

data/lib/splash/cli/daemon.rb

@@ -8,19 +8,52 @@ module CLISplash
 
 
     option :foreground, :type => :boolean
-    desc "start", "Starting Logs Monitor Daemon"
+    option :purge, :type => :boolean
+    option :scheduling, :type => :boolean, default: true
+    long_desc <<-LONGDESC
+    Starting Splash Daemon\n
+    With --foreground, run Splash in foreground\n
+    With --no-scheduling, inhibit commands scheduling\n
+    With --purge, Purge Input Queue for Splash Daemon
+    LONGDESC
+    desc "start", "Starting Splash Daemon"
     def start
-      acase = run_as_root :startdaemon
+      if options[:purge] then
+        transport = get_default_client
+        if transport.class == Hash  and transport.include? :case then
+          splash_exit transport
+        else
+          queue = "splash.#{Socket.gethostname}.input"
+          transport.purge queue: queue
+          puts " * Queue : #{queue} purged"
+          splash_exit case: :quiet_exit
+        end
+      end
+      acase = run_as_root :startdaemon, options
       splash_exit acase
     end
 
-    desc "stop", "Stopping Logs Monitor Daemon"
+
+    desc "purge", "Purge Transport Input queue of Daemon"
+    def purge
+      transport = get_default_client
+      if transport.class == Hash  and transport.include? :case then
+        splash_exit transport
+      else
+        queue = "splash.#{Socket.gethostname}.input"
+        transport.purge queue: queue
+        puts " * Queue : #{queue} purged"
+        splash_exit case: :quiet_exit
+      end
+    end
+
+    desc "stop", "Stopping Splash Daemon"
     def stop
       acase = run_as_root :stopdaemon
       splash_exit acase
     end
 
-    desc "status", "Logs Monitor Daemon status"
+    desc "status", "Splash Daemon status"
     def status
       acase = run_as_root :statusdaemon
       splash_exit acase
@@ -29,19 +62,17 @@ module CLISplash
     desc "ping HOSTNAME", "send a ping to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
     def ping(hostname=Socket.gethostname)
       puts "ctrl+c for interrupt"
-      queue = "splash.#{Socket.gethostname}.returncli"
-      order = {:verb => :ping, :payload => {:hostname => Socket.gethostname}, :return_to => queue}
-
-      lock = Mutex.new
-      condition = ConditionVariable.new
       begin
-        get_default_subscriber(queue: queue).subscribe(timeout: 10) do |delivery_info, properties, payload|
-          puts YAML::load(payload)
-          lock.synchronize { condition.signal }
+        transport = get_default_client
+        if transport.class == Hash  and transport.include? :case then
+          splash_exit transport
+        else
+          puts transport.execute({ :verb => :ping,
+                                  :payload => {:hostname => Socket.gethostname},
+                                  :return_to => "splash.#{Socket.gethostname}.returncli",
+                                  :queue => "splash.#{hostname}.input" })
+          splash_exit case: :quiet_exit
         end
-        get_default_client.publish queue: "splash.#{hostname}.input", message: order.to_yaml
-        lock.synchronize { condition.wait(lock) }
-        splash_exit case: :quiet_exit
       rescue Interrupt
         splash_exit status: :error, case: :interrupt, more: "Ping Command"
       end

data/lib/splash/commands.rb

@@ -7,18 +7,20 @@ module Splash
     include Splash::Backends
     include Splash::Exiter
 
+
+    @@registry = Prometheus::Client.registry
+    @@metric_exitcode = Prometheus::Client::Gauge.new(:errorcode, docstring: 'SPLASH metric batch errorcode')
+    @@metric_time = Prometheus::Client::Gauge.new(:exectime, docstring: 'SPLASH metric batch execution time')
+    @@registry.register(@@metric_exitcode)
+    @@registry.register(@@metric_time)
+
     def initialize(name)
       @config  = get_config
+      @url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
       @name = name
       unless @config.commands.keys.include? @name.to_sym then
         splash_exit case: :not_found, more: "command #{@name} is not defined in configuration"
       end
-      @registry = Prometheus::Client.registry
-      @url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
-      @metric_exitcode = Prometheus::Client::Gauge.new(:errorcode, docstring: 'SPLASH metric batch errorcode')
-      @metric_time = Prometheus::Client::Gauge.new(:exectime, docstring: 'SPLASH metric batch execution time')
-      @registry.register(@metric_exitcode)
-      @registry.register(@metric_time)
     end
 
     def ack
@@ -30,10 +32,10 @@ module Splash
       unless verify_service host: @config.prometheus_pushgateway_host ,port: @config.prometheus_pushgateway_port then
         return { :case => :service_dependence_missing, :more => "Prometheus Notification not send."}
       end
-      @metric_exitcode.set(value)
-      @metric_time.set(time)
+      @@metric_exitcode.set(value)
+      @@metric_time.set(time)
       hostname = Socket.gethostname
-      Prometheus::Client::Push.new(@name, hostname, @url).add(@registry)
+      Prometheus::Client::Push.new(@name, hostname, @url).add(@@registry)
       puts " * Prometheus Gateway notified."
       return { :case => :quiet_exit}
     end
@@ -66,21 +68,20 @@ module Splash
         tp = Template::new(
             list_token: @config.execution_template_tokens,
             template_file: @config.execution_template_path)
-
-        tp.start_date = start_date
-        tp.end_date = DateTime.now.to_s
-        tp.cmd_name = @name
-        tp.cmd_line = @config.commands[@name.to_sym][:command]
-        tp.desc = @config.commands[@name.to_sym][:desc]
-        tp.status = status.to_s
-        tp.stdout = stdout
-        tp.stderr = stderr
-        tp.exec_time = time.to_s
+        data = Hash::new
+        data[:start_date] = start_date
+        data[:end_date] = DateTime.now.to_s
+        data[:cmd_name] = @name
+        data[:cmd_line] = @config.commands[@name.to_sym][:command]
+        data[:desc] = @config.commands[@name.to_sym][:desc]
+        data[:status] = status.to_s
+        data[:stdout] = stdout
+        data[:stderr] = stderr
+        data[:exec_time] = time.to_s
         backend = get_backend :execution_trace
         key = @name
-        backend.put key: key, value: tp.output
+        backend.put key: key, value: data.to_yaml
         exit_code = status.exitstatus
-
       end
 
       puts "  => exitcode #{exit_code}"

data/lib/splash/config.rb

@@ -1,8 +1,11 @@
 # coding: utf-8
+Dir[File.dirname(__FILE__) + '/config/*.rb'].each {|file| require file  }
+
 module Splash
   module Config
     include Splash::Helpers
     include Splash::Constants
+    include Splash::ConfigUtilities
 
 
     # Class to manage configuration in Splash from Splash::Constants override by Yaml CONFIG
@@ -36,22 +39,6 @@ module Splash
 
       # @!group accessors on configurations Items
 
-      def Configuration.user_root
-        return Etc.getpwuid(0).name
-      end
-
-      def Configuration.group_root
-        return Etc.getgrgid(0).name
-      end
-
-      def user_root
-        return Configuration.user_root
-      end
-
-      def group_root
-        return Configuration.group_root
-      end
-
 
       def backends
         return self[:backends]
@@ -131,142 +118,8 @@ module Splash
       return Configuration::new config_file
     end
 
-    # Setup action method for installing Splash
-    # @return [Integer] an errorcode value
-    def setupsplash
-      conf_in_path = search_file_in_gem "prometheus-splash", "config/splash.yml"
-      full_res = 0
-      puts "Splash -> setup : "
-      unless options[:preserve] then
-        print "* Installing Configuration file : #{CONFIG_FILE} : "
-        if install_file source: conf_in_path, target: CONFIG_FILE, mode: "644", owner: Configuration.user_root, group: Configuration.group_root then
-          puts "[OK]"
-        else
-          full_res =+ 1
-          puts "[KO]"
-        end
-      else
-        puts "Config file preservation."
-      end
-      config = get_config
-      report_in_path = search_file_in_gem "prometheus-splash", "templates/report.txt"
-      print "* Installing template file : #{config.execution_template_path} : "
-      if install_file source: report_in_path, target: config.execution_template_path, mode: "644", owner: config.user_root, group: config.group_root then
-        puts "[OK]"
-      else
-        full_res =+ 1
-        puts "[KO]"
-      end
-
-      print "* Creating/Checking pid file path : #{config[:pid_path]} : "
-      if make_folder path: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root then
-        puts "[OK]"
-      else
-        full_res =+ 1
-        puts "[KO]"
-      end
-
-      print "* Creating/Checking trace file path : #{config[:trace_path]} : "
-      if make_folder path: config[:trace_path], mode: "644", owner: config.user_root, group: config.group_root then
-        puts "[OK]"
-      else
-        full_res =+ 1
-        puts "[KO]"
-      end
-
-      if full_res > 0 then
-        $stderr.puts " => #{full_res} errors occured"
-        return { :case => :splash_setup_error}
-      else
-        return { :case => :splash_setup_success }
-      end
-
-    end
-
-    # Sanitycheck action method for testing installation of Splash
-   # @return [Integer] an errorcode value
-    def checkconfig
-      puts "Splash -> sanitycheck : "
-      config = get_config
-      full_res = 0
-      print "* Config file : #{CONFIG_FILE} : "
-      res = verify_file(name: CONFIG_FILE, mode: "644", owner: config.user_root, group: config.group_root)
-      if res.empty? then
-        print "[OK]\n"
-      else
-        print "[KO]\n"
-        full_res =+ 1
-        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
-      end
 
-      print "* PID Path : #{config[:pid_path]} : "
-      res = verify_folder(name: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root)
-      if res.empty? then
-        print "[OK]\n"
-      else
-        print "[KO]\n"
-        full_res =+ 1
-        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
 
-      end
-
-      print "* trace Path : #{config[:trace_path]} : "
-      res = verify_folder(name: config[:trace_path], mode: "777", owner: config.user_root, group: config.group_root)
-      if res.empty? then
-        print "[OK]\n"
-      else
-        print "[KO]\n"
-        full_res =+ 1
-        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
-      end
-
-      print "* Prometheus PushGateway Service running : "
-      if verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
-        print "[OK]\n"
-      else
-        print "[KO]\n"
-        full_res =+ 1
-      end
-
-      if full_res > 0 then
-        $stderr.puts " => #{full_res} errors occured"
-        return { :case => :splash_sanitycheck_error }
-      else
-        return { :case => :splash_sanitycheck_success}
-      end
-    end
-
-    private
-
-    # facilities to find a file in gem path
-    # @param [String] _gem a Gem name
-    # @param [String] _file a file relative path in the gem
-    # @return [String] the path of the file, if found.
-    # @return [False] if not found
-    def search_file_in_gem(_gem,_file)
-      if Gem::Specification.respond_to?(:find_by_name)
-        begin
-          spec = Gem::Specification.find_by_name(_gem)
-        rescue LoadError
-          spec = nil
-        end
-      else
-        spec = Gem.searcher.find(_gem)
-      end
-      if spec then
-        if Gem::Specification.respond_to?(:find_by_name)
-          res = spec.lib_dirs_glob.split('/')
-        else
-          res = Gem.searcher.lib_dirs_for(spec).split('/')
-        end
-        res.pop
-        services_path = res.join('/').concat("/#{_file}")
-        return services_path if File::exist?(services_path)
-        return false
-      else
-        return false
-      end
-    end
 
   end
 end

data/lib/splash/config/sanitycheck.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+module Splash
+  module ConfigUtilities
+    include Splash::Constants
+
+    # Sanitycheck action method for testing installation of Splash
+    # @return [Integer] an errorcode value
+    def checkconfig
+      puts "Splash -> sanitycheck : "
+      config = get_config
+      full_res = 0
+      print "* Config file : #{CONFIG_FILE} : "
+      res = verify_file(name: CONFIG_FILE, mode: "644", owner: config.user_root, group: config.group_root)
+      if res.empty? then
+        print "[OK]\n"
+      else
+        print "[KO]\n"
+        full_res =+ 1
+        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
+      end
+
+      print "* PID Path : #{config[:pid_path]} : "
+      res = verify_folder(name: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root)
+      if res.empty? then
+        print "[OK]\n"
+      else
+        print "[KO]\n"
+        full_res =+ 1
+        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
+
+      end
+
+      print "* trace Path : #{config[:trace_path]} : "
+      res = verify_folder(name: config[:trace_path], mode: "777", owner: config.user_root, group: config.group_root)
+      if res.empty? then
+        print "[OK]\n"
+      else
+        print "[KO]\n"
+        full_res =+ 1
+        puts "    pbm => #{res.map {|p| p.to_s}.join(',')}"
+      end
+
+      print "* Prometheus PushGateway Service running : "
+      if verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
+        print "[OK]\n"
+      else
+        print "[KO]\n"
+        full_res =+ 1
+      end
+
+      if full_res > 0 then
+        $stderr.puts " => #{full_res} errors occured"
+        return { :case => :splash_sanitycheck_error }
+      else
+        return { :case => :splash_sanitycheck_success}
+      end
+    end
+  end
+end

data/lib/splash/config/setup.rb

@@ -0,0 +1,62 @@
+
+# coding: utf-8
+
+
+module Splash
+  module ConfigUtilities
+    include Splash::Constants
+    include Splash::Helpers
+    # Setup action method for installing Splash
+    # @return [Integer] an errorcode value
+    def setupsplash
+      conf_in_path = search_file_in_gem "prometheus-splash", "config/splash.yml"
+      full_res = 0
+      puts "Splash -> setup : "
+      unless options[:preserve] then
+        print "* Installing Configuration file : #{CONFIG_FILE} : "
+        # TODO TTY plateform
+        if install_file source: conf_in_path, target: CONFIG_FILE, mode: "644", owner: user_root, group:  group_root then
+          puts "[OK]"
+        else
+          full_res =+ 1
+          puts "[KO]"
+        end
+      else
+        puts "Config file preservation."
+      end
+      config = get_config
+      report_in_path = search_file_in_gem "prometheus-splash", "templates/report.txt"
+      print "* Installing template file : #{config.execution_template_path} : "
+      if install_file source: report_in_path, target: config.execution_template_path, mode: "644", owner: config.user_root, group: config.group_root then
+        puts "[OK]"
+      else
+        full_res =+ 1
+        puts "[KO]"
+      end
+
+      print "* Creating/Checking pid file path : #{config[:pid_path]} : "
+      if make_folder path: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root then
+        puts "[OK]"
+      else
+        full_res =+ 1
+        puts "[KO]"
+      end
+
+      print "* Creating/Checking trace file path : #{config[:trace_path]} : "
+      if make_folder path: config[:trace_path], mode: "644", owner: config.user_root, group: config.group_root then
+        puts "[OK]"
+      else
+        full_res =+ 1
+        puts "[KO]"
+      end
+
+      if full_res > 0 then
+        $stderr.puts " => #{full_res} errors occured"
+        return { :case => :splash_setup_error}
+      else
+        return { :case => :splash_setup_success }
+      end
+
+    end
+  end
+end

data/lib/splash/constants.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 module Splash
   module Constants
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
 
     # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
@@ -48,7 +48,7 @@ module Splash
     # transports default settings
     TRANSPORTS_STRUCT = { :list => [:rabbitmq],
                         :active => :rabbitmq,
-                        :rabbitmq => { :url => 'amqp://localhost/'} }
+                        :rabbitmq => { :port => 5672, :host => "localhost"} }
 
 
 

data/lib/splash/controller.rb

@@ -12,20 +12,19 @@ module Splash
         unless verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
           return {:case => :service_dependence_missing, :more => 'Prometheus Gateway'}
         end
-
         unless File::exist? config.full_pid_path then
           res = daemonize :description => config.daemon_process_name,
               :pid_file => config.full_pid_path,
               :stdout_trace => config.full_stdout_trace_path,
-              :stderr_trace => config.full_stderr_trace_path do
-              Scheduler::new
+              :stderr_trace => config.full_stderr_trace_path, :foreground => options[:foreground] do
+              Scheduler::new options
           end
           if res == 0 then
             pid = `cat #{config.full_pid_path}`.to_i
             puts "Splash Daemon Started, with PID : #{pid}"
             return {:case => :quiet_exit}
           else
-            return {:case => :unknown_error, :more => "Splash Daemon loading error"}
+            return {:case => :unknown_error, :more => "Splash Daemon loading error, see logs for more details"}
           end
 
         else

data/lib/splash/exiter.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 module Splash
   module Exiter
     EXIT_MAP= {

data/lib/splash/helpers.rb

@@ -3,6 +3,15 @@ module Splash
   module Helpers
 
 
+
+    def user_root
+      return Etc.getpwuid(0).name
+    end
+
+    def group_root
+      return Etc.getgrgid(0).name
+    end
+
     # facilité pour récupérer un PID depuis une regexp
     # @param [Hash] options
     # @option options [String] :pattern une regexp
@@ -17,6 +26,39 @@ module Splash
       end
     end
 
+
+    # facilities to find a file in gem path
+    # @param [String] _gem a Gem name
+    # @param [String] _file a file relative path in the gem
+    # @return [String] the path of the file, if found.
+    # @return [False] if not found
+    def search_file_in_gem(_gem,_file)
+      if Gem::Specification.respond_to?(:find_by_name)
+        begin
+          spec = Gem::Specification.find_by_name(_gem)
+        rescue LoadError
+          spec = nil
+        end
+      else
+        spec = Gem.searcher.find(_gem)
+      end
+      if spec then
+        if Gem::Specification.respond_to?(:find_by_name)
+          res = spec.lib_dirs_glob.split('/')
+        else
+          res = Gem.searcher.lib_dirs_for(spec).split('/')
+        end
+        res.pop
+        services_path = res.join('/').concat("/#{_file}")
+        return services_path if File::exist?(services_path)
+        return false
+      else
+        return false
+      end
+    end
+
+
+
     # facilité pour vérifier si le process actif est root
     # @return [Bool] vrai ou faux
     def is_root?
@@ -35,7 +77,7 @@ module Splash
       unless is_root?
         return {:case => :not_root, :more => "subcommands : #{method.to_s}"}
       else
-        return self.send method
+        return self.send method, options
       end
     end
 
@@ -47,7 +89,7 @@ module Splash
     # @option  options [String] :daemon_group the group to change privileges
     # @option  options [String] :stderr_trace the path of the file where to redirect STDERR
     # @option  options [String] :stdout_trace the path of the file where to redirect STDOUT
-    # @option  options [Bool] :debug option to run foreground
+    # @option  options [Bool] :foreground option to run foreground
     # @yield a process definion or block given
     # @example usage inline
     #    class Test
@@ -86,11 +128,11 @@ module Splash
     def daemonize(options)
       #Process.euid = 0
       #Process.egid = 0
-      return yield if options[:debug]
+
       trap("SIGINT"){ exit! 0 }
       trap("SIGTERM"){ exit! 0 }
       trap("SIGHUP"){ exit! 0 }
-
+      return yield if options[:foreground]
       fork do
         #Process.daemon
         File.open(options[:pid_file],"w"){|f| f.puts Process.pid } if options[:pid_file]

data/lib/splash/orchestrator.rb

@@ -1,54 +1,31 @@
 # coding: utf-8
+Dir[File.dirname(__FILE__) + '/orchestrator/*.rb'].each {|file| require file  }
+
 module Splash
   module Orchestrator
 
-    module SchedulerHooks
-      def on_pre_trigger(job, trigger_time)
-
-      end
-
-      def on_post_trigger(job, trigger_time)
-
-      end
-
-      def init_log
-
-      end
-    end
-
-    module Commander
-      include Splash::Transports
-      def send_message (options)
-        client = get_default_client
-        client.publish  options
-      end
-    end
-
-    module Grammar
-
-      VERBS=[:ping]
-
-      def ping(payload)
-        return "Pong : #{payload[:hostname]} !"
-      end
-    end
-
     class Scheduler
         include Splash::Constants
         include Splash::Helpers
         include Splash::Config
         include Splash::Transports
         include Splash::Orchestrator::Grammar
-        def initialize
+        def initialize(options = {})
+          $stdout.sync = true
+          $stderr.sync = true
           @server  = Rufus::Scheduler::new
           @server.extend SchedulerHooks
-          @server.init_log
           @config = get_config
           @result = LogScanner::new
+          puts "Splash Orchestrator starting :"
+          if options[:scheduling] then
+            puts " * Initializing commands Scheduling."
+            self.init_commands_scheduling
+          end
           sched,value = @config.daemon_logmon_scheduling.flatten
+          puts " * Initializing logs monitorings & notifications."
           @server.send sched,value do
             begin
-              puts "Notify"
               @result.analyse
               @result.notify
               $stdout.flush
@@ -58,12 +35,21 @@ module Splash
           end
           hostname = Socket.gethostname
           transport = get_default_subscriber queue: "splash.#{hostname}.input"
+          if transport.class == Hash and transport.include? :case then
+            splash_exit transport
+          end
           transport.subscribe(:block => true) do |delivery_info, properties, body|
             content = YAML::load(body)
             if VERBS.include? content[:verb]
-              res = self.send content[:verb], content[:payload]
+              puts "Receive valid remote order, verb : #{content[:verb].to_s}"
+              if content[:payload] then
+                res = self.send content[:verb], content[:payload]
+              else
+                res = self.send content[:verb]
+              end
               get_default_client.publish queue: content[:return_to], message: res.to_yaml
             else
+              puts "Receive INVALID remote order, verb : #{content[:verb].to_s}"
               get_default_client.publish queue: content[:return_to], message: "Unkown verb #{content[:verb]}".to_yaml
             end
           end
@@ -72,6 +58,29 @@ module Splash
         def terminate
         end
 
+        private
+        def init_commands_scheduling
+            config = get_config.commands
+            commands = config.select{|key,value| value.include? :schedule}.keys
+            commands.each do |command|
+              sched,value = config[command][:schedule].flatten
+              puts "   => Scheduling command #{command.to_s}"
+              @server.send sched,value do
+                self.execute command: command.to_s
+              end
+            end
+
+        end
+
+        def execute(options)
+          command =  Splash::CommandWrapper::new(options[:command])
+          if options[:ack] then
+            command.ack
+          else
+            command.call_and_notify trace: true, notify: true, callback: true
+          end
+        end
+
       end
 
 

data/lib/splash/orchestrator/grammar.rb

@@ -0,0 +1,43 @@
+# coding: utf-8
+module Splash
+  module Orchestrator
+    module Grammar
+
+      include Splash::Config
+      VERBS=[:ping,:list_commands,:execute_command,:ack_command]
+
+      def ping(payload)
+        return "Pong : #{payload[:hostname]} !"
+      end
+
+
+      def list_commands
+        return get_config.commands
+      end
+
+      def ack_command
+        return self.execute command: payload[:name], ack: true
+      end
+
+
+      def execute_command(payload)
+        unless get_config.commands.include? payload[:name].to_sym
+          puts " * Command not found"
+          return { :case => :not_found }
+        end
+        if payload.include? :schedule then
+          sched,value = payload[:schedule].flatten
+        else
+          sched = :in
+          value = '1s'
+        end
+        puts " * Schedule remote call command #{payload[:name]}, scheduling : #{sched.to_s} #{value}"
+        @server.send sched,value do
+          self.execute command: payload[:name]
+        end
+        return { :case => :quiet_exit }
+      end
+
+    end
+  end
+end

data/lib/splash/orchestrator/hooks.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+module Splash
+  module Orchestrator
+
+    module SchedulerHooks
+      def on_pre_trigger(job, trigger_time)
+
+      end
+
+      def on_post_trigger(job, trigger_time)
+
+      end
+
+    end
+  end
+end

data/lib/splash/transports.rb

@@ -1,19 +1,42 @@
 # coding: utf-8
-Dir[File.dirname(__FILE__) + '/transports/*.rb'].each {|file| require file  }
 
 module Splash
   module Transports
     include Splash::Config
 
-    def get_default_subscriber(queue)
-      aclass = "Splash::Transports::#{get_config[:transports][:active].to_s.capitalize}::Subscriber"
-      return Kernel.const_get(aclass)::new(queue)
+    def get_default_subscriber(options)
+      config = get_config.transports
+      transport = config[:active]
+      host = config[transport][:host]
+      port = config[transport][:port]
+      unless verify_service host: host, port: port then
+        return  { :case => :service_dependence_missing, :more => "RabbitMQ Transport not available." }
+       end
+      aclass = "Splash::Transports::#{transport.capitalize}::Subscriber"
+      begin
+        return Kernel.const_get(aclass)::new(options)
+      rescue
+        return { :case => :configuration_error, :more => "Transport specified for queue #{options[:queue]} inexistant : #{transport}"}
+      end
     end
 
     def get_default_client
-      aclass = "Splash::Transports::#{get_config[:transports][:active].to_s.capitalize}::Client"
-      return Kernel.const_get(aclass)::new
+      config = get_config.transports
+      transport = config[:active]
+      host = config[transport][:host]
+      port = config[transport][:port]
+      unless verify_service host: host, port: port then
+        return  { :case => :service_dependence_missing, :more => "RabbitMQ Transport not available." }
+       end
+      aclass = "Splash::Transports::#{transport.to_s.capitalize}::Client"
+      begin
+        return Kernel.const_get(aclass)::new
+      rescue
+        return { :case => :configuration_error, :more => "Transport specified inexistant : #{transport}"}
+      end
     end
 
   end
 end
+
+Dir[File.dirname(__FILE__) + '/transports/*.rb'].each {|file| require file  }

data/lib/splash/transports/rabbitmq.rb

@@ -11,26 +11,46 @@ module Splash
 
         def initialize(options = {})
           @config = get_config.transports
-          @connection = Bunny.new url: @config[:rabbitmq][:url]
-          @connection.start
-          @channel = @connection.create_channel
-          @queue    = @channel.queue options[:queue]
-
+          host = @config[:rabbitmq][:host]
+          port = @config[:rabbitmq][:port]
+          @url = "amqp://#{host}:#{port}"
+          begin
+            @connection = Bunny.new url: @url
+            @connection.start
+            @channel = @connection.create_channel
+            @queue    = @channel.queue options[:queue]
+          rescue Bunny::Exception
+            return  { :case => :service_dependence_missing, :more => "RabbitMQ Transport not available." }
+          end
         end
 
+
       end
 
 
       class Client
         include Splash::Config
+        include Splash::Transports
+
         def initialize
           @config = get_config.transports
-          @connection = Bunny.new url: @config[:rabbitmq][:url]
-          @connection.start
-          @channel = @connection.create_channel
+          host = @config[:rabbitmq][:host]
+          port = @config[:rabbitmq][:port]
+          @url = "amqp://#{host}:#{port}"
+          begin
+            @connection = Bunny.new url: @url
+            @connection.start
+            @channel = @connection.create_channel
+          rescue Bunny::Exception
+            return  { :case => :service_dependence_missing, :more => "RabbitMQ Transport not available." }
+          end
         end
 
 
+        def purge(options)
+          @channel.queue(options[:queue]).purge
+        end
+
         def publish(options ={})
           return @channel.default_exchange.publish(options[:message], :routing_key => options[:queue])
         end
@@ -39,6 +59,19 @@ module Splash
           return @channel.acknowledge(ack, false)
         end
 
+        def execute(order)
+          queue = order[:return_to]
+          lock = Mutex.new
+          res = nil
+          condition = ConditionVariable.new
+          get_default_subscriber(queue: queue).subscribe(timeout: 5) do |delivery_info, properties, payload|
+            res = YAML::load(payload)
+            lock.synchronize { condition.signal }
+          end
+          get_default_client.publish queue: order[:queue], message: order.to_yaml
+          lock.synchronize { condition.wait(lock) }
+          return res
+        end
 
         def get(options ={})
           queue = @channel.queue(options[:queue])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-splash
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Romain GEORGES
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-10 00:00:00.000000000 Z
+date: 2020-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -236,6 +236,8 @@ files:
 - lib/splash/cli/logs.rb
 - lib/splash/commands.rb
 - lib/splash/config.rb
+- lib/splash/config/sanitycheck.rb
+- lib/splash/config/setup.rb
 - lib/splash/constants.rb
 - lib/splash/controller.rb
 - lib/splash/dependencies.rb
@@ -243,6 +245,8 @@ files:
 - lib/splash/helpers.rb
 - lib/splash/logs.rb
 - lib/splash/orchestrator.rb
+- lib/splash/orchestrator/grammar.rb
+- lib/splash/orchestrator/hooks.rb
 - lib/splash/templates.rb
 - lib/splash/transports.rb
 - lib/splash/transports/rabbitmq.rb