prometheus-splash 0.8.3 → 0.8.6

data/lib/splash/config.rb

@@ -13,8 +13,14 @@ module Splash
 
     class ConfigLinter
       def initialize
-        @lints_present = {:logs => [:label, :log, :pattern ]}
-        @lints_types = {:logs => {:label => Symbol, :log => String, :pattern => String, :retention => Hash}}
+        @lints_present = {:logs => [:label, :log, :pattern ],
+                          :processes => [:process, :patterns ],
+                          :commands => [:name, :desc, :command ]}
+        @lints_types = {:logs => {:label => Symbol, :log => String, :pattern => String, :retention => Hash},
+                        :processes  => {:process => Symbol, :patterns => Array, :retention => Hash},
+                        :commands => {:name => Symbol, :desc => String, :command => String, :schedule => Hash,
+                                      :retention => Hash, :on_failure => Symbol, :on_success => Symbol,
+                                      :user => String, :delegate_to => Hash}}
       end
 
       def verify(options ={})
@@ -97,15 +103,16 @@ module Splash
       end
 
 
-      def add_log(options = {})
+      def add_record(options = {})
         @config_from_file = readconf @config_file
+        key = options[:key]
         res = ConfigLinter::new.verify(options)
         if res[:status] == :success then
-          if @config_from_file[:logs].select{|item| item[:label] == options[:record][:label]}.count > 0 then
+          if @config_from_file[options[:type]].select{|item| item[options[:key]] == options[:record][options[:key]]}.count > 0 then
             return {:status => :already_exist}
           else
             res[:useless].each {|item| options[:record].delete item} if options[:clean]
-            @config_from_file[:logs].push options[:record]
+            @config_from_file[options[:type]].push options[:record]
             writeconf
             hash_config_to_default
             return {:status => :success}
@@ -116,12 +123,12 @@ module Splash
       end
 
 
-      def delete_log(options = {})
+      def delete_record(options = {})
         @config_from_file = readconf @config_file
-        unless @config_from_file[:logs].select{|item| item[:label] == options[:label]}.count > 0 then
+        unless @config_from_file[options[:type]].select{|item| item[options[:key]] == options[options[:key]]}.count > 0 then
           return {:status => :not_found}
         else
-          @config_from_file[:logs].delete_if {|value| options[:label] == value[:label] }
+          @config_from_file[options[:type]].delete_if {|value| options[options[:key]] == value[options[:key]] }
           writeconf
           hash_config_to_default
           return {:status => :success}

data/lib/splash/constants.rb

@@ -7,7 +7,7 @@ module Splash
   module Constants
 
     # Current splash version
-    VERSION = "0.8.3"
+    VERSION = "0.8.6"
     # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
     # the default execution trace_path if backend file

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

@@ -66,7 +66,7 @@ module Splash
         # @return [Hash] Exiter case
         def execute_command(content)
           payload = content[:payload]
-          unless get_config.commands.include? payload[:name].to_sym
+          unless get_config.commands.select {|cmd| cmd[:name] == payload[:name].to_sym}.count > 0 then
             @log.item "Command not found", content[:session]
             return { :case => :not_found }
           end

data/lib/splash/daemon/orchestrator.rb

@@ -84,7 +84,7 @@ module Splash
             if VERBS.include? content[:verb]
               @log.receive "Valid remote order, verb : #{content[:verb].to_s}", session
               res = self.send content[:verb], content
-              get_default_client.publish queue: content[:return_to], message: res.to_yaml
+              get_default_client.publish queue: content[:return_to], message: res.to_yaml unless content[:return_to] == :ignore
               @log.send "Result to #{content[:return_to]}.", session
             else
               @log.receive "INVALID remote order, verb : #{content[:verb].to_s}", session
@@ -155,15 +155,14 @@ module Splash
 
         # prepare commands Scheduling
         def init_commands_scheduling
-          config = get_config.commands
-          commands = config.select{|key,value| value.include? :schedule}.keys
+          commands = @config.commands.select{|command| command.include? :schedule}
           commands.each do |command|
-            sched,value = config[command][:schedule].flatten
-            @log.arrow "Scheduling command #{command.to_s}"
+            sched,value = command[:schedule].flatten
+            @log.arrow "Scheduling command #{command[:name].to_s}"
             @server.send sched,value do
               session  = get_session
-              @log.trigger "Executing Scheduled command #{command.to_s} for Scheduling : #{sched.to_s} #{value.to_s}", session
-              execute command: command.to_s, session: session
+              @log.trigger "Executing Scheduled command #{command[:name].to_s} for Scheduling : #{sched.to_s} #{value.to_s}", session
+              execute command: command[:name].to_s, session: session
             end
           end
         end

data/lib/splash/dependencies.rb

@@ -50,6 +50,7 @@ module Splash
 
 
     # Splash
+    require 'splash/monkeys'
     require 'splash/constants'
     require 'splash/helpers'
     require 'splash/config'

data/lib/splash/logs.rb

@@ -48,6 +48,10 @@ module Splash
         @backend = get_backend :logs_trace
       end
 
+      def clear
+        @backend.del({:key => @name}) if  @backend.exist?({key: @name})
+      end
+
       def purge(retention)
         retention = {} if retention.nil?
         if retention.include? :hours then
@@ -132,7 +136,7 @@ module Splash
           logsrec = LogsRecords::new item[:label]
           errors = (item[:count])? item[:count] : 0
           lines = (item[:lines])? item[:lines] : 0
-          missing = (item[:status] = :missing)? 1 : 0
+          missing = (item[:status] == :missing)? 1 : 0
           file = item[:log]
           logsrec.purge(item[:retention])
           logsrec.add_record :status => item[:status],

data/lib/splash/monkeys.rb

@@ -0,0 +1,5 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+end

data/lib/splash/processes.rb

@@ -52,6 +52,10 @@ module Splash
         @backend = get_backend :process_trace
       end
 
+      def clear
+        @backend.del({:key => @name}) if  @backend.exist?({key: @name})
+      end
+
       def purge(retention)
         retention = {} if retention.nil?
         if retention.include? :hours then

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/webadmin/api/routes/commands.rb

@@ -16,7 +16,7 @@ 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]
+  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

@@ -27,35 +27,122 @@ WebAdminApp.post '/api/config/addlog.?:format?' do
   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_log :record => YAML::load(request.body.read), :type => :logs, :clean => true
+  res = get_config.add_record :record => YAML::load(request.body.read), :key => :label, :type => :logs, :clean => true
   case res[:status]
   when :success
-    addlog = splash_return case: :quiet_exit, :more => "add logs"
+    rehash_daemon
+    addlog = splash_return case: :quiet_exit, :more => "add log done"
   when :already_exist
-    addlog = splash_return case: :already_exist, :more => "add logs"
+    addlog = splash_return case: :already_exist, :more => "add log twice nto allowed"
   when :failure
-    addlog = splash_return case: :configuration_error, :more => "add logs"
+    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}"
-  res = get_config.delete_log label: params[:label].to_sym
   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
-    deletelog = splash_return case: :quiet_exit, :more => "delete logs"
+    rehash_daemon
+    deletelog = splash_return case: :quiet_exit, :more => "delete log done"
   when :not_found
-    deletelog = splash_return case: :not_found, :more => "delete logs"
+    deletelog = splash_return case: :not_found, :more => "nothing done for logs"
   else
-    deletelog = splash_return case: :configuration_error, :more => "delete logs"
+    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/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/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
 

data/lib/splash/webadmin/portal/controllers/commands.rb

@@ -1,9 +1,107 @@
-WebAdminApp.get '/commands' do
+WebAdminApp.get '/commands/?:status?/?:command?' do
   get_menu 2
   log = get_logger
   log.call "WEB : commands, verb : GET, controller : /commands"
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/commands/list.yml"
   raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(raw)[:data]
+  @command_failed = params[:command] if params[:status] == 'failure'
+  @command_saved = params[:command] if params[:status] == 'success'
   slim :commands, :format => :html
 end
+
+WebAdminApp.get '/get_command_history/:command' do
+  get_menu 2
+  log = get_logger
+  log.call "WEB : commands, verb : GET, controller : /get_command_history/:command"
+  @data = {}
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/commands/history/#{params[:command].to_s}.yml"
+  raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+  res = YAML::load(raw)
+  @data = res[:data] if res[:status] == :success
+  @command = params[:command].to_s
+  slim :command_history, :format => :html
+end
+
+WebAdminApp.get '/add_modify_command/?:command?' do
+  get_menu 2
+  log = get_logger
+  log.call "WEB : commands, verb : GET, controller : /add_modify_command/?:command?"
+  @data = {}
+  if params[:command] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/commands/show/#{params[:command].to_s}.yml"
+    raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+    res = YAML::load(raw)
+    @data = res[:data] if res[:status] == :success
+    if @data[:retention].class == Hash then
+      prov = @data[:retention].flatten.reverse.join(' ')
+      @data[:retention] = prov
+    end
+    if @data[:schedule].class == Hash then
+      prov = @data[:schedule].flatten.join(' ')
+      @data[:schedule] = prov
+    end
+    if @data[:delegate_to].class == Hash then
+      prov = "#{@data[:delegate_to][:remote_command]}@#{@data[:delegate_to][:host]}"
+      @data[:delegate_to] = prov
+    end
+    @data[:old_command] = params[:command].to_s
+  end
+  slim :command_form, :format => :html
+end
+
+
+WebAdminApp.post '/save_command' do
+  get_menu 2
+  log = get_logger
+  log.call "WEB : commands, verb : POST, controller : /save_command"
+  data = {}
+  unless params[:retention].blank?
+    value, key = params[:retention].split(' ')
+    key = (key.nil?)? :days : key.to_sym
+    value = value.to_i
+    key = :days if key == :day
+    key = :hours if key == :hour
+    if [:hours,:days].include? key then
+      data[:retention] = {key => value}
+    end
+  end
+
+  unless params[:schedule].blank?
+    key, value = params[:schedule].split(' ')
+    key = key.to_sym unless key.nil?
+    value = '' if value.nil?
+    if [:in,:every,:at].include? key and value.match(/\d+[m,d,s,h]/) then
+      data[:schedule] = {key => value }
+    end
+  end
+
+  unless params[:delegate_to].blank?
+    key, value = params[:delegate_to].split('@')
+    unless  key.blank? or value.blank? then
+      data[:delegate_to] = {:remote_command => key.to_sym, :host => value.to_sym }
+    end
+  end
+
+  data[:desc] = params[:desc]
+  data[:command] = params[:command] unless params[:command].blank?
+  data[:on_failure] = params[:on_failure].to_sym unless params[:on_failure].blank?
+  data[:on_success] = params[:on_success].to_sym unless params[:on_success].blank?
+  data[:user] = params[:user] unless params[:user].blank?
+  data[:name] = params[:name].split(' ').first.to_sym
+  puts params.to_yaml
+  puts data.to_yaml
+  redirect "/command/failure/#{params[:name].to_s}" if data[:command].blank? and data[:delegate_to].blank?
+  if params[:update] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/deletecommand/#{params[:old_command]}"
+    raw = RestClient::Request.execute(method: 'DELETE', url: url,timeout: 10)
+  end
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/addcommand.yml"
+  raw = RestClient::Request.execute(method: 'POST', url: url,timeout: 10, payload: data.to_yaml)
+  res = YAML::load(raw)
+  if res[:status] == :success then
+    redirect "/commands/success/#{params[:name].to_s}"
+  else
+    redirect "/commands/failure/#{params[:name].to_s}"
+  end
+end

data/lib/splash/webadmin/portal/controllers/logs.rb

@@ -21,7 +21,7 @@ end
 WebAdminApp.get '/add_modify_log/?:label?' do
   get_menu 0
   log = get_logger
-  log.call "WEB : logs, verb : POST, controller : /add_modify_log/?:label?"
+  log.call "WEB : logs, verb : GET, controller : /add_modify_log/?:label?"
   @data = {}
   if params[:label] then
     url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/show/#{params[:label].to_s}.yml"
@@ -29,19 +29,46 @@ WebAdminApp.get '/add_modify_log/?:label?' do
     res = YAML::load(raw)
     @data = res[:data] if res[:status] == :success
     @data[:old_label] = params[:label].to_s
+    if @data[:retention].class == Hash then
+      prov = @data[:retention].flatten.reverse.join(' ')
+      @data[:retention] = prov
+    end
   end
-  slim :logs_form, :format => :html
+  slim :log_form, :format => :html
 end
 
 
+WebAdminApp.get '/get_log_history/:label' do
+  get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : GET, controller : /get_log_history/:label"
+  @data = {}
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/history/#{params[:label].to_s}.yml"
+  raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
+  res = YAML::load(raw)
+  @data = res[:data] if res[:status] == :success
+  @label = params[:label].to_s
+  slim :log_history, :format => :html
+end
+
 WebAdminApp.post '/save_log' do
   get_menu 0
   log = get_logger
-  log.call "WEB : logs, verb : POST, controller : /save_log/?:label?"
+  log.call "WEB : logs, verb : POST, controller : /save_log "
   data = {}
+  unless params[:retention].blank?
+    value, key = params[:retention].split(' ')
+    key = (key.nil?)? :days : key.to_sym
+    value = value.to_i
+    key = :days if key == :day
+    key = :hours if key == :hour
+    if [:hours,:days].include? key then
+      data[:retention] = {key => value}
+    end
+  end
   data[:log] = params[:log]
   data[:pattern] = params[:pattern]
-  data[:label] = params[:label].to_sym
+  data[:label] = params[:label].split(' ').first.to_sym
   if params[:update] then
     url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/deletelog/#{params[:old_label]}"
     raw = RestClient::Request.execute(method: 'DELETE', url: url,timeout: 10)