rubix 0.4.3 → 0.5.0

data/lib/rubix/models/application.rb

@@ -8,13 +8,11 @@ module Rubix
 
     def initialize properties={}
       super(properties)
-      @name    = properties[:name]
-      
       self.host_id = properties[:host_id]
       self.host    = properties[:host]
     end
     
-    attr_accessor :name
+    zabbix_attr :name, :required => true
 
     #
     # == Associations ==

data/lib/rubix/models/condition.rb

@@ -0,0 +1,99 @@
+module Rubix
+  
+  class Condition < Model
+
+    # Numeric codes for the operator to use to join conditions for
+    # this action.  Default is 'and_or'.
+    JOIN_CODES = {
+      :and_or => 0,
+      :and    => 1,
+      :or     => 2
+    }.freeze
+    JOIN_NAMES = JOIN_CODES.invert.freeze
+    
+    # Numeric codes for the event source.
+    TYPE_CODES = {
+	:host_group         => 0,
+	:host               => 1,
+	:trigger            => 2,
+	:trigger_name       => 3,
+	:trigger_severity   => 4,
+	:trigger_value      => 5,
+	:time_period        => 6,
+	:dhost_ip           => 7,
+	:dservice_type      => 8,
+	:dservice_port      => 9,
+	:dstatus            => 10,
+	:duptime            => 11,
+	:dvalue             => 12,
+	:host_template      => 13,
+	:event_acknowledged => 14,
+	:application        => 15,
+	:maintenance        => 16,
+	:node               => 17,
+	:drule              => 18,
+	:dcheck             => 19,
+	:proxy              => 20,
+	:dobject            => 21,
+	:host_name          => 22
+    }.freeze
+    TYPE_NAMES = TYPE_CODES.invert.freeze
+
+    # Numeric codes for the operator used to compare a condition's
+    # type to its value.
+    OPERATOR_CODES = {
+      :equal      => 0,
+      :not_equal  => 1,
+      :like       => 2,
+      :not_like   => 3,
+      :in         => 4,
+      :gte        => 5,
+      :lte        => 6,
+      :not_in     => 7,
+    }.freeze
+    OPERATOR_NAMES = OPERATOR_CODES.invert.freeze
+
+    #
+    # == Properties & Finding ==
+    #
+
+    zabbix_attr :type,     :required => true
+    zabbix_attr :operator, :required => true, :default => :equal
+    zabbix_attr :value,    :required => true
+
+    def initialize properties=nil
+      if properties.is_a?(Array)
+        raise ArgumentError.new("Must provide a condition type, operator, and value when initializing a condition with an array.") unless properties.size == 3
+        super({
+                :type     => properties[0],
+                :operator => properties[1],
+                :value    => properties[2]
+              })
+      else
+        super(properties || {})
+      end
+    end
+    
+    #
+    # == Requests ==
+    #
+
+    def create_params
+      {
+        :conditiontype => self.class::TYPE_CODES[type],
+        :operator      => self.class::OPERATOR_CODES[operator],
+        :value         => value.to_s
+      }
+    end
+
+    def self.build condition
+      new({
+            :id       => condition[id_field].to_i,
+            :type     => self::TYPE_NAMES[condition['conditiontype'].to_i],
+            :operator => self::OPERATOR_NAMES[condition['operator'].to_i],
+            :value    => condition['value'].to_s
+          })
+    end
+    
+  end
+end

data/lib/rubix/models/host.rb

@@ -24,20 +24,18 @@ module Rubix
       :proxy_passive => 6
     }.freeze
     STATUS_NAMES = STATUS_CODES.invert.freeze
-    
-    attr_accessor :name, :ip, :port, :profile, :dns, :status
-    attr_writer   :use_ip, :monitored
+
+    zabbix_attr :name
+    zabbix_attr :ip
+    zabbix_attr :port
+    zabbix_attr :profile
+    zabbix_attr :dns
+    zabbix_attr :status
+    zabbix_attr :use_ip,    :default => true
+    zabbix_attr :monitored, :default => true
     
     def initialize properties={}
       super(properties)
-      @name        = properties[:name]
-      @ip          = properties[:ip]
-      @port        = properties[:port]
-      @profile     = properties[:profile]
-      @monitored   = properties[:monitored]
-      @dns         = properties[:dns]
-      @use_ip      = properties[:use_ip]
-      @status      = properties[:status]
 
       self.host_group_ids = properties[:host_group_ids]
       self.host_groups    = properties[:host_groups]

data/lib/rubix/models/host_group.rb

@@ -8,14 +8,11 @@ module Rubix
 
     def initialize properties={}
       super(properties)
-      @name     = properties[:name]
-      
       self.host_ids = properties[:host_ids]
       self.hosts    = properties[:hosts]
     end
     
-    attr_accessor :name
-
+    zabbix_attr :name, :required => true
     
     def self.id_field
       'groupid'

data/lib/rubix/models/item.rb

@@ -79,24 +79,21 @@ module Rubix
     def self.value_code_from_value value
       self::VALUE_CODES[value_type_from_value(value)]
     end
-    
-    attr_accessor :key, :description, :units, :multiply_by, :data_type, :history, :trends, :status, :frequency
-    attr_writer :type, :value_type
+
+    zabbix_attr :type,       :default => :zabbix
+    zabbix_attr :value_type, :default => :character
+    zabbix_attr :data_type,  :default => :decimal
+    zabbix_attr :key,        :required => true
+    zabbix_attr :description
+    zabbix_attr :units
+    zabbix_attr :multiply_by
+    zabbix_attr :history
+    zabbix_attr :trends
+    zabbix_attr :status
+    zabbix_attr :frequency
 
     def initialize properties={}
       super(properties)
-      self.key             = properties[:key]
-      self.description     = properties[:description]
-      self.type            = properties[:type]
-      self.units           = properties[:units]
-      self.multiply_by     = properties[:multiply_by]
-      self.value_type      = properties[:value_type]
-      self.data_type       = properties[:data_type]
-      self.history         = properties[:history]
-      self.trends          = properties[:trends]
-      self.status          = properties[:status]
-      self.frequency       = properties[:frequency]
-
       self.host            = properties[:host]
       self.host_id         = properties[:host_id]
 
@@ -111,18 +108,6 @@ module Rubix
       "#{self.class.resource_name} #{self.key || self.id}"
     end
 
-    def value_type
-      @value_type ||= :character
-    end
-
-    def data_type
-      @data_type ||= :decimal
-    end
-
-    def type
-      @type ||= :zabbix
-    end
-
     #
     # == Associations ==
     #

data/lib/rubix/models/media_type.rb

@@ -18,25 +18,23 @@ module Rubix
     # == Properties & Finding ==
     #
 
-    attr_accessor :description, :server, :helo, :email, :path, :modem, :username, :password
-    
-    attr_writer   :type
-    def type
-      @type ||= :script
-    end
+    zabbix_attr :type, :default => :script, :required => true
+    zabbix_attr :name
 
-    def initialize properties={}
-      super(properties)
-      self.description = properties[:description]
-      self.type        = properties[:type]
-      self.server      = properties[:server]
-      self.helo        = properties[:helo]
-      self.email       = properties[:email]
-      self.path        = properties[:path]
-      self.modem       = properties[:modem]
-      self.username    = properties[:username]
-      self.password    = properties[:password]
-    end
+    # email
+    zabbix_attr :server
+    zabbix_attr :helo
+    zabbix_attr :email
+
+    # script
+    zabbix_attr :path
+
+    # sms
+    zabbix_attr :modem
+    
+    # jabber
+    zabbix_attr :username
+    zabbix_attr :password
     
     #
     # == Requests ==
@@ -44,7 +42,7 @@ module Rubix
 
     def create_params
       {
-        :description => description,
+        :description => name,
         :type        => TYPE_CODES[type]
       }.tap do |p|
         case type
@@ -64,14 +62,14 @@ module Rubix
     end
 
     def self.find_params options={}
-      get_params.merge(:filter => {id_field => options[:id], :description => options[:description]})
+      get_params.merge(:filter => {id_field => options[:id], :description => options[:name]})
     end
 
     def self.build media_type
       new({
             :id          => media_type[id_field].to_i,
             :type        => self::TYPE_NAMES[media_type['type'].to_i],
-            :description => media_type['description'],
+            :name        => media_type['description'],
             :server      => media_type['smtp_server'],
             :helo        => media_type['smtp_helo'],
             :email       => media_type['smtp_email'],

data/lib/rubix/models/medium.rb

@@ -0,0 +1,86 @@
+module Rubix
+
+  class Medium < Model
+
+    # Numeric codes that correspond to accepting triggers that are any
+    # priority less than or equal to that listed.  More fine grained
+    # control is possible, i.e. - accepting :not_classified and
+    # :wanring triggers but rejejcting :information triggers.  In the
+    # interests of simplicity, we avoid exposing that degree of
+    # freedom here.
+    PRIORITY_CODES = {
+      :none           => 0,
+      :not_classified => 1,
+      :information    => 3,
+      :warning        => 7,
+      :average        => 15,
+      :high           => 31,
+      :disaster       => 63,
+      :all            => 63,
+      nil             => 63
+    }.freeze
+    PRIORITY_NAMES = PRIORITY_CODES.invert.freeze
+
+    #
+    # == Properties & Finding ==
+    #
+    
+    zabbix_attr :address,   :required => true
+    zabbix_attr :priority,  :required => true, :default => :all
+    zabbix_attr :timeframe, :required => true, :default => '1-7,00:00-23:59'
+    zabbix_attr :enabled,   :required => true, :default => true
+
+    attr_writer :severity
+    def severity
+      @severity ||= self.class::PRIORITY_CODES[priority]
+    end
+
+    def self.id_field
+      'mediaid'
+    end
+
+    def initialize properties={}
+      super(properties)
+      self.severity      = properties[:severity].to_i if properties[:severity]
+      self.user          = properties[:user]
+      self.user_id       = properties[:user_id]
+      self.media_type    = properties[:media_type]
+      self.media_type_id = properties[:media_type_id]
+    end
+
+    #
+    # == Associations == 
+    #
+
+    include Associations::BelongsToUser
+    include Associations::BelongsToMediaType
+    
+    #
+    # == Requests ==
+    #
+    
+    def create_params
+      {
+        :mediatypeid => media_type_id,
+        :userid      => user_id,
+        :sendto      => address,
+        :active      => (enabled ? 0 : 1),
+        :severity    => (severity || self.class::PRIORITY_CODES[priority]),
+        :period      => timeframe
+      }
+    end
+
+    def self.build medium
+      new({
+            :id            => medium[id_field].to_i,
+            :address       => medium['sendto'],
+            :severity      => medium['severity'].to_i,
+            :priority      => self::PRIORITY_NAMES[medium['severity'].to_i],
+            :timeframe     => medium['period'],
+            :enabled       => (medium['active'].to_i == 0),
+            :user_id       => medium['userid'].to_i,
+            :media_type_id => medium['mediatypeid'].to_i
+          })
+    end
+  end
+end

data/lib/rubix/models/model.rb

@@ -70,6 +70,9 @@ module Rubix
     # @option properties [Fixnum] id the ID of the resource in Zabbix (typically blank for a new resource)
     def initialize properties={}
       @properties = properties
+      self.class.properties.keys.each do |property|
+        self.send("#{property}=", properties[property])
+      end
       @id         = properties[:id]
     end
 
@@ -126,9 +129,19 @@ module Rubix
     #
     # @return [true, false]
     def validate
+      self.class.properties.each_pair do |property, options|
+        raise ValidationError.new("A #{self.class.resource_name} must have a #{property}") if options[:required] && (self.send(property).nil? || self.send(property).empty?)
+      end
       true
     end
 
+    # Return this object as a Hash.
+    #
+    # @return [Hash]
+    def to_hash
+      update_params
+    end
+
     #
     # == Create ==
     #
@@ -161,6 +174,12 @@ module Rubix
         error("Error creating Zabbix #{resource_name}: #{response.error_message}")
         return false
       end
+      after_create
+    end
+
+    # Run this hook after creating a new resource.
+    def after_create
+      true
     end
 
     #
@@ -171,7 +190,11 @@ module Rubix
     #
     # @return [Hash]
     def update_params
-      create_params.merge({id_field => id})
+      if id
+        create_params.merge({id_field => id})
+      else
+        create_params
+      end
     end
 
     # Send a request to update this resource.
@@ -372,6 +395,10 @@ module Rubix
       end
     end
 
+    #
+    # == List ==
+    #
+
     def self.list ids
       return [] if ids.nil? || ids.empty?
       response = request("#{zabbix_name}.get", get_params.merge((id_field + 's') => ids))
@@ -386,6 +413,31 @@ module Rubix
         error("Error listing Zabbix #{resource_name}s: #{response.error_message}")
       end
     end
+
+    #
+    # == Helpers ==
+    #
+
+    def self.properties
+      @properties ||= {}
+    end
+
+    def self.zabbix_attr name, options={}
+      name = name.to_s.to_sym
+      @properties     ||= {}
+      @properties[name] = options
+      
+      if options[:default].nil?
+        attr_accessor name
+      else
+        attr_writer name
+        define_method name do
+          current_value = instance_variable_get("@#{name}")
+          return current_value unless current_value.nil?
+          instance_variable_set("@#{name}", options[:default])
+        end
+      end
+    end
     
   end
 end