rubix 0.0.1

data/lib/rubix/log.rb

@@ -0,0 +1,70 @@
+require 'logger'
+
+module Rubix
+
+  def self.logger= l
+    @logger = l
+  end
+
+  def self.logger
+    return @logger unless @logger.nil?
+    @logger = default_logger
+  end
+
+  def self.default_logger
+    severity = Logger::INFO
+    file     = $stdout
+    
+    if defined?(Settings) && Settings[:log_level]
+      begin
+        severity_name = Settings[:log_level].to_s.upcase
+        severity      = Logger.const_get(severity_name)
+      rescue NameError => e
+      end
+    end
+
+    if defined?(Settings) && Settings[:log]
+      begin
+        file = Settings[:log]
+      rescue NameError => e
+      end
+    end
+    
+    @logger       = Logger.new(file)
+    @logger.level = severity
+    @logger
+  end
+
+  module Logs
+
+    def log_name
+      @log_name
+    end
+    
+    def debug *args
+      return unless Rubix.logger
+      Rubix.logger.log(Logger::DEBUG, args.join(' '), log_name)
+    end
+
+    def info *args
+      return unless Rubix.logger
+      Rubix.logger.log(Logger::INFO, args.join(' '), log_name)
+    end
+
+    def warn *args
+      return unless Rubix.logger
+      Rubix.logger.log(Logger::WARN, args.join(' '), log_name)
+    end
+
+    def error *args
+      return unless Rubix.logger
+      Rubix.logger.log(Logger::ERROR, args.join(' '), log_name)
+    end
+
+    def fatal *args
+      return unless Rubix.logger
+      Rubix.logger.log(Logger::FATAL, args.join(' '), log_name)
+    end
+    
+  end
+end

data/lib/rubix/model.rb

@@ -0,0 +1,56 @@
+require 'rubix/log'
+
+module Rubix
+
+  # It might be worth using ActiveModel -- but maybe not.  The goal is
+  # to keep dependencies low while still retaining expressiveness.
+  class Model
+
+    attr_accessor :properties, :id
+
+    include Logs
+
+    def initialize properties={}
+      @properties = properties
+      @id         = properties[:id]
+      @log_name   = self.class.to_s.split('::').last
+    end
+    
+    def loaded?
+      @loaded
+    end
+
+    def load
+      raise NotImplementedError.new("Override the 'load' method in a subclass.")
+    end
+
+    def exists?
+      load unless loaded?
+      @exists
+    end
+
+    def register
+      exists? ? update : create
+    end
+
+    def unregister
+      destroy if exists?
+    end
+    
+    def request method, params
+      Rubix.connection && Rubix.connection.request(method, params)
+    end
+
+    def self.find_by_id id
+      instance = new(:id => id)
+      instance if instance.exists?
+    end
+
+    def self.find_by_name name
+      instance = new(:name => name)
+      instance if instance.exists?
+    end
+    
+  end
+  
+end

data/lib/rubix/models/application.rb

@@ -0,0 +1,76 @@
+module Rubix
+  
+  class Application < Model
+
+    attr_accessor :name, :host
+
+    def initialize properties={}
+      super(properties)
+      @name = properties[:name]
+      @host = properties[:host]
+    end
+
+    def params
+      {
+        :name   => name,
+        :hostid => host.id
+      }
+    end
+
+    def log_name
+      "APP #{name || id}@#{host.name}"
+    end
+
+    def load
+      response = request('application.get', 'hostids' => [host.id], 'filter' => {'name' => name, 'id' => id}, "output" => "extend")
+      case
+      when response.has_data?
+        app = response.first
+        @id          = app['applicationid'].to_i
+        @name        = app['name']
+        @exists      = true
+        @loaded      = true
+      when response.success?
+        @exists = false
+        @loaded = true
+      else
+        error("Could not load: #{response.error_message}")
+      end
+    end
+
+    def create
+      response = request('application.create', params)
+      if response.has_data?
+        @id     = response['applicationids'].first.to_i
+        @exists = true
+        info("Created")
+      else
+        error("Could not create: #{response.error_message}")
+      end
+    end
+
+    def update
+      # noop
+      info("Updated")
+    end
+
+    def destroy
+      response = request('application.delete', [id])
+      case
+      when response.has_data? && response['applicationids'].first.to_i == id
+        info("Deleted")
+      when response.zabbix_error? && response.error_message =~ /does not exist/i
+        # was never there...
+      else
+        error("Could not delete: #{response.error_message}.")
+      end
+    end
+
+    def self.find_or_create_by_name_and_host name, host
+      new(:name => name, :host => host).tap do |app|
+        app.create unless app.exists?
+      end
+    end
+    
+  end
+end

data/lib/rubix/models/host.rb

@@ -0,0 +1,127 @@
+module Rubix
+
+  class Host < Model
+
+    # The IP for a Host that not supposed to be polled by the Zabbix
+    # server.
+    BLANK_IP = '0.0.0.0'
+
+    # The default port.
+    DEFAULT_PORT = 10050
+    
+    attr_accessor :name, :ip, :port, :profile, :status, :host_groups, :templates
+
+    #
+    # Initialization and properties.
+    #
+    def initialize properties={}
+      super(properties)
+      @name        = properties[:name]
+      @ip          = properties[:ip]
+      @port        = properties[:port]
+      @profile     = properties[:profile]
+      @status      = properties[:status]
+      @host_groups = properties[:host_groups]
+      @templates   = properties[:templates]
+    end
+
+    def log_name
+      "HOST #{name || id}"
+    end
+    
+    def params
+      {}.tap do |hp|
+        hp['host']    = name
+        
+        hp['profile'] = profile if profile
+        hp['status']  = status  if status
+        
+        if ip
+          hp['ip']      = ip
+          hp['useip']   = true
+          hp['port']    = port || self.class::DEFAULT_PORT
+        else
+          hp['ip'] = self.class::BLANK_IP
+        end
+        
+      end
+    end
+    
+    #
+    # Actions
+    #
+
+    def validate
+      raise ValidationError.new("A host must have at least one host group.") if host_groups.nil? || host_groups.empty?
+    end
+
+    def load
+      response = request('host.get', 'filter' => {'host' => name}, 'select_groups' => 'refer', 'selectParentTemplates' => 'refer', 'select_profile' => 'refer', 'output' => 'extend')
+      case
+      when response.has_data?
+        host          = response.result.first
+        @id           = host['hostid'].to_i
+        @host_groups  = host['groups'].map { |group| HostGroup.new(:id => group['groupid'].to_i) }
+        @templates    = host['parentTemplates'].map { |template| Template.new((template['templateid'] || template['hostid']).to_i) }
+        @profile      = host['profile']
+        @port         = host['port']
+        @exists       = true
+        @loaded       = true
+      when response.success?
+        @exists = false
+        @loaded = true
+      else
+        error("Could not load: #{response.error_message}")
+      end
+    end
+    
+    def create
+      validate
+
+      host_group_ids = (host_groups || []).map { |g| { 'groupid'    => g.id } }
+      template_ids   = (templates || []).map   { |t| { 'templateid' => t.id } }
+      response = request('host.create', params.merge('groups' => host_group_ids, 'templates' => template_ids))
+      
+      if response.has_data?
+        @exists  = true
+        @id      = response.result['hostids'].first.to_i
+        info("Created")
+      else
+        error("Could not create: #{response.error_message}.")
+      end
+    end
+
+    def update
+      validate
+      response = request('host.update', params.merge('hostid' => id))
+      if response.has_data?
+        info("Updated")
+      else
+        error("Could not update: #{response.error_message}.")
+      end
+      mass_update_templates_and_host_groups
+    end
+
+    def mass_update_templates_and_host_groups
+      response = request('host.massUpdate', { 'groupids' => (host_groups || []).map(&:id), 'templateids' => (templates || []).map(&:id) })
+      if response.has_data?
+        info("Updated templates and host groups")
+      else
+        error("Could not update all templates and/or host groups: #{response.error_message}")
+      end
+    end
+
+    def destroy
+      response = request('host.delete', [{'hostid' => id}])
+      case
+      when response.has_data? && response.result['hostids'].first.to_i == id
+        info("Deleted")
+      when response.error_message =~ /does not exist/i
+        # was never there...
+      else
+        error("Could not delete: #{response.error_message}")
+      end
+    end
+
+  end
+end

data/lib/rubix/models/host_group.rb

@@ -0,0 +1,74 @@
+module Rubix
+  
+  class HostGroup < Model
+
+    attr_accessor :name, :host_ids
+
+    def initialize properties={}
+      super(properties)
+      @name = properties[:name]
+    end
+
+    def log_name
+      "GROUP #{name || id}"
+    end
+    
+    def load
+      response = request('hostgroup.get', 'filter' => {'groupid' => id, 'name' => name}, 'select_hosts' => 'refer', 'output' => 'extend')
+      case
+      when response.has_data?
+        @id       = response.first['groupid'].to_i
+        @name     = response.first['name']
+        @host_ids = response.first['hosts'].map { |host_info| host_info['hostid'].to_i }
+        @exists   = true
+        @loaded   = true
+      when response.success?
+        @exists = false
+        @loaded = true
+      else
+        error("Could not load: #{response.error_message}")
+      end
+    end
+
+    def create
+      response = request('hostgroup.create', [{'name' => name}])
+      if response.has_data?
+        @id     = response['groupids'].first.to_i
+        @exists = true
+        @loaded = true
+        info("Created")
+      else
+        error("Could not create: #{response.error_message}")
+      end
+    end
+
+    def update
+      # noop
+      info("Updated")
+    end
+
+    def destroy
+      response = request('hostgroup.delete', [{'groupid' => id}])
+      case
+      when response.has_data? && response['groupids'].first.to_i == id
+        info("Deleted")
+      when response.zabbix_error? && response.error_message =~ /does not exist/i
+        # was never there...
+      else
+        error("Could not delete: #{response.error_message}.")
+      end
+    end
+
+    def contains? host
+      return unless exists?
+      host_ids.include?(host.id)
+    end
+
+    def self.find_or_create_by_name name
+      new(:name => name).tap do |group|
+        group.create unless group.exists?
+      end
+    end
+    
+  end
+end

data/lib/rubix/models/item.rb

@@ -0,0 +1,122 @@
+module Rubix
+  
+  class Item < Model
+
+    # The numeric code for a Zabbix item of type 'Zabbix trapper'.  The
+    # item must have this type in order for the Zabbix server to listen
+    # and accept data submitted by +zabbix_sender+.
+    TRAPPER_TYPE = 2.freeze
+
+    # The numeric codes for the value types of a Zabbix item.  This Hash
+    # is used by ZabbixPipe#value_code_from_value to dynamically set the
+    # type of a value when creating a new Zabbix item.
+    VALUE_CODES = {
+      :float        => 0,         # Numeric (float)
+      :character    => 1,         # Character
+      :log_line     => 2,         # Log
+      :unsigned_int => 3,         # Numeric (unsigned)
+      :text         => 4          # Text
+    }.freeze
+
+    VALUE_NAMES = {
+      0 => :float,              # Numeric (float)
+      1 => :character,          # Character
+      2 => :log_line,           # Log
+      3 => :unsigned_int,       # Numeric (unsigned)
+      4 => :text                # Text
+    }.freeze
+    
+    attr_accessor :host, :applications, :key, :description, :value_type
+
+    def initialize properties={}
+      super(properties)
+      @host         = properties[:host]
+      @key          = properties[:key]
+      @description  = properties[:description]
+      @value_type   = properties[:value_type]
+      @applications = properties[:applications]
+    end
+
+    def log_name
+      "ITEM #{key}@#{host.name}"
+    end
+
+    def params
+      {
+        :hostid       => host.id,
+        :description  => (description || 'Unknown'),
+        :type         => self.class::TRAPPER_TYPE,
+        :key_         => key,
+        :value_type   => self.class::VALUE_CODES[value_type],
+      }.tap do |p|
+        p[:applications] = applications.map(&:id) if applications
+      end
+    end
+
+    def load
+      response = request('item.get', 'host' => host.name, 'filter' => {'key_' => key, 'id' => id}, "output" => "extend")
+      case
+      when response.has_data?
+        item = response.first
+        @id          = item['itemid'].to_i
+        @host        = Host.new(:id => item['hostid'])
+        @description = item['description']
+        @value_type  = self.class::VALUE_NAMES[item['value_type']] # it's actually a 'code' that's returned...
+        @key         = item['key_']
+        @exists      = true
+        @loaded      = true
+      when response.success?
+        @exists = false
+        @loaded = true
+      else
+        error("Could not load: #{response.error_message}")
+      end
+    end
+
+    def create
+      response = request('item.create', params)
+      if response.has_data?
+        @id     = response['itemids'].first.to_i
+        @exists = true
+        info("Created")
+      else
+        error("Could not create: #{response.error_message}.")
+      end
+    end
+
+    def update
+      # noop
+      info("Updated")
+    end
+
+    def destroy
+      response = request('item.delete', [id])
+      case
+      when response.has_data? && response['itemids'].first.to_i == id
+        info("Deleted")
+      when response.zabbix_error? && response.error_message =~ /does not exist/i
+        # was never there...
+      else
+        error("Could not delete: #{response.error_message}.")
+      end
+    end
+
+    # Return the +value_type+ name (:float, :text, &c.) for a Zabbix
+    # item's value type by examining the given +value+.
+    def self.value_type_from_value value
+      case
+      when value =~ /\d+/       then :unsigned_int
+      when value =~ /-?[\d\.]+/ then :float
+      when value.include?("\n") then :text
+      else :character
+      end
+    end
+
+    # Return the +value_type+'s numeric code for a Zabbix item's value
+    # type by examining the given +value+.
+    def self.value_code_from_value value
+      self::VALUE_CODES[value_type_from_value(value)]
+    end
+    
+  end
+end