rubix 0.4.3 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.5.0

data/bin/zabbix_api

@@ -16,41 +16,59 @@ Settings.define :password,           :description => "Password for the Zabbix AP
 Settings.define :server_error_sleep, :description => "Seconds to sleep after a 50x error from the server",      :required => true, :type => Integer, :default => 1
 
 def Settings.usage
-  %Q{usage: #{raw_script_name} [...--param=val...] METHOD PARAMS}
+  %Q{usage: #{raw_script_name} [...--param=val...] [--shell || METHOD PARAMS]}
 end
 
-begin
-  Settings.resolve!
-rescue RuntimeError => e
-  puts e.message
-  Settings.dump_help
+def bail msg=nil
+  $stderr.puts msg if msg
   exit(1)
 end
 
-if Settings.rest.size < 2
-  Settings.dump_help
-  exit(1)
+def connect
+  Rubix.connect(Settings[:url], Settings[:username], Settings[:password])  
 end
 
-method      = Settings.rest[0]
-json_params = Settings.rest[1]
-
-begin
-  Rubix.connect(Settings[:url], Settings[:username], Settings[:password])
-  
-  params   = JSON.parse(json_params)
-  response = Rubix.connection.request(method, params)
-  
-  if Settings[:pretty]
-    puts JSON.pretty_generate(response.parsed)
-  else
-    puts response.parsed.to_json
+def perform_query
+  begin
+    method   = Settings.rest[0]
+    params   = JSON.parse(Settings.rest[1])
+    response = Rubix.connection.request(method, params)
+    
+    if Settings[:pretty]
+      puts JSON.pretty_generate(response.parsed)
+    else
+      puts response.parsed.to_json
+    end
+    exit(0)
+  rescue JSON::ParserError => e
+    bail("Invalid JSON -- #{e.message}")
+  rescue Rubix::Error => e
+    bail($e.message)
   end
+end
   
-rescue JSON::ParserError => e
-  puts "Invalid JSON -- #{e.message}"
-  exit(1)
+def drop_into_a_shell
+  require 'irb'
+  ARGV.clear
+  include Rubix
+  IRB.start
+end
+
+begin
+  Settings.resolve!
+rescue RuntimeError => e
+  Settings.dump_help
+  bail(e.message)
+end
+
+begin
+  connect
 rescue Rubix::Error => e
-  puts e.message
-  exit(1)
+  bail("Could not connect to Zabbix API: #{e.message}")
+end
+
+if Settings.rest.size < 2
+  drop_into_a_shell
+else
+  perform_query
 end

data/lib/rubix.rb

@@ -42,6 +42,20 @@ module Rubix
     @connection = connection
   end
 
+  # Is Rubix presently connected to a Zabbix server?
+  #
+  # @return [true, false]
+  def self.connected?
+    (!! connection)
+  end
+
+  # Is Rubix presently connected and authorized with a Zabbix server?
+  #
+  # @return [true, false]
+  def self.authorized?
+    connection && connection.authorized?
+  end
+
   # Return the current connection to a Zabbix API.  Useful for
   # directly sending queries.
   #
@@ -71,5 +85,8 @@ module Rubix
   # from being saved by the Zabbix API (i.e. - no host group for a
   # host).
   ValidationError     = Class.new(Error)
+
+  # Given an incorrect argument.
+  ArgumentError       = Class.new(Error)
   
 end

data/lib/rubix/associations.rb

@@ -7,11 +7,17 @@ module Rubix
     autoload :HasManyUserMacros,    'rubix/associations/has_many_user_macros'
     autoload :HasManyApplications,  'rubix/associations/has_many_applications'
     autoload :HasManyItems,         'rubix/associations/has_many_items'
+    autoload :HasManyUsers,         'rubix/associations/has_many_users'
+    autoload :HasManyUserGroups,    'rubix/associations/has_many_user_groups'
+    autoload :HasManyConditions,    'rubix/associations/has_many_conditions'
     
     autoload :BelongsToHost,        'rubix/associations/belongs_to_host'
     autoload :BelongsToTemplate,    'rubix/associations/belongs_to_template'
     autoload :BelongsToItem,        'rubix/associations/belongs_to_item'
-    
+    autoload :BelongsToAction,      'rubix/associations/belongs_to_action'
+    autoload :BelongsToUser,        'rubix/associations/belongs_to_user'
+    autoload :BelongsToUserGroup,   'rubix/associations/belongs_to_user_group'
+    autoload :BelongsToMediaType,   'rubix/associations/belongs_to_media_type'
   end
 end
 

data/lib/rubix/associations/belongs_to_action.rb

@@ -0,0 +1,31 @@
+module Rubix
+  module Associations
+
+    module BelongsToAction
+
+      def action= a
+        return unless a
+        @action    = a
+        @action_id = a.id
+      end
+
+      def action
+        @action
+      end
+
+      def action_id= aid
+        return unless aid
+        @action_id = aid
+      end
+
+      def action_id
+        return @action_id if @action_id
+        return unless @action
+        @action_id = @action.id
+      end
+
+    end
+  end
+end
+
+      

data/lib/rubix/associations/belongs_to_media_type.rb

@@ -0,0 +1,33 @@
+module Rubix
+  module Associations
+
+    module BelongsToMediaType
+
+      def media_type= mt
+        return unless mt
+        @media_type    = mt
+        @media_type_id = mt.id
+      end
+
+      def media_type
+        return @media_type if @media_type
+        return unless @media_type_id
+        @media_type = MediaType.find(:id => @media_type_id)
+      end
+
+      def media_type_id= mtid
+        return unless mtid
+        @media_type_id = mtid
+      end
+
+      def media_type_id
+        return @media_type_id if @media_type_id
+        return unless @media_type
+        @media_type_id = @media_type.id
+      end
+
+    end
+  end
+end
+
+      

data/lib/rubix/associations/belongs_to_user.rb

@@ -0,0 +1,33 @@
+module Rubix
+  module Associations
+
+    module BelongsToUser
+
+      def user= u
+        return unless u
+        @user    = u
+        @user_id = u.id
+      end
+
+      def user
+        return @user if @user
+        return unless @user_id
+        @user = User.find(:id => @user_id)
+      end
+
+      def user_id= uid
+        return unless uid
+        @user_id = uid
+      end
+
+      def user_id
+        return @user_id if @user_id
+        return unless @user
+        @user_id = @user.id
+      end
+
+    end
+  end
+end
+
+      

data/lib/rubix/associations/belongs_to_user_group.rb

@@ -0,0 +1,32 @@
+module Rubix
+  module Associations
+    module BelongsToUserGroup
+
+      def user_group= ug
+        return unless ug
+        @user_group    = ug
+        @user_group_id = ug.id
+      end
+
+      def user_group
+        return @user_group if @user_group
+        return unless @user_group_id
+        @user_group = UserGroup.find(:id => @user_group_id)
+      end
+
+      def user_group_id= ugid
+        return unless ugid
+        @user_group_id = ugid
+      end
+
+      def user_group_id
+        return @user_group_id if @user_group_id
+        return unless @user_group
+        @user_group_id = @user_group.id
+      end
+
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_conditions.rb

@@ -0,0 +1,23 @@
+module Rubix
+  module Associations
+    module HasManyConditions
+
+      def self.included klass
+        klass.send(:zabbix_attr, :condition_operator, :default => :and_or, :required => true)
+      end
+
+      def conditions
+        @conditions ||= []
+      end
+
+      def conditions= cs
+        @conditions = cs.map do |c|
+          c.kind_of?(Condition) ? c : Condition.new(c)
+        end
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_user_groups.rb

@@ -0,0 +1,32 @@
+module Rubix
+  module Associations
+    module HasManyUserGroups
+      
+      def user_groups= ugs
+        return unless ugs
+        @user_groups    = ugs
+        @user_group_ids = ugs.map(&:id)
+      end
+      
+      def user_groups
+        return @user_groups if @user_groups
+        return unless @user_group_ids
+        @user_groups = @user_group_ids.map { |ugid| UserGroup.find(:id => ugid) }
+      end
+
+      def user_group_ids= ugids
+        return unless ugids
+        @user_group_ids = ugids
+      end
+      
+      def user_group_ids
+        return @user_group_ids if @user_group_ids
+        return unless @user_groups
+        @user_group_ids = @user_groups.map(&:id)
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_users.rb

@@ -0,0 +1,32 @@
+module Rubix
+  module Associations
+    module HasManyUsers
+      
+      def users= us
+        return unless us
+        @users    = us
+        @user_ids = us.map(&:id)
+      end
+      
+      def users
+        return @users if @users
+        return unless @user_ids
+        @users = @user_ids.map { |uid| User.find(:id => uid) }
+      end
+
+      def user_ids= uids
+        return unless uids
+        @user_ids = uids
+      end
+      
+      def user_ids
+        return @user_ids if @user_ids
+        return unless @users
+        @user_ids = @users.map(&:id)
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/models.rb

@@ -1,12 +1,19 @@
 module Rubix
-  autoload :Model,          'rubix/models/model'
-  autoload :HostGroup,      'rubix/models/host_group'
-  autoload :Template,       'rubix/models/template'
-  autoload :Host,           'rubix/models/host'
-  autoload :Item,           'rubix/models/item'
-  autoload :Application,    'rubix/models/application'
-  autoload :UserMacro,      'rubix/models/user_macro'
-  autoload :Trigger,        'rubix/models/trigger'
-  autoload :TimeSeries,     'rubix/models/time_series'
-  autoload :MediaType,      'rubix/models/media_type'
+  autoload :Model,           'rubix/models/model'
+  autoload :HostGroup,       'rubix/models/host_group'
+  autoload :Template,        'rubix/models/template'
+  autoload :Host,            'rubix/models/host'
+  autoload :Item,            'rubix/models/item'
+  autoload :Application,     'rubix/models/application'
+  autoload :UserMacro,       'rubix/models/user_macro'
+  autoload :Trigger,         'rubix/models/trigger'
+  autoload :TimeSeries,      'rubix/models/time_series'
+  autoload :MediaType,       'rubix/models/media_type'
+  autoload :Script,          'rubix/models/script'
+  autoload :Action,          'rubix/models/action'
+  autoload :Condition,       'rubix/models/condition'
+  autoload :Operation,       'rubix/models/operation'
+  autoload :User,            'rubix/models/user'
+  autoload :UserGroup,       'rubix/models/user_group'
+  autoload :Medium,          'rubix/models/medium'
 end

data/lib/rubix/models/action.rb

@@ -0,0 +1,117 @@
+module Rubix
+  
+  class Action < Model
+
+    # Numeric codes for the event source.  Default will be 'triggers'.
+    EVENT_SOURCE_CODES = {
+      :triggers          => 0,
+      :discovery         => 1,
+      :auto_registration => 2
+    }.freeze
+    EVENT_SOURCE_NAMES = EVENT_SOURCE_CODES.invert.freeze
+
+    # The default subject for messages.
+    MESSAGE_SUBJECT = "{TRIGGER.NAME}: {TRIGGER.STATUS}"
+    
+    # The default body for messages.
+    MESSAGE_BODY = "{TRIGGER.NAME}: {TRIGGER.STATUS}\nLast value: {ITEM.LASTVALUE}\n\n{TRIGGER.URL}"
+
+    #
+    # == Properties & Finding ==
+    #
+
+    zabbix_attr :name,                     :required => true
+    zabbix_attr :event_source,             :default => :triggers, :required => true
+    zabbix_attr :escalation_time,          :default => 0
+    zabbix_attr :enabled,                  :default => true
+    zabbix_attr :message_subject,          :default => MESSAGE_SUBJECT
+    zabbix_attr :message_body,             :default => MESSAGE_BODY
+    zabbix_attr :send_recovery_message,    :default => false
+    zabbix_attr :recovery_message_subject, :default => MESSAGE_SUBJECT
+    zabbix_attr :recovery_message_body,    :default => MESSAGE_BODY
+
+    def initialize properties={}
+      super(properties)
+
+      self.operations = (properties[:operations] || [])
+      self.conditions = (properties[:conditions] || [])
+    end
+
+    #
+    # == Associations ==
+    #
+
+    include Associations::HasManyConditions
+
+    def operations
+      @operations ||= []
+    end
+
+    def operations= os
+      @operations = os.map do |o|
+        o.kind_of?(Operation) ? o : Operation.new(o)
+      end
+    end
+
+    #
+    # == Validations ==
+    #
+    def validate
+      super()
+      raise ValidationError.new("An action must have at least one operation defined.") if operations.empty?
+      operations.each do |operation|
+        return false unless operation.validate
+      end
+      true
+    end
+    
+    #
+    # == Requests ==
+    #
+
+    def create_params
+      {
+        :name          => name,
+        :eventsource   => self.class::EVENT_SOURCE_CODES[event_source],
+        :evaltype      => Condition::JOIN_CODES[condition_operator],
+        :status        => (enabled ? 0 : 1),
+        :esc_period    => escalation_time,
+        :def_shortdata => message_subject,
+        :def_longdata  => message_body,
+        :recovery_msg  => (send_recovery_message ? 1 : 0),
+        :r_shortdata   => recovery_message_subject,
+        :r_longdata    => recovery_message_body
+      }.tap do |cp|
+        cp[:conditions] = conditions.map(&:to_hash) unless conditions.empty?
+        cp[:operations] = operations.map(&:to_hash) unless operations.empty?
+      end
+    end
+
+    def self.find_params options={}
+      get_params.merge(:filter => {id_field => options[:id], :name => options[:name]})
+    end
+
+    def self.get_params
+      super().merge({:select_conditions => :refer, :select_operations => :refer})
+    end
+
+    def self.build action
+      new({
+            :id                       => action[id_field].to_i,
+            :name                     => action['name'],
+            :event_source             => self::EVENT_SOURCE_NAMES[action['eventsource'].to_i],
+            :condition_operator       => Condition::JOIN_NAMES[action['evaltype'].to_i],
+            :enabled                  => (action['status'].to_i == 0),
+            :escalation_time          => action['esc_period'].to_i,
+            :message_subject          => action['def_shortdata'],
+            :message_body             => action['def_longdata'],
+            :send_recovery_message    => (action['recovery_msg'].to_i == 1),
+            :recovery_message_subject => action['r_shortdata'],
+            :recovery_message_body    => action['r_longdata'],
+            :conditions               => (action['conditions'] || []).map { |c| Condition.build(c) },
+            :operations               => (action['operations'] || []).map { |o| Operation.build(o) }
+          })
+    end
+    
+  end
+end