prometheus-splash 0.6.1 → 0.8.3

data/lib/splash/webadmin.rb

@@ -21,7 +21,7 @@ module Splash
       # @param [Hash] options
       # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
       # @return [Hash] Exiter Case (:quiet_exit, :already_exist, :unknown_error or other)
-      def startdaemon(options = {})
+      def startweb(options = {})
         require 'splash/webadmin/main'
         config = get_config
         log = get_logger
@@ -64,7 +64,7 @@ module Splash
       # @param [Hash] options
       # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
       # @return [Hash] Exiter Case (:quiet_exit, :not_found, other)
-      def stopdaemon(options = {})
+      def stopweb(options = {})
           config = get_config
           log = get_logger
           log.level = :fatal if options[:quiet]
@@ -86,7 +86,7 @@ module Splash
       # Status of the Splash WebAdmin, display status
       # @param [Hash] options ignored
       # @return [Hash] Exiter Case (:status_ko, :status_ok)
-      def statusdaemon(options = {})
+      def statusweb(options = {})
         log = get_logger
         config = get_config
         pid = realpid = ''

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,7 +15,7 @@ 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}"
+  log.call "API : commands, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
   commands_recordset = get_config.commands[params[:name].to_sym]
   unless commands_recordset.nil? then
     obj = splash_return case: :quiet_exit

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

@@ -1,10 +1,61 @@
 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_log :record => YAML::load(request.body.read), :type => :logs, :clean => true
+  case res[:status]
+  when :success
+    addlog = splash_return case: :quiet_exit, :more => "add logs"
+  when :already_exist
+    addlog = splash_return case: :already_exist, :more => "add logs"
+  when :failure
+    addlog = splash_return case: :configuration_error, :more => "add logs"
+    addlog[:data] = res
+  end
+  content_type format
+  format_response(addlog, (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 = {}
+  case res[:status]
+  when :success
+    deletelog = splash_return case: :quiet_exit, :more => "delete logs"
+  when :not_found
+    deletelog = splash_return case: :not_found, :more => "delete logs"
+  else
+    deletelog = splash_return case: :configuration_error, :more => "delete logs"
+  end
+  content_type format
+  format_response(deletelog, (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

@@ -5,7 +5,7 @@
 WebAdminApp.get '/api/process/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 : process, verb : GET, route : list, format : #{format}"
   process_recordset = get_config.processes
   obj =  splash_return case: :quiet_exit, :more => "Processes list"
   obj[:data] = process_recordset
@@ -16,7 +16,7 @@ WebAdminApp.get '/api/process/list.?:format?' do
 WebAdminApp.get '/api/process/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}"
+  log.call "API : process, verb : GET, route : show, item : #{params[:name]} , format : #{format}"
   process_recordset = get_config.processes.select{|item| item[:process] == params[:name] }
   unless process_recordset.empty? then
     record = process_recordset.first
@@ -32,7 +32,7 @@ end
 WebAdminApp.post '/api/process/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 : process, verb : POST, route : analyse, format : #{format}"
   results = Splash::Processes::ProcessScanner::new
   results.analyse
   res = results.output
@@ -46,7 +46,7 @@ end
 WebAdminApp.post '/api/process/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 : process, verb : POST, route : monitor, format : #{format}"
   results = Splash::Processes::ProcessScanner::new
   results.analyse
   res = splash_return results.notify

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

@@ -0,0 +1,28 @@
+
+
+
+
+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}"
+  obj =  splash_return case: :quiet_exit, :more => "Sequences list"
+  obj[:data] = get_config.sequences
+  content_type format
+  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  end
+
+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}"
+  sequences_recordset = get_config.sequences[params[:name].to_sym]
+  unless sequences_recordset.nil? then
+    obj = splash_return case: :quiet_exit
+    obj[:data] = sequences_recordset
+  else
+    obj = splash_return case: :not_found, :more => "Sequence not configured"
+  end
+  content_type format
+  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end

data/lib/splash/webadmin/main.rb

@@ -6,6 +6,7 @@ class WebAdminApp < Sinatra::Base
   include Splash::Helpers
   include Splash::Exiter
   include Splash::Loggers
+  include Splash::Daemon::Controller
 
   set :server, 'thin'
   set :port, get_config.webadmin_port

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

@@ -1,5 +1,7 @@
 WebAdminApp.get '/commands' 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]

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

@@ -1,5 +1,7 @@
 WebAdminApp.get '/documentation' do
-  get_menu 5
+  get_menu 6
+  log = get_logger
+  log.call "WEB : documentation, verb : GET, controller : /documentation"
     filename = search_file_in_gem("prometheus-splash","README.md")
     @data = Kramdown::Document.new(File::readlines(filename).join).to_html
     slim :documentation, :format => :html

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

@@ -1,12 +1,36 @@
 WebAdminApp.get '/' do
+  log = get_logger
+  log.call "WEB : BASE, verb : GET, controller : /"
   get_menu -1
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/full.yml"
   @raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(@raw)[:data]
+  @status = get_processes({ :pattern => get_config.daemon_process_name}).empty?
   slim :home, :format => :html
 end
 
 WebAdminApp.get '/home' do
   get_menu 0
+  log = get_logger
+  log.call "WEB : home, verb : GET, controller : /home"
   slim :home, :format => :html
 end
+
+WebAdminApp.get '/daemon/:action' do
+  content_type :text
+  log = get_logger
+  log.call "WEB : daemon, verb : GET, controller : /daemon/:action"
+  case params[:action]
+  when 'start'
+    startdaemon scheduling: true, purge: false
+    return 'start'
+  when 'stop'
+    stopdaemon
+    return 'stop'
+  when 'restart'
+    stopdaemon
+    startdaemon scheduling: true, purge: false
+    return 'start'
+  else
+  end
+end

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

@@ -1,5 +1,7 @@
-WebAdminApp.get '/logs' do
+WebAdminApp.get '/logs/?:status?/?:label?' do
   get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : GET, controller : /logs/?:status?/?:label?"
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/list.yml"
   raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(raw)[:data]
@@ -7,8 +9,49 @@ WebAdminApp.get '/logs' do
   raw = RestClient::Request.execute(method: 'POST', url: url,timeout: 10)
   prov = YAML::load(raw)[:data]
   @result = {}
+  @log_failed = params[:label] if params[:status] == 'failure'
+  @log_saved = params[:label] if params[:status] == 'success'
   prov.each {|item|
     @result[item[:label]] = item
   }
   slim :logs, :format => :html
 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?"
+  @data = {}
+  if params[:label] then
+    url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/logs/show/#{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
+    @data[:old_label] = params[:label].to_s
+  end
+  slim :logs_form, :format => :html
+end
+
+
+WebAdminApp.post '/save_log' do
+  get_menu 0
+  log = get_logger
+  log.call "WEB : logs, verb : POST, controller : /save_log/?:label?"
+  data = {}
+  data[:log] = params[:log]
+  data[:pattern] = params[:pattern]
+  data[:label] = params[:label].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)
+  end
+  url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/config/addlog.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 "/logs/success/#{params[:label].to_s}"
+  else
+    redirect "/logs/failure/#{params[:label].to_s}"
+  end
+end

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

@@ -1,5 +1,7 @@
 WebAdminApp.get '/processes' do
   get_menu 1
+  log = get_logger
+  log.call "WEB : processes, verb : GET, controller : /processes"
   url = "http://#{get_config.webadmin_ip}:#{get_config.webadmin_port}/api/process/list.yml"
   raw = RestClient::Request.execute(method: 'GET', url: url,timeout: 10)
   @data = YAML::load(raw)[:data]

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

@@ -1,27 +1,36 @@
 
 
 WebAdminApp.use Rack::ReverseProxy do
-  reverse_proxy /^\/pushgateway\/?(.*)$/, get_config.prometheus_pushgateway_url
+  reverse_proxy /^\/pushgateway\/?(.*)$/, get_config.prometheus_pushgateway_url + '/'
   reverse_proxy_options preserve_host: true
 end
 
 
 WebAdminApp.use Rack::ReverseProxy do
-  reverse_proxy /^\/prometheus\/?(.*)$/, get_config.prometheus_url
+  reverse_proxy /^\/prometheus\/?(.*)$/, get_config.prometheus_url + '/'
   reverse_proxy_options preserve_host: true
 end
 
-WebAdminApp.get '/proxy/links' do
-  get_menu 4
 
+WebAdminApp.use Rack::ReverseProxy do
+  reverse_proxy /^\/alertmanager\/?(.*)$/, get_config.prometheus_alertmanager_url + '/'
+  reverse_proxy_options preserve_host: true
+end
+
+WebAdminApp.get '/proxy/links' do
+  get_menu 5
+  log = get_logger
+  log.call "WEB : proxy, verb : GET, controller : /proxy/links"
   config = get_config
   if config.webadmin_proxy == true then
     @proxy = true
     @pushgateway_url = "http://#{config.webadmin_ip}:#{config.webadmin_port}/pushgateway"
     @prometheus_url = "http://#{config.webadmin_ip}:#{config.webadmin_port}/prometheus"
+    @alertmanager_url = "http://#{config.webadmin_ip}:#{config.webadmin_port}/prometheus"
   else
     @proxy = false
     @pushgateway_url = "#{config.prometheus_pushgateway_url}"
+    @alertmanager_url = "#{config.prometheus_alertmanager_url}"
     @prometheus_url = "#{config.prometheus_url}"
   end
   slim :proxy, :format => :html

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

@@ -1,14 +1,19 @@
 WebAdminApp.get '/restclient' do
-  get_menu 3
+  log = get_logger
+  log.call "WEB : restclient, verb : GET, controller : /restclient"
+  get_menu 4
   slim :restclient,  :format => :html
 end
 
 WebAdminApp.post '/restclient/query' do
+  log = get_logger
+  log.call "WEB : processes, verb : GET, controller : /restclient/query"
   @method = params[:method]
   @url = params[:url]
+  @body = params[:body]
   @notfound = false
   begin
-    @result = RestClient::Request.execute(method: @method.to_sym, url: @url,timeout: 10)
+    @result = RestClient::Request.execute(method: @method.to_sym, url: @url,timeout: 10, payload: @body)
   rescue SocketError
     @result = false
   rescue RestClient::NotFound => e