rubix 0.0.1 → 0.0.2

data/lib/rubix/models/host.rb

@@ -2,6 +2,10 @@ module Rubix
 
   class Host < Model
 
+    #
+    # == Properties & Finding ==
+    #
+    
     # The IP for a Host that not supposed to be polled by the Zabbix
     # server.
     BLANK_IP = '0.0.0.0'
@@ -9,11 +13,8 @@ module Rubix
     # The default port.
     DEFAULT_PORT = 10050
     
-    attr_accessor :name, :ip, :port, :profile, :status, :host_groups, :templates
-
-    #
-    # Initialization and properties.
-    #
+    attr_accessor :name, :ip, :port, :profile, :status
+    
     def initialize properties={}
       super(properties)
       @name        = properties[:name]
@@ -21,14 +22,62 @@ module Rubix
       @port        = properties[:port]
       @profile     = properties[:profile]
       @status      = properties[:status]
-      @host_groups = properties[:host_groups]
-      @templates   = properties[:templates]
+
+      self.host_group_ids = properties[:host_group_ids]
+      self.host_groups    = properties[:host_groups]
+
+      self.template_ids   = properties[:template_ids]
+      self.templates      = properties[:templates]
+
+      self.user_macro_ids = properties[:user_macro_ids]
+      self.user_macros    = properties[:user_macros]
     end
 
+    def self.find_request options={}
+      request('host.get', 'filter' => {'host' => options[:name], 'hostid' => options[:id]}, 'select_groups' => 'refer', 'selectParentTemplates' => 'refer', 'select_profile' => 'refer', 'select_macros' => 'extend', 'output' => 'extend')
+    end
+
+    def self.build host
+      new({
+            :id             => host['hostid'].to_i,
+            :name           => host['host'],
+            :host_group_ids => host['groups'].map { |group| group['groupid'].to_i },
+            :template_ids   => host['parentTemplates'].map { |template| (template['templateid'] || template['hostid']).to_i },
+            :user_macros    => host['macros'].map { |um| UserMacro.new(:host_id => um['hostid'].to_i, :id => um['hostmacroid'], :value => um['value'], :macro => um['macro']) },
+            :profile        => host['profile'],
+            :port           => host['port']
+          })
+    end
+    
     def log_name
       "HOST #{name || id}"
     end
+
+    def self.id_field
+      'hostid'
+    end
+
+    #
+    # == Associations == 
+    #
+
+    include Associations::HasManyHostGroups
+    include Associations::HasManyTemplates
+    include Associations::HasManyUserMacros
+
+    #
+    # == Validation == 
+    #
+
+    def validate
+      raise ValidationError.new("A host must have at least one host group.") if host_group_ids.nil? || host_group_ids.empty?
+      true
+    end
     
+    #
+    # == CRUD ==
+    #
+
     def params
       {}.tap do |hp|
         hp['host']    = name
@@ -47,81 +96,28 @@ module Rubix
       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
+    def create_request
+      request('host.create', params.merge('groups' => host_group_params, 'templates' => template_params, 'macros' => user_macro_params))
     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
+    def update_request
+      request('host.update', params.merge('hostid' => id))
     end
 
-    def mass_update_templates_and_host_groups
-      response = request('host.massUpdate', { 'groupids' => (host_groups || []).map(&:id), 'templateids' => (templates || []).map(&:id) })
+    def after_update
+      response = request('host.massUpdate', { 'groups' => host_group_params, 'templates' => template_params, 'macros' => user_macro_params, 'hosts' => [{'hostid' => id}]})
       if response.has_data?
-        info("Updated templates and host groups")
+        info("Updated templates, host groups, & macros")
+        true
       else
-        error("Could not update all templates and/or host groups: #{response.error_message}")
+        error("Could not update all templates, host groups, and/or macros: #{response.error_message}")
+        false
       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
+    
+    def destroy_request
+      request('host.delete', [{'hostid' => id}])
     end
-
+    
   end
 end

data/lib/rubix/models/host_group.rb

@@ -2,73 +2,62 @@ module Rubix
   
   class HostGroup < Model
 
-    attr_accessor :name, :host_ids
+    #
+    # == Properties & Finding ==
+    #
 
     def initialize properties={}
       super(properties)
-      @name = properties[:name]
+      @name     = properties[:name]
+      
+      self.host_ids = properties[:host_ids]
+      self.hosts    = properties[:hosts]
     end
+    
+    attr_accessor :name
 
-    def log_name
-      "GROUP #{name || id}"
+    def self.find_request options={}
+      request('hostgroup.get', 'filter' => {'groupid' => options[:id], 'name' => options[:name]}, 'select_hosts' => 'refer', 'output' => 'extend')
+    end
+
+    def self.build host_group
+      new({
+            :id       => host_group['groupid'].to_i,
+            :name     => host_group['name'],
+            :host_ids => host_group['hosts'].map { |host_info| host_info['hostid'].to_i }
+          })
     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
+    def log_name
+      "GROUP #{name || id}"
     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
+    def self.id_field
+      'groupid'
     end
+    
 
-    def update
-      # noop
-      info("Updated")
-    end
+    #
+    # == Associations ==
+    #
+    
+    include Associations::HasManyHosts
 
-    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
+    #
+    # == CRUD ==
+    #
+    
+    def create_request
+      request('hostgroup.create', [{'name' => name}])
     end
 
-    def contains? host
-      return unless exists?
-      host_ids.include?(host.id)
+    def update_request
+      request('hostgroup.update', [{'groupid' => id, 'name' => name}])
     end
 
-    def self.find_or_create_by_name name
-      new(:name => name).tap do |group|
-        group.create unless group.exists?
-      end
+    def destroy_request
+      request('hostgroup.delete', [{'groupid' => id}])
     end
-    
+
   end
 end

data/lib/rubix/models/item.rb

@@ -2,6 +2,10 @@ module Rubix
   
   class Item < Model
 
+    #
+    # == Properties & Finding ==
+    #
+
     # 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+.
@@ -25,97 +29,104 @@ module Rubix
       3 => :unsigned_int,       # Numeric (unsigned)
       4 => :text                # Text
     }.freeze
-    
-    attr_accessor :host, :applications, :key, :description, :value_type
 
+    # 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
+    
+    attr_accessor :key, :description
+    attr_reader :value_type
+    
     def initialize properties={}
       super(properties)
-      @host         = properties[:host]
-      @key          = properties[:key]
-      @description  = properties[:description]
-      @value_type   = properties[:value_type]
-      @applications = properties[:applications]
+      @key            = properties[:key]
+      @description    = properties[:description]
+      
+      self.value_type = properties[:value_type]
+
+      self.host            = properties[:host]
+      self.host_id         = properties[:host_id]
+      self.applications    = properties[:applications]
+      self.application_ids = properties[:application_ids]
+    end
+
+    def self.find_request options={}
+      request('item.get', 'hostids' => [options[:host_id]], 'filter' => {'key_' => options[:key], 'id' => options[:id]}, "select_applications" => "refer", "output" => "extend")
     end
 
+    def self.build item
+      new({
+            :id              => item['itemid'].to_i,
+            :host_id         => item['hostid'].to_i,
+            :description     => item['description'],
+            :value_type      => item['value_type'] ? self::VALUE_NAMES[item['value_type'].to_i] : :character,
+            :application_ids => (item['applications'] || []).map { |app| app['applicationid'].to_i },
+            :key             => item['key_']
+          })
+    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
+    def self.id_field
+      'itemid'
     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
+    def value_type= vt
+      if vt.nil? || vt.to_s.empty? || !self.class::VALUE_CODES.include?(vt.to_sym)
+        @value_type = :character
       else
-        error("Could not load: #{response.error_message}")
+        @value_type = vt.to_sym
       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
+    #
+    # == Associations ==
+    #
 
-    def update
-      # noop
-      info("Updated")
-    end
+    include Associations::BelongsToHost
+    include Associations::HasManyApplications
 
-    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}.")
+    #
+    # == CRUD == 
+    #
+    
+    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] = application_ids if application_ids
       end
     end
+    
+    def create_request
+      request('item.create', params)
+    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
+    def update_request
+      request('item.update', params.merge('itemid' => id))
     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)]
+    def destroy_request
+      request('item.delete', [id])
     end
     
   end