mumboe-soap4r 1.5.8.2

data/lib/soap/rpc/driver.rb

@@ -0,0 +1,221 @@
+# SOAP4R - SOAP RPC driver
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/soap'
+require 'soap/attrproxy'
+require 'soap/mapping'
+require 'soap/rpc/rpc'
+require 'soap/rpc/proxy'
+require 'soap/rpc/element'
+require 'soap/streamHandler'
+require 'soap/property'
+require 'soap/header/handlerset'
+
+
+module SOAP
+module RPC
+
+
+class Driver
+  include AttrProxy
+
+  attr_proxy :endpoint_url, true
+  attr_proxy :mapping_registry, true
+  attr_proxy :literal_mapping_registry, true
+  attr_proxy :allow_unqualified_element, true
+  attr_proxy :default_encodingstyle, true
+  attr_proxy :generate_explicit_type, true
+  attr_proxy :use_default_namespace, true
+  attr_proxy :return_response_as_xml, true
+  attr_proxy :headerhandler
+  attr_proxy :filterchain
+  attr_proxy :streamhandler
+  attr_proxy :test_loopback_response
+  attr_proxy :reset_stream
+
+  attr_reader :proxy
+  attr_reader :options
+  attr_accessor :soapaction
+
+  def inspect
+    "#<#{self.class}:#{@proxy.inspect}>"
+  end
+
+  def httpproxy
+    options["protocol.http.proxy"]
+  end
+
+  def httpproxy=(httpproxy)
+    options["protocol.http.proxy"] = httpproxy
+  end
+
+  def wiredump_dev
+    options["protocol.http.wiredump_dev"]
+  end
+
+  def wiredump_dev=(wiredump_dev)
+    options["protocol.http.wiredump_dev"] = wiredump_dev
+  end
+
+  def mandatorycharset
+    options["protocol.mandatorycharset"]
+  end
+
+  def mandatorycharset=(mandatorycharset)
+    options["protocol.mandatorycharset"] = mandatorycharset
+  end
+
+  def wiredump_file_base
+    options["protocol.wiredump_file_base"]
+  end
+
+  def wiredump_file_base=(wiredump_file_base)
+    options["protocol.wiredump_file_base"] = wiredump_file_base
+  end
+
+  def initialize(endpoint_url, namespace = nil, soapaction = nil)
+    @namespace = namespace
+    @soapaction = soapaction
+    @options = setup_options
+    @wiredump_file_base = nil
+    @proxy = Proxy.new(endpoint_url, @soapaction, @options)
+  end
+
+  def loadproperty(propertyname)
+    unless options.loadproperty(propertyname)
+      raise LoadError.new("No such property to load -- #{propertyname}")
+    end
+  end
+
+  def add_rpc_method(name, *params)
+    add_rpc_method_with_soapaction_as(name, name, @soapaction, *params)
+  end
+
+  def add_rpc_method_as(name, name_as, *params)
+    add_rpc_method_with_soapaction_as(name, name_as, @soapaction, *params)
+  end
+
+  def add_rpc_method_with_soapaction(name, soapaction, *params)
+    add_rpc_method_with_soapaction_as(name, name, soapaction, *params)
+  end
+
+  def add_rpc_method_with_soapaction_as(name, name_as, soapaction, *params)
+    param_def = SOAPMethod.create_rpc_param_def(params)
+    qname = XSD::QName.new(@namespace, name_as)
+    @proxy.add_rpc_method(qname, soapaction, name, param_def)
+    add_rpc_method_interface(name, param_def)
+  end
+
+  # add_method is for shortcut of typical rpc/encoded method definition.
+  alias add_method add_rpc_method
+  alias add_method_as add_rpc_method_as
+  alias add_method_with_soapaction add_rpc_method_with_soapaction
+  alias add_method_with_soapaction_as add_rpc_method_with_soapaction_as
+
+  def add_document_method(name, soapaction, req_qname, res_qname)
+    param_def = SOAPMethod.create_doc_param_def(req_qname, res_qname)
+    @proxy.add_document_method(soapaction, name, param_def)
+    add_document_method_interface(name, param_def)
+  end
+
+  def add_rpc_operation(qname, soapaction, name, param_def, opt = {})
+    @proxy.add_rpc_operation(qname, soapaction, name, param_def, opt)
+    add_rpc_method_interface(name, param_def)
+  end
+
+  def add_document_operation(soapaction, name, param_def, opt = {})
+    @proxy.add_document_operation(soapaction, name, param_def, opt)
+    add_document_method_interface(name, param_def)
+  end
+
+  def invoke(headers, body)
+    if headers and !headers.is_a?(SOAPHeader)
+      headers = create_header(headers)
+    end
+    set_wiredump_file_base(body.elename.name)
+    env = @proxy.invoke(headers, body)
+    if env.nil?
+      return nil, nil
+    else
+      return env.header, env.body
+    end
+  end
+
+  def call(name, *params)
+    set_wiredump_file_base(name)
+    @proxy.call(name, *params)
+  end
+
+private
+
+  def attrproxy
+    @proxy
+  end
+
+  def set_wiredump_file_base(name)
+    if @wiredump_file_base
+      @proxy.set_wiredump_file_base("#{@wiredump_file_base}_#{name}")
+    end
+  end
+
+  def create_header(headers)
+    header = SOAPHeader.new()
+    headers.each do |content, mustunderstand, encodingstyle|
+      header.add(SOAPHeaderItem.new(content, mustunderstand, encodingstyle))
+    end
+    header
+  end
+
+  def setup_options
+    if opt = Property.loadproperty(::SOAP::PropertyName)
+      opt = opt["client"]
+    end
+    opt ||= Property.new
+    opt.add_hook("protocol.mandatorycharset") do |key, value|
+      @proxy.mandatorycharset = value
+    end
+    opt.add_hook("protocol.wiredump_file_base") do |key, value|
+      @wiredump_file_base = value
+    end
+    opt["protocol.http.charset"] ||= XSD::Charset.xml_encoding_label
+    opt["protocol.http.proxy"] ||= Env::HTTP_PROXY
+    opt["protocol.http.no_proxy"] ||= Env::NO_PROXY
+    opt
+  end
+
+  def add_rpc_method_interface(name, param_def)
+    param_count = RPC::SOAPMethod.param_count(param_def,
+      RPC::SOAPMethod::IN, RPC::SOAPMethod::INOUT)
+    add_method_interface(name, param_count)
+  end
+
+  def add_document_method_interface(name, param_def)
+    param_count = RPC::SOAPMethod.param_count(param_def, RPC::SOAPMethod::IN)
+    add_method_interface(name, param_count)
+  end
+
+  # Mapping.define_singleton_method calls define_method with proc and it
+  # exhausts much memory for each singleton Object.  just instance_eval instead
+  # of it.
+  def add_method_interface(name, param_count)
+    instance_eval <<-EOS
+      def #{name}(*arg)
+        unless arg.size == #{param_count}
+          raise ArgumentError.new(
+            "wrong number of arguments (\#{arg.size} for #{param_count})")
+        end
+        call(#{name.dump}, *arg)
+      end
+    EOS
+    self.method(name)
+  end
+end
+
+
+end
+end

data/lib/soap/rpc/element.rb

@@ -0,0 +1,374 @@
+# SOAP4R - RPC element definition.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/baseData'
+require 'soap/rpc/methodDef'
+
+
+module SOAP
+
+# Add method definitions for RPC to common definition in element.rb
+class SOAPBody < SOAPStruct
+  public
+
+  def request
+    root_node
+  end
+
+  def response
+    root = root_node
+    if !@is_fault
+      if root.nil?
+        nil
+      elsif root.is_a?(SOAPBasetype)
+        root
+      else
+        # Initial element is [retval].
+        root[0]
+      end
+    else
+      root
+    end
+  end
+
+  def outparams
+    root = root_node
+    if !@is_fault and !root.nil? and !root.is_a?(SOAPBasetype)
+      op = root[1..-1]
+      op = nil if op && op.empty?
+      op
+    else
+      nil
+    end
+  end
+
+  def fault
+    if @is_fault
+      self['fault']
+    else
+      nil
+    end
+  end
+
+  def fault=(fault)
+    @is_fault = true
+    add('fault', fault)
+  end
+end
+
+
+module RPC
+
+
+class RPCError < Error; end
+class MethodDefinitionError < RPCError; end
+class ParameterError < RPCError; end
+
+class SOAPMethod < SOAPStruct
+  RETVAL = :retval
+  IN = :in
+  OUT = :out
+  INOUT = :inout
+
+  attr_reader :param_def
+  attr_reader :inparam
+  attr_reader :outparam
+  attr_reader :retval_name
+  attr_reader :retval_class_name
+
+  def initialize(qname, param_def = nil)
+    super(nil)
+    @elename = qname
+    @encodingstyle = nil
+
+    @param_def = param_def
+
+    @signature = []
+    @inparam_names = []
+    @inoutparam_names = []
+    @outparam_names = []
+
+    @inparam = {}
+    @outparam = {}
+    @retval_name = nil
+    @retval_class_name = nil
+
+    init_params(@param_def) if @param_def
+  end
+
+  def have_member
+    true
+  end
+
+  def have_outparam?
+    @outparam_names.size > 0
+  end
+
+  def input_params
+    collect_params(IN, INOUT)
+  end
+
+  def output_params
+    collect_params(OUT, INOUT)
+  end
+
+  def input_param_types
+    collect_param_types(IN, INOUT)
+  end
+
+  def output_param_types
+    collect_param_types(OUT, INOUT)
+  end
+
+  def set_param(params)
+    params.each do |param, data|
+      @inparam[param] = data
+      data.elename = XSD::QName.new(data.elename.namespace, param)
+      data.parent = self
+    end
+  end
+
+  def set_outparam(params)
+    params.each do |param, data|
+      @outparam[param] = data
+      data.elename = XSD::QName.new(data.elename.namespace, param)
+    end
+  end
+
+  def get_paramtypes(names)
+    types = []
+    @signature.each do |io_type, name, type_qname|
+      if type_qname && idx = names.index(name)
+        types[idx] = type_qname
+      end
+    end
+    types
+  end
+
+  def SOAPMethod.param_count(param_def, *type)
+    count = 0
+    param_def.each do |param|
+      param = MethodDef.to_param(param)
+      if type.include?(param.io_type.to_sym)
+        count += 1
+      end
+    end
+    count
+  end
+
+  def SOAPMethod.derive_rpc_param_def(obj, name, *param)
+    if param.size == 1 and param[0].is_a?(Array)
+      return param[0]
+    end
+    if param.empty?
+      method = obj.method(name)
+      param_names = (1..method.arity.abs).collect { |i| "p#{i}" }
+    else
+      param_names = param
+    end
+    create_rpc_param_def(param_names)
+  end
+
+  def SOAPMethod.create_rpc_param_def(param_names)
+    param_def = []
+    param_names.each do |param_name|
+      param_def.push([IN, param_name, nil])
+    end
+    param_def.push([RETVAL, 'return', nil])
+    param_def
+  end
+
+  def SOAPMethod.create_doc_param_def(req_qnames, res_qnames)
+    req_qnames = [req_qnames] if req_qnames.is_a?(XSD::QName)
+    res_qnames = [res_qnames] if res_qnames.is_a?(XSD::QName)
+    param_def = []
+    # req_qnames and res_qnames can be nil
+    if req_qnames
+      req_qnames.each do |qname|
+        param_def << [IN, qname.name, [nil, qname.namespace, qname.name]]
+      end
+    end
+    if res_qnames
+      res_qnames.each do |qname|
+        param_def << [OUT, qname.name, [nil, qname.namespace, qname.name]]
+      end
+    end
+    param_def
+  end
+
+private
+
+  def collect_param_types(*type)
+    names = []
+    @signature.each do |io_type, name, type_qname|
+      names << type_qname if type.include?(io_type)
+    end
+    names
+  end
+
+  def collect_params(*type)
+    names = []
+    @signature.each do |io_type, name, type_qname|
+      names << name if type.include?(io_type)
+    end
+    names
+  end
+
+  def init_params(param_def)
+    param_def.each do |param|
+      param = MethodDef.to_param(param)
+      init_param(param)
+    end
+  end
+
+  def init_param(param)
+    mapped_class = SOAPMethod.parse_mapped_class(param.mapped_class)
+    qname = param.qname
+    if qname.nil? and mapped_class
+      qname = TypeMap.key(mapped_class)
+    end
+    case param.io_type
+    when IN
+      @signature.push([IN, param.name, qname])
+      @inparam_names.push(param.name)
+    when OUT
+      @signature.push([OUT, param.name, qname])
+      @outparam_names.push(param.name)
+    when INOUT
+      @signature.push([INOUT, param.name, qname])
+      @inoutparam_names.push(param.name)
+    when RETVAL
+      if @retval_name
+        raise MethodDefinitionError.new('duplicated retval')
+      end
+      @retval_name = param.name
+      @retval_class_name = mapped_class
+    else
+      raise MethodDefinitionError.new("unknown type: #{param.io_type}")
+    end
+  end
+
+  def self.parse_mapped_class(mapped_class)
+    # the first element of typedef in param_def can be a String like
+    # "::SOAP::SOAPStruct" or "CustomClass[]".  turn this String to a class if
+    # we can.
+    if mapped_class.is_a?(String)
+      if /\[\]\Z/ =~ mapped_class
+        # when '[]' is added, ignore this.
+        mapped_class = nil
+      else
+        mapped_class = Mapping.class_from_name(mapped_class)
+      end
+    end
+    mapped_class
+  end
+end
+
+
+class SOAPMethodRequest < SOAPMethod
+  attr_accessor :soapaction
+
+  def SOAPMethodRequest.create_request(qname, *params)
+    param_def = []
+    param_value = []
+    i = 0
+    params.each do |param|
+      param_name = "p#{i}"
+      i += 1
+      param_def << [IN, param_name, nil]
+      param_value << [param_name, param]
+    end
+    param_def << [RETVAL, 'return', nil]
+    o = new(qname, param_def)
+    o.set_param(param_value)
+    o
+  end
+
+  def initialize(qname, param_def = nil, soapaction = nil)
+    super(qname, param_def)
+    @soapaction = soapaction
+  end
+
+  def each
+    input_params.each do |name|
+      unless @inparam[name]
+        raise ParameterError.new("parameter: #{name} was not given")
+      end
+      yield(name, @inparam[name])
+    end
+  end
+
+  def dup
+    req = self.class.new(@elename.dup, @param_def, @soapaction)
+    req.encodingstyle = @encodingstyle
+    req
+  end
+
+  def create_method_response(response_name = nil)
+    response_name ||=
+      XSD::QName.new(@elename.namespace, @elename.name + 'Response')
+    SOAPMethodResponse.new(response_name, @param_def)
+  end
+end
+
+
+class SOAPMethodResponse < SOAPMethod
+
+  def initialize(qname, param_def = nil)
+    super(qname, param_def)
+    @retval = nil
+  end
+
+  def retval
+    @retval
+  end
+
+  def retval=(retval)
+    @retval = retval
+    @retval.elename = @retval.elename.dup_name(@retval_name || 'return')
+    retval.parent = self
+    retval
+  end
+
+  def each
+    if @retval_name and !@retval.is_a?(SOAPVoid)
+      yield(@retval_name, @retval)
+    end
+
+    output_params.each do |name|
+      unless @outparam[name]
+        raise ParameterError.new("parameter: #{name} was not given")
+      end
+      yield(name, @outparam[name])
+    end
+  end
+end
+
+
+# To return(?) void explicitly.
+#  def foo(input_var)
+#    ...
+#    return SOAP::RPC::SOAPVoid.new
+#  end
+class SOAPVoid < XSD::XSDAnySimpleType
+  include SOAPBasetype
+  extend SOAPModuleUtils
+  Name = XSD::QName.new(Mapping::RubyCustomTypeNamespace, nil)
+
+public
+  def initialize()
+    @elename = Name
+    @id = nil
+    @precedents = []
+    @parent = nil
+  end
+end
+
+
+end
+end