salus 0.1.2

data/lib/salus/cli.rb

@@ -0,0 +1,53 @@
+require "thor"
+require "yaml"
+require "salus/cli/baseutils"
+require "salus/cli/zabbix"
+
+module Salus
+  class CLI < Thor
+    include BaseCliUtils
+    include Thor::Actions
+
+    register Salus::ZabbixCli, :zabbix, "zabbix", "Zabbix specific actions"
+
+    desc "once", "Run check once"
+    method_option :file,  aliases: "-f", :type => :array,  desc: "File(s) with metrics' definition"
+    method_option :state, aliases: "-s", :type => :string, desc: "State file location"
+    method_option :debug, aliases: "-d", :type => :boolean, :default => false
+    method_option :renderer, aliases: "-r", :type => :array, desc: "Append predefined renderers"
+    def once
+      Salus.logger.level = options[:debug] ? Logger::DEBUG : Logger::WARN
+      load_files(get_files(options))
+      state_file = get_state_file(options)
+      load_state(state_file)
+      append_renderers(options)
+      Salus.tick
+      save_state(state_file)
+    end
+
+    desc "loop", "Run check loop"
+    method_option :file,  aliases: "-f", :type => :array,  desc: "File(s) with metrics' definition"
+    method_option :debug, aliases: "-d", :type => :boolean, :default => false
+    method_option :renderer, aliases: "-r", :type => :array, desc: "Append predefined renderers"
+    def loop
+      Salus.logger.level = options[:debug] ? Logger::DEBUG : Logger::WARN
+      load_files(get_files(options))
+      append_renderers(options)
+      Salus.run
+    end
+
+    default_task :once
+
+    private
+    def append_renderers(options={})
+      renderers = options.fetch(:renderer, Salus.renders.empty? ? ["stdout"] : [])
+
+      BaseRenderer.descendants.each do |m|
+        sym = m.name.split('::').last.downcase.sub(/renderer$/, '')
+        if renderers.include?(sym)
+          Salus.render(m.new)
+        end
+      end
+    end
+  end
+end

data/lib/salus/cli/baseutils.rb

@@ -0,0 +1,92 @@
+module Salus
+  module BaseCliUtils
+    include Logging
+    SALUS_STATE_FILE = "salus.state.yml"
+    SALUS_FILE = "Salusfile"
+    SALUS_GLOB = "*.salus"
+
+    def read_file(file)
+      ret = nil
+      File.open(file, "r") do |f|
+        f.flock(File::LOCK_SH)
+        ret = f.read
+        f.flock(File::LOCK_UN)
+      end
+      ret
+    end
+
+    def write_file(file, data)
+      ret = nil
+      File.open(file, File::RDWR|File::CREAT) do |f|
+        f.flock(File::LOCK_EX)
+        begin
+          f.rewind
+          ret = f.write(data)
+          f.flush
+          f.truncate(f.pos)
+        ensure
+          f.flock(File::LOCK_UN)
+        end
+      end
+      ret
+    end
+
+    def load_files(files)
+      raise "No metric definition files found" if files.empty?
+      files.each do |file|
+        begin
+          Salus.load(file)
+        rescue Exception => e
+          log ERROR, "Failed to load #{file}: " + e.message
+        end
+      end
+    end
+
+    def load_state(file)
+      return unless file
+      Salus.load_state do
+        begin
+          YAML.load(read_file(file)) if File.exists?(file)
+        rescue Exception => e
+          log ERROR, "Failed to load state #{file}: " + e.message
+        end
+      end
+    end
+
+    def save_state(file)
+      return unless file
+      Salus.save_state do |data|
+        begin
+          write_file(file, data.to_yaml)
+        rescue Exception => e
+          log ERROR, "Failed to save state #{file}: " + e.message
+        end
+      end
+    end
+
+    def get_state_file(options={})
+      options.fetch(:state,
+        Salus.var(:state_file,
+          File.join(Dir.pwd, SALUS_STATE_FILE)))
+    end
+
+    def get_files(options={})
+      if options.key?(:file)
+        ret = []
+        options[:file].each do |file|
+          next unless File.exists?(file)
+          if File.directory?(file)
+            ret += Dir.glob(File.join(file, SALUS_GLOB)).sort
+          else
+            ret.push(file)
+          end
+        end
+        ret
+      elsif File.exists?(SALUS_FILE)
+        [SALUS_FILE]
+      else
+        Dir.glob(SALUS_GLOB).sort
+      end
+    end
+  end
+end

data/lib/salus/cli/zabbix.rb

@@ -0,0 +1,150 @@
+require "salus/zabbix"
+
+module Salus
+  class ZabbixCacheRenderer < BaseRenderer
+    ZABBIX_DEFAULT_TTL = 60
+    attr_reader :data
+
+    def render(data)
+      @data = {}
+      iterate(data) do |name, metric|
+        name  = name.gsub(/\.\[/, '[')
+        value = metric.value
+        # Metric cache TTL is a half of real metric TTL
+        ttl   = metric.ttl.nil? ? ZABBIX_DEFAULT_TTL : (metric.ttl / 2)
+        @data[name] = {timestamp: metric.timestamp, cache_ttl: ttl, value: value}
+      end
+    end
+  end
+
+  class ZabbixCli < Thor
+    include BaseCliUtils
+    include Thor::Actions
+    ZABBIX_CACHE_FILE  = "zabbix.cache.yml"
+
+    desc "discover NAME", "Run discovery"
+    method_option :file,  aliases: "-f", :type => :array, desc: "File(s) with metrics' definition"
+    method_option :debug, aliases: "-d", :type => :boolean, :default => false
+    def discover(name)
+      Salus.logger.level = options[:debug] ? Logger::DEBUG : Logger::WARN
+      load_files(get_files(options))
+      puts Salus.discovery(name)
+    end
+
+    desc "parameter NAME", "Get a requested parameter"
+    method_option :file,  aliases: "-f", :type => :array,  desc: "File(s) with metrics' definition"
+    method_option :state, aliases: "-s", :type => :string, desc: "State file location"
+    method_option :cache, aliases: "-c", :type => :string, desc: "Cache file location"
+    method_option :cache_ttl, aliases: "-t", :type => :numeric, desc: "Force metric cache ttl"
+    method_option :debug, aliases: "-d", :type => :boolean, :default => false
+    def parameter(name)
+      Salus.logger.level = options[:debug] ? Logger::DEBUG : Logger::WARN
+      load_files(get_files(options))
+
+      cache_file = options.fetch(:cache,
+        Salus.vars.fetch(:zabbix_cache_file,
+          File.join(Dir.pwd, ZABBIX_CACHE_FILE)))
+      cache  = load_cache(cache_file)
+
+      if (cache.key?(name) && !expired?(cache[name], options))
+        STDOUT.puts cache[name][:value] unless cache[name][:value].nil?
+        return
+      end
+
+      state_file = get_state_file(options)
+      load_state(state_file)
+
+      render = ZabbixCacheRenderer.new
+      Salus.renders.clear
+      Salus.render(render)
+      Salus.tick
+      cache  = render.data
+
+      if (cache.key?(name))
+        STDOUT.puts cache[name][:value] unless cache[name][:value].nil?
+      end
+
+      save_state(state_file)
+      save_cache(cache_file, cache)
+      raise "Unknown parameter #{name}" unless cache.key?(name)
+    end
+
+    desc "bulk GROUP", "Get a bunch of parameters under the GROUP group"
+    method_option :file,  aliases: "-f", :type => :array,  desc: "File(s) with metrics' definition"
+    method_option :state, aliases: "-s", :type => :string, desc: "State file location"
+    method_option :debug, aliases: "-d", :type => :boolean, :default => false
+    def bulk(group=nil)
+      Salus.logger.level = options[:debug] ? Logger::DEBUG : Logger::WARN
+      load_files(get_files(options))
+
+      cache_file = options.fetch(:cache,
+        Salus.var(:zabbix_cache_file,
+          File.join(Dir.pwd, ZABBIX_CACHE_FILE)))
+      cache  = load_cache(cache_file)
+
+      re = group.nil? ? // : /^#{Regexp.escape(group)}\./
+      keys = cache.keys.grep(re)
+      if !keys.empty? && (keys.reduce(true) { |x, v| x &= !expired?(cache[v], options) })
+        result = {}
+        keys.each do |key|
+          name = key.sub(re, '')
+          name = name.gsub(/\.\[/, '[')
+
+          parts = name.split(/\./)
+          node  = result
+          parts[0...-1].each do |part|
+            node[part] = {} unless node.key?(part)
+            node = node[part]
+          end
+          node[parts.last] = cache[key][:value]
+        end
+        STDOUT.puts result.to_json
+        return
+      end
+
+      state_file = get_state_file(options)
+      load_state(state_file)
+
+      Salus.renders.clear
+      Salus.render(ZabbixBulkRenderer.new(group: group))
+      render = ZabbixCacheRenderer.new
+      Salus.render(render)
+      Salus.tick
+      cache  = render.data
+
+      save_state(state_file)
+      save_cache(cache_file, cache)
+    end
+
+    private
+    def expired?(metric, options={})
+      return true if metric.nil?
+      ttl = options.fetch(:cache_ttl, metric[:cache_ttl])
+      ttl ||= 0
+      (Time.now.to_f > metric[:timestamp] + ttl)
+    end
+
+    def load_cache(file)
+      return {} unless file
+      begin
+        if File.exists?(file)
+          YAML.load(read_file(file))
+        else
+          {}
+        end
+      rescue Exception => e
+        log ERROR, "Failed to load state #{file}: " + e.message
+        {}
+      end
+    end
+
+    def save_cache(file, data)
+      return unless file
+      begin
+        write_file(file, data.to_yaml)
+      rescue Exception => e
+        log ERROR, "Failed to save state #{file}: " + e.message
+      end
+    end
+  end
+end

data/lib/salus/configuration.rb

@@ -0,0 +1,38 @@
+module Salus
+  module Configuration
+    # An array of valid keys in the options hash when configuring Salus.
+    VALID_OPTIONS_KEYS = %i(min_threads max_threads interval tick_timeout render_timeout logger).freeze
+
+    # @private
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    # Sets all configuration options to their default values
+    # when this module is extended.
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block.
+    def configure
+      yield self
+    end
+
+    # Creates a hash of options and their values.
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # Resets all configuration options to the defaults.
+    def reset
+      self.min_threads = CPU.count / 2
+      self.min_threads = 1 if self.min_threads == 0
+      self.max_threads = CPU.count * 2
+      self.interval = 30
+      self.tick_timeout   = 15
+      self.render_timeout = 10
+      self.logger   = Logger.new(STDERR)
+    end
+  end
+end

data/lib/salus/group.rb

@@ -0,0 +1,159 @@
+require "forwardable"
+require "salus/metric"
+require "salus/metric/absolute"
+require "salus/metric/counter"
+require "salus/metric/derive"
+require "salus/metric/gauge"
+require "salus/metric/text"
+
+module Salus
+  class Group
+    extend Forwardable
+    include Lockable
+
+    def_delegators :@_metrics, :[], :key?, :values_at, :fetch, :length, :delete, :empty?
+
+    def initialize(defaults={}, &block)
+      @_metrics = {}
+      @_groups  = {}
+      @_cache   = {}
+      @_proc    = block
+      @_opts    = defaults.clone
+    end
+
+    Metric.descendants.each do |m|
+      sym = m.name.split('::').last.downcase.to_sym
+      define_method(sym) do |title, args={}, &blk|
+        raise ArgumentError, "Metric needs a name!" if title.nil? or !title.is_a?(String)
+
+        unless @_metrics.key?(title)
+          @_metrics[title] = m.new(@_opts)
+        end
+
+        @_metrics[title].push(args, &blk)
+      end
+    end
+
+    def on_win?
+      Salus.on_win?
+    end
+
+    def var(arg, default=nil, &block)
+      Salus.var(arg, default, &block)
+    end
+
+    def default(opts)
+      return unless opts.is_a?(Hash)
+      opts.each do |k, v|
+        next if [:value, :timestamp].include?(k)
+        @_opts[k] = v
+      end
+    end
+
+    def group(title, &block)
+      synchronize do
+        unless @_groups.key?(title)
+          @_groups[title] = Group.new(@_opts, &block)
+          if @_cache.key?(title)
+            @_groups[title].load(@_cache[title])
+            @_cache.delete(title)
+          end
+        end
+      end
+    end
+
+    def groups
+      synchronize { @_groups }
+    end
+
+    def has_subgroups?
+      synchronize { !@_groups.empty? }
+    end
+
+    def value(title)
+      synchronize { @_metrics.key?(title) ? @_metrics[title].value : nil }
+    end
+
+    def keys(allow_mute=false)
+      synchronize do
+        if allow_mute
+          @_metrics.keys
+        else
+          @_metrics.keys.select { |x| !@_metrics[x].mute? }
+        end
+      end
+    end
+
+    def values(allow_mute=false)
+      synchronize do
+        if allow_mute
+          @_metrics.values
+        else
+          @_metrics.values.select { |x| !x.mute? }
+        end
+      end
+    end
+
+    def each(allow_mute=false, &block)
+      synchronize do
+        if allow_mute
+          @_metrics.each(&block)
+        else
+          @_metrics.select { |k, v| !v.mute? }.each(&block)
+        end
+      end
+    end
+
+    def load(data)
+      return unless data
+      return if data.empty?
+      synchronize do
+        if data.key?(:defaults)
+          @_opts = data[:defaults].clone
+        end
+        if data.key?(:metrics)
+          types = Metric.descendants.map{ |x| x.name.split("::").last }
+          data[:metrics].each do |k, v|
+            next unless v.key?(:type)
+            next unless types.include?(v[:type])
+            @_metrics[k] = Object.const_get("Salus::" + v[:type]).new(@_opts)
+            @_metrics[k].load(v)
+          end
+        end
+        if data.key?(:groups)
+          @_cache = data[:groups]
+        end
+      end
+    end
+
+    def save
+      to_h
+    end
+
+    def to_h
+      ret = {}
+      synchronize do
+        unless @_metrics.empty?
+          ret[:metrics] = {}
+          @_metrics.each { |k, v| ret[:metrics][k] = v.to_h }
+        end
+        unless @_groups.empty?
+          ret[:groups]  = {}
+          @_groups.each  { |k, v| ret[:groups][k]  = v.to_h }
+        end
+        unless @_opts.empty?
+          ret[:defaults] = @_opts
+        end
+        ret
+      end
+    end
+
+    def tick
+      instance_eval(&@_proc)
+      @_groups.each do |k, v|
+        v.tick
+      end
+      @_cache.clear unless @_cache.empty?
+    end
+  end
+end