class ZabbixAPI_Method

Public Class Methods

new(apiclass,apimethod) click to toggle source
# File api_classes/api_dsl.rb, line 125
def initialize(apiclass,apimethod)
  @apiclass=apiclass
  @apimethod=apimethod
  @login_required=true
  @arg_processors={}  # {version=>block}
  @validparams={} # {version=>[valid parameters]}
  @requiredparams={}  # {version=>[required parameters]}
  @default=:default   # Which is the default version to use
  @method_names={}
  @method_names["0"]="#{@apiclass}.#{@apimethod}".downcase
  @deprecated=nil
  @invalidated=nil
end

Public Instance Methods

add_arg_processor(ver,&block) click to toggle source

add_arg_processor Creates an argument processor suitable for versions starting at ver ver is a string denoting the starting version number this argument processor should be used on This method also needs a block to be passed. The block

# File api_classes/api_dsl.rb, line 180
def add_arg_processor(ver,&block)
  raise InvalidArity.new("Argument processor must accept one parameter") if block.arity !=1
  @arg_processors[ver]=block
  @default=ver
end
add_required_params(ver,params) click to toggle source
# File api_classes/api_dsl.rb, line 208
def add_required_params(ver,params)
  deprecate_dsl("DSL statement add_required_params is deprecated, use the parameters statement")
  @requiredparams[ver]=params
end
add_valid_params(ver,params) click to toggle source
# File api_classes/api_dsl.rb, line 203
def add_valid_params(ver,params)
  deprecate_dsl("DSL statement add_valid_params is deprecated, use the parameters statement")
  @validparams[ver]=params
end
call_arg_processor(ver,params={}) click to toggle source

calls the argument processor appropriate for ver If no argument processor found, params are returned unchanged

# File api_classes/api_dsl.rb, line 194
def call_arg_processor(ver,params={})
  processor=get_arg_processor(ver)
  if processor.nil?
    params
  else
    processor.call(params)
  end
end
deprecate(ver,msg=nil) click to toggle source

Deprecate this function starting at API version ver If msg is nil the following will be printed: “#{method} is deprecated for API versions #{ver} and higher”

Where method is the current method name for the API
# File api_classes/api_dsl.rb, line 147
def deprecate(ver,msg=nil)
  #Deprecate can only be called once
  raise AlreadyUsedError.new("Deprecate can only be used once per method") if @deprecated
  @deprecated={ver=>(msg || "") }
end
deprecate_dsl(msg) click to toggle source
# File api_classes/api_dsl.rb, line 153
def deprecate_dsl(msg)
  warn msg
  caller[1]=~/(.*:\d+):.*`(.*?)'/
  warn "from: #{$1}"
end
do(server,params={}) click to toggle source

This is the function that does the actual APIcall.

# File api_classes/api_dsl.rb, line 289
def do(server,params={})
  debug(7,:msg=>"Method Name",:var=>@method_names[@method_names.keys.sort.first])
  debug(7,:msg=>"Server",:var=>server)
  debug(7,:msg=>"Params",:var=>params)

  ver=get_version(server.API_version,@method_names)
  name=@method_names[ver]

  debug(8,:msg=>"Method Name used",:var=>name)

  if @invalidated
    ver=get_version(server.API_version,@invalidated)
    if ver
      msg=@invalidated.values.first.empty? ?
        "#{name} is invalid for api versions #{@invalidated.keys.first} and higher" : @invalidated.values.first
      raise InvalidMethodError.new(msg)
    end
  end

  if @deprecated
    ver=get_version(server.API_version,@deprecated)
    if ver
      msg=@deprecated.values.first.empty? ?
        "#{name} is deprecated for api versions #{@deprecated.keys.first} and higher" : @deprecated.values.first
      warn("Warning: #{msg}")
    end
  end

  debug(8,:msg=>"Params before arg processor",:var=>params)
  params=call_arg_processor(server.API_version,params)
  debug(7,:msg=>"Params after arg processor",:var=>params)
  params_good?(server.API_version,params)
  server.api_call(name,params)
end
get_arg_processor(ver) click to toggle source
# File api_classes/api_dsl.rb, line 186
def get_arg_processor(ver)
  ver=get_version(ver,@arg_processors)
  return nil if ver.nil?
  @arg_processors[ver]
end
get_required_params(ver) click to toggle source
# File api_classes/api_dsl.rb, line 225
def get_required_params(ver)
  ver=get_version(ver,@requiredparams)
  return nil if ver.nil?
  @requiredparams[ver]
end
get_valid_params(ver) click to toggle source

Return the valid parameters for the method given version. If version is nil, the highest version number available in the valid parameters hash is used. If ver is a version number, the closest version number in the valid parameters hash which is less than or equal to is returned. nil is returned is no valid parameters are found

# File api_classes/api_dsl.rb, line 219
def get_valid_params(ver)
  ver=get_version(ver,@validparams)
  return nil if ver.nil?
  @validparams[ver]
end
get_version(server,hash) click to toggle source

returns the version number closest to server which is less than or equal to server If no versions exist in hash, nil is returned

# File api_classes/api_dsl.rb, line 327
def get_version(server,hash)
  return nil if hash.nil?
  if server
    #server=server.split(".").map{|i| i.to_i }
    keys=hash.keys.sort do |a,b|
      aa=a.split(".")
      bb=b.split(".")
      last_pos=((aa.length > bb.length) ? aa.length : bb.length)-1
      pos=0
      while aa[pos].to_i==bb[pos].to_i
        break if pos>=last_pos
        pos+=1
      end
      (aa[pos].to_i<=>bb[pos].to_i)
    end

    keys.delete_if do |k|
      kk=k.split(".")
      ss=server.split(".")
      last_pos=((kk.length > ss.length) ? ss.length : ss.length)-1
      pos=0
      while kk[pos].to_i<=ss[pos].to_i
        break if pos>=last_pos
        pos+=1
      end
      kk[pos].to_i>ss[pos].to_i
    end

    if keys.empty?
      return nil
    else
      return keys.last
    end
  else
    sorted=hash.keys.sort do |a,b|
      aa=a.split(".")
      bb=b.split(".")
      last_pos=((aa.length > bb.length) ? aa.length : bb.length)-1
      pos=0
      while aa[pos].to_i==bb[pos].to_i
        break if pos>=last_pos
        pos+=1
      end
      (aa[pos].to_i<=>bb[pos].to_i)
    end
    sorted.last
  end
end
invalidate(ver,msg=nil) click to toggle source

Invalidate this function starting at API version ver This will raise the ZabbixAPI_Method::InvalidMethod exception If msg is nil the following string will be used in the exception: “#{method} is invalid for API versions #{ver} and higher”

Where method is the current method name for the API
# File api_classes/api_dsl.rb, line 164
def invalidate(ver,msg=nil)
  #Invalidate can only be called once
  raise AlreadyUsedError.new("Invalidate can only be used once per method") if @deprecated
  @invalidated={ver=>(msg || "") }
end
login_not_required() click to toggle source
# File api_classes/api_dsl.rb, line 139
def login_not_required
  @login_required=false
end
method_override(ver,name) click to toggle source

Allows for the override of the API method to be called The default method is version 0 which can be overridden

# File api_classes/api_dsl.rb, line 172
def method_override(ver,name)
  @method_names[ver]=name
end
parameters(ver,*params,&block) click to toggle source
# File api_classes/api_dsl.rb, line 231
def parameters(ver,*params,&block)
  parameters=ZabbixAPI_ParametersDSL.new(@validparams,@requiredparams)

  parameters.add(params) if !params.nil?
  parameters.instance_eval(&block) if !block.nil?
  @validparams[ver]=parameters.valid_params
  @requiredparams[ver]=parameters.required_params
end
params_good?(server_version, params) click to toggle source
# File api_classes/api_dsl.rb, line 240
  def params_good?(server_version, params)
    debug(8,:msg=>"Server Version", :var=>server_version)
    var=params.is_a?(Hash) ? params.keys : params
    debug(8,:msg=>"Param keys", :var=>var)

    valid_params=get_valid_params(server_version)

    if valid_params  #continue to see if there's a required param
      raise ArgumentError.new("Named Arguments (Hash) expected for #{@apiclass}.#{@apimethod},"\
                              " '#{params.class}' received: #{params.inspect}") if !params.is_a?(Hash)
      args=params.keys.map{|key|key.to_s}

      invalid_args=args-valid_params
      debug(9,:msg=>"Invalid args",:var=>invalid_args)
      raise ZbxAPI_ParameterError.new("Invalid parameters #{invalid_args.inspect}") if !invalid_args.empty?
    end

    required_params=get_required_params(server_version)
#    ver=get_version(server_version,@requiredparams)

    return true if required_params.nil?
    required_args=required_params.reject { |i| i.class==Array }
    required_or_args=required_params.reject { |i| i.class!=Array }

    missing_args=[]
    missing_args=required_args-args

    required_or_args.delete_if do |i|
      count=i.length
      missing_args<<i if (i-args).count==count
    end

    debug(9,:msg=>"Required Params",:var=>required_params)
    debug(9,:msg=>"Missing params",:var=>missing_args)

    if !missing_args.empty?
      msg=missing_args.map do |i|
        if i.class==Array
          "(#{i.join(" | ")})"
        else
          i
        end
      end.join(", ")
      raise ZbxAPI_ParameterError.new("Missing required arguments: #{msg}")
    end
    true
  end