rubix 0.0.1 → 0.0.2

data/lib/rubix/models/model.rb

@@ -0,0 +1,126 @@
+module Rubix
+
+  # It might be worth using ActiveModel -- but maybe not.  The goal is
+  # to keep dependencies low while still retaining expressiveness.
+  class Model
+
+    attr_accessor :properties, :id
+
+    extend Logs
+    include Logs
+
+    def self.model_name
+      self.to_s.split('::').last
+    end
+
+    def self.log_name
+      model_name
+    end
+
+    def initialize properties={}
+      @properties = properties
+      @id         = properties[:id]
+      @log_name   = self.class.model_name
+    end
+    
+    def new_record?
+      @id.nil?
+    end
+
+    def request method, params
+      self.class.request(method, params)
+    end
+
+    def self.request method, params
+      Rubix.connection && Rubix.connection.request(method, params)
+    end
+
+    def self.find options={}
+      response = find_request(options)
+      case
+      when response.has_data?
+        build(response.result.first)
+      when response.success?
+        # a successful but empty response means it wasn't found
+      else
+        error("Could not find #{options.inspect}: #{response.error_message}")
+        nil
+      end
+    end
+
+    def self.find_or_create options={}
+      response = find_request(options)
+      case
+      when response.has_data?
+        build(response.result.first)
+      when response.success?
+        # doesn't exist
+        obj = new(options)
+        if obj.save
+          obj
+        else
+          false
+        end
+      else
+        error("Could not create #{options.inspect}: #{response.error_message}")
+        false
+      end
+    end
+
+    def validate
+      true
+    end
+    
+    def create
+      return false unless validate
+      response = create_request
+      if response.has_data?
+        @id = response.result[self.class.id_field + 's'].first.to_i
+        info("Created")
+        true
+      else
+        error("Could not create: #{response.error_message}")
+        false
+      end
+    end
+
+    def update
+      return false unless validate
+      return create if new_record?
+      response = update_request
+      if response.has_data?
+        info("Updated")
+        after_update
+      else
+        error("Could not update: #{response.error_message}")
+        false
+      end
+      after_update
+    end
+
+    def after_update
+      true
+    end
+
+    def save
+      new_record? ? create : update
+    end
+
+    def destroy
+      return false if new_record?
+      response = destroy_request
+      case
+      when response.has_data? && response.result.values.first.first.to_i == id
+        info("Destroyed")
+        true
+      when response.zabbix_error? && response.error_message =~ /does not exist/i
+        # was never there
+        true
+      else
+        error("Could not destroy: #{response.error_message}")
+        false
+      end
+    end
+
+  end
+end

data/lib/rubix/models/template.rb

@@ -2,79 +2,81 @@ module Rubix
   
   class Template < Model
 
-    attr_accessor :name, :host_ids
+    #
+    # == Properties & Finding ==
+    #
 
+    attr_accessor :name
+    
     def initialize properties={}
       super(properties)
-      @name = properties[:name]
-    end
-
-    def log_name
-      "TEMPLATE #{name || id}"
-    end
+      @name     = properties[:name]
+      
+      self.host_ids = properties[:host_ids]
+      self.hosts    = properties[:hosts]
 
-    def register
-      exists? ? update : create
+      self.host_group_ids = properties[:host_group_ids]
+      self.host_groups    = properties[:host_groups]
     end
 
-    def unregister
-      destroy if exists?
-    end
-    
-    def load
-      response = request('template.get', 'filter' => {'templateid' => id, 'name' => name}, 'select_hosts' => 'refer', 'output' => 'extend')
+    def self.find_request options={}
+      params = {'select_groups' => 'refer', 'select_hosts' => 'refer', 'output' => 'extend'}
       case
-      when response.has_data?
-        @id       = response.first['templateid'].to_i
-        @name     = response.first['name']
-        @host_ids = response.first['hosts'].map { |host_info| host_info['hostid'].to_i }
-        @loaded   = true
-        @exists   = true
-      when response.success?
-        @exists = false
-        @loaded = true
-      else
-        error("Could not load: #{response.error_messaage}")
+      when options[:id]
+        params['templateids'] = [options[:id]]
+      when options[:name]
+        params['filter'] = { 'host' => options[:name] }
       end
+      request('template.get', params)
     end
 
-    def create
-      response = request('template.create', [{'name' => name}])
-      if response.has_data?
-        @id     = response['templateids'].first.to_i
-        @exists = true
-        info("Created")
-      else
-        error("Could not create: #{response.error_message}.")
-      end
+    def self.build template
+      new({
+            :id       => (template['templateid'] || template['hostid']).to_i,
+            :name     => template['host'],
+            :host_ids => template['hosts'].map { |host_info| host_info['hostid'].to_i },
+            :host_group_ids => template['groups'].map { |group| group['groupid'].to_i }
+          })
+    end
+
+    def log_name
+      "TEMPLATE #{name || id}"
     end
 
-    def update
-      # noop
-      info("Updated")
+    def self.id_field
+      'templateid'
     end
 
-    def destroy
-      response = request('template.delete', [{'templateid' => id}])
-      case
-      when response.has_data? && response['templateids'].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
+    #
+    # == Validation ==
+    #
+
+    def validate
+      raise ValidationError.new("A template must have at least one host group.") if host_group_ids.nil? || host_group_ids.empty?
+      true
     end
+    
+    #
+    # == Associations ==
+    #
 
-    def contains? host
-      return unless exists?
-      host_ids.include?(host.id)
+    include Associations::HasManyHosts
+    include Associations::HasManyHostGroups
+
+    #
+    # == CRUD ==
+    #
+    
+    def create_request
+      request('template.create', {'host' => name, 'groups' => host_group_params})
+    end
+    
+    def update_request
+      request('template.update', [{'host' => name, 'templateid' => id, 'groups' => host_group_params}])
     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('template.delete', [{'templateid' => id}])
     end
     
   end

data/lib/rubix/models/user_macro.rb

@@ -0,0 +1,84 @@
+module Rubix
+  
+  class UserMacro < Model
+
+    #
+    # == Properties & Finding ==
+    #
+    
+    attr_accessor :name, :value
+
+    def initialize properties={}
+      super(properties)
+      @name  = properties[:name] || self.class.unmacro_name(properties[:macro])
+      @value = properties[:value]
+
+      self.host    = properties[:host]
+      self.host_id = properties[:host_id]
+    end
+
+    def self.find_request options={}
+      request('usermacro.get', 'hostids' => [options[:host_id]], 'filter' => {'macro' => macro_name(options[:name])}, "output" => "extend")
+    end
+
+    def self.build macro
+      new({
+            :id      => macro['hostmacroid'].to_i,
+            :name    => unmacro_name(macro['macro']),
+            :value   => macro['value'],
+            :host_id => macro['hostid']
+          })
+    end
+    
+    def log_name
+      "MACRO #{macro_name}@#{host.name}"
+    end
+
+    def self.unmacro_name name
+      (name || '').gsub(/^\{\$/, '').gsub(/\}$/, '').upcase
+    end
+
+    def self.macro_name name
+      "{$#{name.upcase}}"
+    end
+
+    def macro_name
+      self.class.macro_name(name)
+    end
+    
+    def self.id_field
+      'hostmacroid'
+    end
+
+    #
+    # == Associations ==
+    #
+    
+    include Associations::BelongsToHost
+
+    #
+    # == Validation ==
+    #
+    def validate
+      raise ValidationError.new("A user macro must have both a 'name' and a 'value'") if name.nil? || name.strip.empty? || value.nil? || value.strip.empty?
+      true
+    end
+    
+    #
+    # == CRUD ==
+    #
+    
+    def create_request
+      request('usermacro.massAdd', 'macros' => [{'macro' => macro_name, 'value' => value}], 'hosts' => [{'hostid' => host_id}])
+    end
+    
+    def update_request
+      request('usermacro.massUpdate', 'macros' => [{'macro' => macro_name, 'value' => value}], 'hosts' => [{'hostid' => host_id}])
+    end
+
+    def destroy_request
+      request('usermacro.massRemove', 'hostids' => [host_id], 'macros' => [macro_name])
+    end
+    
+  end
+end

data/lib/rubix/monitors.rb

@@ -0,0 +1,5 @@
+module Rubix
+  autoload :Monitor,        'rubix/monitors/monitor'
+  autoload :ChefMonitor,    'rubix/monitors/chef_monitor'
+  autoload :ClusterMonitor, 'rubix/monitors/cluster_monitor'
+end

data/spec/requests/application_request_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "CRUD for hosts" do
+
+  before do
+    @hg = Rubix::HostGroup.new(:name => 'rubix_spec_host_group_1')
+    @hg.save
+    
+    @h1  = Rubix::Host.new(:name => 'rubix_spec_host_1', :host_groups => [@hg])
+    @h1.save
+
+    @h2  = Rubix::Host.new(:name => 'rubix_spec_host_2', :host_groups => [@hg])
+    @h2.save
+  end
+
+  after do
+    @h1.destroy
+    @h2.destroy
+    @hg.destroy
+  end
+  
+  it "should be able to create, update, and destroy a host" do
+    integration_test
+    
+    Rubix::Application.find(:name => 'rubix_spec_app_1', :host_id => @h1.id).should be_nil
+    
+    app = Rubix::Application.new(:name => 'rubix_spec_app_1', :host_id => @h1.id)
+    app.save
+    new_a = Rubix::Application.find(:name => 'rubix_spec_app_1', :host_id => @h1.id)
+    new_a.should_not be_nil
+    new_a.id.should == app.id
+    new_a.host_id.should == @h1.id
+    id = app.id
+    id.should_not be_nil
+
+    app.name = 'rubix_spec_app_2'
+    app.update
+    new_a = Rubix::Application.find(:id => id, :name => 'rubix_spec_app_2', :host_id => @h1.id)
+    new_a.should_not be_nil
+    new_a.name.should == 'rubix_spec_app_2'
+    
+    app.destroy
+    Rubix::Application.find(:id => id, :host_id => @h1.id).should be_nil
+  end
+end

data/spec/requests/host_group_request_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "CRUD for host groups" do
+
+  it "should be able to create, update, and destroy a host group" do
+    integration_test
+    
+    Rubix::HostGroup.find(:name => 'rubix_spec_host_group_1').should be_nil
+    
+    hg = Rubix::HostGroup.new(:name => 'rubix_spec_host_group_1')
+    hg.save
+    Rubix::HostGroup.find(:name => 'rubix_spec_host_group_1').should_not be_nil
+    id = hg.id
+    id.should_not be_nil
+
+    hg.name = 'rubix_spec_host_group_2'
+    hg.update
+    Rubix::HostGroup.find(:id => id).name.should == 'rubix_spec_host_group_2'
+    
+    hg.destroy
+    Rubix::HostGroup.find(:id => id).should be_nil
+  end
+end

data/spec/requests/host_request_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe "CRUD for hosts" do
+
+  before do
+    @hg1 = Rubix::HostGroup.new(:name => 'rubix_spec_host_group_1')
+    @hg1.save
+
+    @hg2 = Rubix::HostGroup.new(:name => 'rubix_spec_host_group_2')
+    @hg2.save
+    
+    @t1 = Rubix::Template.new(:name => 'rubix_spec_template_1', :host_groups => [@hg1])
+    @t1.save
+
+    @t2 = Rubix::Template.new(:name => 'rubix_spec_template_2', :host_groups => [@hg2])
+    @t2.save
+
+    @um1 = Rubix::UserMacro.new(:name => 'rubix_spec_macro_1', :value => 'rubix_spec_value_1')
+    @um2 = Rubix::UserMacro.new(:name => 'rubix_spec_macro_2', :value => 'rubix_spec_value_2')
+    
+  end
+
+  after do
+    @t1.destroy
+    @t2.destroy
+    @hg1.destroy
+    @hg2.destroy
+  end
+  
+  it "should be able to create, update, and destroy a host" do
+    integration_test
+    
+    Rubix::Host.find(:name => 'rubix_spec_host_1').should be_nil
+    
+    h = Rubix::Host.new(:name => 'rubix_spec_host_1', :host_groups => [@hg1], :templates => [@t1], :user_macros => [@um1])
+    h.save
+    begin
+      new_h = Rubix::Host.find(:name => 'rubix_spec_host_1')
+      new_h.should_not be_nil
+      new_h.template_ids.should include(@t1.id)
+      new_h.host_group_ids.should include(@hg1.id)
+      new_h.user_macros.size.should == 1
+      new_h.user_macros.first.name.should  == 'RUBIX_SPEC_MACRO_1'
+      new_h.user_macros.first.value.should == 'rubix_spec_value_1'
+      
+      id = h.id
+      id.should_not be_nil
+      
+      h.name = 'rubix_spec_host_2'
+      h.host_groups = [@hg2]
+      h.templates = [@t2]
+      h.user_macros = [@um2]
+      h.update
+      
+      new_h = Rubix::Host.find(:name => 'rubix_spec_host_2')
+      new_h.should_not be_nil
+      new_h.template_ids.should include(@t2.id)
+      new_h.host_group_ids.should include(@hg2.id)
+      new_h.user_macros.size.should == 1
+      new_h.user_macros.first.name.should  == 'RUBIX_SPEC_MACRO_2'
+      new_h.user_macros.first.value.should == 'rubix_spec_value_2'
+    rescue => e
+      puts "#{e.class} -- #{e.message}"
+      puts e.backtrace
+    ensure
+      h.destroy
+    end
+    Rubix::Host.find(:id => id).should be_nil
+  end
+end