zabcon 0.0.6 → 0.0.327

data/libs/printer.rb

@@ -19,11 +19,11 @@
 
 ##########################################
 # Subversion information
-# $Id: printer.rb 272 2011-01-06 21:04:22Z nelsonab $
-# $Revision: 272 $
+# $Id: printer.rb 325 2011-09-26 08:57:00Z nelsonab $
+# $Revision: 325 $
 ##########################################
 
-require 'libs/zdebug'
+require 'zbxapi/zdebug'
 require 'libs/zabcon_globals'
 
 if RUBY_PLATFORM =~ /.*?mswin.*?/
@@ -61,7 +61,7 @@ class OutputPrinter
     @lines=0                    # how many lines have been displayed thus far?
 
     # Check the environment variables to see if screen height has been set
-    EnvVars.instance["sheight"]=25 if EnvVars.instance["sheight"].nil?
+    EnvVars.instance["lines"]=24 if EnvVars.instance["lines"].nil?
   end
 
   def hash_width(item)
@@ -170,9 +170,9 @@ class OutputPrinter
   # after n lines have been printed
   # If @lines is set to -1 a side effect is created where pause is disabled.
   def pause? (lines=1)
-    if @interactive and EnvVars.instance["sheight"]>0 and (@lines>-1) then
+    if @interactive and EnvVars.instance["lines"]>0 and (@lines>-1) then
       @lines += lines
-      if @lines>=(EnvVars.instance["sheight"]-1) then
+      if @lines>=(EnvVars.instance["lines"]-1) then
         pause_msg = "Pause, q to quit, a to stop pausing output"
         Kernel.print pause_msg
         if RUBY_PLATFORM =~ /.*?mswin.*?/
@@ -207,8 +207,8 @@ class OutputPrinter
   def printline(widths)
     output="+"
     widths.each { |width| output+="-"+("-"*width)+"-+" }
-    pause? 1
     puts output
+    pause? 1
   end
 
   #Prints the table header
@@ -258,20 +258,20 @@ class OutputPrinter
   end
 
   def print_array(dataset,cols)
-    debug(6,dataset,"dataset",150)
-    debug(6,cols,"cols",50)
+    debug(6,:var=>dataset,:msg=>"dataset",:truncate=>150)
+    debug(6,:var=>cols,:msg=>"cols",:truncate=>50)
     count=0
-    type=dataset[:class]
-    results=dataset[:result]
+    type=dataset.type
+    results=dataset.data
 
-    debug(6,type,"Array type")
+    debug(6,:var=>type,:msg=>"Array type")
 
-    puts "#{dataset[:class].to_s.capitalize} result set"  if EnvVars.instance["echo"]
+    puts "#{dataset.type.to_s.capitalize} result set"  if EnvVars.instance["echo"]
 
     if results.length==0
       puts "Result set empty"
     elsif results[0].class==Hash then
-      debug(7,"Results type is Hash")
+      debug(7,:msg=>"Results type is Hash")
       header=[]
       if cols.nil? then
         case type
@@ -299,7 +299,7 @@ class OutputPrinter
         header=cols.split(',')
       end
 
-      debug(6,header,"header")
+      debug(6,:var=>header,:msg=>"header")
 
       widths=getcolwidth(results,header)
 
@@ -319,7 +319,7 @@ class OutputPrinter
 
 
     else
-      debug(7,"Results type is not Hash, assuming array")
+      debug(7,:msg=>"Results type is not Hash, assuming array")
       widths = getcolwidth(results,["id"])   # always returns an array of widths
 
       printline(widths)            # hacking parameters to overload functions
@@ -334,14 +334,14 @@ class OutputPrinter
 
   def print_hash(dataset,cols)
     puts "Hash object printing not implemented, here is the raw result"
-    p dataset
+    p dataset.result
   end
 
 
   def print(dataset,cols)
     begin
-      debug(6,dataset,"Dataset",200)
-      debug(6,cols,"Cols",40)
+      debug(6,:var=>dataset,:msg=>"Dataset",:truncate=>200)
+      debug(6,:var=>cols,:msg=>"Cols",:truncate=>40)
       @lines=0
       if !cols   #cols==nil
         cols_to_show=nil
@@ -349,18 +349,18 @@ class OutputPrinter
         cols_to_show=cols.empty? ? nil : cols[:show]
       end
     
-      puts dataset[:message] if dataset[:message]
+      puts dataset.message if dataset.message
 
 #    p dataset[:result].class
-      if dataset[:result].class==Array then
+      if dataset.data.class==Array then
         print_array(dataset,cols_to_show)
-      elsif dataset[:result].class==Hash then
+      elsif dataset.data.class==Hash then
         print_hash(dataset,cols_to_show)
-      elsif dataset[:result].class!=NilClass then
+      elsif dataset.data.class!=NilClass then
         puts "Unknown object received by the print routine"
-        puts "Class type: #{dataset[:result].class}"
+        puts "Class type: #{dataset.result.class}"
         puts "Data:"
-        p dataset[:result]
+        p dataset.data
       end
     rescue TypeError
       puts "***********************************************************"

data/libs/revision.rb

@@ -0,0 +1 @@
+REVISION=327

data/libs/utility_items.rb

@@ -0,0 +1,137 @@
+#License:: GPL 2.0  http://www.gnu.org/licenses/gpl-2.0.html
+#Copyright:: Copyright (C) 2009,2010 Andrew Nelson nelsonab(at)red-tux(dot)net
+#
+#This program is free software; you can redistribute it and/or
+#modify it under the terms of the GNU General Public License
+#as published by the Free Software Foundation; either version 2
+#of the License, or (at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+##########################################
+# Subversion information
+# $Id: utility_items.rb 325 2011-09-26 08:57:00Z nelsonab $
+# $Revision: 325 $
+##########################################
+
+require "zbxapi/zdebug"
+
+Object.class_eval do
+  def env
+    EnvVars.instance
+  end
+end
+
+
+String.class_eval do
+# String::split2(*options)
+# Valid options, and ther defaults:
+#  :splitchar = '\s'
+#    pivot string or regex
+#  :include_split = false
+#  :trim_empty = true
+#    trim_empty will remove empty and whitespace characters by default
+#    if include_split is true whitespace characters (but not empty) will
+#    be included if the splitchar is a whitespace character (default)
+# This is a special split routine which will split str using splitchar as a split point.
+# If items are within quotes or brackets they will not be split even when splitchar is
+# found within those quotes or brackets.
+  def split2(*options)
+    defaults={:split_char=>'\s', :include_split=>false, :trim_empty=>true}
+
+    options=
+        if options.empty?
+          defaults
+        else
+          raise "split2 requires parameters to be in hash form" if options[0].class!=Hash
+          unknown_keys=options[0].keys-defaults.keys
+
+          raise "Unknown keys: #{unknown_keys.join(", ")}" if !unknown_keys.empty?
+          defaults.merge(options[0])
+        end
+
+    splitchar=options[:split_char]
+    include_split=options[:include_split]
+    trim_empty=options[:trim_empty]
+    str=self
+    quote_chars=["\"", "'"]
+    left=["(", "{", "["]
+    right=[")", "}", "]"]
+    quote_regex=Regexp.escape(quote_chars.to_s)
+    left_regex=Regexp.escape(left.to_s)
+    right_regex=Regexp.escape(right.to_s)
+    splitchar_regex= Regexp.new(/#{splitchar}/)
+    stack=[]
+    splits=[]
+    result=[]
+    s=StringScanner.new(str)
+    #set up our regex for scanning.  We scan for brackets, quotes and escaped characters
+    char_class=Regexp.new("[\\\\#{quote_regex}#{left_regex}#{right_regex}#{splitchar}]")
+    while !s.eos?
+      s.scan_until(char_class)
+      break if !s.matched?  # break out if nothing matched
+      ch=str[s.pos-1].chr
+      case ch
+        when "\\"  #hande an escaped character by moving the pointer up one
+          s.getch
+        when /[#{quote_regex}]/  #handle a quoted section
+          raise "Unbalanced String: #{str}" if (!stack.index(ch).nil? && stack.index(ch)!=(stack.length-1))
+          if stack.index(ch)==nil
+            stack<<ch
+          else
+            stack.pop
+          end
+        when /[#{left_regex}]/  #open bracket found
+          stack<<left.index(ch)
+        when /[#{right_regex}]/  #close bracket found
+          raise "Unbalanced String: #{str}" if ch!=right[stack.last]
+          stack.pop
+        when /#{splitchar_regex}/  #pivot character found
+          splits<<s.pos-1 if stack.empty?
+      end
+    end
+
+    raise "Unbalanced String: #{str}" if !stack.empty?
+    splits<<str.length
+
+    pos=0
+    while !splits.empty?
+      split_pos=splits.first
+      splits.delete(splits.first)
+      result<<str[pos..split_pos-1] if split_pos>0
+      result<<str[split_pos].chr if !str[split_pos].nil? && include_split
+      pos=split_pos+1
+    end
+
+      result=result.delete_if {|item|
+        if include_split
+          #delete the line if nil or empty or the current item is not the splitchar and not full of whitespace
+          item.nil? || item.empty? || (item.scan(/^#{splitchar}$/).empty? && !item.scan(/^\s*$/).empty?)
+        else
+          item.nil? || item.empty? || !item.scan(/^\s*$/).empty?
+        end
+      } if trim_empty
+
+    result
+  end
+
+  def strip_comments
+    splits = self.split2(:split_char=>'#', :include_split=>true)
+    if !(index=splits.index('#')).nil?
+      if index>0
+        splits=splits[0..index-1]
+      else
+        splits=[]
+      end
+    end
+    splits.join.strip
+  end
+
+end # end String.class_eval

data/libs/zabbix_server.rb

@@ -0,0 +1,379 @@
+#GPL 2.0  http://www.gnu.org/licenses/gpl-2.0.html
+#Zabbix CLI Tool and associated files
+#Copyright (C) 2009,2010 Andrew Nelson nelsonab(at)red-tux(dot)net
+#
+#This program is free software; you can redistribute it and/or
+#modify it under the terms of the GNU General Public License
+#as published by the Free Software Foundation; either version 2
+#of the License, or (at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+##########################################
+# Subversion information
+# $Id: zabbix_server.rb 325 2011-09-26 08:57:00Z nelsonab $
+# $Revision: 325 $
+##########################################
+
+require 'zbxapi'
+require 'zbxapi/zdebug'
+require 'libs/zabcon_globals'
+require 'libs/command_tree'
+
+class ZabbixServer_overload < ZabbixAPI
+  alias zbxapi_initialize initialize
+  alias zbxapi_do_request do_request
+
+  def initialize(url,debug_level=0)
+    @env = env
+    zbxapi_initialize(url,debug_level)
+  end
+
+  #truncate_length is set to the symbol :not_used as do_request is passed a different variable
+  def do_request(json_obj,truncate_length=:not_used)
+    zbxapi_do_request(json_obj,@env["truncate_length"])
+  end
+end
+
+class ZabbixServer
+
+  include Singleton
+  include ZDebug
+
+  class ConnectionProblem < Exception
+    def initialize(msg)
+      @msg=msg
+    end
+
+    def message
+      "There was a problem connecting to the Zabbix server: #{@msg}"
+    end
+  end
+
+  attr_accessor :server_url, :username, :password
+  attr_reader :version, :connected, :connection
+
+  def initialize
+    @server_url=nil
+    @username=nil
+    @password=nil
+    @connected=false
+    @version=nil
+    @connection=nil
+  end
+
+  #login
+  # Perform the actual login to the Zabbix server
+  # If the object variables url, username, and password have not been
+  # set previously, an attempt will be made to use the global environment
+  # variables.  If that does not work an exception will be raised.
+  def login
+    @server_url = @server_url.nil? ? env["server"] : @server_url
+    @username = @username.nil? ? env["username"] : @username
+    @password = @password.nil? ? env["password"] : @password
+
+    error_msg=[]
+    error_msg<<"Url not set" if @server_url.nil?
+    error_msg<<"Username not set" if @username.nil?
+    error_msg<<"Password not set" if @password.nil?
+
+    raise ConnectionProblem.new(error_msg.join(", ")) if !error_msg.empty?
+
+    @connection = ZabbixServer_overload.new(@server_url,env["debug"])
+    @connection.login(@username,@password)
+    @connected=true
+    GlobalVars.instance["auth"]=@connection.auth
+    @version=@connection.API_version
+    puts "#{@server_url} connected"  if env["echo"]
+    puts "API Version: #{@version}"  if env["echo"]
+
+  end
+
+  def logout
+    begin
+      @connection.logout
+    rescue ZbxAPI_GeneralError => e
+      #if it's -32400, it's probably because the function does not exist.
+      raise e if e.message["code"]!=-32400
+    ensure
+      @connection=nil
+      @connected=false
+      @version=nil
+      GlobalVars.instance.delete("auth")
+      puts "Logout complete from #{@server_url}" if env["echo"]
+    end
+  end
+
+  def loggedin?
+    @connected
+  end
+
+  #TODO come back and finish the class to have automated
+  #timeout of the connection, and improve the usability of
+  #this function which should tell you if you have a valid
+  #connection or not, which includes timeout and login.
+  def connected?
+    @connected
+  end
+
+  def version
+    @connection.API_version
+  end
+
+  def reconnect
+    @connection.login(@user,@password)
+  end
+
+#  def getuser(parameters)
+#    debug(6,parameters)
+#
+#    result=@connection.user.get(parameters)
+#    {:class=>:user, :result=>result}
+#  end
+#
+#  def gethost(parameters)
+#    debug(6,parameters)
+#
+#    result=@connection.host.get(parameters)
+#    {:class=>:host, :result=>result}
+#  end
+
+#  def addhost(parameters)
+#    debug(6,parameters)
+#    result=@connection.host.create(parameters)
+#    {:class=>:host, :message=>"The following host was created: #{result['hostids']}", :result=>result}
+#  end
+
+#  def deletehost(parameters)
+#    debug(6,parameters)
+#    result=@connection.host.delete(parameters)
+#    {:class=>:host, :message=>"The following host(s) was/were deleted: #{result['hostids']}", :result=>result}
+#  end
+
+#  def getitem(parameters)
+#    debug(6,parameters)
+#
+#    result=@connection.item.get(parameters)
+#    {:class=>:item, :result=>result}
+#  end
+
+#  def additem(parameters)
+#    debug(6,parameters)
+#    {:class=>:item, :result=>@connection.item.create(parameters)}
+#  end
+
+#  def deleteitem(parameters)
+#    debug(6,parameters)
+#    {:class=>:item, :result=>@connection.item.delete(parameters)}
+#  end
+
+#  def adduser(parameters)
+#    debug(6,parameters)
+#    begin
+#      uid=@connection.user.create(parameters)
+#      puts "Created userid: #{uid["userids"]}"
+#    rescue ZbxAPI_ParameterError => e
+#      puts "Add user failed, error: #{e.message}"
+#    end
+#  end
+
+#  def deleteuser(parameter)
+#    debug(6,parameter)
+#    id=0  #id to delete
+##    if parameters.nil? then
+##      puts "User id required"
+##      return
+##    end
+#
+#    if !parameter["name"].nil?
+#      users=@connection.user.get({"pattern"=>parameter["name"], "extendoutput"=>true})
+#      users.each { |user| id=user["userid"] if user["alias"]==parameter }
+#    else
+#      id=parameter["id"]
+#    end
+#    result=@connection.user.delete(id)
+#    if !result.empty?
+#      puts "Deleted user id #{result["userids"]}"
+#    else
+#      puts "Error deleting #{parameter.to_a[0][1]}"
+#    end
+#  end
+
+#  def updateuser(parameters)
+#    debug(6,parameters)
+#    valid_parameters=['userid','name', 'surname', 'alias', 'passwd', 'url', 'autologin',
+#                      'autologout', 'lang', 'theme', 'refresh', 'rows_per_page', 'type',]
+#    if parameters.nil? or parameters["userid"].nil? then
+#      puts "Edit User requires arguments, valid fields are:"
+#      puts "name, surname, alias, passwd, url, autologin, autologout, lang, theme, refresh"
+#      puts "rows_per_page, type"
+#      puts "userid is a required field"
+#      puts "example:  edit user userid=<id> name=someone alias=username passwd=pass autologout=0"
+#      return false
+#    else
+#      p_keys = parameters.keys
+#
+#      valid_parameters.each {|key| p_keys.delete(key)}
+#      if !p_keys.empty? then
+#        puts "Invalid items"
+#        p p_keys
+#        return false
+#      elsif parameters["userid"].nil?
+#        puts "Missing required userid statement."
+#      end
+#      p @connection.user.update([parameters])  #TODO: remove print statement or comment if needed
+#    end
+#  end
+
+  def addusermedia(parameters)
+    debug(6,:var=>parameters)
+    valid_parameters=["userid", "mediatypeid", "sendto", "severity", "active", "period"]
+
+    if parameters.nil? then
+      puts "add usermedia requires arguments, valid fields are:"
+      puts "userid, mediatypeid, sendto, severity, active, period"
+      puts "example:  add usermedia userid=<id> mediatypeid=1 sendto=myemail@address.com severity=63 active=1 period=\"\""
+    else
+
+      p_keys = parameters.keys
+
+      valid_parameters.each {|key| p_keys.delete(key)}
+      if !p_keys.empty? then
+        puts "Invalid items"
+        p p_keys
+        return false
+      elsif parameters["userid"].nil?
+        puts "Missing required userid statement."
+      end
+      begin
+        @connection.user.addmedia(parameters)
+      rescue ZbxAPI_ParameterError => e
+        puts e.message
+      end
+    end
+
+  end
+
+#  def addhostgroup(parameters)
+#    debug(6,parameters)
+#    result = @connection.hostgroup.create(parameters)
+#    {:class=>:hostgroup, :result=>result}
+#  end
+
+#  def gethostgroup(parameters)
+#    debug(6,parameters)
+#
+#    result=@connection.hostgroup.get(parameters)
+#    {:class=>:hostgroup, :result=>result}
+#  end
+
+  def gethostgroupid(parameters)
+    debug(6,:var=>parameters)
+    result = @connection.hostgroup.getObjects(parameters)
+    {:class=>:hostgroupid, :result=>result}
+  end
+
+#  def getapp(parameters)
+#    debug(6,parameters)
+#
+#    result=@connection.application.get(parameters)
+#    {:class=>:application, :result=>result}
+#  end
+#
+#  def addapp(parameters)
+#    debug(6,parameters)
+#    result=@connection.application.create(parameters)
+#    {:class=>:application, :result=>result}
+#  end
+
+  def getappid(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.application.getid(parameters)
+    {:class=>:application, :result=>result}
+  end
+
+  def gettrigger(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.trigger.get(parameters)
+    {:class=>:trigger, :result=>result}
+  end
+
+#  # addtrigger( { trigger1, trigger2, triggern } )
+#  # Only expression and description are mandatory.
+#  # { { expression, description, type, priority, status, comments, url }, { ...} }
+#  def addtrigger(parameters)
+#    debug(6,parameters)
+#    result=@connection.trigger.create(parameters)
+#    {:class=>:trigger, :result=>result}
+#  end
+
+  def addlink(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.sysmap.addlink(parameters)
+    {:class=>:map, :result=>result}
+  end
+
+  def addsysmap(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.sysmap.create(parameters)
+    {:class=>:map, :result=>result}
+  end
+
+  def addelementtosysmap(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.sysmap.addelement(parameters)
+    {:class=>:map, :result=>result}
+  end
+
+  def getseid(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.sysmap.getseid(parameters)
+    {:class=>:map, :result=>result}
+  end
+
+  def addlinktrigger(parameters)
+    debug(6,:var=>parameters)
+    result=@connection.sysmap.addlinktrigger(parameters)
+    {:class=>:map, :result=>result}
+  end
+
+#  def raw_api(parameters)
+#    debug(6,parameters)
+#    result=@connection.raw_api(parameters[:method],parameters[:params])
+#    {:class=>:raw, :result=>result}
+#  end
+
+#  def raw_json(parameters)
+#    debug(6,parameters)
+#    begin
+#      result=@connection.do_request(parameters)
+#      {:class=>:raw, :result=>result["result"]}
+#    rescue ZbxAPI_GeneralError => e
+#      puts "An error was received from the Zabbix server"
+#      if e.message.class==Hash
+#        puts "Error code: #{e.message["code"]}"
+#        puts "Error message: #{e.message["message"]}"
+#        puts "Error data: #{e.message["data"]}"
+#      end
+#      puts "Original text:"
+#      puts parameters
+#      puts
+#      return {:class=>:raw, :result=>nil}
+#    end
+#  end
+
+end
+
+##############################################
+# Unit test
+##############################################
+
+if __FILE__ == $0
+end