zabcon 0.0.332 → 0.0.350

data/libs/argument_processor.rb

@@ -18,8 +18,8 @@
 
 ##########################################
 # Subversion information
-# $Id: argument_processor.rb 330 2011-09-27 06:16:40Z nelsonab $
-# $Revision: 330 $
+# $Id: argument_processor.rb 345 2011-11-23 04:28:53Z nelsonab $
+# $Revision: 345 $
 ##########################################
 
 require 'zbxapi/zdebug'
@@ -202,7 +202,7 @@ module ArgumentProcessor
   # In :num_args is passed with a value, and error will be returned if more than that many args are passed
 
   def default_processor(args,arg_info,flags={})
-    args=args.strip  #remove preceding and trailing whitespace
+#    args=args.strip  #remove preceding and trailing whitespace
     #valid_args=arg_info[:valid_args]
     #required_args=arg_info[:required_args]
     invalid_args=[]
@@ -216,6 +216,7 @@ module ArgumentProcessor
     elsif flags[:string_params]
       args=args
     else
+
       args=params_to_hash(args)
 
       if !arg_info[:valid_args].empty?

data/libs/command_tree.rb

@@ -19,8 +19,8 @@
 #--
 ##########################################
 # Subversion information
-# $Id: command_tree.rb 330 2011-09-27 06:16:40Z nelsonab $
-# $Revision: 330 $
+# $Id: command_tree.rb 347 2011-11-23 06:59:47Z nelsonab $
+# $Revision: 347 $
 ##########################################
 #++
 
@@ -29,7 +29,7 @@ require 'libs/lexer'
 require 'zbxapi/zdebug'
 require 'libs/zabcon_exceptions'
 require 'libs/zabcon_globals'
-require 'libs/argument_processor'
+#require 'libs/argument_processor'
 
 class ZabconExecuteBase
   include ZDebug
@@ -114,13 +114,14 @@ class ZabconExecuteContainer
 
   attr_reader :show_params, :results, :options
 
-  def initialize(usr_str)
-    @initial_string=usr_str
+  def initialize(tokens)
+#    @initial_string=usr_str
+    @initial_tokens=tokens
     @commands=[]
     @printing=true
     commandlist=CommandList.instance
 
-    tokens=Tokenizer.new(usr_str)
+#    tokens=ExpressionTokenizer.new(usr_str)
 
     #split_str=usr_str.split2(:split_char=>'=|\s', :include_split=>true)
     #
@@ -217,11 +218,12 @@ class Command
   attr_reader :required_args, :valid_args
   attr_reader :help_tag, :path
 
-  include ArgumentProcessor
+#  include ArgumentProcessor
+  include ZDebug
 
   #Class containing processed arguments to be passed to the command
   class Arguments
-    class ParameterError < Exception
+    class ParameterError < ZError
     end
 
     attr_accessor :cmd_params
@@ -257,7 +259,7 @@ class Command
   class LoginRequired < Exception
   end
 
-  class ParameterError < Exception
+  class ParameterError < ZError
   end
 
   class ArgumentError < Exception
@@ -276,7 +278,15 @@ class Command
     @result_type=nil
 
     #TODO Can the argument processor stuff be cleaned up?
-    @argument_processor=method(:default_processor)
+#    @argument_processor=method(:default_processor)
+    #The argument processor is nil by default.
+    #The method call_arg_processor will call the tokenizer and the
+    #argument processor if it is not nil.
+    #Otherwise a default method will be called which will check the
+    #current parameters list for validity.
+    @argument_processor=nil
+    @tokenizer=ExpressionTokenizerHash
+
     @help_tag=nil
     @depreciated=nil
   end
@@ -352,6 +362,10 @@ class Command
     @help_tag=sym
   end
 
+  def set_tokenizer(tokenizer)
+    @tokenizer=tokenizer
+  end
+
   #--
   #TODO Complete type casting section and add error checking
   #++
@@ -359,32 +373,60 @@ class Command
   # :login_required  - command requires a valid login
   # :print_output  - the output of the command will be passed to the print processor
   # :array_params  - Only process the parameters as an array
-  def set_flag(flag)
+  def set_flag(flag,val=nil)
     case flag.class.to_s
       when "Symbol"
-        flag={flag=>true}
+        flag=val.nil? ? {flag=>true} : {flag=>val}
     end
 
     @flags.merge!(flag)
   end
 
-  def call_arg_processor(parameters)
-    def set_show_args(args)
-      @arguments.show_params=args
-    end
+  def check_parameters(parameters)
+    return if !parameters.is_a?(Hash)
 
-    @arguments=Arguments.new("",@flags)
-    result=@argument_processor.call(parameters,{:valid_args=>@valid_args,:required_args=>@required_args},@flags)
-    return result if result.is_a?(Arguments)
-    if !result.is_a?(String) && !result.is_a?(Hash) && !result.is_a?(Array)
-      raise ("Arugment processor for \"#{command_name}\" returned invalid parameters: class: #{result.class}, #{result}")
-    else
-      @arguments.cmd_params=result
-      arguments=@arguments
-      return arguments
+    if !@valid_args.empty?
+      args_keys=parameters.keys
+
+      invalid_args=args_keys-@valid_args if @valid_args
+      raise ParameterError.new("Invalid parameters: "+invalid_args.join(", "),
+                               :retry=>true) if !invalid_args.empty?
+
+      required_args=@required_args.reject{|i| i.class==Array }
+      required_or_args=@required_args.reject{|i| i.class!=Array }
+
+      missing_args=[]
+      missing_args=required_args-args_keys
+
+      required_or_args.delete_if do |i|
+        count=i.length
+        missing_args<<i if (i-args_keys).count==count
+      end
+
+      if !missing_args.empty?
+        msg=missing_args.map do |i|
+          if i.class==Array
+            "(#{i.join(" | ")})"
+          else
+            i
+          end
+        end.join(", ")
+        raise ParameterError.new("Missing required arguments: #{msg}",:retry=>true)
+      end
     end
   end
 
+  def call_arg_processor(parameters)
+    debug(6,:msg=>"parameters",:var=>"\"#{parameters.to_s}\"")
+    debug(7,:msg=>"Using tokenizer", :var=>@tokenizer.to_s)
+    tokenized_parameters=@tokenizer.new(parameters).parse
+    debug(7,:msg=>"Tokenized Parameters",:var=>tokenized_parameters)
+    check_parameters(tokenized_parameters)
+    @arguments=Arguments.new(tokenized_parameters, @flags)
+    debug(6,:var=>@arguments)
+    @arguments
+  end
+
   #Sets the symbold describing the result type.  May be used by the print processor
   # as a hint for printing the output.
   def result_type(type)
@@ -502,7 +544,8 @@ class CommandList
 
   def find_and_parse(str)
 
-    tokens=Tokenizer.new(str)
+    tokens=CommandTokenizer.new(str)
+
     token_items=tokens.length
 
     cur_node=@cmd_tree
@@ -532,7 +575,7 @@ class CommandList
 
     debug(6,:msg=>"Tokens", :var=>tokens)
     debug(6,:msg=>"Pos", :var=>pos)
-    debug(6,:msg=>"Parsed", :var=>tokens.parse)
+#    debug(6,:msg=>"Parsed", :var=>tokens.parse)
     params = tokens.drop(pos+1).join
 
     debug(6,:msg=>"Parameters", :var=>params)

data/libs/lexer.rb

@@ -19,8 +19,8 @@
 #--
 ##########################################
 # Subversion information
-# $Id: lexer.rb 330 2011-09-27 06:16:40Z nelsonab $
-# $Revision: 330 $
+# $Id: lexer.rb 345 2011-11-23 04:28:53Z nelsonab $
+# $Revision: 345 $
 ##########################################
 #++
 
@@ -28,8 +28,9 @@
 #The origional source for his work can be found here:
 # https://github.com/michaelbaldry/lexr
 
-require 'zbxapi/exceptions'
-require "zbxapi/zdebug"
+require 'libs/zabcon_exceptions'
+#require 'zbxapi/exceptions'
+#require "zbxapi/zdebug"
 
 #This is a wrapper class for creating a generalized lexer.
 class Lexr
@@ -292,6 +293,7 @@ ExpressionLexer = Lexr.setup {
   matches /\\/ => :escape
   matches /\$[\w]+/ => :variable
   matches /"([^"\\]*(\\.[^"\\]*)*)"/ => :quote
+  matches /"([^'\\]*(\\.[^'\\]*)*)"/ => :quote
   matches "(" => :l_paren, :increment=>:paren
   matches ")" => :r_paren, :decrement=>:paren
   matches "{" => :l_curly, :increment=>:curly
@@ -305,13 +307,45 @@ ExpressionLexer = Lexr.setup {
   matches "=" => :equals
   matches "\"" => :umatched_quote, :raises=> "Unmatched quote"
   matches /#.*$/ => :comment
-  default /[^\s^\\^"^\(^\)^\{^\}^\[^\]^,^=]+/ => :word
+  default /[^\s^\\^"^'^\(^\)^\{^\}^\[^\]^,^=]+/ => :word
 }
 
+CommandLexer = Lexr.setup {
+  matches /\\/ => :escape
+  matches /\$[\w]+/ => :variable
+  matches /"([^"\\]*(\\.[^"\\]*)*)"/ => :quote
+  matches /"([^'\\]*(\\.[^'\\]*)*)"/ => :quote
+  matches /\s+/ => :whitespace
+  matches /[-+]?\d*\.\d+/ => :number, :convert_with => lambda { |v| Float(v) }
+  matches /[-+]?\d+/ => :number, :convert_with => lambda { |v| Integer(v) }
+  matches "=" => :equals
+  matches "\"" => :umatched_quote, :raises=> "Unmatched quote"
+  matches /#.*$/ => :comment
+  default /[^\s^=^\$^"^']+/ => :word
+}
+
+SimpleLexer = Lexr.setup{
+  matches /"([^"\\]*(\\.[^"\\]*)*)"/ => :quote
+  matches /"([^'\\]*(\\.[^'\\]*)*)"/ => :quote
+  matches /\s+/ => :whitespace
+  matches "\"" => :umatched_quote, :raises=> "Unmatched quote"
+  matches /#.*$/ => :comment
+  default /[^\s^"^']+/ => :word
+}
+
+#Base Class for all Tokenizers
+#Inherits from Array
 class Tokenizer < Array
   include ZDebug
 
-  class InvalidCharacter <ZError
+  class NoLexer < ZabconError
+    def initialize(message=nil, params={})
+      super(message,params)
+      @message=message || "No Lexer Passed"
+    end
+  end
+
+  class InvalidCharacter <ZabconError
     attr_accessor :invalid_char, :invalid_str, :position
 
     def initialize(message=nil, params={})
@@ -328,9 +362,52 @@ class Tokenizer < Array
       puts preamble+@invalid_str
       puts pointer
     end
+  end
+
+  attr_accessor :parsed
+  attr :items
+
+  #Base class version of initialize
+  #Will raise an exception if a Lexer is not passed in.
+  #Takes a string str and and hash arguments and creates a Lexical token reference of str
+  #It will also parse the lexical tokens into an array of items.
+  #:keep_escape determines weather or not to keep all escape backslashes, default false
+  def initialize(str,args={})
+    super()
+    raise NoLexer.new if args[:lexer].nil?
+    debug(8,:msg=>"Initial String",:var=>str.inspect)
+    replace(str.lexer_parse(args[:lexer]))  #replace self with array from lexer_parse
+    debug(8,:msg=>"Tokens",:var=>self)
+    debug(8,:msg=>"Tokens(Length)",:var=>length)
+    @available_tokens=args[:lexer].available_tokens
+  end
 
+  def parse(args={})
+    raise BaseClassError.new
   end
 
+end
+
+class BasicExpressionTokenizer < Tokenizer
+  def initialize(str,args={})
+    args[:lexer]||=ExpressionLexer
+    super(str,args)
+    #@parsed=parse(args)
+    #@items=@parsed.clone
+  end
+
+  def parse
+    map {|i|  #SimpleTokenizer inherits from Array
+      next if i.kind==:end
+      i.value
+    }.compact
+
+  end
+
+end
+
+class ExpressionTokenizer < Tokenizer
+
   class UnexpectedClose < InvalidCharacter
     def initialize(message=nil, params={})
       super(message,params)
@@ -373,14 +450,10 @@ class Tokenizer < Array
   #It will also parse the lexical tokens into an array of items.
   #:keep_escape determines weather or not to keep all escape backslashes, default false
   def initialize(str,args={})
-    super()
-    debug(8,:msg=>"Initial String",:var=>str.inspect)
-    replace(str.lexer_parse(ExpressionLexer))
-    debug(8,:msg=>"Tokens",:var=>self)
-    debug(8,:msg=>"Tokens(Length)",:var=>length)
-    @available_tokens=ExpressionLexer.available_tokens
-    @parsed=parse(args)
-    @items=@parsed.clone
+    args[:lexer]||=ExpressionLexer
+    super(str,args)
+    #@parsed=parse(args)
+    #@items=@parsed.clone
   end
 
   def parse(args={})
@@ -870,6 +943,65 @@ class Tokenizer < Array
   end
 end
 
+class ExpressionTokenizerHash < ExpressionTokenizer
+
+  @default_val = true
+
+  class InvalidItem <ZabconError
+    attr_accessor :invalid_item
+
+    def initialize(message=nil, params={})
+      super(message,params)
+      @message=message || "Invalid Token"
+      @invalid_item=params[:invalid_item] || nil
+    end
+
+    def show_message
+      puts "#{@message}  \"#{@invalid_item}\""
+    end
+  end
+
+
+  def parse(args={})
+    parsed=super(args)
+    ret_hash={}
+    parsed.each do |item|
+      if item.is_a?(Hash)
+        val=item
+      elsif item.is_a?(Numeric) || item.is_a?(String)
+        val={item.to_s=>@default_val}
+      else
+        raise InvaliItem.new("Invalid token for hash key",:invalid_item=>item.to_s)
+      end
+      ret_hash.merge!(val)
+    end
+    ret_hash
+  end
+
+end
+
+class CommandTokenizer < ExpressionTokenizer
+  def initialize(str,args={})
+    args[:lexer]||=CommandLexer
+
+    super(str,args)
+  end
+end
+
+class SimpleTokenizer < BasicExpressionTokenizer
+  def initialize(str,args={})
+    args[:lexer]||=SimpleLexer
+
+    super(str,args)
+  end
+end
+
+class SimpleTokenizerString < SimpleTokenizer
+  def parse
+    super.join
+  end
+end
+
 
 
 #p test_str="\"test\"=test1,2.0,3, 4 \"quote test\" value = { a = { b = [ c = { d = [1,a,g=f,3,4] }, e=5,6,7,8] } }"
@@ -881,6 +1013,6 @@ end
 #p test_str="a=b \\(a=c\\)"
 #p test_str="\\)"
 
-#p tokens=Tokenizer.new(test_str)
+#p tokens=ExpressionTokenizer.new(test_str)
 #p result=tokens.parse
 

data/libs/revision.rb

@@ -1 +1 @@
-REVISION=332
+REVISION=350

data/libs/zabcon_commands.rb

@@ -17,8 +17,8 @@
 
 ##########################################
 # Subversion information
-# $Id: zabcon_commands.rb 332 2011-09-30 07:24:38Z nelsonab $
-# $Revision: 332 $
+# $Id: zabcon_commands.rb 350 2011-11-23 09:46:46Z nelsonab $
+# $Revision: 350 $
 ##########################################
 
 require "zbxapi/zdebug"
@@ -47,8 +47,9 @@ ZabconCommand.add_command "help" do
       end
     end
   end
-  set_flag :array_params
+#  set_flag :array_params
   set_help_tag :help
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "help commands" do
@@ -69,7 +70,8 @@ ZabconCommand.add_command "login" do
     server.login
   end
   set_help_tag :help
-  set_flag :array_params
+#  set_flag :array_params
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "logout" do
@@ -120,8 +122,9 @@ ZabconCommand.add_command "set debug" do
     env["debug"]=params[0]
   end
   depreciated "set env debug=N"
-  set_flag :array_params
+#  set_flag :array_params
   set_help_tag :set_debug
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "set lines" do
@@ -129,8 +132,9 @@ ZabconCommand.add_command "set lines" do
     env["lines"]=params[0]
   end
   depreciated "set env lines=N"
-  set_flag :array_params
+#  set_flag :array_params
   set_help_tag :set_lines
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "set pause" do
@@ -149,8 +153,9 @@ ZabconCommand.add_command "set pause" do
     end
     env["lines"]=24 if env["lines"]==0
   end
-  set_flag :array_params
+#  set_flag :array_params
   set_help_tag :set_pause
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "show var" do
@@ -174,7 +179,8 @@ ZabconCommand.add_command "show var" do
     end
   end
   set_help_tag :show_var
-  set_flag :array_params
+#  set_flag :array_params
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "show env" do
@@ -198,7 +204,8 @@ ZabconCommand.add_command "show env" do
     end
   end
   set_help_tag :show_env
-  set_flag :array_params
+#  set_flag :array_params
+  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "set var" do
@@ -226,39 +233,62 @@ ZabconCommand.add_command "unset var" do
       }
     end
   end
-  set_flag :array_params
+#  set_flag :array_params
   set_help_tag :unset_var
+  set_tokenizer SimpleTokenizer
 end
 
-ZabconCommand.add_command "raw api" do
+ZabconCommand.add_command "show revisions" do
   set_method do |params|
-    api_func=params[:method]
-    params=params[:params]
-    server.connection.raw_api(api_func, params)
+    revision_path=File.join(ZABCON_PATH,"revision_information")
+    raise ZabconError.new("Revision file not found!",:retry=>true) if !File.file?(revision_path)
+    revision_file=File.new(revision_path)
+    while !revision_file.eof
+      puts revision_file.gets
+    end
+    revision_file.close
   end
+  set_help_tag :show_revision
+end
 
-  arg_processor do |params,args,flags|
-    params=Tokenizer.new(params).parse
-    parameter_error "Command \"raw api\" requires parameters" if params.empty?
+ZabconCommand.add_command "raw api" do
+  set_method do |params|
     api_func=params[0]
     params.delete_at(0)
-    params2={}
-    params.each do |i|
-      params2.merge!(i)
+    args={}
+    if !params.empty?
+      args=ExpressionTokenizerHash.new(params.join(" ")).parse
     end
-    {:method=>api_func, :params=>params2}
-  end
+    #api_func=params[:method]
+    #params=params[:params]
+    server.connection.raw_api(api_func, args)
+  end
+
+  #arg_processor do |params,args,flags|
+  #  debug(6,:var=>params)
+  #  params=ExpressionTokenizer.new(params).parse
+  #  parameter_error "Command \"raw api\" requires parameters" if params.empty?
+  #  api_func=params[0]
+  #  params.delete_at(0)
+  #  params2={}
+  #  params.each do |i|
+  #    params2.merge!(i)
+  #  end
+  #  {:method=>api_func, :params=>params2}
+  #end
   set_flag :login_required
   set_flag :print_output
   set_help_tag :raw_api
   result_type :raw_api
+  set_tokenizer CommandTokenizer
+#  set_tokenizer SimpleTokenizer
 end
 
 ZabconCommand.add_command "raw json" do
   set_method do |params|
     begin
       result=server.connection.do_request(params)
-      return result["result"]
+      retval=result["result"]
     rescue ZbxAPI_GeneralError => e
       puts "An error was received from the Zabbix server"
       if e.message.class==Hash
@@ -267,15 +297,20 @@ ZabconCommand.add_command "raw json" do
         puts "Error data: #{e.message["data"]}"
       end
       puts "Original text:"
-      puts parameters
+      puts params
       puts
-      return nil
+      retval=nil
     end
+    retval
   end
+  #arg_processor do |params,args,flags|
+  #  params
+  #end
   set_flag :login_required
   set_flag :print_output
   set_help_tag :raw_api
   result_type :raw_api
+  set_tokenizer SimpleTokenizerString
 end
 
 ###############################################################################
@@ -519,7 +554,7 @@ ZabconCommand.add_command "update user" do
       valid_parameters.each {|key| p_keys.delete(key)}
       if !p_keys.empty? then
         puts "Invalid items"
-        p p_keys
+        debug(8,p_keys)
         return false
       elsif parameters["userid"].nil?
         puts "Missing required userid statement."

data/libs/zabcon_core.rb

@@ -20,11 +20,11 @@
 
 ##########################################
 # Subversion information
-# $Id: zabcon_core.rb 330 2011-09-27 06:16:40Z nelsonab $
-# $Revision: 330 $
+# $Id: zabcon_core.rb 350 2011-11-23 09:46:46Z nelsonab $
+# $Revision: 350 $
 ##########################################
 
-require 'libs/utility_items'
+#require 'libs/utility_items'
 require 'libs/revision'
 require 'parseconfig'
 require 'ostruct'
@@ -39,14 +39,13 @@ require 'libs/command_tree'
 require 'libs/command_help'
 require 'libs/zabcon_globals'
 require 'libs/zabcon_commands'
-
-
+require 'libs/lexer'
+require 'pp'
 
 class ZabconCore
 
   include ZDebug
 
-
   def initialize()
     # This must be set first or the debug module will throw an error
     set_debug_level(env["debug"])
@@ -56,12 +55,10 @@ class ZabconCore
 
     @printer=OutputPrinter.new
     debug(5,:msg=>"Setting up help")
-#    @cmd_help=CommandHelp.new("english")  # Setup help functions, determine default language to use
     CommandHelp.setup("english")
 
     #TODO Remove reference to ArgumentProcessor when new command objects in use
     debug(5,:msg=>"Setting up ArgumentProcessor")
-#    @arg_processor=ArgumentProcessor.new  # Need to instantiate for debug routines
 
     if !env["server"].nil? and !env["username"].nil? and !env["password"].nil? then
       puts "Found valid login credentials, attempting login"  if env["echo"]
@@ -93,9 +90,10 @@ class ZabconCore
     end
 
 ###############################################################################
+# Configure the history command.
 ###############################################################################
     zabconcore=self
-    if @input.respond_to?(:history)
+    if @input.respond_to?(:history)  #does our input object have a history method?
       ZabconCommand.add_command "history" do
         set_method do  zabconcore.show_history end
         set_help_tag :history
@@ -111,57 +109,80 @@ class ZabconCore
 
     debug(5,:msg=>"Setting up custom commands")
 
-    if !env["custom_commands"].nil?
-      filename=nil
-      cmd_file=env["custom_commands"]
-      filename=File.exist?(cmd_file) && cmd_file
-      cmd_file=File::expand_path("~/#{env["custom_commands"]}")
-      filename=File.exist?(cmd_file) && cmd_file if filename.class!=String
-      if filename.class==String
-        puts "Loading custom commands from #{filename}" if env["echo"]
-        begin
-          load filename
-        rescue Exception=> e
-          puts "There was an error loading your custom commands"
-          p e
+
+    if !(custom_commands=env["custom_commands"]).nil?
+      if custom_commands.is_a?(String)
+        load_command_path(custom_commands)
+      elsif custom_commands.is_a?(Hash)
+        base_path=custom_commands["base_path"]
+        custom_commands.delete("base_path") if base_path
+        show_load=custom_commands["show_load"]
+        if show_load
+          show_load=show_load.downcase
+          custom_commands.delete("show_load")
+          if !show_load.is_a?(String) ||
+            !(show_load=="total" || show_load=="all")
+            warn "Invalid value for show_load: #{custom_commands}"
+            warn "Valid arguments are \"all\" and \"total\""
+            env["show_load"]=nil
+          else
+            env["show_load"]=show_load
+          end
+        else
+          env["show_load"]="all"
         end
+
+        env["load_count"]=0
+
+        custom_commands.each { |k,v|
+          load_command_path(v,base_path,show_load)
+        }
+
+        puts "#{env["load_count"]} Custom command files loaded" if show_load=="total"
+      else
+        warn "\"#{custom_commands.to_s}\" is an invalid parameter for custom_commands"
       end
     end
 
     debug(5,:msg=>"Setup complete")
   end
 
-#  #TODO The following method may need to be removed when new command object in use
-#  # Argument logged in is used to determine which set of commands to load. If loggedin is true then commands which
-#  # require a valid login are loaded
-#  def setupcommands(loggedin)
-#    debug(5,loggedin,"Starting setupcommands (loggedin)")
-#
-#
-##    no_cmd=nil
-##    no_args=nil
-##    no_help=nil
-##    no_verify=nil
-#
-#    login_required = lambda {
-#      debug(6,"Lambda 'login_required'")
-#      puts "Login required"
-#      }
-#
-#    # parameters for insert:  insert_path, command, commandproc, arguments=[], helpproc=nil, verify_func=nil, options
-#
-#      #Import commented out until fixed
-#      #@commands.insert ["import"], self.method(:do_import),no_args,@cmd_help.method(:import),@arg_processor.default,:not_empty, :use_array_processor, :num_args=>"==1"
-#
-#      @commands.insert ["add","app","id"], @server.method(:getappid),no_args,no_help,no_verify
-#      @commands.insert ["add","link"], @server.method(:addlink),no_args,no_help,no_verify
-#      @commands.insert ["add","link","trigger"], @server.method(:addlinktrigger),no_args,no_help,no_verify
-#      @commands.insert ["add","sysmap"], @server.method(:addsysmap),no_args,no_help,no_verify
-#      @commands.insert ["add","sysmap","element"], @server.method(:addelementtosysmap),no_args,no_help,no_verify
-#      @commands.insert ["add","user","media"], @server.method(:addusermedia),no_args,@cmd_help.method(:add_user_media),no_verify
-#
-#      @commands.insert ["get","host","group","id"], @server.method(:gethostgroupid), no_args, no_help, @arg_processor.method(:get_group_id)
-#      @commands.insert ["get","seid"], @server.method(:getseid), no_args, no_help, @arg_processor.default_get
+  def load_command_path(path,base_path=nil,show_load=nil)
+    base_path||="~"
+    load_path=nil
+    path=File.expand_path(path,base_path)
+    if File.file?(path)
+      load_path=[path]
+    elsif File.directory?(path)
+      load_path=Dir.entries(path).map { |i|
+        if i =~ /^\..*/
+          nil
+        else
+          File.join(path,i)
+        end
+      }
+      load_path.compact!
+    else
+      load_path=Dir[path]
+    end
+
+    return if load_path.nil? || load_path.empty?
+
+    load_path.each { |f|
+      env["load_count"]+=1
+      puts "Loading custom commands from #{f}" if env["echo"] && env["show_load"]=="all"
+
+      begin
+        load f
+      rescue Exception=> e
+        warn "*** Error loading custom commands ***"
+        warn "#{e.class.to_s}: #{e}"
+        warn "Custom commands from: #{f} were not loaded."
+        warn ""
+        env["load_count"]-=1
+      end
+    }
+  end
 
   def start
     debug(5,:msg=>"Entering main zabcon start routine")
@@ -171,12 +192,15 @@ class ZabconCore
     begin
       catch(:exit) do
         while line=@input.get_line()
-          line=line.strip_comments
+          #tokens=ExpressionTokenizer.new(line)
+          tokens=CommandTokenizer.new(line)
+#          line=line.strip_comments
+          tokens.delete_if {|item| item.kind==:comment}
           next if line.nil?
           next if line.strip.length==0  # don't bother parsing an empty line'
           debug(6, :var=>line, :msg=>"Input from user")
 
-          commands=ZabconExecuteContainer.new(line)
+          commands=ZabconExecuteContainer.new(tokens)
           debug(8,:var=>commands,:msg=>"Commands tree")
 
           commands.execute
@@ -241,26 +265,6 @@ class ZabconCore
   @server.login? ? " #{debug_part}+> " : " #{debug_part}-> "
   end
 
-#  def set_lines(input)
-#    @printer.sheight=input.keys[0].to_i
-#  end
-
-#  def set_pause(input)
-#    if input.nil? then
-#      puts "set pause requires either Off or On"
-#      return
-#    end
-#
-#    if input.keys[0].upcase=="OFF"
-#      @printer.sheight=@printer.sheight.abs*(-1)
-#    elsif input.keys[0].upcase=="ON"
-#      @printer.sheight=@printer.sheight.abs
-#    else
-#      puts "set pause requires either Off or On"
-#    end
-#    @printer.sheight = 24 if @printer.sheight==0
-#  end
-
   def set_debug(input)
     if input["prompt"].nil? then
       puts "This command is deprecated, please use \"set env debug=n\""
@@ -275,29 +279,6 @@ class ZabconCore
     set_facility_debug_level(:api,value)
   end
 
-#  def set_var(input)
-#    debug(6,input)
-#    input.each {|key,val|
-#      GlobalVars.instance[key]=val
-#      puts "#{key} : #{val.inspect}"
-#    }
-#  end
-
-#  def unset_var(input)
-#    if input.empty?
-#      puts "No variables given to unset"
-#    else
-#      input.each {|item|
-#        if GlobalVars.instance[item].nil?
-#          puts "#{item} *** Not Defined ***"
-#        else
-#          GlobalVars.instance.delete(item)
-#          puts "#{item} Deleted"
-#        end
-#      }
-#    end
-#  end
-
 #
 # Import config from an XML file:
 #

data/libs/zabcon_exceptions.rb

@@ -18,8 +18,8 @@
 
 ##########################################
 # Subversion information
-# $Id: zabcon_exceptions.rb 325 2011-09-26 08:57:00Z nelsonab $
-# $Revision: 325 $
+# $Id: zabcon_exceptions.rb 333 2011-10-12 16:58:11Z nelsonab $
+# $Revision: 333 $
 ##########################################
 
 #------------------------------------------------------------------------------
@@ -43,3 +43,11 @@ end
 
 class ZabconError < ZError
 end
+
+class BaseClassError < ZabconError
+  def initialize(message=nil, params={})
+    super(message,params)
+    @message=mesasge || "Base Class Method Called"
+  end
+end
+

data/revision_information

@@ -0,0 +1,9 @@
+**** 11/23/11 nelsonab
+* Added revision file and command to display revision information
+  "show revision"
+* Added support for multiple custom command files.
+  See Sample command file for full information.
+  Sample can be found here:
+   http://trac.red-tux.net/browser/trunk/ruby/zabcon/zabcon.conf.default
+* Fixed Raw JSON support
+  variable substitution currently not working.

data/zabcon.conf.default

@@ -27,15 +27,40 @@ password=zabbix
 #output related environment variables
 
 # Are we displaying a well formatted table or csv?  Zabcon will automatically
-# set this variable to true for intaractive use.
+# set this variable to true for interactive use.
 # true = table   false = csv
 #table_output=true
 
 # Print the table header?
 #table_header=true
 
-# The default seperator character for csv output.
+# The default separator character for csv output.
 #table_separator=","
 
+[custom_commands]
+#This is a sub section which deals with Custom commands
+#ONLY CUSTOM COMMAND INFORMATION IS ALLOWED IN THIS SECTION
+#Custom commands can be explicitly called paths or globs may be given.
+#Each entry however must have a unique name.  There are two reserved names
+#in this section "base_path" and "show_load".
+#base_path denotes the base path to be used for relative paths, by default
+#it is ~ (home directory of the current user)
+#show_load has two values "show" and "all" and is case insensitive.
+#"all" (default) will show each file being loaded if echo is enabled
+#"total" will only show a total of how many files were loaded if echo is
+#enabled.
+
+#The following are some examples
+#base_path=/usr/local/zabcon
+#show_load=all
+
+#dir1=custom_commands
+#If custom_commands is a directory in /usr/local/zabcon all files i that
+#directory, except (dot) files, will be loaded because the base search
+#path is /usr/loca/zabcon
+
+#dir2=~/zabcon_commands
+#file1=~/my_zabcon_commands.rb
+#file2=~/ruby/zabcon*.rb
 # File to store custom commands
 #custom_commands=sample_custom_commands

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zabcon
 version: !ruby/object:Gem::Version 
-  hash: 647
+  hash: 675
   prerelease: false
   segments: 
   - 0
   - 0
-  - 332
-  version: 0.0.332
+  - 350
+  version: 0.0.350
 platform: ruby
 authors: 
 - A. Nelson
@@ -15,7 +15,7 @@ autorequire:
 bindir: .
 cert_chain: []
 
-date: 2011-09-30 00:00:00 -04:00
+date: 2011-11-23 00:00:00 -05:00
 default_executable: zabcon
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -74,6 +74,7 @@ files:
 - zabcon.rb
 - zabcon.conf.default
 - README
+- revision_information
 - libs/argument_processor.rb
 - libs/revision.rb
 - libs/command_help.rb