rubix 0.4.0 → 0.4.1

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/rubix/connection.rb

@@ -1,4 +1,5 @@
 require 'uri'
+require 'cgi'
 require 'net/http'
 require 'json'
 
@@ -11,6 +12,13 @@ module Rubix
 
     include Logs
 
+    # The name of the cookie used by the Zabbix web application.  Used
+    # when emulating a request from a browser.
+    COOKIE_NAME = 'zbx_sessionid'
+
+    # The content type header to send when emulating a browser.
+    CONTENT_TYPE = 'multipart/form-data'
+
     # @return [URI] The URI for the Zabbix API.
     attr_reader :uri
 
@@ -62,18 +70,33 @@ module Rubix
     #
     # @param [String] method the name of the Zabbix API method
     # @param [Hash,Array] params parameters for the method call
-    # @retrn [Rubix::Response]
+    # @return [Rubix::Response]
     def request method, params
+      authorize! unless authorized?
+      response = till_response do
+        send_api_request :jsonrpc => "2.0",
+        :id      => request_id,
+        :method  => method,
+        :params  => params,
+        :auth    => auth
+      end
+      Response.new(response)
+    end
+
+    # Send a request to the Zabbix web application.  The request is
+    # designed to emulate a web browser.
+    #
+    # Any values in +data+ which are file handles will trigger a
+    # multipart POST request, uploading those files.
+    #
+    # @param [String] verb one of "GET" or "POST"
+    # @param [String] path the path to send the request to
+    # @param [Hash] data the data to include in the request
+    # @return [Net::HTTP::Response]
+    def web_request verb, path, data={}
       authorize! unless authorized?
       till_response do
-        raw_params = {
-          :jsonrpc => "2.0",
-          :id      => request_id,
-          :method  => method,
-          :params  => params,
-          :auth    => auth
-        }
-        send_raw_request(raw_params)
+        send_web_request(verb, path, data)
       end
     end
     
@@ -86,7 +109,7 @@ module Rubix
     # Force the connection to execute an authorization request and
     # renew (or set) the authorization token.
     def authorize!
-      response = till_response { send_raw_request(authorization_params) }
+      response = Response.new(till_response { send_api_request(authorization_params) })
       raise AuthenticationError.new("Could not authenticate with Zabbix API at #{uri}: #{response.error_message}") if response.error?
       raise AuthenticationError.new("Malformed response from Zabbix API: #{response.body}") unless response.string?
       @auth = response.result
@@ -145,7 +168,7 @@ module Rubix
       when response.code.to_i >= 500
         raise ConnectionError.new("Too many consecutive failed requests (#{max_attempts}) to the Zabbix API at (#{uri}).")
       else
-        @last_response = Response.new(response)
+        @last_response = response
       end
     end
 
@@ -153,21 +176,42 @@ module Rubix
     #
     # @param [Hash, #to_json] raw_params the complete parameters of the request.
     # @return [Net::HTTP::Response]
-    def send_raw_request raw_params
+    def send_api_request raw_params
       @request_id += 1
       begin
-        raw_response = server.request(raw_post_request(raw_params))
+        raw_response = server.request(raw_api_request(raw_params))
       rescue NoMethodError, SocketError => e
         raise RequestError.new("Could not connect to Zabbix server at #{host_with_port}")
       end
       raw_response
     end
+
+    # Send a Web request to Zabbix.
+    #
+    # The existing authorization token will be used to emulate a
+    # request sent by a browser.
+    #
+    # Any values in +data+ which are file handles will trigger a
+    # multipart POST request, uploading those files.
+    #
+    # @param [String] verb one of "GET" or "POST"
+    # @param [String] path the path to send the request to
+    # @param [Hash] data the data to include in the request
+    def send_web_request verb, path, data={}
+      # Don't increment this for web requests?
+      # @request_id += 1
+      begin
+        raw_response = server.request(raw_web_request(verb, path, data))
+      rescue NoMethodError, SocketError => e
+        raise RequestError.new("Could not connect to the Zabbix server at #{host_with_port}")
+      end
+    end
     
     # Generate the raw POST request to send to the Zabbix API
     #
     # @param [Hash, #to_json] raw_params the complete parameters of the request.
     # @return [Net::HTTP::Post]
-    def raw_post_request raw_params
+    def raw_api_request raw_params
       json_body = raw_params.to_json
       Rubix.logger.log(Logger::DEBUG, "SEND: #{json_body}") if Rubix.logger
       Net::HTTP::Post.new(uri.path).tap do |req|
@@ -176,6 +220,94 @@ module Rubix
       end
     end
 
+    # Generate a raw web request to send to the Zabbix web application
+    # as though it came from a browser.
+    #
+    # @param [String] verb the HTTP verb, either "GET" (default) or "POST"
+    # @param [String] path the path on the server to send the request to
+    # @param [Hash]   data the data for the request
+    def raw_web_request verb, path, data={}
+      case
+      when verb == "GET"
+        raw_get_request(path)
+      when verb == "POST" && data.values.any? { |value| value.respond_to?(:read) }
+        raw_multipart_post_request(path, data)
+      when verb == "POST"
+        raw_post_request(path, data)
+      else
+        raise Rubix::RequestError.new("Invalid HTTP verb: #{verb}")
+      end
+    end
+
+    # Generate an authenticated GET request emulating a browser.
+    #
+    # @param [String] path the path to send the request to.
+    # @return [Net::HTTP::Get]
+    def raw_get_request(path)
+      Net::HTTP::Get.new(path).tap do |req|
+        req['Content-Type'] = self.class::CONTENT_TYPE
+        req['Cookie']       = "#{self.class::COOKIE_NAME}=#{CGI::escape(auth.to_s)}"
+      end
+    end
+
+    # Generate an authenticated POST request emulating a browser.  It
+    # is assumed that +data+ is not multipart data.
+    #
+    # @param [String] path the path to send the request to.
+    # @param [Hash] data the data to send
+    # @return [Net::HTTP::Post]
+    def raw_post_request(path, data={})
+      Net::HTTP::Post.new(path).tap do |req|
+        req['Content-Type'] = self.class::CONTENT_TYPE
+        req['Cookie']       = "#{self.class::COOKIE_NAME}=#{CGI::escape(auth.to_s)}"
+        req.body            = formatted_post_body(data)
+      end
+    end
+
+    # Generate an authenticated POST request emulating a browser.
+    # Assumes data is multipart data, with some values being file
+    # handles.
+    #
+    # @param [String] path the path to send the request to.
+    # @param [Hash] data the data to send
+    # @return [Net::HTTP::Post::Multipart]
+    def raw_multipart_post_request(path, data={})
+      require 'net/http/post/multipart'
+      Net::HTTP::Post::Multipart.new(path, wrapped_multipart_post_data(data)).tap do |req|
+        req['Cookie'] = "#{self.class::COOKIE_NAME}=#{CGI::escape(auth.to_s)}"
+      end
+    end
+
+    # Wrap +data+ with +UploadIO+ objects so that it can be properly
+    # handled by the Net::HTTP::Post::Multipart class.
+    #
+    # @param [Hash] data
+    # @return [Hash]
+    def wrapped_multipart_post_data data
+      {}.tap do |wrapped|
+        data.each_pair do |key, value|
+          if value.respond_to?(:read)
+            # We are going to assume it's always XML we're uploading.
+            wrapped[key] = UploadIO.new(value, "application/xml", File.basename(value.path))
+          else
+            wrapped[key] = value
+          end
+        end
+      end
+    end
+
+    # Format +data+ as a POST data string.
+    #
+    # @param [Hash] data
+    # @return [String]
+    def formatted_post_body data
+      [].tap do |pairs|
+        data.each_pair do |key, value|
+          pairs << [key, value].map { |s| CGI::escape(s.to_s) }.join('=')
+        end
+      end.join('&')
+    end
+
     # Used for generating helpful error messages.
     #
     # @return [String]

data/lib/rubix/models/host.rb

@@ -101,6 +101,7 @@ module Rubix
           hp[:port]  = port || self.class::DEFAULT_PORT
         else
           hp[:ip] = self.class::BLANK_IP
+          hp[:useip] = 1
         end
       end
     end

data/lib/rubix/models/model.rb

@@ -93,6 +93,16 @@ module Rubix
       Rubix.connection && Rubix.connection.request(method, params)
     end
 
+    # Send a web request to the Zabbix web application.  This is just
+    # a convenience method for <tt>Rubix::Connection#web_request</tt>.
+    #
+    # @param [String] verb one of "GET" or "POST"
+    # @param [String] path the path to send the request to
+    # @param [Hash] data the data to include with the request
+    def self.web_request verb, path, data={}
+      Rubix.connection && Rubix.connection.web_request(verb, path, data)
+    end
+
     # Is this a new record?  We can tell because the ID must be blank.
     #
     # @return [true, false]

data/lib/rubix/models/template.rb

@@ -67,6 +67,48 @@ module Rubix
             :host_group_ids => template['groups'].map { |group| group['groupid'].to_i }
           })
     end
+
+    #
+    # == Import/Export ==
+    #
+
+    # Options which control the template import process and the Zabbix
+    # keys they need to be mapped to.
+    IMPORT_OPTIONS = {
+      :update_hosts     => 'rules[host][exist]',
+      :add_hosts        => 'rules[host][missed]',
+      :update_items     => 'rules[item][exist]',
+      :add_items        => 'rules[item][missed]',
+      :update_triggers  => 'rules[trigger][exist]',
+      :add_triggers     => 'rules[trigger][missed]',
+      :update_graphs    => 'rules[graph][exist]',
+      :add_graphs       => 'rules[graph][missed]',
+      :update_templates => 'rules[template][exist]'
+    }.freeze
+
+    # Import/update a template from XML contained in an open file
+    # handle +fh+.
+    #
+    # By default all hosts, items, triggers, and graphs the XML
+    # defines will be both added and updated.  (Linked templates will
+    # also be updated.)  This behavior matches the default behavior of
+    # the web interface in Zabbix 1.8.8.
+    #
+    # This can be controlled with options like <tt>:update_hosts</tt>
+    # or <tt>:add_graphs</tt>, all of which default to true.  (Linked
+    # templates are controlled with <tt>:update_templates</tt>.)
+    def self.import fh, options={}
+      response = web_request("POST", "/templates.php", import_options(options).merge(:import_file => fh))
+      File.open('/tmp/output.html', 'w') { |f| f.puts(response.body) }
+    end
+
+    def self.import_options options
+      {}.tap do |o|
+        self::IMPORT_OPTIONS.each_pair do |name, zabbix_name|
+          o[zabbix_name] = 'yes' unless options[name] == false
+        end
+      end
+    end
     
   end
 end

data/lib/rubix/models/time_series.rb

@@ -13,6 +13,7 @@ module Rubix
       super(properties)
       @from       = properties[:from]
       @upto       = properties[:upto]
+      @raw_data   = properties[:raw_data]
       
       self.item    = properties[:item]
       self.item_id = properties[:item_id]
@@ -37,6 +38,14 @@ module Rubix
     def upto
       @upto ||= self.class.default_upto
     end
+    
+    def history
+      @history ||= self.class.default_history(item)
+    end
+    
+    def self.default_history item
+      item.respond_to?(:value_type) ? Item::VALUE_CODES[item.value_type] : 3
+    end
 
     def raw_data
       @raw_data ||= []
@@ -60,7 +69,8 @@ module Rubix
       super().merge({
                       :itemids => [options[:item_id].to_s],
                       :time_from => (options[:from] || default_from).to_i.to_s,
-                      :time_till => (options[:upto] || default_upto).to_i.to_s
+                      :time_till => (options[:upto] || default_upto).to_i.to_s,
+                      :history   => (options[:history] || default_history(options[:item])).to_s
                     })
     end
 

data/spec/data/test_template.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<zabbix_export version="1.0" date="13.02.12" time="19.56">
+  <hosts>
+    <host name="test">
+      <proxy_hostid>0</proxy_hostid>
+      <useip>1</useip>
+      <dns></dns>
+      <ip>127.0.0.1</ip>
+      <port>10050</port>
+      <status>3</status>
+      <useipmi>0</useipmi>
+      <ipmi_ip>127.0.0.1</ipmi_ip>
+      <ipmi_port>623</ipmi_port>
+      <ipmi_authtype>0</ipmi_authtype>
+      <ipmi_privilege>2</ipmi_privilege>
+      <ipmi_username></ipmi_username>
+      <ipmi_password></ipmi_password>
+      <groups>
+        <group>Templates</group>
+      </groups>
+      <triggers/>
+      <items/>
+      <templates/>
+      <graphs/>
+      <macros/>
+    </host>
+  </hosts>
+  <dependencies/>
+</zabbix_export>

data/spec/requests/connection_request_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Rubix::Connection do
+
+  before do
+    integration_test
+  end
+
+  after do
+    truncate_all_tables
+  end
+
+  it "can perform an authorized GET request to the homepage" do
+    response = Rubix.connection.web_request("GET", "/")
+    response.should_not be_nil
+    response.code.to_i.should == 200
+    response.body.should_not include('guest')
+    response.body.should     include($RUBIX_INTEGRATION_TEST['username'])
+  end
+
+  it "can perform an authorized POST request to the homepage" do
+    response = Rubix.connection.web_request("POST", "/", :foo => 'bar', :baz => 'buzz')
+    response.should_not be_nil
+    response.code.to_i.should == 200
+    response.body.should_not include('guest')
+    response.body.should     include($RUBIX_INTEGRATION_TEST['username'])
+  end
+
+  it "can perform an authorized multipart POST request to the homepage" do
+    response = Rubix.connection.web_request("POST", "/", :foo => File.new(data_path('test_template.xml')))
+    response.should_not be_nil
+    response.code.to_i.should == 200
+    response.body.should_not include('guest')
+    response.body.should     include($RUBIX_INTEGRATION_TEST['username'])
+  end
+  
+end
+

data/spec/requests/template_request_spec.rb

@@ -22,6 +22,11 @@ describe "Templates" do
       template = Rubix::Template.new(:name => 'rubix_spec_template_1', :host_groups => [@host_group_1])
       template.save.should be_true
     end
+
+    it "can be imported" do
+      Rubix::Template.import(File.new(data_path('test_template.xml')))
+      Rubix::Template.find(:name => 'test').should_not be_nil
+    end
     
   end
 
@@ -45,8 +50,4 @@ describe "Templates" do
     
   end
 
-  it "should be able to import and export a template" do
-    pending "Learning how to import/export XML via the API"
-  end
-  
 end

data/spec/requests/time_series_request_spec.rb

@@ -5,7 +5,7 @@ describe "TimeSeries" do
   before do
     integration_test
     @host_group = ensure_save(Rubix::HostGroup.new(:name => 'rubix_spec_host_group_1'))
-    @host       = ensure_save(Rubix::Host.new(:name => 'rubix_spec_host_1', :host_groups => [@host_group]))
+    @host       = ensure_save(Rubix::Host.new(:name => 'rubix_spec_host_1', :host_groups => [@host_group]))        
   end
 
   after do
@@ -18,6 +18,10 @@ describe "TimeSeries" do
       Rubix::TimeSeries.new.from.should_not be_nil
       Rubix::TimeSeries.new.upto.should_not be_nil
     end
+    
+    it "should set a default item type (history)" do
+      Rubix::TimeSeries.new.history.should_not be_nil
+    end
 
     it "should accept a given timeframe when querying" do
       Rubix::TimeSeries.find_params(:item_id => 100, :from => '1327543430', :upto => Time.at(1327543450))[:time_from].should == '1327543430'
@@ -41,13 +45,14 @@ describe "TimeSeries" do
 
     before do
       @item = ensure_save(Rubix::Item.new(:host_id => @host.id, :key => 'foo.bar.baz', :value_type => :unsigned_int, :description => "rubix item description"))
+      @history = create_history(@item)
     end
 
     it "should parse the results properly" do
       @ts = Rubix::TimeSeries.find(:item_id => @item.id)
       @ts.should_not be_nil
-      @ts.should_receive(:raw_data).and_return([{'clock' => '1327543429', 'value' => '3'}, {'clock' => '1327543430'}])
-      @ts.parsed_data.should == [{'time' => Time.at(1327543429), 'value' => 3}]
+      @ts.raw_data.should == @history.reverse
+      @ts.parsed_data.should == @history.reverse.collect{|history| { 'time' => Time.at(history["clock"].to_i), 'value' => history["value"].to_i } }
     end
 
   end

data/spec/rubix/connection_spec.rb

@@ -20,24 +20,50 @@ describe Rubix::Connection do
     @connection = Rubix::Connection.new('localhost/api.php', 'username', 'password')
   end
 
-  it "should attempt to authorize itself without being asked" do
-    @connection.should_receive(:authorize!)
-    @connection.request('foobar', {})
-  end
+  describe "sending API requests" do
 
-  it "should not repeatedly authorize itself" do
-    @mock_response.stub!(:body).and_return(@good_auth_response, @blah_response, @blah_response)
-    @connection.request('foobar', {})
-    @connection.should_not_receive(:authorize!)
-    @connection.request('foobar', {})
-  end
+    it "should attempt to authorize itself without being asked" do
+      @connection.should_receive(:authorize!)
+      @connection.request('foobar', {})
+    end
+
+    it "should not repeatedly authorize itself" do
+      @mock_response.stub!(:body).and_return(@good_auth_response, @blah_response, @blah_response)
+      @connection.request('foobar', {})
+      @connection.should_not_receive(:authorize!)
+      @connection.request('foobar', {})
+    end
+
+    it "should increment its request ID" do
+      @mock_response.stub!(:body).and_return(@good_auth_response, @blah_response, @blah_response)
+      @connection.request('foobar', {})
+      @connection.request('foobar', {})
+      @connection.request_id.should == 3 # it's the number used for the *next* request
+    end
 
-  it "should increment its request ID" do
-    @mock_response.stub!(:body).and_return(@good_auth_response, @blah_response, @blah_response)
-    @connection.request('foobar', {})
-    @connection.request('foobar', {})
-    @connection.request_id.should == 3 # it's the number used for the *next* request
   end
 
-end
+  describe "sending web requests" do
+
+    it "should attempt to authorize itself without being asked" do
+      @connection.should_receive(:authorize!)
+      @connection.web_request("GET", "/")
+    end
+
+    it "should not repeatedly authorize itself" do
+      @mock_response.stub!(:body).and_return(@good_auth_response, @blah_response, @blah_response)
+      @connection.web_request("GET", "/")
+      @connection.should_not_receive(:authorize!)
+      @connection.web_request("GET", "/")
+    end
+
+    it "should NOT increment its request ID" do
+      @mock_response.stub!(:body).and_return(@good_auth_response, @blah_response, @blah_response)
+      @connection.web_request("GET", "/")
+      @connection.web_request("GET", "/")
+      @connection.request_id.should == 1
+    end
+
+  end
   
+end

data/spec/support/integration_helper.rb

@@ -46,6 +46,14 @@ module Rubix
         raise e
       end
     end
+    
+    def create_history item
+      (1..10).to_a.collect do |i|
+        history = { "itemid" => item.id.to_s, "clock" => (Time.now.to_i - 5*i).to_s, "value" => rand(100).to_s }
+        $RUBIX_MYSQL_CLIENT.query("INSERT INTO history_uint (#{history.keys.join(', ')}) VALUES (#{history.values.join(', ')})")
+        history
+      end
+    end
 
     def self.setup_integration_tests test_yml_path
       return unless File.exist?(test_yml_path)
@@ -68,7 +76,7 @@ module Rubix
       $RUBIX_INTEGRATION_TEST = api_connection
     end
 
-    RUBIX_TABLES_TO_TRUNCATE = %w[applications groups hostmacro hosts hosts_groups hosts_profiles hosts_profiles_ext hosts_templates items items_applications profiles triggers trigger_depends]
+    RUBIX_TABLES_TO_TRUNCATE = %w[applications groups hostmacro hosts hosts_groups hosts_profiles hosts_profiles_ext hosts_templates items items_applications profiles triggers trigger_depends history sessions]
     
     def self.truncate_all_tables
       return unless $RUBIX_INTEGRATION_TEST
@@ -78,6 +86,10 @@ module Rubix
     def truncate_all_tables
       IntegrationHelper.truncate_all_tables
     end
+
+    def data_path *args
+      File.join(File.expand_path('../../data', __FILE__), *args)
+    end
     
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 4
-  - 0
-  version: 0.4.0
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Dhruv Bansal
@@ -134,6 +134,7 @@ files:
 - spec/requests/item_request_spec.rb
 - spec/requests/host_group_request_spec.rb
 - spec/requests/user_macro_request_spec.rb
+- spec/requests/connection_request_spec.rb
 - spec/requests/template_request_spec.rb
 - spec/requests/trigger_request_spec.rb
 - spec/requests/host_request_spec.rb
@@ -142,6 +143,7 @@ files:
 - spec/support/integration_helper.rb
 - spec/support/response_helper.rb
 - spec/support/configliere_helper.rb
+- spec/data/test_template.xml
 - LICENSE
 - README.rdoc
 - VERSION