prometheus-splash 0.4.5 → 0.6.1

data/lib/splash/daemon/orchestrator/grammar.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module Daemon
+
+    # orchestrator specific module
+    module Orchestrator
+
+      # Orchestrator grammar method defiition  module
+      module Grammar
+
+        include Splash::Config
+        include Splash::Loggers
+
+        # list of known verbs for Splash orchestrator
+        VERBS=[:ping,:list_commands,:execute_command,:ack_command, :shutdown]
+
+        # shutdown verb : stop the Splash daemon gracefully
+        # @param [Hash] content message content Hash Structure, ignored
+        # @return [Hash] Exiter Case :quiet_exit
+        def shutdown(content)
+          terminate
+        end
+
+        # ping verb : return pong to hostname precise in payload
+        # @param [Hash] content message content Hash Structure, include  mandatory payload[:hostname]
+        # @return [String] the pong
+        def ping(content)
+          return "Pong : #{content[:payload][:hostname]} !"
+        end
+
+        # list_commands verb : return the list of specified commands in local Splash
+        # @param [Hash] content message content Hash Structure, ignored
+        # @return [Hash] structure of commands
+        def list_commands(content)
+          return get_config.commands
+        end
+
+        # ack_command verb : send ack to Prometheus, for command specified in payload
+        # @param [Hash] content message content Hash Structure, include  mandatory payload[:name]
+        # @return [Hash] Exiter case
+        def ack_command(content)
+          return execute command: content[:payload][:name], ack: true
+        end
+
+        # execute_command verb : execute command specified in payload
+        # @param [Hash] content message content Hash Structure, include  mandatory payload[:name]
+        # @return [Hash] Exiter case
+        def execute_command(content)
+          payload = content[:payload]
+          unless get_config.commands.include? payload[:name].to_sym
+            @log.item "Command not found", content[:session]
+            return { :case => :not_found }
+          end
+          if payload.include? :schedule then
+            sched,value = payload[:schedule].flatten
+            @log.schedule "remote call command #{payload[:name]}, scheduling : #{sched.to_s} #{value}", content[:session]
+            @server.send sched,value do
+              @log.trigger "Executing Scheduled command #{payload[:name]} for Scheduling : #{sched.to_s} #{value}", content[:session]
+              execute command: payload[:name], session: content[:session]
+            end
+            return { :case => :quiet_exit }
+          else
+            @log.info "Execute direct command",  content[:session]
+            res = execute command: payload[:name], session: content[:session]
+            return res
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/splash/daemon/orchestrator/hooks.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module Daemon
+
+    # orchestrator specific module
+    module Orchestrator
+
+      # Rufus Scheduler Hooks
+      module SchedulerHooks
+
+        # not yet implemented
+        def on_pre_trigger(job, trigger_time)
+
+        end
+
+        # not yet implemented
+        def on_post_trigger(job, trigger_time)
+
+        end
+
+      end
+    end
+  end
+end

data/lib/splash/dependencies.rb

@@ -12,6 +12,8 @@ module Splash
     require 'fileutils'
     require 'etc'
     require 'forwardable'
+    require 'json'
+    require 'uri'
 
 
 
@@ -26,6 +28,14 @@ module Splash
       require 'tty-pager'
       require 'colorize'
       require "redis"
+      require 'ps-ruby'
+      require 'sinatra/base'
+      require 'thin'
+      require 'slim'
+      require 'rest-client'
+      require 'kramdown'
+      require 'rack/reverse_proxy'
+
 
     rescue Gem::GemNotFoundException
       $stderr.puts "Loadind error, it's like you try to run Splash, with a lake of dependencies."
@@ -46,9 +56,14 @@ module Splash
 
 
     require 'splash/commands'
+    require 'splash/sequences'
+
     require 'splash/logs'
-    require 'splash/orchestrator'
-    require 'splash/controller'
+    require 'splash/processes'
+
+    require 'splash/daemon'
+    require 'splash/webadmin'
+
 
   end
 end

data/lib/splash/exiter.rb

@@ -1,5 +1,9 @@
 # coding: utf-8
+
+# base Splash namespace
 module Splash
+
+  # Exiter namespace
   module Exiter
     include Splash::Loggers
     EXIT_MAP= {
@@ -20,6 +24,7 @@ module Splash
 
        # global
        :quiet_exit => {:code => 0},
+       :error_exit => {:code => 99, :message => "Operation failure"},
 
        # events
        :interrupt => {:message => "Splash user operation interrupted", :code => 33},
@@ -34,6 +39,10 @@ module Splash
 
     }
 
+    # exiter wrapper
+    # @param [Hash] options
+    # @option options [Symbol] :case an exit case
+    # @option options [String] :more a complementary string to display
     def splash_exit(options = {})
       log = get_logger
       mess = ""
@@ -49,7 +58,13 @@ module Splash
       end
     end
 
+    def splash_return(options = {})
 
+      data = EXIT_MAP[options[:case]]
+      data[:status] = (data[:code]>0)? :failure : :success
+      data[:more] = options[:more] if options[:more]
+      return data
+    end
 
   end
 end

data/lib/splash/helpers.rb

@@ -1,34 +1,47 @@
-# @option  options [String] :stdout_trace the path of the file where to redirect STDOUT
 # coding: utf-8
+
+# base Splash Module
 module Splash
-  module Helpers
 
+  # Helpers namespace
+  module Helpers
 
 
+    # return the 'root' name
+    # @return [String] name
     def user_root
       return Etc.getpwuid(0).name
     end
 
+    # return the 'root' group name : root or wheel
+    # @return [String] name
     def group_root
       return Etc.getgrgid(0).name
     end
 
-    # facilité pour récupérer un PID depuis une regexp
+    # facility for retreiving PID from process query
     # @param [Hash] options
-    # @option options [String] :pattern une regexp
-    # @return [String] le PID
-    def get_process(options = {})
-      pattern = options[:pattern]
-      res = `ps aux|grep '#{pattern}'|grep -v grep`.to_s
-      unless res.empty? then
-        return res.split(/\s+/)[1]
+    # @option options [String] :pattern a regexp to search
+    # @option options [Array] :patterns an array of regexp to search
+    # @option options [Bool] :full flag to retrieve all process data not only PID
+    # @return [String|Array] PID or data structure
+    def get_processes(options = {})
+      patterns = []
+      patterns  = options[:patterns] if options[:patterns]
+      patterns << options[:pattern] if options[:pattern]
+      res = PS.get_all_processes
+      patterns.each do |item|
+        res = res.find_processes item
+      end
+      if options[:full] then
+        return res
       else
-        return ''
+        return res.pick_attr('PID')
       end
     end
 
 
-    # facilities to find a file in gem path
+    # facility 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.
@@ -60,8 +73,8 @@ module Splash
 
 
 
-    # facilité pour vérifier si le process actif est root
-    # @return [Bool] vrai ou faux
+    # facility to verifyingif the active process run as root
+    # @return [Bool] status
     def is_root?
       case (Process.uid)
       when 0
@@ -71,9 +84,9 @@ module Splash
       end
     end
 
-    # facilité pour s'assurer qu'on execute une méthode avec les droits root
+    # wrapping execution if process run as root
     # @param [Symbol] method a method name th wrap
-    # @return [void] le retour de la méthode wrappée
+    # @return [void] return of wrapped method
     def run_as_root(method, options = {})
       unless is_root?
         return {:case => :not_root, :more => "subcommands : #{method.to_s}"}
@@ -156,6 +169,7 @@ module Splash
        }
       if options[:foreground]
         change_logger logger: :dual
+        Process.setproctitle options[:description] if options[:description]
         return yield
       end
       fork do
@@ -180,15 +194,15 @@ module Splash
       return 0
     end
 
-    # @!group facilités sur le système de fichier
+    # @!group facilities for file system commands
 
-    # facilité d'installation de fichier
+    # facility for file installation
     # @param [Hash] options
-    # @option options [String] :source le chemin source du fichier
-    # @option options [String] :target le chemin cible du fichier
-    # @option options [String] :mode les droits du fichier du type Octal "XXX"
-    # @option options [String] :owner le owner du fichier
-    # @option options [String] :group le groupe du fichier
+    # @option options [String] :source file source path
+    # @option options [String] :target file target path
+    # @option options [String] :mode String for OCTAL rights like "644"
+    # @option options [String] :owner file owner for target
+    # @option options [String] :group  file group for target
     def install_file(options = {})
       #begin
         FileUtils::copy options[:source], options[:target] #unless File::exist? options[:target]
@@ -200,12 +214,12 @@ module Splash
       #end
     end
 
-    # facilité de création de répertoire
+    # facility for folder creation
     # @param [Hash] options
-    # @option options [String] :path le répertoire à créer (relatif ou absolut)
-    # @option options [String] :mode les droits du fichier du type Octal "XXX"
-    # @option options [String] :owner le owner du fichier
-    # @option options [String] :group le groupe du fichier
+    # @option options [String] :path folder path (relative or absolute)
+    # @option options [String] :mode String for OCTAL rights like "644"
+    # @option options [String] :owner file owner for folder
+    # @option options [String] :group  file group for folder
     def make_folder(options = {})
       begin
         FileUtils::mkdir_p options[:path] unless File::exist? options[:path]
@@ -217,10 +231,10 @@ module Splash
       end
     end
 
-    # facilité de liaison symbolique  de fichier
+    # facility for Symbolic link
     # @param [Hash] options
-    # @option options [String] :source le chemin source du fichier
-    # @option options [String] :link le chemin du lien symbolique
+    # @option options [String] :source path of the file
+    # @option options [String] :link path of the symlink
     def make_link(options = {})
       begin
         FileUtils::rm options[:link] if (File::symlink? options[:link] and not File::exist? options[:link])
@@ -233,15 +247,15 @@ module Splash
     # @!endgroup
 
 
-    #@!group  Vérifiers de l'application
+    #@!group  Verifiers for application : FS and TCP/IP services
 
-    # verifier d'existence d'un repertoire
+    # check folder
     # @return [Array] of Symbol with error type : [:inexistant,:mode,:owner,:group]
     # @param [Hash] options
-    # @option options [String] :path le répertoire (relatif ou absolut) obligatoire
-    # @option options [String] :mode droit du  répertoire optionnel
-    # @option options [String] :owner owner du répertoire optionnel
-    # @option options [String] :group groupe du répertoire optionnel
+    # @option options [String] :path folder path (relative or absolute)
+    # @option options [String] :mode String for OCTAL rights like "644", optionnal
+    # @option options [String] :owner file owner for folder, optionnal
+    # @option options [String] :group  file group for folder, optionnal
     def verify_folder(options ={})
       res = Array::new
       return  [:inexistant] unless File.directory?(options[:name])
@@ -259,21 +273,21 @@ module Splash
       return res
     end
 
-    # verifier d'existence d'un lien
-    # @return [Bool] vrai ou faux
+    # check symlink
+    # @return [Boolean]
     # @param [Hash] options
-    # @option options [String] :name path du lien
+    # @option options [String] :name path of the link
     def verify_link(options ={})
       return File.file?(options[:name])
     end
 
-    # verifier d'existence d'un fichier
+    # check file
     # @return [Array] of Symbol with error type : [:inexistant,:mode,:owner,:group]
     # @param [Hash] options
-    # @option options [String] :name path du fichier obligatoire
-    # @option options [String] :mode droit du fichier optionnel
-    # @option options [String] :owner owner du fichier optionnel
-    # @option options [String] :group groupe du fichier optionnel
+    # @option options [String] :name path of file
+    # @option options [String] :mode String for OCTAL rights like "644", optionnal
+    # @option options [String] :owner file owner for file, optionnal
+    # @option options [String] :group  file group for file, optionnal
     def verify_file(options ={})
       res = Array::new
       return  [:inexistant] unless File.file?(options[:name])
@@ -291,16 +305,25 @@ module Splash
       return res
     end
 
-    # verifier de l'ecoute d'un service sur un host et port donné en TCP
-    # @return [Bool] vrai ou faux
+    # TCP/IP service checker
+    # @return [Bool] status
     # @param [Hash] options
-    # @option options [String] :host le nom d'hote
-    # @option options [String] :port le port TCP
+    # @option options [String] :host hostname
+    # @option options [String] :port TCP port
+    # @option options [String] :url full URL, priority on :host and :port
     def verify_service(options ={})
       begin
+        if options[:url] then
+          uri = URI.parse(options[:url])
+          host = uri.host
+          port = uri.port
+        else
+          host = options[:host]
+          port = options[:port]
+        end
         Timeout::timeout(1) do
           begin
-            s = TCPSocket.new(options[:host], options[:port])
+            s = TCPSocket.new(host, port)
             s.close
             return true
           rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
@@ -314,6 +337,24 @@ module Splash
     #!@endgroup
 
 
+    def format_response(data, format)
+      response = case format
+                 when 'application/json' then JSON.pretty_generate(data)
+                 when 'text/x-yaml' then data.to_yaml
+                 else JSON.pretty_generate(data)
+                 end
+      return response
+    end
+
+    def format_by_extensions(extension)
+      result = {
+        'json' => 'application/json',
+        'yaml' => 'text/x-yaml',
+        'yml' => 'text/x-yaml'
+      }
+       return result[extension]
+    end
+
 
   end
 end

data/lib/splash/loggers.rb

@@ -1,55 +1,78 @@
 # coding: utf-8
 
-
+# base Splash module
 module Splash
+
+  # Loggers namespace
   module Loggers
     include Splash::Config
 
     @@logger=nil
 
+
+    # factory for Loggers
+    # @param [Hash] options
+    # @option options [Symbol] :logger the name of the logger actually in [:cli, :daemon, :dual]
+    # @option options [Boolean] :force to force new instance creation (Logger is class variable)
+    # @return [SPlash::Loggers::<type>] type is Cli, Dual, Daemon, Web
     def get_logger(options = {})
       logger = (get_config.loggers[:list].include? options[:logger])? options[:logger].to_s : get_config.loggers[:default].to_s
       aclass = "Splash::Loggers::#{logger.capitalize}"
-#      begin
+      begin
         return @@logger = Kernel.const_get(aclass)::new if options[:force]
         return @@logger ||= Kernel.const_get(aclass)::new
-#      rescue
-#        splash_exit case: :configuration_error, more: "Logger specified inexistant : #{logger}"
-#      end
+      rescue
+        splash_exit case: :configuration_error, more: "Logger specified inexistant : #{logger}"
+      end
+    end
+
+    # build a session number
+    # @return [String] Session number
+    def get_session
+      return "#{Time.now.to_i.to_s}#{rand(999)}"
     end
 
 
+    # wrapper to change logger, call get_logger with force: true
+    # @option options [Symbol] :logger the name of the logger actually in [:cli, :daemon, :dual]
     def change_logger(options = {})
+      level = get_logger.level
       options[:force] = true
-      get_logger(options)
+      get_logger(options).level = level
     end
 
+    LEVELS = [:debug, :warn, :info, :result, :fatal, :unknown]
+    ALIAS = {:flat => :info, :item => :info, :ok => :info, :ko => :info, :trigger => :info,
+      :schedule => :info, :arrow => :info, :send => :info, :call => :info,
+      :receive => :info, :error => :result, :success => :result }
 
-
+      # class template for loggers
     class LoggerTemplate
       include Splash::Config
 
-      LEVELS = [:debug, :warn, :info, :result, :fatal, :unknown]
-      ALIAS = {:flat => :info, :item => :info, :ok => :info, :ko => :info, :trigger => :info,
-        :schedule => :info, :arrow => :info, :send => :info,
-        :receive => :info, :error => :result, :success => :result }
+
       LEVELS.each do |method|
-        define_method(method) do |message|
-            self.log({ :level => method, :message => message})
+        define_method(method) do |message,session = ''|
+            self.log({ :level => method, :message => message, :session => session})
         end
       end
       ALIAS.keys.each do |method|
-        define_method(method) do |message|
-            self.log({ :level => method, :message => message})
+        define_method(method) do |message,session = ''|
+            self.log({ :level => method, :message => message, :session => session})
         end
       end
+
+      # constructor
       def initialize
         self.level = get_config.loggers[:level]
 
 
       end
 
-
+      # abstract method for log wrapper
+      # @param [Hash] options
+      # @option options [Symbol] :level, a valid level in LEVELS or ALIAS
+      # @option options [String] :message text
       def log(options)
         level = (ALIAS.keys.include? options[:level])?  ALIAS[options[:level]] : options[:level]
         if @active_levels.include? level then
@@ -57,11 +80,15 @@ module Splash
         end
       end
 
-
+      # getter for the current level
+      # @return [Symbol] level
       def level
         return @active_levels.first
       end
 
+      # virtual setter for level, set the current level
+      # @raise a badLevel in case of bad level
+      # @param [Symbol] level
       def level=(level)
         if LEVELS.include? level then
           @active_levels = LEVELS.dup
@@ -73,6 +100,9 @@ module Splash
 
 
       private
+      # mapper for symbol Symbol to String
+      # @param [Symbol] symbol
+      # @return [String] in upcase, exception :arrow give '=>', :flat give ''
       def alt(symbol)
         return "=>" if symbol == :arrow
         return '' if symbol == :flat
@@ -81,6 +111,7 @@ module Splash
 
     end
 
+    # badLevel Exception
     class BadLevel < Exception; end
 
   end