soap5r 2.0.0

data/lib/soap/rpc/element.rb

@@ -0,0 +1,375 @@
+# encoding: ASCII-8BIT
+# 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.respond_to?(:key) ? TypeMap.key(mapped_class) : TypeMap.index(mapped_class) # RubyJedi: compatible with Ruby 1.8.6 and above 
+    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

data/lib/soap/rpc/httpserver.rb

@@ -0,0 +1,143 @@
+# encoding: ASCII-8BIT
+# SOAP4R - WEBrick HTTP 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 'logger'
+require 'soap/attrproxy'
+require 'soap/rpc/soaplet'
+require 'soap/streamHandler'
+require 'webrick'
+
+
+module SOAP
+module RPC
+
+
+class HTTPServer < Logger::Application
+  include AttrProxy
+
+  attr_reader :server
+  attr_accessor :default_namespace
+
+  attr_proxy :mapping_registry, true
+  attr_proxy :literal_mapping_registry, true
+  attr_proxy :generate_explicit_type, true
+  attr_proxy :use_default_namespace, true
+
+  def initialize(config)
+    actor = config[:SOAPHTTPServerApplicationName] || self.class.name
+    super(actor)
+    @default_namespace = config[:SOAPDefaultNamespace]
+    @webrick_config = config.dup
+    self.level = Logger::Severity::ERROR # keep silent by default
+    @webrick_config[:Logger] ||= @log
+    @log = @webrick_config[:Logger]     # sync logger of App and HTTPServer
+    @router = ::SOAP::RPC::Router.new(actor)
+    @soaplet = ::SOAP::RPC::SOAPlet.new(@router)
+    on_init
+    @server = WEBrick::HTTPServer.new(@webrick_config)
+    @server.mount('/soaprouter', @soaplet)
+    if wsdldir = config[:WSDLDocumentDirectory]
+      @server.mount('/wsdl', WEBrick::HTTPServlet::FileHandler, wsdldir)
+    end
+    @server.mount('/', @soaplet)
+  end
+
+  def on_init
+    # do extra initialization in a derived class if needed.
+  end
+
+  def status
+    @server.status if @server
+  end
+
+  def shutdown
+    @server.shutdown if @server
+  end
+
+  def authenticator
+    @soaplet.authenticator
+  end
+
+  def authenticator=(authenticator)
+    @soaplet.authenticator = authenticator
+  end
+
+  # servant entry interface
+
+  def add_rpc_request_servant(factory, namespace = @default_namespace)
+    @router.add_rpc_request_servant(factory, namespace)
+  end
+
+  def add_rpc_servant(obj, namespace = @default_namespace)
+    @router.add_rpc_servant(obj, namespace)
+  end
+  
+  def add_request_headerhandler(factory)
+    @router.add_request_headerhandler(factory)
+  end
+
+  def add_headerhandler(obj)
+    @router.add_headerhandler(obj)
+  end
+  alias add_rpc_headerhandler add_headerhandler
+
+  def filterchain
+    @router.filterchain
+  end
+
+  # method entry interface
+
+  def add_rpc_method(obj, name, *param)
+    add_rpc_method_as(obj, name, name, *param)
+  end
+  alias add_method add_rpc_method
+
+  def add_rpc_method_as(obj, name, name_as, *param)
+    qname = XSD::QName.new(@default_namespace, name_as)
+    soapaction = nil
+    param_def = SOAPMethod.derive_rpc_param_def(obj, name, *param)
+    @router.add_rpc_operation(obj, qname, soapaction, name, param_def)
+  end
+  alias add_method_as add_rpc_method_as
+
+  def add_document_method(obj, soapaction, name, req_qnames, res_qnames)
+    param_def = SOAPMethod.create_doc_param_def(req_qnames, res_qnames)
+    @router.add_document_operation(obj, soapaction, name, param_def)
+  end
+
+  def add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {})
+    @router.add_rpc_operation(receiver, qname, soapaction, name, param_def, opt)
+  end
+
+  def add_rpc_request_operation(factory, qname, soapaction, name, param_def, opt = {})
+    @router.add_rpc_request_operation(factory, qname, soapaction, name, param_def, opt)
+  end
+
+  def add_document_operation(receiver, soapaction, name, param_def, opt = {})
+    @router.add_document_operation(receiver, soapaction, name, param_def, opt)
+  end
+
+  def add_document_request_operation(factory, soapaction, name, param_def, opt = {})
+    @router.add_document_request_operation(factory, soapaction, name, param_def, opt)
+  end
+
+private
+
+  def attrproxy
+    @router
+  end
+
+  def run
+    @server.start
+  end
+end
+
+
+end
+end

data/lib/soap/rpc/methodDef.rb

@@ -0,0 +1,69 @@
+# encoding: ASCII-8BIT
+# SOAP4R - A method 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.
+
+
+module SOAP
+module RPC
+
+
+class MethodDef
+  attr_reader :name
+  attr_reader :soapaction
+  attr_reader :qname
+  attr_accessor :style
+  attr_accessor :inputuse
+  attr_accessor :outputuse
+  attr_reader :parameters
+  attr_reader :faults
+
+  def initialize(name, soapaction, qname)
+    @name = name
+    @soapaction = soapaction
+    @qname = qname
+    @style = @inputuse = @outputuse = nil
+    @parameters = []
+    @faults = {}
+  end
+
+  def add_parameter(io_type, name, qname, mapped_class)
+    @parameters << Parameter.new(io_type, name, qname, mapped_class)
+  end
+
+  def self.to_param(param)
+    if param.respond_to?(:io_type)
+      param
+    else
+      io_type, name, param_type = param
+      mapped_class_str, nsdef, namedef = param_type
+      if nsdef && namedef
+        qname = XSD::QName.new(nsdef, namedef)
+      else
+        qname = nil
+      end
+      MethodDef::Parameter.new(io_type.to_sym, name, qname, mapped_class_str)
+    end
+  end
+
+  class Parameter
+    attr_reader :io_type
+    attr_reader :name
+    attr_reader :qname
+    attr_reader :mapped_class
+
+    def initialize(io_type, name, qname, mapped_class)
+      @io_type = io_type
+      @name = name
+      @qname = qname
+      @mapped_class = mapped_class
+    end
+  end
+end
+
+
+end
+end