rubix 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/rubix.rb

@@ -1,7 +1,16 @@
 require 'rubygems'
+
 require 'rubix/log'
+require 'rubix/models'
+require 'rubix/associations'
+require 'rubix/monitors'
+
 module Rubix
 
+  autoload :Connection,     'rubix/connection'
+  autoload :Response,       'rubix/response'
+  autoload :Sender,         'rubix/sender'
+  
   def self.connect server, username=nil, password=nil
     self.connection = Connection.new(server, username, password)
   end
@@ -17,22 +26,6 @@ module Rubix
     @connection
   end
 
-  autoload :Connection,     'rubix/connection'
-  autoload :Response,       'rubix/response'
-
-  autoload :Model,          'rubix/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 :Monitor,        'rubix/monitor'
-  autoload :ChefMonitor,    'rubix/monitors/chef_monitor'
-  autoload :ClusterMonitor, 'rubix/monitors/cluster_monitor'
-
-  autoload :Sender,         'rubix/sender'
-
   Error               = Class.new(RuntimeError)
   ConnectionError     = Class.new(Error)
   AuthenticationError = Class.new(Error)

data/lib/rubix/associations.rb

@@ -0,0 +1,14 @@
+module Rubix
+  module Associations
+    
+    autoload :HasManyHosts,         'rubix/associations/has_many_hosts'
+    autoload :HasManyTemplates,     'rubix/associations/has_many_templates'
+    autoload :HasManyHostGroups,    'rubix/associations/has_many_host_groups'
+    autoload :HasManyUserMacros,    'rubix/associations/has_many_user_macros'
+    autoload :HasManyApplications,  'rubix/associations/has_many_applications'
+    
+    autoload :BelongsToHost, 'rubix/associations/belongs_to_host'
+    
+  end
+end
+

data/lib/rubix/associations/belongs_to_host.rb

@@ -0,0 +1,32 @@
+module Rubix
+  module Associations
+    module BelongsToHost
+      
+      def host= h
+        return unless h
+        @host    = h
+        @host_id = h.id
+      end
+      
+      def host
+        return @host if @host
+        return unless @host_id
+        @host = Host.find(:id => @host_id)
+      end
+
+      def host_id= hid
+        return unless hid
+        @host_id = hid
+      end
+      
+      def host_id
+        return @host_id if @host_id
+        return unless @host
+        @host_id = @host.id
+      end
+
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_applications.rb

@@ -0,0 +1,32 @@
+module Rubix
+  module Associations
+    module HasManyApplications
+      
+      def applications= hs
+        return unless hs
+        @applications    = hs
+        @application_ids = hs.map(&:id)
+      end
+      
+      def applications
+        return @applications if @applications
+        return unless @application_ids
+        @applications = @application_ids.map { |aid| Application.find(:id => aid, :host_id => host_id) }
+      end
+
+      def application_ids= aids
+        return unless aids
+        @application_ids = aids
+      end
+      
+      def application_ids
+        return @application_ids if @application_ids
+        return unless @applications
+        @application_ids = @applications.map(&:id)
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_host_groups.rb

@@ -0,0 +1,37 @@
+module Rubix
+  module Associations
+    module HasManyHostGroups
+      
+      def host_groups= hs
+        return unless hs
+        @host_groups    = hs
+        @host_group_ids = hs.map(&:id)
+      end
+      
+      def host_groups
+        return @host_groups if @host_groups
+        return unless @host_group_ids
+        @host_groups = @host_group_ids.map { |hgid| HostGroup.find(:id => hgid) }
+      end
+
+      def host_group_ids= hgids
+        return unless hgids
+        @host_group_ids = hgids
+      end
+      
+      def host_group_ids
+        return @host_group_ids if @host_group_ids
+        return unless @host_groups
+        @host_group_ids = @host_groups.map(&:id)
+      end
+
+      def host_group_params
+        return [] unless host_group_ids
+        host_group_ids.map { |hid| { 'groupid' => hid } }
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_hosts.rb

@@ -0,0 +1,32 @@
+module Rubix
+  module Associations
+    module HasManyHosts
+      
+      def hosts= hs
+        return unless hs
+        @hosts    = hs
+        @host_ids = hs.map(&:id)
+      end
+      
+      def hosts
+        return @hosts if @hosts
+        return unless @host_ids
+        @hosts = @host_ids.map { |hid| Host.find(:id => hid) }
+      end
+
+      def host_ids= hids
+        return unless hids
+        @host_ids = hids
+      end
+      
+      def host_ids
+        return @host_ids if @host_ids
+        return unless @hosts
+        @host_ids = @hosts.map(&:id)
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_templates.rb

@@ -0,0 +1,37 @@
+module Rubix
+  module Associations
+    module HasManyTemplates
+      
+      def templates= hs
+        return unless hs
+        @templates    = hs
+        @template_ids = hs.map(&:id)
+      end
+      
+      def templates
+        return @templates if @templates
+        return unless @template_ids
+        @templates = @template_ids.map { |tid| Template.find(:id => tid) }
+      end
+
+      def template_ids= tids
+        return unless tids
+        @template_ids = tids
+      end
+      
+      def template_ids
+        return @template_ids if @template_ids
+        return unless @templates
+        @template_ids = @templates.map(&:id)
+      end
+
+      def template_params
+        return [] unless template_ids
+        template_ids.map { |tid| { 'templateid' => tid } }
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/associations/has_many_user_macros.rb

@@ -0,0 +1,37 @@
+module Rubix
+  module Associations
+    module HasManyUserMacros
+      
+      def user_macros= hs
+        return unless hs
+        @user_macros    = hs
+        @user_macro_ids = hs.map(&:id)
+      end
+      
+      def user_macros
+        return @user_macros if @user_macros
+        return unless @user_macro_ids
+        @user_macros = @user_macro_ids.map { |umid| UserMacro.find(:id => umid) }
+      end
+
+      def user_macro_ids= umids
+        return unless umids
+        @user_macro_ids = umids
+      end
+      
+      def user_macro_ids
+        return @user_macro_ids if @user_macro_ids
+        return unless @user_macros
+        @user_macro_ids = @user_macros.map(&:id)
+      end
+
+      def user_macro_params
+        return [] unless user_macros
+        user_macros.map { |um| { 'macro' => um.macro_name, 'value' => um.value } }
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rubix/log.rb

@@ -12,29 +12,42 @@ module Rubix
   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
+    @logger       = Logger.new(default_log_path)
+    @logger.level = default_log_severity
+    p default_log_severity
+    @logger
+  end
 
-    if defined?(Settings) && Settings[:log]
-      begin
-        file = Settings[:log]
-      rescue NameError => e
-      end
+  def self.default_log_severity
+    case
+    when defined?(Settings) && Settings[:log_level]
+      Logger.const_get(Settings[:log_level].to_s.strip)
+    when ENV["RUBIX_LOG_LEVEL"]
+      severity_name = ENV["RUBIX_LOG_LEVEL"].to_s.strip
+    else
+      severity_name = 'info'
     end
     
-    @logger       = Logger.new(file)
-    @logger.level = severity
-    @logger
+    begin
+      return Logger.const_get(severity_name.upcase)
+    rescue NameError => e
+      return Logger::INFO
+    end
   end
 
+  def self.default_log_path
+    case
+    when defined?(Settings) && Settings[:log]
+      Settings[:log]
+    when ENV["RUBIX_LOG_PATH"] == '-'
+      $stdout
+    when ENV["RUBIX_LOG_PATH"]
+      ENV["RUBIX_LOG_PATH"]
+    else
+      $stdout
+    end
+  end
+      
   module Logs
 
     def log_name

data/lib/rubix/models.rb

@@ -0,0 +1,9 @@
+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'
+end

data/lib/rubix/models/application.rb

@@ -2,74 +2,68 @@ module Rubix
   
   class Application < Model
 
-    attr_accessor :name, :host
+    #
+    # == Properties & Finding ==
+    #
 
     def initialize properties={}
       super(properties)
-      @name = properties[:name]
-      @host = properties[:host]
+      @name    = properties[:name]
+      
+      self.host_id = properties[:host_id]
+      self.host    = properties[:host]
     end
+    
+    attr_accessor :name
 
-    def params
-      {
-        :name   => name,
-        :hostid => host.id
-      }
+    def self.find_request options={}
+      request('application.get', 'hostids' => [options[:host_id]], 'filter' => {'name' => options[:name], 'applicationid' => options[:id]}, "output" => "extend")
     end
 
-    def log_name
-      "APP #{name || id}@#{host.name}"
-    end
+    def self.build app
+      params = {
+        :id   => app['applicationid'].to_i,
+        :name => app['name']
+      }
 
-    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
+      # use the host id if available, else use the template id
+      if app['hosts'] && app['hosts'].first && app['hosts'].first['hostid']
+        params[:host_id] = app['hosts'].first['hostid'].to_i
       else
-        error("Could not load: #{response.error_message}")
+        params[:host_id] = app['templateid']
       end
+      new(params)
+    end
+    
+    def log_name
+      "APP #{name || id}@#{host.name}"
     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
+    def self.id_field
+      'applicationid'
     end
+    
+    
+    #
+    # == Associations ==
+    #
 
-    def update
-      # noop
-      info("Updated")
+    include Associations::BelongsToHost
+    
+    #
+    # == CRUD ==
+    #
+    
+    def create_request
+      request('application.create', 'name' => name, 'hostid' => host_id)
     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
+    def update_request
+      request('application.update', 'applicationid' => id, 'name' => name, 'hosts' => {'hostid' => host_id})
     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
+    def destroy_request
+      request('application.delete', [id])
     end
     
   end