rubysl-soap 0.0.1 → 1.0.0

data/lib/soap/rpc/element.rb

@@ -0,0 +1,325 @@
+# SOAP4R - RPC element definition.
+# Copyright (C) 2000, 2001, 2003, 2005  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'
+
+
+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_member('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_param(@param_def) if @param_def
+  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 set_param(params)
+    params.each do |param, data|
+      @inparam[param] = data
+      data.elename.name = param
+      data.parent = self
+    end
+  end
+
+  def set_outparam(params)
+    params.each do |param, data|
+      @outparam[param] = data
+      data.elename.name = param
+    end
+  end
+
+  def SOAPMethod.param_count(param_def, *type)
+    count = 0
+    param_def.each do |io_type, name, param_type|
+      if type.include?(io_type)
+        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.each do |qname|
+      param_def << [IN, qname.name, [nil, qname.namespace, qname.name]]
+    end
+    res_qnames.each do |qname|
+      param_def << [OUT, qname.name, [nil, qname.namespace, qname.name]]
+    end
+    param_def
+  end
+
+private
+
+  def collect_params(*type)
+    names = []
+    @signature.each do |io_type, name, param_type|
+      names << name if type.include?(io_type)
+    end
+    names
+  end
+
+  def init_param(param_def)
+    param_def.each do |io_type, name, param_type|
+      case io_type
+      when IN
+        @signature.push([IN, name, param_type])
+        @inparam_names.push(name)
+      when OUT
+        @signature.push([OUT, name, param_type])
+        @outparam_names.push(name)
+      when INOUT
+        @signature.push([INOUT, name, param_type])
+        @inoutparam_names.push(name)
+      when RETVAL
+        if @retval_name
+          raise MethodDefinitionError.new('duplicated retval')
+        end
+        @retval_name = name
+        @retval_class_name = nil
+        if param_type
+          if param_type[0].is_a?(String)
+            @retval_class_name = Mapping.class_from_name(param_type[0])
+          else
+            @retval_class_name = param_type[0]
+          end
+        end
+      else
+        raise MethodDefinitionError.new("unknown type: #{io_type}")
+      end
+    end
+  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)
+    check_elename(qname)
+    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
+
+private
+
+  def check_elename(qname)
+    # NCName & ruby's method name
+    unless /\A[\w_][\w\d_\-]*\z/ =~ qname.name
+      raise MethodDefinitionError.new("element name '#{qname.name}' not allowed")
+    end
+  end
+end
+
+
+class SOAPMethodResponse < SOAPMethod
+
+  def initialize(qname, param_def = nil)
+    super(qname, param_def)
+    @retval = nil
+  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,129 @@
+# SOAP4R - WEBrick HTTP Server
+# Copyright (C) 2003, 2004 by 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/rpc/soaplet'
+require 'soap/streamHandler'
+require 'webrick'
+
+
+module SOAP
+module RPC
+
+
+class HTTPServer < Logger::Application
+  attr_reader :server
+  attr_accessor :default_namespace
+
+  def initialize(config)
+    super(config[:SOAPHTTPServerApplicationName] || self.class.name)
+    @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(self.class.name)
+    @soaplet = ::SOAP::RPC::SOAPlet.new(@router)
+    on_init
+    @server = WEBrick::HTTPServer.new(@webrick_config)
+    @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 mapping_registry
+    @router.mapping_registry
+  end
+
+  def mapping_registry=(mapping_registry)
+    @router.mapping_registry = mapping_registry
+  end
+
+  def generate_explicit_type
+    @router.generate_explicit_type
+  end
+
+  def generate_explicit_type=(generate_explicit_type)
+    @router.generate_explicit_type = generate_explicit_type
+  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
+
+  # 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 run
+    @server.start
+  end
+end
+
+
+end
+end