prometheus-splash 0.8.0 → 0.8.5

data/lib/splash/sequences.rb

@@ -25,12 +25,17 @@ module Splash
         list[name][:definition].each do |step|
           log.info "STEP : #{step[:step]}",session
           if step[:on_host].nil? then
-            command =  CommandWrapper::new(step[:command].to_s)
+            if get_config.commands.select{|cmd| cmd[:name] == step[:command]}.count > 0 then
+              command =  CommandWrapper::new(step[:command].to_s)
               step[:callback] = true if step[:callback].nil?
               step[:trace] = true if step[:trace].nil?
               step[:notify] = true if step[:notify].nil?
               step[:session] = session
               acase = command.call_and_notify step
+            else
+              log.error "Commmand #{step[:command]} not found, for STEP : #{step[:step]}", session
+              acase =  splash_return :not_found
+            end
           else
             log.info "Remote execution of #{step[:command]} on #{step[:on_host]}", session
             begin

data/lib/splash/transfers.rb

@@ -49,40 +49,45 @@ module Splash
 
     class TxRecords
       include Splash::Backends
+      include Splash::Constants
+
       def initialize(name)
         @name = name
-        @backend = get_backend :transferts_trace
+        @backend = get_backend :transfers_trace
       end
 
       def purge(retention)
+        retention = {} if retention.nil?
         if retention.include? :hours then
           adjusted_datetime = DateTime.now - retention[:hours].to_f / 24
         elsif retention.include? :hours then
           adjusted_datetime = DateTime.now - retention[:days].to_i
         else
-          retention = TRANSFER_DEFAULT_RETENTION
+          adjusted_datetime = DateTime.now - DEFAULT_RETENTION
         end
 
         data = get_all_records
 
-        data.delete_if { |item,value|
-          DateTime.parse(item) <= (adjusted_datetime) and value[:status] != :prepared}
+        data.delete_if { |item|
+          DateTime.parse(item.keys.first) <= (adjusted_datetime)}
         @backend.put key: @name, value: data.to_yaml
       end
 
       def add_record(record)
         data = get_all_records
-        data[DateTime.now.to_s] = record
+        data.push({ DateTime.now.to_s => record })
         @backend.put key: @name, value: data.to_yaml
       end
 
-      def get_all_records
-        return (@backend.exist?({key: @name}))? YAML::load(@backend.get({key: @name})) : {}
+      def get_all_records(options={})
+        return (@backend.exist?({key: @name}))? YAML::load(@backend.get({key: @name})) : []
       end
 
       def check_prepared
         return :never_run_prepare unless @backend.exist?({key: @name})
-        return :never_prepare unless YAML::load(@backend.get({key: @name})).select {|item,value|
+        return :never_prepare unless YAML::load(@backend.get({key: @name})).select {|item|
+          record =item.keys.first
+          value=item[record]
           value[:status] == :prepared
         }.count > 0
         return :prepared

data/lib/splash/webadmin/api/routes/commands.rb

@@ -5,7 +5,7 @@
 WebAdminApp.get '/api/commands/list.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : commands, verb : GET, route : list, format : #{format}"
+  log.call "API : commands, verb : GET, route : list, format : #{format}"
   obj =  splash_return case: :quiet_exit, :more => "Commands list"
   obj[:data] = get_config.commands
   content_type format
@@ -15,8 +15,8 @@ WebAdminApp.get '/api/commands/list.?:format?' do
 WebAdminApp.get '/api/commands/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : commands, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
-  commands_recordset = get_config.commands[params[:name].to_sym]
+  log.call "API : commands, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  commands_recordset = get_config.commands.select {|command| command[:name] == params[:name].to_sym}.first
   unless commands_recordset.nil? then
     obj = splash_return case: :quiet_exit
     obj[:data] = commands_recordset
@@ -26,3 +26,15 @@ WebAdminApp.get '/api/commands/show/:name.?:format?' do
   content_type format
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
+
+WebAdminApp.get '/api/commands/history/:name.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : commands, verb : GET, route : history, format : #{format}"
+  record = Splash::Commands::CmdRecords::new(params[:name]).get_all_records
+  history =  splash_return case: :quiet_exit, :more => "command monitoring history"
+  history[:data] = record
+  content_type format
+  status 201
+  format_response(history, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end

data/lib/splash/webadmin/api/routes/config.rb

@@ -1,10 +1,148 @@
 WebAdminApp.get '/api/config/full.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : config, verb : GET, route : show, format : #{format}"
+  log.call "API : config, verb : GET, route : full, format : #{format}"
   config = get_config.full
-  obj =  splash_return case: :quiet_exit, :more => "logses list"
+  obj =  splash_return case: :quiet_exit, :more => "Show internal Splash Config"
   obj[:data] = config
   content_type format
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
+
+WebAdminApp.get '/api/config/fromfile.?:format?' do
+  log = get_logger
+  fromfile = {}
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : GET, route : fromfile, format : #{format}"
+  config = get_config.config_from_file
+  fromfile =  splash_return case: :quiet_exit, :more => "Show config from file"
+  fromfile[:data] = config
+  content_type format
+  format_response(fromfile, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+
+WebAdminApp.post '/api/config/addlog.?:format?' do
+  log = get_logger
+  addlog = {}
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : POST, route : addlog, format : #{format}"
+  res = get_config.add_record :record => YAML::load(request.body.read), :key => :label, :type => :logs, :clean => true
+  case res[:status]
+  when :success
+    rehash_daemon
+    addlog = splash_return case: :quiet_exit, :more => "add log done"
+  when :already_exist
+    addlog = splash_return case: :already_exist, :more => "add log twice nto allowed"
+  when :failure
+    addlog = splash_return case: :configuration_error, :more => "add log failed"
+    addlog[:data] = res
+  end
+  content_type format
+  format_response(addlog, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+WebAdminApp.post '/api/config/addprocess.?:format?' do
+  log = get_logger
+  addprocess = {}
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : POST, route : addprocess, format : #{format}"
+  res = get_config.add_record :record => YAML::load(request.body.read), :type => :processes, :key => :process, :clean => true
+  case res[:status]
+  when :success
+    rehash_daemon
+    addprocess = splash_return case: :quiet_exit, :more => "add process done"
+  when :already_exist
+    addprocess = splash_return case: :already_exist, :more => "add process twice not allowed"
+  when :failure
+    addprocess = splash_return case: :configuration_error, :more => "add process failed"
+    addprocess[:data] = res
+  end
+  content_type format
+  format_response(addprocess, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+WebAdminApp.post '/api/config/addcommand.?:format?' do
+  log = get_logger
+  addcommand = {}
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : POST, route : addcommand, format : #{format}"
+  res = get_config.add_record :record => YAML::load(request.body.read), :type => :commands, :key => :name, :clean => true
+  case res[:status]
+  when :success
+    rehash_daemon
+    addcommand = splash_return case: :quiet_exit, :more => "add command done"
+  when :already_exist
+    addcommand = splash_return case: :already_exist, :more => "add command twice not allowed"
+  when :failure
+    addpraddcommandocess = splash_return case: :configuration_error, :more => "add command failed"
+    addcommand[:data] = res
+  end
+  content_type format
+  format_response(addcommand, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+
+
+WebAdminApp.delete '/api/config/deletelog/:label.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : DELETE, route : deletelog, format : #{format}"
+  deletelog = {}
+  logsrec = Splash::Logs::LogsRecords::new params[:label].to_sym
+  logsrec.clear
+  res = get_config.delete_record :type => :logs, key: :label, label: params[:label].to_sym
+  case res[:status]
+  when :success
+    rehash_daemon
+    deletelog = splash_return case: :quiet_exit, :more => "delete log done"
+  when :not_found
+    deletelog = splash_return case: :not_found, :more => "nothing done for logs"
+  else
+    deletelog = splash_return case: :configuration_error, :more => "delete log failed"
+  end
+  content_type format
+  format_response(deletelog, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+WebAdminApp.delete '/api/config/deleteprocess/:process.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : DELETE, route : deleteprocess, format : #{format}"
+  deleteprocess = {}
+  procrec = Splash::Processes::ProcessRecords::new params[:process].to_sym
+  procrec.clear
+  res = get_config.delete_record :type => :processes, :key => :process, process: params[:process].to_sym
+  case res[:status]
+  when :success
+    rehash_daemon
+    deleteprocess = splash_return case: :quiet_exit, :more => "delete process done"
+  when :not_found
+    deleteprocess = splash_return case: :not_found, :more => "nothing done for processes"
+  else
+    deleteprocess = splash_return case: :configuration_error, :more => "delete process failed"
+  end
+  content_type format
+  format_response(deleteprocess, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+WebAdminApp.delete '/api/config/deletecommand/:command.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : config, verb : DELETE, route : deletecommand, format : #{format}"
+  deletecommand = {}
+  cmdrec = Splash::Commands::CmdRecords::new params[:command].to_sym
+  cmdrec.clear
+  res = get_config.delete_record :type => :commands, :key => :name, name: params[:command].to_sym
+  case res[:status]
+  when :success
+    rehash_daemon
+    deletecommand = splash_return case: :quiet_exit, :more => "delete command done"
+  when :not_found
+    deletecommand = splash_return case: :not_found, :more => "nothing done for commands"
+  else
+    deletecommand = splash_return case: :configuration_error, :more => "delete command failed"
+  end
+  content_type format
+  format_response(deletecommand, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end

data/lib/splash/webadmin/api/routes/logs.rb

@@ -4,56 +4,71 @@
 
 WebAdminApp.get '/api/logs/list.?:format?' do
   log = get_logger
+  list = {}
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : GET, route : list, format : #{format}"
+  log.call "API : logs, verb : GET, route : list, format : #{format}"
   logs_recordset = get_config.logs
-  obj =  splash_return case: :quiet_exit, :more => "logses list"
-  obj[:data] = logs_recordset
+  list =  splash_return case: :quiet_exit, :more => "logs list"
+  list[:data] = logs_recordset
   content_type format
-  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(list, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
   end
 
 WebAdminApp.get '/api/logs/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  log.call "API : logs, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
   logs_recordset = get_config.logs.select{|item| item[:label] == params[:name].to_sym }
+  show = {}
   unless logs_recordset.empty? then
     record = logs_recordset.first
-    obj = splash_return case: :quiet_exit
-    obj[:data] = record
+    show = splash_return case: :quiet_exit
+    show[:data] = record
+    status 201
   else
-    obj = splash_return case: :not_found, :more => "logs not configured"
+    show = splash_return case: :not_found, :more => "logs not configured"
   end
-  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(show, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
 WebAdminApp.post '/api/logs/analyse.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : POST, route : analyse, format : #{format}"
+  log.call "API : logs, verb : POST, route : analyse, format : #{format}"
   results = Splash::Logs::LogScanner::new
   results.analyse
   res = results.output
-  obj =  splash_return case: :quiet_exit, :more => "logs analyse report"
-  obj[:data] = res
+  analyse =  splash_return case: :quiet_exit, :more => "logs analyse report"
+  analyse[:data] = res
   status 201
   content_type format
-  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(analyse, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
 WebAdminApp.post '/api/logs/monitor.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : logs, verb : POST, route : monitor, format : #{format}"
+  log.call "API : logs, verb : POST, route : monitor, format : #{format}"
   results = Splash::Logs::LogScanner::new
   results.analyse
-  res = splash_return results.notify
-  if res[:status] == :failure then
+  monitor = splash_return results.notify
+  if monitor[:status] == :failure then
     status 503
   else
     status 201
   end
   content_type format
-  format_response(res, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  format_response(monitor, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end
+
+WebAdminApp.get '/api/logs/history/:label.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : logs, verb : GET, route : history, format : #{format}"
+  record = Splash::Logs::LogsRecords::new(params[:label]).get_all_records
+  history =  splash_return case: :quiet_exit, :more => "log monitoring history"
+  history[:data] = record
+  content_type format
+  status 201
+  format_response(history, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end

data/lib/splash/webadmin/api/routes/process.rb

@@ -2,10 +2,10 @@
 
 
 
-WebAdminApp.get '/api/process/list.?:format?' do
+WebAdminApp.get '/api/processes/list.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : GET, route : list, format : #{format}"
+  log.call "API : processes, verb : GET, route : list, format : #{format}"
   process_recordset = get_config.processes
   obj =  splash_return case: :quiet_exit, :more => "Processes list"
   obj[:data] = process_recordset
@@ -13,11 +13,11 @@ WebAdminApp.get '/api/process/list.?:format?' do
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
   end
 
-WebAdminApp.get '/api/process/show/:name.?:format?' do
+WebAdminApp.get '/api/processes/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
-  process_recordset = get_config.processes.select{|item| item[:process] == params[:name] }
+  log.call "API : processes, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  process_recordset = get_config.processes.select{|item| item[:process] == params[:name].to_sym }
   unless process_recordset.empty? then
     record = process_recordset.first
     obj = splash_return case: :quiet_exit
@@ -29,10 +29,10 @@ WebAdminApp.get '/api/process/show/:name.?:format?' do
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
-WebAdminApp.post '/api/process/analyse.?:format?' do
+WebAdminApp.post '/api/processes/analyse.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : POST, route : analyse, format : #{format}"
+  log.call "API : processes, verb : POST, route : analyse, format : #{format}"
   results = Splash::Processes::ProcessScanner::new
   results.analyse
   res = results.output
@@ -43,10 +43,10 @@ WebAdminApp.post '/api/process/analyse.?:format?' do
   format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
 
-WebAdminApp.post '/api/process/monitor.?:format?' do
+WebAdminApp.post '/api/processes/monitor.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : process, verb : POST, route : monitor, format : #{format}"
+  log.call "API : processes, verb : POST, route : monitor, format : #{format}"
   results = Splash::Processes::ProcessScanner::new
   results.analyse
   res = splash_return results.notify
@@ -58,3 +58,15 @@ WebAdminApp.post '/api/process/monitor.?:format?' do
   content_type format
   format_response(res, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
 end
+
+WebAdminApp.get '/api/processes/history/:process.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  log.call "API : processes, verb : GET, route : history, format : #{format}"
+  record = Splash::Processes::ProcessRecords::new(params[:process]).get_all_records
+  history =  splash_return case: :quiet_exit, :more => "Proces monitoring history"
+  history[:data] = record
+  content_type format
+  status 201
+  format_response(history, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end

data/lib/splash/webadmin/api/routes/sequences.rb

@@ -5,7 +5,7 @@
 WebAdminApp.get '/api/sequences/list.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : sequences, verb : GET, route : list, format : #{format}"
+  log.call "API : sequences, verb : GET, route : list, format : #{format}"
   obj =  splash_return case: :quiet_exit, :more => "Sequences list"
   obj[:data] = get_config.sequences
   content_type format
@@ -15,7 +15,7 @@ WebAdminApp.get '/api/sequences/list.?:format?' do
 WebAdminApp.get '/api/sequences/show/:name.?:format?' do
   log = get_logger
   format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
-  log.call "api : sequences, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
+  log.call "API : sequences, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
   sequences_recordset = get_config.sequences[params[:name].to_sym]
   unless sequences_recordset.nil? then
     obj = splash_return case: :quiet_exit

data/lib/splash/webadmin/main.rb

@@ -7,6 +7,9 @@ class WebAdminApp < Sinatra::Base
   include Splash::Exiter
   include Splash::Loggers
   include Splash::Daemon::Controller
+  include Splash::Logs
+  include Splash::Processes
+  include Splash::Transports
 
   set :server, 'thin'
   set :port, get_config.webadmin_port
@@ -19,7 +22,18 @@ class WebAdminApp < Sinatra::Base
     rehash_config
   end
 
-
+  def rehash_daemon
+    status = get_processes({ :pattern => get_config.daemon_process_name}).empty?
+    if status == false then
+      transport = get_default_client
+      unless transport.class == Hash  and transport.include? :case then
+        transport.publish queue: "splash.#{Socket.gethostname}.input",
+                          message: { :verb => :reset,
+                            :return_to => :ignore,
+                            :queue => "splash.#{Socket.gethostname}.input" }.to_yaml
+      end
+    end
+  end
 
 end