railsware-soap4r 1.5.8.1

data/lib/soap/standaloneServer.rb

@@ -0,0 +1,9 @@
+# SOAP4R - Standalone Server
+# 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/compat'

data/lib/soap/streamHandler.rb

@@ -0,0 +1,302 @@
+# SOAP4R - Stream handler.
+# 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/httpconfigloader'
+require 'soap/filter/filterchain'
+begin
+  require 'stringio'
+  require 'zlib'
+rescue LoadError
+  warn("Loading stringio or zlib failed.  No gzipped response support.") if $DEBUG
+end
+
+
+module SOAP
+
+
+class StreamHandler
+  RUBY_VERSION_STRING = "ruby #{ RUBY_VERSION } (#{ RUBY_RELEASE_DATE }) [#{ RUBY_PLATFORM }]"
+
+  attr_reader :filterchain
+
+  class ConnectionData
+    attr_accessor :send_string
+    attr_accessor :send_contenttype
+    attr_accessor :receive_string
+    attr_accessor :receive_contenttype
+    attr_accessor :is_fault
+    attr_accessor :is_nocontent
+    attr_accessor :soapaction
+
+    def initialize(send_string = nil)
+      @send_string = send_string
+      @send_contenttype = nil
+      @receive_string = nil
+      @receive_contenttype = nil
+      @is_fault = false
+      @is_nocontent = false
+      @soapaction = nil
+    end
+  end
+
+  def initialize
+    @filterchain = Filter::FilterChain.new
+  end
+
+  def self.parse_media_type(str)
+    if /^#{ MediaType }(?:\s*;\s*charset=([^"]+|"[^"]+"))?$/i !~ str
+      return nil
+    end
+    charset = $1
+    charset.gsub!(/"/, '') if charset
+    charset || 'us-ascii'
+  end
+
+  def self.create_media_type(charset)
+    "#{ MediaType }; charset=#{ charset }"
+  end
+
+  def send(url, conn_data, soapaction = nil, charset = nil)
+    # send a ConnectionData to specified url.
+    # return value is a ConnectionData with receive_* property filled.
+    # You can fill values of given conn_data and return it.
+  end
+
+  def reset(url = nil)
+    # for initializing connection status if needed.
+    # return value is not expected.
+  end
+
+  def set_wiredump_file_base(wiredump_file_base)
+    # for logging.  return value is not expected.
+    # Override it when you want.
+    raise NotImplementedError
+  end
+
+  def test_loopback_response
+    # for loopback testing.  see HTTPStreamHandler for more detail.
+    # return value is an Array of loopback responses.
+    # Override it when you want.
+    raise NotImplementedError
+  end
+end
+
+
+class HTTPStreamHandler < StreamHandler
+  include SOAP
+
+  begin
+    require 'httpclient'
+    Client = HTTPClient
+    RETRYABLE = true
+  rescue LoadError
+    begin
+      require 'http-access2'
+      if HTTPAccess2::VERSION < "2.0"
+        raise LoadError.new("http-access/2.0 or later is required.")
+      end
+      Client = HTTPAccess2::Client
+      RETRYABLE = true
+    rescue LoadError
+      warn("Loading http-access2 failed.  Net/http is used.") if $DEBUG
+      require 'soap/netHttpClient'
+      Client = SOAP::NetHttpClient
+      RETRYABLE = false
+    end
+  end
+
+  class HttpPostRequestFilter
+    def initialize(filterchain)
+      @filterchain = filterchain
+    end
+
+    def filter_request(req)
+      @filterchain.each do |filter|
+        filter.on_http_outbound(req)
+      end
+    end
+
+    def filter_response(req, res)
+      @filterchain.each do |filter|
+        filter.on_http_inbound(req, res)
+      end
+    end
+  end
+
+public
+  
+  attr_reader :client
+  attr_accessor :wiredump_file_base
+  
+  MAX_RETRY_COUNT = 10       	# [times]
+
+  def self.create(options)
+    new(options)
+  end
+
+  def initialize(options)
+    super()
+    @client = Client.new(nil, "SOAP4R/#{ Version }")
+    if @client.respond_to?(:request_filter)
+      @client.request_filter << HttpPostRequestFilter.new(@filterchain)
+    end
+    @wiredump_file_base = nil
+    @charset = @wiredump_dev = nil
+    @options = options
+    set_options
+    @client.debug_dev = @wiredump_dev
+    @cookie_store = nil
+    @accept_encoding_gzip = false
+  end
+
+  def test_loopback_response
+    @client.test_loopback_response
+  end
+
+  def accept_encoding_gzip=(allow)
+    @accept_encoding_gzip = allow
+  end
+
+  def inspect
+    "#<#{self.class}>"
+  end
+
+  def send(url, conn_data, soapaction = nil, charset = @charset)
+    conn_data.soapaction ||= soapaction # for backward conpatibility
+    conn_data = send_post(url, conn_data, charset)
+    @client.save_cookie_store if @cookie_store
+    conn_data
+  end
+
+  def reset(url = nil)
+    if url.nil?
+      @client.reset_all
+    else
+      @client.reset(url)
+    end
+    @client.save_cookie_store if @cookie_store
+  end
+
+private
+
+  def set_options
+    @options["http"] ||= ::SOAP::Property.new
+    HTTPConfigLoader.set_options(@client, @options["http"])
+    @charset = @options["http.charset"] || XSD::Charset.xml_encoding_label
+    @options.add_hook("http.charset") do |key, value|
+      @charset = value
+    end
+    @wiredump_dev = @options["http.wiredump_dev"]
+    @options.add_hook("http.wiredump_dev") do |key, value|
+      @wiredump_dev = value
+      @client.debug_dev = @wiredump_dev
+    end
+    set_cookie_store_file(@options["http.cookie_store_file"])
+    @options.add_hook("http.cookie_store_file") do |key, value|
+      set_cookie_store_file(value)
+    end
+    ssl_config = @options["http.ssl_config"]
+    basic_auth = @options["http.basic_auth"]
+    auth = @options["http.auth"]
+    @options["http"].lock(true)
+    ssl_config.unlock
+    basic_auth.unlock
+    auth.unlock
+  end
+
+  def set_cookie_store_file(value)
+    value = nil if value and value.empty?
+    @cookie_store = value
+    @client.set_cookie_store(@cookie_store) if @cookie_store
+  end
+
+  def send_post(url, conn_data, charset)
+    conn_data.send_contenttype ||= StreamHandler.create_media_type(charset)
+
+    if @wiredump_file_base
+      filename = @wiredump_file_base + '_request.xml'
+      f = File.open(filename, "w")
+      f << conn_data.send_string
+      f.close
+    end
+
+    extheader = {}
+    extheader['Content-Type'] = conn_data.send_contenttype
+    extheader['SOAPAction'] = "\"#{ conn_data.soapaction }\""
+    extheader['Accept-Encoding'] = 'gzip' if send_accept_encoding_gzip?
+    send_string = conn_data.send_string
+    @wiredump_dev << "Wire dump:\n\n" if @wiredump_dev
+    begin
+      retry_count = 0
+      while true
+        res = @client.post(url, send_string, extheader)
+        if RETRYABLE and HTTP::Status.redirect?(res.status)
+          retry_count += 1
+          if retry_count >= MAX_RETRY_COUNT
+            raise HTTPStreamError.new("redirect count exceeded")
+          end
+          url = res.header["location"][0]
+          puts "redirected to #{url}" if $DEBUG
+        else
+          break
+        end
+      end
+    rescue
+      @client.reset(url)
+      raise
+    end
+    @wiredump_dev << "\n\n" if @wiredump_dev
+    receive_string = res.content
+    if @wiredump_file_base
+      filename = @wiredump_file_base + '_response.xml'
+      f = File.open(filename, "w")
+      f << receive_string
+      f.close
+    end
+    case res.status
+    when 405
+      raise PostUnavailableError.new("#{ res.status }: #{ res.reason }")
+    when 200, 202, 500
+      # Nothing to do.  202 is for oneway service.
+    else
+      raise HTTPStreamError.new("#{ res.status }: #{ res.reason }")
+    end
+
+    # decode gzipped content, if we know it's there from the headers
+    if res.respond_to?(:header) and !res.header['content-encoding'].empty? and
+        res.header['content-encoding'][0].downcase == 'gzip'
+      receive_string = decode_gzip(receive_string)
+    # otherwise check for the gzip header
+    elsif @accept_encoding_gzip && receive_string[0..1] == "\x1f\x8b"
+      receive_string = decode_gzip(receive_string)
+    end
+    conn_data.receive_string = receive_string
+    conn_data.receive_contenttype = res.contenttype
+    conn_data
+  end
+
+  def send_accept_encoding_gzip?
+    @accept_encoding_gzip and defined?(::Zlib)
+  end
+
+  def decode_gzip(instring)
+    unless send_accept_encoding_gzip?
+      raise HTTPStreamError.new("Gzipped response content.")
+    end
+    begin
+      gz = Zlib::GzipReader.new(StringIO.new(instring))
+      gz.read
+    ensure
+      gz.close
+    end
+  end
+end
+
+
+end

data/lib/soap/wsdlDriver.rb

@@ -0,0 +1,597 @@
+# SOAP4R - SOAP WSDL 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 'wsdl/parser'
+require 'wsdl/importer'
+require 'xsd/qname'
+require 'xsd/codegen/gensupport'
+require 'soap/mapping/wsdlencodedregistry'
+require 'soap/mapping/wsdlliteralregistry'
+require 'soap/rpc/driver'
+require 'wsdl/soap/methodDefCreator'
+require 'wsdl/soap/classDefCreatorSupport'
+require 'wsdl/soap/classNameCreator'
+
+
+module SOAP
+
+
+class WSDLDriverFactory
+  include WSDL::SOAP::ClassDefCreatorSupport
+
+  class FactoryError < StandardError; end
+
+  attr_reader :wsdl
+
+  def initialize(wsdl)
+    @wsdl = import(wsdl)
+    name_creator = WSDL::SOAP::ClassNameCreator.new
+    @modulepath = 'WSDLDriverFactory'
+    @methoddefcreator =
+      WSDL::SOAP::MethodDefCreator.new(@wsdl, name_creator, @modulepath, {})
+  end
+  
+  def inspect
+    sprintf("#<%s:%s:0x%x\n\n%s>", self.class.name, @wsdl.name, __id__, dump_method_signatures)
+  end
+
+  def create_rpc_driver(servicename = nil, portname = nil)
+    port = find_port(servicename, portname)
+    drv = SOAP::RPC::Driver.new(port.soap_address.location)
+    init_driver(drv, port)
+    add_operation(drv, port)
+    drv
+  end
+
+  # deprecated old interface
+  def create_driver(servicename = nil, portname = nil)
+    warn("WSDLDriverFactory#create_driver is deprecated.  Use create_rpc_driver instead.")
+    port = find_port(servicename, portname)
+    WSDLDriver.new(@wsdl, port, nil)
+  end
+
+  # Backward compatibility.
+  alias createDriver create_driver
+
+  def dump_method_signatures(servicename = nil, portname = nil)
+    targetservice = XSD::QName.new(@wsdl.targetnamespace, servicename) if servicename
+    targetport = XSD::QName.new(@wsdl.targetnamespace, portname) if portname
+    sig = []
+    element_definitions = @wsdl.collect_elements
+    @wsdl.services.each do |service|
+      next if targetservice and service.name != targetservice
+      service.ports.each do |port|
+        next if targetport and port.name != targetport
+        sig << port.porttype.operations.collect { |operation|
+          dump_method_signature(operation, element_definitions).gsub(/^#/, ' ')
+        }.join("\n")
+      end
+    end
+    sig.join("\n")
+  end
+
+private
+
+  def find_port(servicename = nil, portname = nil)
+    service = port = nil
+    if servicename
+      service = @wsdl.service(
+        XSD::QName.new(@wsdl.targetnamespace, servicename))
+    else
+      service = @wsdl.services[0]
+    end
+    if service.nil?
+      raise FactoryError.new("service #{servicename} not found in WSDL")
+    end
+    if portname
+      port = service.ports[XSD::QName.new(@wsdl.targetnamespace, portname)]
+      if port.nil?
+        raise FactoryError.new("port #{portname} not found in WSDL")
+      end
+    else
+      port = service.ports.find { |port| !port.soap_address.nil? }
+      if port.nil?
+        raise FactoryError.new("no ports have soap:address")
+      end
+    end
+    if port.soap_address.nil?
+      raise FactoryError.new("soap:address element not found in WSDL")
+    end
+    port
+  end
+
+  def init_driver(drv, port)
+    wsdl_elements = @wsdl.collect_elements
+    wsdl_types = @wsdl.collect_complextypes + @wsdl.collect_simpletypes
+    rpc_decode_typemap = wsdl_types +
+      @wsdl.soap_rpc_complextypes(port.find_binding)
+    drv.proxy.mapping_registry =
+      Mapping::WSDLEncodedRegistry.new(rpc_decode_typemap)
+    drv.proxy.literal_mapping_registry =
+      Mapping::WSDLLiteralRegistry.new(wsdl_types, wsdl_elements)
+  end
+
+  def add_operation(drv, port)
+    port.find_binding.operations.each do |op_bind|
+      op_name = op_bind.soapoperation_name
+      soapaction = op_bind.soapaction || ''
+      orgname = op_name.name
+      name = XSD::CodeGen::GenSupport.safemethodname(orgname)
+      param_def = create_param_def(op_bind)
+      opt = {
+        :request_style => op_bind.soapoperation_style,
+        :response_style => op_bind.soapoperation_style,
+        :request_use => op_bind.soapbody_use_input,
+        :response_use => op_bind.soapbody_use_output
+      }
+      if op_bind.soapoperation_style == :rpc
+        drv.add_rpc_operation(op_name, soapaction, name, param_def, opt)
+      else
+        drv.add_document_operation(soapaction, name, param_def, opt)
+      end
+      if orgname != name and orgname.capitalize == name.capitalize
+        ::SOAP::Mapping.define_singleton_method(drv, orgname) do |*arg|
+          __send__(name, *arg)
+        end
+      end
+    end
+  end
+
+  def import(location)
+    WSDL::Importer.import(location)
+  end
+
+  def create_param_def(op_bind)
+    op = op_bind.find_operation
+    if op_bind.soapoperation_style == :rpc
+      param_def = @methoddefcreator.collect_rpcparameter(op)
+    else
+      param_def = @methoddefcreator.collect_documentparameter(op)
+    end
+    # the first element of typedef in param_def is a String like
+    # "::SOAP::SOAPStruct".  turn this String to a class.
+    param_def.collect { |io_type, name, param_type|
+      [io_type, name, ::SOAP::RPC::SOAPMethod.parse_param_type(param_type)]
+    }
+  end
+
+  def partqname(part)
+    if part.type
+      part.type
+    else
+      part.element
+    end
+  end
+
+  def param_def(type, name, klass, partqname)
+    [type, name, [klass, partqname.namespace, partqname.name]]
+  end
+
+  def filter_parts(partsdef, partssource)
+    parts = partsdef.split(/\s+/)
+    partssource.find_all { |part| parts.include?(part.name) }
+  end
+end
+
+
+class WSDLDriver
+  class << self
+    if RUBY_VERSION >= "1.7.0"
+      def __attr_proxy(symbol, assignable = false)
+        name = symbol.to_s
+        define_method(name) {
+          @servant.__send__(name)
+        }
+        if assignable
+          aname = name + '='
+          define_method(aname) { |rhs|
+            @servant.__send__(aname, rhs)
+          }
+        end
+      end
+    else
+      def __attr_proxy(symbol, assignable = false)
+        name = symbol.to_s
+        module_eval <<-EOS
+          def #{name}
+            @servant.#{name}
+          end
+        EOS
+        if assignable
+          module_eval <<-EOS
+            def #{name}=(value)
+              @servant.#{name} = value
+            end
+          EOS
+        end
+      end
+    end
+  end
+
+  __attr_proxy :options
+  __attr_proxy :headerhandler
+  __attr_proxy :streamhandler
+  __attr_proxy :test_loopback_response
+  __attr_proxy :endpoint_url, true
+  __attr_proxy :mapping_registry, true		# for RPC unmarshal
+  __attr_proxy :wsdl_mapping_registry, true	# for RPC marshal
+  __attr_proxy :default_encodingstyle, true
+  __attr_proxy :generate_explicit_type, true
+  __attr_proxy :allow_unqualified_element, true
+
+  def httpproxy
+    @servant.options["protocol.http.proxy"]
+  end
+
+  def httpproxy=(httpproxy)
+    @servant.options["protocol.http.proxy"] = httpproxy
+  end
+
+  def wiredump_dev
+    @servant.options["protocol.http.wiredump_dev"]
+  end
+
+  def wiredump_dev=(wiredump_dev)
+    @servant.options["protocol.http.wiredump_dev"] = wiredump_dev
+  end
+
+  def mandatorycharset
+    @servant.options["protocol.mandatorycharset"]
+  end
+
+  def mandatorycharset=(mandatorycharset)
+    @servant.options["protocol.mandatorycharset"] = mandatorycharset
+  end
+
+  def wiredump_file_base
+    @servant.options["protocol.wiredump_file_base"]
+  end
+
+  def wiredump_file_base=(wiredump_file_base)
+    @servant.options["protocol.wiredump_file_base"] = wiredump_file_base
+  end
+
+  def initialize(wsdl, port, logdev)
+    @servant = Servant__.new(self, wsdl, port, logdev)
+  end
+
+  def inspect
+    "#<#{self.class}:#{@servant.port.name}>"
+  end
+
+  def reset_stream
+    @servant.reset_stream
+  end
+
+  # Backward compatibility.
+  alias generateEncodeType= generate_explicit_type=
+
+  class Servant__
+    include SOAP
+
+    attr_reader :options
+    attr_reader :port
+
+    attr_accessor :soapaction
+    attr_accessor :default_encodingstyle
+    attr_accessor :allow_unqualified_element
+    attr_accessor :generate_explicit_type
+    attr_accessor :mapping_registry
+    attr_accessor :wsdl_mapping_registry
+
+    def initialize(host, wsdl, port, logdev)
+      @host = host
+      @wsdl = wsdl
+      @port = port
+      @logdev = logdev
+      @soapaction = nil
+      @options = setup_options
+      @default_encodingstyle = nil
+      @allow_unqualified_element = nil
+      @generate_explicit_type = false
+      @mapping_registry = nil		# for rpc unmarshal
+      @wsdl_mapping_registry = nil	# for rpc marshal
+      @wiredump_file_base = nil
+      @mandatorycharset = nil
+      @wsdl_elements = @wsdl.collect_elements
+      @wsdl_types = @wsdl.collect_complextypes + @wsdl.collect_simpletypes
+      @rpc_decode_typemap = @wsdl_types +
+	@wsdl.soap_rpc_complextypes(port.find_binding)
+      @wsdl_mapping_registry = Mapping::WSDLEncodedRegistry.new(
+        @rpc_decode_typemap)
+      @doc_mapper = Mapping::WSDLLiteralRegistry.new(
+        @wsdl_types, @wsdl_elements)
+      endpoint_url = @port.soap_address.location
+      # Convert a map which key is QName, to a Hash which key is String.
+      @operation = {}
+      @port.inputoperation_map.each do |op_name, op_info|
+        orgname = op_name.name
+        name = XSD::CodeGen::GenSupport.safemethodname(orgname)
+	@operation[name] = @operation[orgname] = op_info
+	add_method_interface(op_info)
+      end
+      @proxy = ::SOAP::RPC::Proxy.new(endpoint_url, @soapaction, @options)
+    end
+
+    def inspect
+      "#<#{self.class}:#{@proxy.inspect}>"
+    end
+
+    def endpoint_url
+      @proxy.endpoint_url
+    end
+
+    def endpoint_url=(endpoint_url)
+      @proxy.endpoint_url = endpoint_url
+    end
+
+    def headerhandler
+      @proxy.headerhandler
+    end
+
+    def streamhandler
+      @proxy.streamhandler
+    end
+
+    def test_loopback_response
+      @proxy.test_loopback_response
+    end
+
+    def reset_stream
+      @proxy.reset_stream
+    end
+
+    def rpc_call(name, *values)
+      set_wiredump_file_base(name)
+      unless op_info = @operation[name]
+        raise RuntimeError, "method: #{name} not defined"
+      end
+      req_header = create_request_header
+      req_body = create_request_body(op_info, *values)
+      reqopt = create_options({
+        :soapaction => op_info.soapaction || @soapaction})
+      resopt = create_options({
+        :decode_typemap => @rpc_decode_typemap})
+      env = @proxy.route(req_header, req_body, reqopt, resopt)
+      raise EmptyResponseError unless env
+      receive_headers(env.header)
+      begin
+        @proxy.check_fault(env.body)
+      rescue ::SOAP::FaultError => e
+	Mapping.fault2exception(e)
+      end
+      ret = env.body.response ?
+	Mapping.soap2obj(env.body.response, @mapping_registry) : nil
+      if env.body.outparams
+	outparams = env.body.outparams.collect { |outparam|
+  	  Mapping.soap2obj(outparam)
+   	}
+    	return [ret].concat(outparams)
+      else
+      	return ret
+      end
+    end
+
+    # req_header: [[element, mustunderstand, encodingstyle(QName/String)], ...]
+    # req_body: SOAPBasetype/SOAPCompoundtype
+    def document_send(name, header_obj, body_obj)
+      set_wiredump_file_base(name)
+      unless op_info = @operation[name]
+        raise RuntimeError, "method: #{name} not defined"
+      end
+      req_header = header_obj ? header_from_obj(header_obj, op_info) : nil
+      req_body = body_from_obj(body_obj, op_info)
+      opt = create_options({
+        :soapaction => op_info.soapaction || @soapaction,
+        :decode_typemap => @wsdl_types})
+      env = @proxy.invoke(req_header, req_body, opt)
+      raise EmptyResponseError unless env
+      if env.body.fault
+	raise ::SOAP::FaultError.new(env.body.fault)
+      end
+      res_body_obj = env.body.response ?
+	Mapping.soap2obj(env.body.response, @mapping_registry) : nil
+      return env.header, res_body_obj
+    end
+
+  private
+
+    def create_options(hash = nil)
+      opt = {}
+      opt[:default_encodingstyle] = @default_encodingstyle
+      opt[:allow_unqualified_element] = @allow_unqualified_element
+      opt[:generate_explicit_type] = @generate_explicit_type
+      opt.update(hash) if hash
+      opt
+    end
+
+    def set_wiredump_file_base(name)
+      if @wiredump_file_base
+      	@proxy.set_wiredump_file_base(@wiredump_file_base + "_#{name}")
+      end
+    end
+
+    def create_request_header
+      header = SOAPHeader.new
+      items = @proxy.headerhandler.on_outbound(header)
+      items.each do |item|
+        header.add(item.elename.name, item)
+      end
+      header
+    end
+
+    def receive_headers(header)
+      @proxy.headerhandler.on_inbound(header) if header
+    end
+
+    def create_request_body(op_info, *values)
+      method = create_method_struct(op_info, *values)
+      SOAPBody.new(method)
+    end
+
+    def create_method_struct(op_info, *params)
+      parts_names = op_info.bodyparts.collect { |part| part.name }
+      obj = create_method_obj(parts_names, params)
+      method = Mapping.obj2soap(obj, @wsdl_mapping_registry, op_info.op_name)
+      if method.members.size != parts_names.size
+	new_method = SOAPStruct.new
+	method.each do |key, value|
+	  if parts_names.include?(key)
+	    new_method.add(key, value)
+	  end
+	end
+	method = new_method
+      end
+      method.elename = op_info.op_name
+      method.type = XSD::QName.new	# Request should not be typed.
+      method
+    end
+
+    def create_method_obj(names, params)
+      o = Object.new
+      idx = 0
+      while idx < params.length
+        o.instance_variable_set('@' + names[idx], params[idx])
+        idx += 1
+      end
+      o
+    end
+
+    def header_from_obj(obj, op_info)
+      if obj.is_a?(SOAPHeader)
+	obj
+      elsif op_info.headerparts.empty?
+	if obj.nil?
+	  nil
+	else
+	  raise RuntimeError.new("no header definition in schema: #{obj}")
+	end
+      elsif op_info.headerparts.size == 1
+       	part = op_info.headerparts[0]
+	header = SOAPHeader.new()
+	header.add(headeritem_from_obj(obj, part.element || part.eletype))
+	header
+      else
+	header = SOAPHeader.new()
+	op_info.headerparts.each do |part|
+	  child = Mapping.get_attribute(obj, part.name)
+	  ele = headeritem_from_obj(child, part.element || part.eletype)
+	  header.add(part.name, ele)
+	end
+	header
+      end
+    end
+
+    def headeritem_from_obj(obj, name)
+      if obj.nil?
+	SOAPElement.new(name)
+      elsif obj.is_a?(SOAPHeaderItem)
+	obj
+      else
+        Mapping.obj2soap(obj, @doc_mapper, name)
+      end
+    end
+
+    def body_from_obj(obj, op_info)
+      if obj.is_a?(SOAPBody)
+	obj
+      elsif op_info.bodyparts.empty?
+	if obj.nil?
+	  nil
+	else
+	  raise RuntimeError.new("no body found in schema")
+	end
+      elsif op_info.bodyparts.size == 1
+       	part = op_info.bodyparts[0]
+	ele = bodyitem_from_obj(obj, part.element || part.type)
+	SOAPBody.new(ele)
+      else
+	body = SOAPBody.new
+	op_info.bodyparts.each do |part|
+	  child = Mapping.get_attribute(obj, part.name)
+	  ele = bodyitem_from_obj(child, part.element || part.type)
+	  body.add(ele.elename.name, ele)
+	end
+	body
+      end
+    end
+
+    def bodyitem_from_obj(obj, name)
+      if obj.nil?
+	SOAPElement.new(name)
+      elsif obj.is_a?(SOAPElement)
+	obj
+      else
+        Mapping.obj2soap(obj, @doc_mapper, name)
+      end
+    end
+
+    def add_method_interface(op_info)
+      name = XSD::CodeGen::GenSupport.safemethodname(op_info.op_name.name)
+      orgname = op_info.op_name.name
+      parts_names = op_info.bodyparts.collect { |part| part.name }
+      case op_info.style
+      when :document
+        if orgname != name and orgname.capitalize == name.capitalize
+          add_document_method_interface(orgname, parts_names)
+        end
+	add_document_method_interface(name, parts_names)
+      when :rpc
+        if orgname != name and orgname.capitalize == name.capitalize
+          add_rpc_method_interface(orgname, parts_names)
+        end
+	add_rpc_method_interface(name, parts_names)
+      else
+	raise RuntimeError.new("unknown style: #{op_info.style}")
+      end
+    end
+
+    def add_rpc_method_interface(name, parts_names)
+      param_count = parts_names.size
+      @host.instance_eval <<-EOS
+        def #{name}(*arg)
+          unless arg.size == #{param_count}
+            raise ArgumentError.new(
+              "wrong number of arguments (\#{arg.size} for #{param_count})")
+          end
+          @servant.rpc_call(#{name.dump}, *arg)
+        end
+      EOS
+      @host.method(name)
+    end
+
+    def add_document_method_interface(name, parts_names)
+      @host.instance_eval <<-EOS
+        def #{name}(h, b)
+          @servant.document_send(#{name.dump}, h, b)
+        end
+      EOS
+      @host.method(name)
+    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|
+	@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
+  end
+end
+
+
+end