salus 0.1.2

data/lib/salus/renderer/zabbixbulk.rb

@@ -0,0 +1,30 @@
+module Salus
+  class ZabbixBulkRenderer < BaseRenderer
+    def initialize(opts={})
+      super(opts)
+      @group = opts.fetch(:group, nil)
+    end
+
+    def render(data)
+      # Zabbix 3.4+ with preprocessor
+      result = {}
+      re = @group.nil? ? // : /^#{Regexp.escape(@group)}\./
+      iterate(data) do |name, metric|
+        next unless name.match(re)
+        name  = name.sub(re, '')
+        name  = name.gsub(/\.\[/, '[')
+
+        unless metric.timestamp.nil?
+          parts = name.split(/\./)
+          node  = result
+          parts[0...-1].each do |part|
+            node[part] = {} unless node.key?(part)
+            node = node[part]
+          end
+          node[parts.last] = metric.value
+        end
+      end
+      STDOUT.puts result.to_json
+    end
+  end
+end

data/lib/salus/renderer/zabbixsender.rb

@@ -0,0 +1,24 @@
+module Salus
+  class ZabbixSenderRenderer < BaseRenderer
+    def render(data)
+      # Top level groups are considered hostnames
+      result = {}
+      data.each do |hostname, group|
+        iterate(group) do |name, metric|
+          unless metric.timestamp.nil?
+            timestamp = metric.timestamp.to_i
+            name  = name.gsub(/\.\[/, '[')
+            value = metric.value
+            value = '""' if value.nil?
+            value = value.to_json if (!value.nil? && metric.is_a?(Salus::Text))
+
+            result[timestamp] = [] unless result.key?(timestamp)
+            result[timestamp] << "#{hostname.dump} #{name} #{timestamp} #{value}"
+          end
+        end
+      end
+      # Zabbix requires timestamps to be sorted
+      result.keys.sort.each { |k| STDOUT.puts result[k] }
+    end
+  end
+end

data/lib/salus/thread.rb

@@ -0,0 +1,8 @@
+require "thread"
+require "salus/thread/cpu"
+require "salus/thread/monotonictime"
+require "salus/thread/lockable"
+require "salus/thread/observable"
+require "salus/thread/pool"
+require "salus/thread/future"
+require "salus/thread/latch"

data/lib/salus/thread/cpu.rb

@@ -0,0 +1,18 @@
+module Salus
+  class CPU
+    def self.count
+      @count ||= self.get_count
+    end
+
+    private
+    def self.get_count
+      return Java::Java.lang.Runtime.getRuntime.availableProcessors if RUBY_PLATFORM == "java"
+      return File.read('/proc/cpuinfo').scan(/^processor\s*:/).size if File.exist?('/proc/cpuinfo')
+      require 'win32ole'
+      WIN32OLE.connect("winmgmts://").ExecQuery("select NumberOfLogicalProcessors from Win32_Processor")
+        .to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
+    rescue LoadError
+      Integer `sysctl -n hw.ncpu 2>/dev/null` rescue 1
+    end
+  end
+end

data/lib/salus/thread/future.rb

@@ -0,0 +1,168 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+# borrowed from https://github.com/meh/ruby-thread
+require 'weakref'
+
+# A future is an object that incapsulates a block which is called in a
+# different thread, upon retrieval the caller gets blocked until the block has
+# finished running, and its result is returned and cached.
+module Salus
+  class Future
+    include Observable
+    include Logging
+    Cancel = Class.new(Exception)
+
+    # Create a future with the passed block and optionally using the passed pool.
+    def initialize(pool = nil, &block)
+      raise ArgumentError, 'no block given' unless block
+
+      @mutex = Mutex.new
+
+      task = proc {
+        begin
+          deliver block.call
+          notify_and_delete_observers(Time.now, @value, nil)
+        rescue Exception => e
+          @exception = e
+          notify_and_delete_observers(Time.now, nil, e)
+          log DEBUG, @exception
+          deliver nil
+        end
+      }
+
+      @thread = pool ? pool.process(&task) : Thread.new(&task)
+
+      ObjectSpace.define_finalizer self, self.class.finalizer(WeakRef.new(@thread))
+    end
+
+    # @private
+    def self.finalizer(thread)
+      proc {
+        if thread.weakref_alive?
+          if thread.is_a? Thread
+            thread.raise Cancel
+          else
+            thread.terminate! Cancel
+          end
+        end
+      }
+    end
+
+    # Check if an exception has been raised.
+    def exception?
+      @mutex.synchronize {
+        instance_variable_defined? :@exception
+      }
+    end
+
+    # Return the raised exception.
+    def exception
+      @mutex.synchronize {
+        @exception
+      }
+    end
+
+    # Check if the future has been called.
+    def delivered?
+      @mutex.synchronize {
+        instance_variable_defined? :@value
+      }
+    end
+
+    alias realized? delivered?
+
+    # Cancel the future, {#value} will yield a Cancel exception
+    def cancel
+      return self if delivered?
+
+      @mutex.synchronize {
+        if @thread.is_a? Thread
+          @thread.raise Cancel
+        else
+          @thread.terminate! Cancel
+        end
+
+        @exception = Cancel.new
+      }
+
+      self
+    end
+
+    # Check if the future has been cancelled
+    def cancelled?
+      @mutex.synchronize {
+        @exception.is_a? Cancel
+      }
+    end
+
+    # Get the value of the future, if it's not finished running this call will block.
+    #
+    # In case the block raises an exception, it will be raised, the exception is cached
+    # and will be raised every time you access the value.
+    #
+    # An optional timeout can be passed which will return nil if nothing has been
+    # delivered.
+    def value(timeout = nil)
+      raise @exception if exception?
+
+      return @value if delivered?
+
+      @mutex.synchronize {
+        cond.wait(@mutex, *timeout)
+      }
+
+      if exception?
+        raise @exception
+      elsif delivered?
+        return @value
+      end
+    end
+
+    alias ~ value
+
+    # Do the same as {#value}, but return nil in case of exception.
+    def value!(timeout = nil)
+      begin
+        value(timeout)
+      rescue Exception
+        nil
+      end
+    end
+
+    alias ! value!
+
+  private
+    def cond?
+      instance_variable_defined? :@cond
+    end
+
+    def cond
+      @cond ||= ConditionVariable.new
+    end
+
+    def deliver (value)
+      return if delivered?
+
+      @mutex.synchronize {
+        @value = value
+
+        cond.broadcast if cond?
+      }
+
+      self
+    end
+  end
+
+  class ThreadPool
+    def future(&block)
+      Future.new(self, &block)
+    end
+  end
+end

data/lib/salus/thread/latch.rb

@@ -0,0 +1,28 @@
+module Salus
+  # Based on code from https://github.com/ruby-concurrency/concurrent-ruby/
+  class CountDownLatch
+    include Lockable
+
+    def initialize(to=1)
+      synchronize { @count = to.to_i }
+      raise ArgumentError, "cannot count down from negative integer" unless @count >= 0
+    end
+
+    def count_down
+      synchronize do
+        @count -= 1 if @count >  0
+        broadcast   if @count == 0
+      end
+    end
+
+    def count
+      synchronize { @count }
+    end
+
+    def wait(timeout=nil)
+      synchronize do
+        wait_until(timeout) { @count == 0 }
+      end
+    end
+  end
+end

data/lib/salus/thread/lockable.rb

@@ -0,0 +1,56 @@
+module Salus
+  # Based on code from https://github.com/ruby-concurrency/concurrent-ruby/
+  module Lockable
+    def synchronize
+      if __lock.owned?
+        yield
+      else
+        __lock.synchronize { yield }
+      end
+    end
+
+    def signal
+      __condition.signal
+      self
+    end
+
+    def broadcast
+      __condition.broadcast
+      self
+    end
+
+    def wait_until(timeout=nil, &condition)
+      if timeout
+        wait_until = MonotonicTime.get + timeout
+        loop do
+          now = MonotonicTime.get
+          res = condition.call
+          return res if now >= wait_until || res
+          __wait(wait_until - now)
+        end
+      else
+        __wait(timeout) until condition.call
+        true
+      end
+    end
+
+    def wait(timeout=nil)
+      __wait(timeout)
+    end
+
+    protected
+    def __lock
+      @__lock__ ||= ::Mutex.new
+      @__lock__
+    end
+
+    def __condition
+      @__condition__ ||= ::ConditionVariable.new
+      @__condition__
+    end
+
+    def __wait(timeout=nil)
+      __condition.wait __lock, timeout
+    end
+  end
+end

data/lib/salus/thread/monotonictime.rb

@@ -0,0 +1,15 @@
+module Salus
+  # Monotonic time if possible
+  class MonotonicTime
+    # Get monotonic time
+    if defined?(Process::CLOCK_MONOTONIC)
+      def self.get
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    else
+      def self.get
+        Time.now.to_f
+      end
+    end
+  end
+end

data/lib/salus/thread/observable.rb

@@ -0,0 +1,117 @@
+module Salus
+  # Loosely based on code from https://github.com/ruby-concurrency/concurrent-ruby/
+  class ObserversSet
+    include Lockable
+
+    def initialize
+      synchronize { @observers = {} }
+    end
+
+    def add(observer=nil, func=:update, &block)
+      if observer.nil? && block.nil?
+        raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError, 'cannot provide both an observer and a block'
+      end
+
+      if block
+        observer = block
+        func = :call
+      end
+
+      synchronize do
+        new_observers = @observers.dup
+        new_observers[observer] = func
+        @observers = new_observers
+        observer
+      end
+    end
+
+    def delete(observer)
+      synchronize do
+        new_observers = @observers.dup
+        new_observers.delete(observer)
+        @observers = new_observers
+        observer
+      end
+    end
+
+    def delete_all
+      synchronize { @observers = {} }
+      self
+    end
+
+    def notify(*args, &block)
+      obs = synchronize { @observers }
+      notify_to(obs, *args, &block)
+      self
+    end
+
+    def notify_and_delete(*args, &block)
+      old = synchronize do
+        old =  @observers
+        @observers = {}
+        old
+      end
+      notify_to(old, *args, &block)
+      self
+    end
+
+    def count
+      synchronize { @observers.count }
+    end
+
+    private
+    def notify_to(obs, *args, &block)
+      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+      obs.each do |observer, function|
+        args = yield if block_given?
+        observer.send(function, *args)
+      end
+    end
+  end
+
+  module Observable
+    def add_observer(observer=nil, func=:update, &block)
+      observers.add(observer, func, &block)
+    end
+
+    def with_observer(observer=nil, func=:update, &block)
+      observers.add(observer, func, &block)
+      self
+    end
+
+    def count_observers
+      observers.count
+    end
+
+    def delete_observer(observer)
+      observers.delete(observer)
+    end
+
+    def delete_observers
+      observers.delete_all
+      self
+    end
+
+    def notify_observers(*args, &block)
+      observers.notify(*args, &block)
+      self
+    end
+
+    def notify_and_delete_observers(*args, &block)
+      observers.notify_and_delete(*args, &block)
+      self
+    end
+
+    protected
+    def observers
+      @__observers__ ||= ObserversSet.new
+      @__observers__
+    end
+
+    def observers=(obs)
+      @__observers__ = obs
+    end
+  end
+end