prometheus-splash 0.5.0 → 0.7.0

data/lib/splash/templates.rb

@@ -1,12 +1,19 @@
 # coding: utf-8
+
+# base Splash Module
 module Splash
+
+  # Templates namespace
   module Templates
 
     # KISS template Engine
     class Template
 
+      # getter of the list of token
       attr_reader :list_token
+      # getter of the template file
       attr_reader :template_file
+      # getter of the flat content of the template
       attr_reader :content
 
       # constructor : generate the pseudo accessor for template Class from token list
@@ -72,8 +79,11 @@ module Splash
 
     end
 
+    # Exception for an invalid Token list
     class InvalidTokenList < Exception; end
+    # Exception for an malformed token
     class NotAToken < Exception; end
+    # Exception for an invalid template file
     class NoTemplateFile < Exception; end
 
   end

data/lib/splash/transports.rb

@@ -1,9 +1,16 @@
 # coding: utf-8
 
+# base Splash module
 module Splash
+
+  # Splash Transports namespace
   module Transports
     include Splash::Config
 
+
+    # factory for Splash::Transports::Rabbitmq::Subscriber
+    # @param [Hash] options
+    # @return [Splash::Transports::Rabbitmq::Subscriber|Hash] Subscriber or Exiter case :configuration_error
     def get_default_subscriber(options)
       config = get_config.transports
       transport = config[:active]
@@ -20,6 +27,8 @@ module Splash
       end
     end
 
+    # factory for Splash::Transports::Rabbitmq::Client
+    # @return [Splash::Transports::Rabbitmq::Client|Hash] Client or Exiter case :configuration_error
     def get_default_client
       config = get_config.transports
       transport = config[:active]

data/lib/splash/transports/rabbitmq.rb

@@ -1,14 +1,24 @@
 # coding: utf-8
+
+# base Splash module
 module Splash
+
+  # Splash Transports namespace
   module Transports
+
+    # RabbitMQ Transport
     module Rabbitmq
 
+      # Subscriber Mode RabbitMQ Client
       class Subscriber
         include Splash::Config
         extend Forwardable
 
         def_delegators :@queue, :subscribe
 
+        # Constructor Forward subscribe method and initialize a Bunny Client atribute @queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the subscribed queue
         def initialize(options = {})
           @config = get_config.transports
 
@@ -32,12 +42,13 @@ module Splash
 
       end
 
-
+      # publish / get Mode RabbitMQ Client
       class Client
         include Splash::Config
         include Splash::Transports
         include Splash::Loggers
 
+        # Constructor initialize a Bunny Client
         def initialize
           @config = get_config.transports
           host = @config[:rabbitmq][:host]
@@ -48,7 +59,7 @@ module Splash
           conf  = { :host => host, :vhost => vhost, :user => user, :password => passwd, :port => port.to_i}
 
           begin
-            @connection = Bunny.new conf 
+            @connection = Bunny.new conf
             @connection.start
             @channel = @connection.create_channel
           rescue Bunny::Exception
@@ -56,19 +67,32 @@ module Splash
           end
         end
 
-
+        # purge a queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the queue to purge
         def purge(options)
           @channel.queue(options[:queue]).purge
         end
 
+        # publish to a queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the queue to purge
+        # @option options [String] :message the message to send
         def publish(options ={})
           return @channel.default_exchange.publish(options[:message], :routing_key => options[:queue])
         end
 
+        # ack a specific message for manual ack with a delivery tag to a queue
+        # @param [String] ack
+        # @return [Boolean]
         def ack(ack)
           return @channel.acknowledge(ack, false)
         end
 
+
+        # send an execution order message (verb+payload) via RabbitMQ to an slash input queue
+        # @param [Hash] order
+        # @return [Void] unserialized Void object from YAML
         def execute(order)
           queue = order[:return_to]
           lock = Mutex.new
@@ -76,7 +100,6 @@ module Splash
           condition = ConditionVariable.new
           get_default_subscriber(queue: queue).subscribe do |delivery_info, properties, payload|
             res = YAML::load(payload)
-
             lock.synchronize { condition.signal }
           end
           get_logger.send "Verb : #{order[:verb].to_s} to queue : #{order[:queue]}."
@@ -85,6 +108,11 @@ module Splash
           return res
         end
 
+        # Get a message from a RabbitMQ queue
+        # @param [Hash] options
+        # @option options [String] :queue the name of the queue to query
+        # @option options [String] :manual_ack flag to inhibit ack
+        # @return [Hash] Payload + ack tag if :manual_ack
         def get(options ={})
           queue = @channel.queue(options[:queue])
           opt = {}; opt[:manual_ack] = (options[:manual_ack])? true : false
@@ -94,6 +122,7 @@ module Splash
           return res
         end
 
+        # close the RabbitMQ connection
         def close
           @connection.close
         end

data/lib/splash/webadmin.rb

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module WebAdmin
+
+    # Daemon Controller Module
+    module Controller
+      include Splash::Constants
+      include Splash::Helpers
+      include Splash::Config
+      include Splash::Exiter
+      include Splash::Loggers
+
+
+      # Start the Splash Daemon
+      # @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 = {})
+        require 'splash/webadmin/main'
+        config = get_config
+        log = get_logger
+        log.level = :fatal if options[:quiet]
+        realpid = get_processes pattern: get_config.webadmin_process_name
+
+
+        unless File::exist? config.webadmin_full_pid_path then
+          unless realpid.empty? then
+            return {:case => :already_exist, :more => "Splash WebAdmin Process already launched "}
+          end
+
+          daemon_config = {:description => config.webadmin_process_name,
+              :pid_file => config.webadmin_full_pid_path,
+              :stdout_trace => config.webadmin_full_stdout_trace_path,
+              :stderr_trace => config.webadmin_full_stderr_trace_path
+            }
+
+          ["int","term","hup"].each do |type| daemon_config["sig#{type}_handler".to_sym] = Proc::new {  WebAdminApp.quit! } end
+          res = daemonize daemon_config do
+            log = get_logger logger: :web, force: true
+            log.info "Starting Splash WebAdmin"
+            WebAdminApp.run!
+          end
+          sleep 1
+          if res == 0 then
+            pid = `cat #{config.webadmin_full_pid_path}`.to_i
+            log.ok "Splash WebAdmin Started, with PID : #{pid}"
+            return {:case => :quiet_exit, :more => "Splash WebAdmin successfully loaded."}
+          else
+            return {:case => :unknown_error, :more => "Splash WebAdmin loading error, see logs for more details."}
+          end
+
+        else
+          return {:case => :already_exist, :more => "Pid File, please verify if Splash WebAdmin is running."}
+        end
+      end
+
+      # Stop the Splash WebAdmin
+      # @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 = {})
+          config = get_config
+          log = get_logger
+          log.level = :fatal if options[:quiet]
+          if File.exist?(config.webadmin_full_pid_path) then
+            begin
+              pid = `cat #{config.webadmin_full_pid_path}`.to_i
+              Process.kill("TERM", pid)
+              acase = {:case => :quiet_exit, :more => 'Splash WebAdmin stopped succesfully'}
+            rescue Errno::ESRCH
+              acase =  {:case => :not_found, :more => "Process of PID : #{pid} not found"}
+            end
+            FileUtils::rm config.webadmin_full_pid_path if File::exist? config.webadmin_full_pid_path
+          else
+            acase =  {:case => :not_found, :more => "Splash WebAdmin is not running"}
+          end
+          return acase
+      end
+
+      # Status of the Splash WebAdmin, display status
+      # @param [Hash] options ignored
+      # @return [Hash] Exiter Case (:status_ko, :status_ok)
+      def statusdaemon(options = {})
+        log = get_logger
+        config = get_config
+        pid = realpid = ''
+        pid = `cat #{config.webadmin_full_pid_path}`.to_s if File.exist?(config.webadmin_full_pid_path)
+        listpid = get_processes({ :pattern => get_config.webadmin_process_name})
+        pid.chomp!
+        if listpid.empty? then
+          realpid = ''
+        else
+          realpid = listpid.first
+        end
+        unless realpid.empty? then
+          log.item "Splash  WebAdmin Process is running with PID #{realpid} "
+        else
+          log.item 'Splash  WebAdminProcess not found '
+        end
+        unless pid.empty? then
+          log.item "and PID file exist with PID #{pid}"
+        else
+          log.item "and PID file don't exist"
+        end
+        if pid == realpid then
+          return {:case => :status_ok }
+        elsif pid.empty? then
+          return {:case => :status_ko, :more => "PID File error, you have to kill process manualy, with : '(sudo )kill -TERM #{realpid}'"}
+        elsif realpid.empty? then
+          return {:case => :status_ko, :more => "Process Splash WebAdmin missing, run 'splash webadmin stop' before reload properly"}
+        end
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,10 @@
+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}"
+  config = get_config.full
+  obj =  splash_return case: :quiet_exit, :more => "logses list"
+  obj[:data] = config
+  content_type format
+  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+end

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

@@ -0,0 +1,2 @@
+# encoding: UTF-8
+Dir[File.dirname(__FILE__) + '/*.rb'].each {|file| require file  unless File.basename(file) == 'init.rb'}

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

@@ -0,0 +1,59 @@
+
+
+
+
+WebAdminApp.get '/api/logs/list.?:format?' do
+  log = get_logger
+  format = (params[:format])? format_by_extensions(params[:format]) : format_by_extensions('json')
+  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
+  content_type format
+  format_response(obj, (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}"
+  logs_recordset = get_config.logs.select{|item| item[:label] == params[:name].to_sym }
+  unless logs_recordset.empty? then
+    record = logs_recordset.first
+    obj = splash_return case: :quiet_exit
+    obj[:data] = record
+  else
+    obj = splash_return case: :not_found, :more => "logs not configured"
+  end
+  format_response(obj, (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}"
+  results = Splash::Logs::LogScanner::new
+  results.analyse
+  res = results.output
+  obj =  splash_return case: :quiet_exit, :more => "logs analyse report"
+  obj[:data] = res
+  status 201
+  content_type format
+  format_response(obj, (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}"
+  results = Splash::Logs::LogScanner::new
+  results.analyse
+  res = splash_return results.notify
+  if res[: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)
+end

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

@@ -0,0 +1,60 @@
+
+
+
+
+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}"
+  process_recordset = get_config.processes
+  obj =  splash_return case: :quiet_exit, :more => "Processes list"
+  obj[:data] = process_recordset
+  content_type format
+  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+  end
+
+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}"
+  process_recordset = get_config.processes.select{|item| item[:process] == params[:name] }
+  unless process_recordset.empty? then
+    record = process_recordset.first
+    obj = splash_return case: :quiet_exit
+    obj[:data] = record
+  else
+    obj = splash_return case: :not_found, :more => "Process not configured"
+  end
+  content_type format
+  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+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}"
+  results = Splash::Processes::ProcessScanner::new
+  results.analyse
+  res = results.output
+  obj =  splash_return case: :quiet_exit, :more => "Process analyse report"
+  obj[:data] = res
+  status 201
+  content_type format
+  format_response(obj, (params[:format])? format_by_extensions(params[:format]): request.accept.first)
+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}"
+  results = Splash::Processes::ProcessScanner::new
+  results.analyse
+  res = splash_return results.notify
+  if res[: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)
+end