# File xmlrpc/server.rb, line 366
def call_method(methodname, *args)
  begin
    [true, dispatch(methodname, *args)]
  rescue XMLRPC::FaultException => e  
    [false, e]  
  rescue Exception => e
    [false, XMLRPC::FaultException.new(ERR_UNCAUGHT_EXCEPTION, "Uncaught exception #{e.message} in method #{methodname}")]
  end
end
            

 
               # File xmlrpc/server.rb, line 354
def check_arity(obj, n_args)
  ary = obj.arity

  if ary >= 0
    n_args == ary
  else
    n_args >= (ary+1).abs 
  end
end
            

 
               # File xmlrpc/server.rb, line 324
def dispatch(methodname, *args)
  for name, obj in @handler
    if obj.kind_of? Proc
      next unless methodname == name
    else
      next unless methodname =~ /^#{name}(.+)$/
      next unless obj.respond_to? $1
      obj = obj.method($1)
    end

    if check_arity(obj, args.size)
      if @service_hook.nil?
        return obj.call(*args) 
      else
        return @service_hook.call(obj, *args)
      end
    end
  end 
 
  if @default_handler.nil?
    raise XMLRPC::FaultException.new(ERR_METHOD_MISSING, "Method #{methodname} missing or wrong number of parameters!")
  else
    @default_handler.call(methodname, *args) 
  end
end
            

 
               # File xmlrpc/client.rb, line 500
def do_rpc(request, async=false)
  header = {  
   "User-Agent"     =>  USER_AGENT,
   "Content-Type"   => "text/xml; charset=utf-8",
   "Content-Length" => request.size.to_s, 
   "Connection"     => (async ? "close" : "keep-alive")
  }

  header["Cookie"] = @cookie        if @cookie
  header.update(@http_header_extra) if @http_header_extra

  if @auth != nil
    # add authorization header
    header["Authorization"] = @auth
  end
 
  resp = nil
  @http_last_response = nil

  if async
    # use a new HTTP object for each call
    Net::HTTP.version_1_2
    http = Net::HTTP.new(@host, @port, @proxy_host, @proxy_port) 
    http.use_ssl = @use_ssl if @use_ssl
    http.read_timeout = @timeout
    http.open_timeout = @timeout
    
    # post request
    http.start {
      resp = http.post2(@path, request, header) 
    }
  else
    # reuse the HTTP object for each call => connection alive is possible
    # we must start connection explicitely first time so that http.request
    # does not assume that we don't want keepalive
    @http.start if not @http.started?
    
    # post request
    resp = @http.post2(@path, request, header) 
  end
  
  @http_last_response = resp

  data = resp.body

  if resp.code == "401"
    # Authorization Required
    raise "Authorization failed.\nHTTP-Error: #{resp.code} #{resp.message}" 
  elsif resp.code[0,1] != "2"
    raise "HTTP-Error: #{resp.code} #{resp.message}" 
  end

  ct = parse_content_type(resp["Content-Type"]).first
  if ct != "text/xml"
    if ct == "text/html"
      raise "Wrong content-type (received '#{ct}' but expected 'text/xml'): \n#{data}"
    else
      raise "Wrong content-type (received '#{ct}' but expected 'text/xml')"
    end
  end

  expected = resp["Content-Length"] || "<unknown>"
  if data.nil? or data.size == 0 
    raise "Wrong size. Was #{data.size}, should be #{expected}" 
  elsif expected != "<unknown>" and expected.to_i != data.size and resp["Transfer-Encoding"].nil?
    raise "Wrong size. Was #{data.size}, should be #{expected}"
  end

  c = resp["Set-Cookie"]
  @cookie = c if c

  return data
end
            

 
               # File xmlrpc/client.rb, line 574
def gen_multicall(methods=[], async=false)
  meth = :call2
  meth = :call2_async if async

  ok, params = self.send(meth, "system.multicall", 
    methods.collect {|m| {'methodName' => m[0], 'params' => m[1..-1]} }
  )

  if ok 
    params = params.collect do |param|
      if param.is_a? Array
        param[0]
      elsif param.is_a? Hash
        XMLRPC::FaultException.new(param["faultCode"], param["faultString"])
      else
        raise "Wrong multicall return value"
      end 
    end
  end

  return ok, params
end
            

 
               # File xmlrpc/server.rb, line 379
def handle(methodname, *args)
  create().methodResponse(*call_method(methodname, *args))
end