rubix 0.4.3 → 0.5.0

data/lib/rubix/models/operation.rb

@@ -0,0 +1,134 @@
+module Rubix
+  
+  class Operation < Model
+
+    # Numeric codes for the action's type.
+    TYPE_CODES = {
+      :message           => 0,
+      :command           => 1,
+      :host_add          => 2,
+      :host_remove       => 3,
+      :host_group_add    => 4,
+      :host_group_remove => 5,
+      :template_add      => 6,
+      :template_remove   => 7,
+      :host_enable       => 8,
+      :host_disable      => 9
+    }.freeze
+    TYPE_NAMES = TYPE_CODES.invert.freeze
+
+    # Numeric codes for the type of object that should be notified.
+    # Default will be 'group'.
+    NOTIFICATION_OBJECT_CODES = {
+      :user       => 0,
+      :user_group => 1
+    }.freeze
+    NOTIFICATION_OBJECT_NAMES = NOTIFICATION_OBJECT_CODES.invert.freeze
+
+    #
+    # == Properties & Finding ==
+    #
+
+    zabbix_attr :type,                :default => :message, :required => true
+    zabbix_attr :message_subject,     :default => Action::MESSAGE_SUBJECT
+    zabbix_attr :message_body,        :default => Action::MESSAGE_BODY
+    zabbix_attr :use_default_message, :default => true
+    zabbix_attr :escalation_time,     :default => 0
+    zabbix_attr :start,               :default => 1
+    zabbix_attr :stop,                :default => 1
+
+    def step= s
+      self.start = s
+      self.stop  = s
+    end
+
+    def initialize properties={}
+      super(properties)
+      self.step          = properties[:step] if properties[:step]
+
+      self.user_id       = properties[:user_id]
+      self.user          = properties[:user]
+
+      self.user_group_id = properties[:user_group_id]
+      self.user_group    = properties[:user_group]
+
+      self.conditions    = (properties[:conditions] || [])
+
+      self.media_type    = properties[:media_type]
+      self.media_type_id = properties[:media_type_id]
+    end
+
+    def notification_object_name
+      case
+      when user_id       then :user
+      when user_group_id then :user_group
+      else
+        raise Error.new("An #{resource_name} must have either a user or a user group.")
+      end
+    end
+      
+    def notification_object_id
+      if user_id || user_group_id
+        return user_id || user_group_id
+      else
+        raise Error.new("An #{resource_name} must have either a user or a user group.")
+      end
+    end
+
+    #
+    # == Associations ==
+    #
+
+    include Associations::HasManyConditions
+    include Associations::BelongsToUser
+    include Associations::BelongsToUserGroup
+    include Associations::BelongsToMediaType
+
+    #
+    # == Requests ==
+    #
+
+    def create_params
+      {
+        :operationtype => self.class::TYPE_CODES[type],
+        :object        => self.class::NOTIFICATION_OBJECT_CODES[notification_object_name],
+        :objectid      => notification_object_id,
+        :shortdata     => message_subject,
+        :longdata      => message_body,
+        :default_msg   => (use_default_message ? 1 : 0),
+        :evaltype      => Condition::JOIN_CODES[condition_operator],
+        :esc_period    => escalation_time,
+        :esc_step_from => start,
+        :esc_step_to   => stop
+      }.tap do |cp|
+        cp[:opconditions] = conditions.map(&:to_hash) unless conditions.empty?
+        cp[:opmediatypes] = [{ :mediatypeid => media_type_id }] if media_type_id
+      end
+    end
+
+    def self.build operation
+      new({
+            :id                  => operation[id_field].to_i,
+            :type                => self::TYPE_NAMES[operation['operationtype'].to_i],
+            :message_subject     => operation['shortdata'],
+            :message_body        => operation['longdata'],
+            :escalation_period   => operation['esc_period'].to_i,
+            :use_default_message => (operation['default_msg'].to_i == 1),
+            :condition_operator  => Condition::JOIN_NAMES[operation['evaltype'].to_i],
+            :conditions          => (operation['opconditions'] || []).map { |c| Condition.build(c) },
+            :start               => operation['esc_step_from'].to_i,
+            :stop                => operation['esc_step_to'].to_i
+          }).tap do |o|
+        if self::NOTIFICATION_OBJECT_NAMES[operation['object'].to_i] == :user
+          o.user_id = operation['objectid']
+        else
+          o.user_group_id = operation['objectid']
+        end
+        if (operation['opmediatypes'] || []).first
+          o.media_type_id = (operation['opmediatypes'] || []).first['mediatypeid'].to_i
+        end
+      end
+    end
+    
+  end
+end

data/lib/rubix/models/script.rb

@@ -0,0 +1,49 @@
+module Rubix
+  
+  class Script < Model
+
+    # Numeric codes of the access types a script can require to run on
+    # a host.
+    #
+    # Default is 'read'.
+    ACCESS_CODES = {
+      :read  => 2,
+      :write => 3
+    }.freeze
+    ACCESS_NAMES = ACCESS_CODES.invert.freeze
+
+    #
+    # == Properties & Finding ==
+    #
+
+    zabbix_attr :name,    :required => true
+    zabbix_attr :command, :required => true
+    zabbix_attr :access,  :default => :read
+
+    #
+    # == Requests ==
+    #
+
+    def create_params
+      {
+        :name        => name,
+        :command     => command,
+        :host_access => self.class::ACCESS_CODES[access]
+      }
+    end
+
+    def self.find_params options={}
+      get_params.merge(:filter => {id_field => options[:id], :name => options[:name]})
+    end
+
+    def self.build script
+      new({
+            :id          => script[id_field].to_i,
+            :name        => script['name'],
+            :command     => script['command'],
+            :access      => self::ACCESS_NAMES[script['host_access'].to_i]
+          })
+    end
+    
+  end
+end

data/lib/rubix/models/template.rb

@@ -6,11 +6,10 @@ module Rubix
     # == Properties & Finding ==
     #
 
-    attr_accessor :name
+    zabbix_attr :name, :required => true
     
     def initialize properties={}
       super(properties)
-      @name     = properties[:name]
       
       self.host_ids = properties[:host_ids]
       self.hosts    = properties[:hosts]
@@ -24,6 +23,7 @@ module Rubix
     #
 
     def validate
+      super()
       raise ValidationError.new("A template must have at least one host group.") if host_group_ids.nil? || host_group_ids.empty?
       true
     end

data/lib/rubix/models/trigger.rb

@@ -22,18 +22,15 @@ module Rubix
     }.freeze
     STATUS_CODES = STATUS_NAMES.invert.freeze
     
-    attr_accessor :description, :url, :status, :priority, :comments
-    attr_reader   :expression
+    zabbix_attr :description
+    zabbix_attr :url
+    zabbix_attr :status
+    zabbix_attr :priority
+    zabbix_attr :comments
     
     def initialize properties={}
       super(properties)
-      @description = properties[:description]
-      @url         = properties[:url]
-      @status      = properties[:status]
-      @priority    = properties[:priority]
-      @comments    = properties[:comments]
-
-      self.expression  = properties[:expression]
+      self.expression = properties[:expression]
       
       self.host     = properties[:host]
       self.template = properties[:template]
@@ -45,7 +42,9 @@ module Rubix
       self.item_ids = properties[:item_ids]
     end
 
+    attr_reader :expression
     def expression= e
+      return unless e
       if e =~ %r!^\{(.*)\}!
         trigger_condition = $1
         if trigger_condition && trigger_condition =~ /:/

data/lib/rubix/models/user.rb

@@ -0,0 +1,145 @@
+require 'digest/md5'
+
+module Rubix
+
+  class User < Model
+
+    # Numeric codes for the various user types.
+    TYPE_CODES = {
+      :normal      => 1,
+      :admin       => 2,
+      :super_admin => 3
+    }.freeze
+    TYPE_NAMES = TYPE_CODES.invert.freeze
+
+    #
+    # == Properties & Finding ==
+    #
+
+    zabbix_attr :username,           :required => true
+    zabbix_attr :first_name,         :required => true
+    zabbix_attr :last_name,          :required => true
+    zabbix_attr :url
+    zabbix_attr :auto_login
+    zabbix_attr :type
+    zabbix_attr :lang
+    zabbix_attr :theme
+    zabbix_attr :auto_logout_period
+    zabbix_attr :refresh_period
+    zabbix_attr :rows_per_page
+    zabbix_attr :password
+
+    attr_accessor :password_md5
+
+    def initialize properties={}
+      super(properties)
+      self.password_md5 = properties[:password_md5]
+
+      self.user_group_ids = properties[:user_group_ids]
+      self.user_groups    = properties[:user_groups]
+
+      self.media          = properties[:media]
+    end
+
+    #
+    # == Validations ==
+    #
+    def validate
+      super()
+      raise ValidationError.new("A new user must have a password") if new_record? && (password.nil? || password.empty?)
+      true
+    end
+
+    #
+    # == Associations == 
+    #
+
+    include Associations::HasManyUserGroups
+
+    attr_reader :media
+
+    def media= ms
+      return if ms.nil?
+      @media = ms.map do |m|
+        m      = Medium.new(m) unless m.kind_of?(Medium)
+        m.user = self
+        m
+      end
+    end
+
+    #
+    # == Requests ==
+    #
+
+    def create_params
+      {
+        :alias         => username,
+        :name          => first_name,
+        :surname       => last_name,
+        :url           => url,
+        :lang          => lang,
+        :refresh       => refresh_period,
+        :type          => self.class::TYPE_CODES[type],
+        :theme         => theme,
+        :rows_per_page => rows_per_page
+      }.tap do |cp|
+        cp[:passwd] = password if password && (!password.empty?)
+        
+        case
+        when auto_login
+          cp[:autologin] = 1
+        when (!auto_logout_period.nil?)
+          cp[:autologout] = auto_logout_period
+        end
+        
+      end
+    end
+
+    def after_create
+      update_media
+    end
+
+    def before_update
+      update_media
+    end
+
+    def update_media
+      return true if media.nil?
+      response = request("user.updateMedia", { :users => [{:userid => id}], :medias => media.map(&:to_hash) })
+      if response.has_data?
+        true
+      else
+        error("Could not update media for #{resource_name}: #{response.error_message}")
+        false
+      end
+    end
+    
+    def self.build user
+      new({
+            :id                 => user[id_field].to_i,
+            :username           => user['alias'],
+            :first_name         => user['name'],
+            :last_name          => user['surname'],
+            :password_md5       => user['passwd'],
+            :url                => user['url'],
+            :auto_login         => (user['autologin'].to_i == 1),
+            :auto_logout_period => user['autologout'],
+            :lang               => user['lang'],
+            :refresh_period     => user['refresh'].to_i,
+            :type               => self::TYPE_NAMES[user['type'].to_i],
+            :theme              => user['theme'],
+            :rows_per_page      => user['rows_per_page'].to_i
+          })
+    end
+    
+    def self.get_params
+      # FIXME -- select_medias doesn't seem to work here...
+      super().merge({})
+    end
+
+    def self.find_params options={}
+      get_params.merge(:filter => {:alias => options[:username], id_field => options[:id]})
+    end
+    
+  end
+end

data/lib/rubix/models/user_group.rb

@@ -0,0 +1,94 @@
+module Rubix
+  
+  class UserGroup < Model
+
+    # Numeric codes for the types of access allowed to the GUI for
+    # users in the group.  Default is, well, 'default'.
+    GUI_ACCESS_CODES = {
+      :default  => 0,
+      :internal => 1,
+      :disabled => 2
+    }.freeze
+    GUI_ACCESS_NAMES = GUI_ACCESS_CODES.invert.freeze
+
+    #
+    # == Properties & Finding ==
+    #
+
+    zabbix_attr :name
+    zabbix_attr :api_access, :default => false
+    zabbix_attr :debug_mode, :default => false
+    zabbix_attr :banned,     :default => false
+    zabbix_attr :gui_access, :default => :default
+
+    def initialize properties={}
+      super(properties)
+      self.user_ids = properties[:user_ids]
+      self.users    = properties[:users]
+    end
+    
+    def self.id_field
+      'usrgrpid'
+    end
+    
+    #
+    # == Associations ==
+    #
+    
+    include Associations::HasManyUsers
+
+    #
+    # == Requests ==
+    #
+
+    def create_params
+      {
+        :name         => name,
+        :gui_access   => self.class::GUI_ACCESS_CODES[gui_access],
+        :users_status => (banned ? 1 : 0),
+        :api_access   => (api_access ? 1 : 0),
+        :debug_mode   => (debug_mode ? 1 : 0)
+      }
+    end
+
+    def after_create
+      update_users
+    end
+
+    def before_update
+      update_users
+    end
+
+    def update_users
+      return true unless self.user_ids
+      response = request("usergroup.massUpdate", { :usrgrpids => [id], :userids => self.user_ids })
+      if response.has_data?
+        true
+      else
+        error("Could not update users for #{resource_name}: #{response.error_message}")
+        false
+      end
+    end
+
+    def self.get_params
+      super().merge(:select_users => :refer)
+    end
+
+    def self.find_params options={}
+      get_params.merge(:filter => {id_field => options[:id], :name => options[:name]})
+    end
+
+    def self.build user_group
+      new({
+            :id         => user_group[id_field].to_i,
+            :name       => user_group['name'],
+            :gui_access => self::GUI_ACCESS_NAMES[user_group['gui_access'].to_i],
+            :banned     => (user_group['users_status'].to_i == 1),
+            :api_access => (user_group['api_access'].to_i == 1),
+            :debug_mode => (user_group['debug_mode'].to_i == 1),
+            :user_ids   => user_group['users'].map { |user_info| user_info['userid'].to_i }
+          })
+    end
+    
+  end
+end