soap4r-spox 1.6.0

data/sample/howto/wsdl_hash/client.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'soap/wsdlDriver'
+wsdl = 'hash.wsdl'
+driver = SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver
+driver.generate_explicit_type = true
+
+backup = driver.wsdl_mapping_registry
+driver.wsdl_mapping_registry = SOAP::Mapping::DefaultRegistry
+p driver.hash({1=>2, 3=>4})
+driver.wsdl_mapping_registry = backup

data/sample/howto/wsdl_hash/hash.wsdl

@@ -0,0 +1,69 @@
+<?xml version="1.0"?>
+<definitions
+    name="HashSample"
+    targetNamespace="urn:www.example.org:hashsample"
+    xmlns:tns="urn:www.example.org:hashsample"
+    xmlns="http://schemas.xmlsoap.org/wsdl/"
+    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    xmlns:apachesoap="http://xml.apache.org/xml-soap">
+
+  <types>
+    <!-- type definition for ApacheSOAP's Map -->
+    <schema
+	xmlns="http://www.w3.org/2001/XMLSchema"
+	targetNamespace="http://xml.apache.org/xml-soap">
+      <complexType name="Map">
+	<sequence>
+	  <element name="item" minOccurs="0" maxOccurs="unbounded">
+	    <complexType>
+	      <sequence>
+		<element name="key" type="xsd:anyType" />
+		<element name="value" type="xsd:anyType" />
+	      </sequence>
+	    </complexType>
+	  </element>
+	</sequence>
+      </complexType>
+    </schema>
+  </types>
+
+  <message name="hashRequest">
+    <part name="arg" type="apachesoap:Map"/>
+  </message>
+
+  <message name="hashResponse">
+    <part name="return" type="apachesoap:Map"/>
+  </message>
+
+  <portType name="HashBaseServicePortType">
+    <operation name="hash" parameterOrder="arg">
+      <input message="tns:hashRequest"/>
+      <output message="tns:hashResponse"/>
+    </operation>
+  </portType>
+
+  <binding name="HashBaseServicePortBinding" type="tns:HashBaseServicePortType">
+    <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
+
+    <operation name="hash">
+      <soap:operation soapAction=""/>
+      <input>
+	<soap:body use="encoded"
+	    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+	    namespace="urn:www.example.org:hashsample"/>
+      </input>
+      <output>
+	<soap:body use="encoded"
+	    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+	    namespace="urn:www.example.org:hashsample"/>
+      </output>
+    </operation>
+  </binding>
+
+  <service name="HashService">
+    <port name="HashBaseServicePort" binding="tns:HashBaseServicePortBinding">
+      <soap:address location="http://localhost:7171"/>
+    </port>
+  </service>
+</definitions>

data/sample/howto/wsdl_hash/server.rb

@@ -0,0 +1,17 @@
+require 'soap/rpc/standaloneServer'
+
+class Server < SOAP::RPC::StandaloneServer
+  def on_init
+    add_method(self, 'hash')
+  end
+
+  def hash(arg)
+    arg.update({5=>6, 7=>8})
+  end
+end
+
+if $0 == __FILE__
+  server = Server.new('svr', 'urn:www.example.org:hashsample', '0.0.0.0', 7171)
+  trap(:INT) { server.shutdown }
+  server.start
+end

data/sample/marshal/customfactory.rb

@@ -0,0 +1,97 @@
+require 'soap/marshal'
+include SOAP
+
+class DummyStruct
+  include Enumerable
+
+  QName = XSD::QName.new(nil, 'DummyStruct')
+
+  def initialize(hash = nil)
+    @hash = {}
+    @hash.update(hash) if hash
+  end
+
+  def [](key)
+    @hash[key]
+  end
+
+  def []=(key, value)
+    @hash[key] = value
+  end
+
+  def each
+    @hash.each do |key, value|
+      yield(key, value)
+    end
+  end
+end
+
+class DummyStructFactory
+  def obj2soap(soap_class, obj, info, map)
+    unless obj.is_a?(DummyStruct)
+      return nil
+    end
+    soap_obj = soap_class.new(DummyStruct::QName)
+    obj.each do |key, value|
+      soap_obj[key] = SOAPString.new(value.to_s)
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    unless node.type == DummyStruct::QName
+      return false
+    end
+    obj = obj_class.new
+    node.each do |key, value|
+      obj[key] = value.data
+    end
+    return true, obj
+  end
+end
+
+class ExplicitTypedArrayFactory < SOAP::Mapping::Factory
+  def obj2soap(soap_class, obj, info, map)
+    unless obj.respond_to?(:arytype)
+      return nil
+    end
+    soap_obj = soap_class.new(ValueArrayName, 1, obj.arytype)
+    mark_marshalled_obj(obj, soap_obj)
+    obj.each do |item|
+      soap_obj.add(Mapping._obj2soap(item, map))
+    end
+    soap_obj
+  end
+
+  # let default TypedArrayFactory handle that.
+  def soap2obj(obj_class, node, info, map)
+    return false
+  end
+end
+
+map = Mapping::Registry.new
+map.set(DummyStruct, SOAPStruct, DummyStructFactory.new)
+map.set(Array, SOAPArray, ExplicitTypedArrayFactory.new)
+
+puts
+puts "== DummyStruct =="
+puts
+
+obj = DummyStruct.new('family' => 'Na', 'given' => 'Hi')
+puts marshalledstring = SOAPMarshal.marshal(obj, map)
+p SOAPMarshal.unmarshal(marshalledstring, map)
+
+puts
+puts "== Custom array =="
+puts
+
+obj1 = [1, 2, 3]
+obj2 = [4, 5, 6]
+def obj1.arytype
+  XSD::XSDInt::Type
+end
+
+puts marshalledstring = SOAPMarshal.marshal(obj1, map)
+p SOAPMarshal.unmarshal(marshalledstring, map)
+puts marshalledstring = SOAPMarshal.marshal(obj2, map)
+p SOAPMarshal.unmarshal(marshalledstring, map)

data/sample/marshal/customregistry.rb

@@ -0,0 +1,17 @@
+require 'soap/marshal'
+
+class IntArray < Array; end
+
+map = SOAP::Mapping::Registry.new
+map.add(
+  IntArray, SOAP::SOAPArray, SOAP::Mapping::Registry::TypedArrayFactory,
+  {
+    :type => XSD::QName.new(XSD::Namespace, XSD::IntLiteral)
+  }
+)
+
+puts "== dumps anyType array =="
+puts SOAP::Marshal.marshal(IntArray[1, 2, 3])
+puts
+puts "== dumps int array with custom registry =="
+puts SOAP::Marshal.marshal(IntArray[1, 2, 3], map)

data/sample/marshal/digraph.rb

@@ -0,0 +1,43 @@
+require 'soap/marshal'
+
+class Node; include SOAP::Marshallable
+  attr_reader :first, :second, :str
+
+  def initialize(*init_next)
+    @first = init_next[0]
+    @second = init_next[1]
+  end
+end
+
+n9 = Node.new
+n81 = Node.new(n9)
+n82 = Node.new(n9)
+n7 = Node.new(n81, n82)
+n61 = Node.new(n7)
+n62 = Node.new(n7)
+n5 = Node.new(n61, n62)
+n41 = Node.new(n5)
+n42 = Node.new(n5)
+n3 = Node.new(n41, n42)
+n21 = Node.new(n3)
+n22 = Node.new(n3)
+n1 = Node.new(n21, n22)
+
+File.open("digraph_marshalled_string.soap", "wb") do |f|
+  SOAP::Marshal.dump(n1, f)
+end
+
+marshalledString = File.open("digraph_marshalled_string.soap") { |f| f.read }
+
+puts marshalledString
+
+newnode = SOAP::Marshal.unmarshal(marshalledString)
+
+puts newnode.inspect
+
+p newnode.first.first.__id__
+p newnode.second.first.__id__
+p newnode.first.first.first.first.__id__
+p newnode.second.first.second.first.__id__
+
+File.unlink("digraph_marshalled_string.soap")

data/sample/marshal/enum/README.txt

@@ -0,0 +1,6 @@
+enum.xsd ........ original definition
+enumsample.rb ... generated class definition
+
+run xsd2ruby.rb to get enumsample.rb from enum.xsd
+
+% xsd2ruby.rb --xsd enum.xsd --classdef --mapping_registry --mapper --force

data/sample/marshal/enum/enum.xsd

@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<schema
+    xmlns="http://www.w3.org/2001/XMLSchema"
+    xmlns:txd="urn:org.example.enumsample"
+    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    targetNamespace="urn:org.example.enumsample">
+
+  <complexType name="hobbit.type">
+    <sequence>
+      <element name="name" type="txd:hobbit.name.type"/>
+      <element name="age" type="xsd:int"/>
+    </sequence>
+  </complexType>
+
+  <simpleType name="hobbit.name.type">
+    <restriction base="xsd:string">
+      <enumeration value="frodo"/>
+      <enumeration value="sam"/>
+      <enumeration value="meriadoc"/>
+      <enumeration value="peregrin"/>
+    </restriction>
+  </simpleType>
+</schema>

data/sample/marshal/enum/enumsample.rb

@@ -0,0 +1,20 @@
+require 'xsd/qname'
+
+# {urn:org.example.enumsample}hobbit.type
+class HobbitType
+  attr_accessor :name
+  attr_accessor :age
+
+  def initialize(name = nil, age = nil)
+    @name = name
+    @age = age
+  end
+end
+
+# {urn:org.example.enumsample}hobbit.name.type
+class HobbitNameType < ::String
+  Frodo = HobbitNameType.new("frodo")
+  Meriadoc = HobbitNameType.new("meriadoc")
+  Peregrin = HobbitNameType.new("peregrin")
+  Sam = HobbitNameType.new("sam")
+end

data/sample/marshal/enum/enumsample_mapper.rb

@@ -0,0 +1,7 @@
+require 'enumsample_mapping_registry.rb'
+
+class EnumsampleMapper < XSD::Mapping::Mapper
+  def initialize
+    super(EnumsampleMappingRegistry::Registry)
+  end
+end

data/sample/marshal/enum/enumsample_mapping_registry.rb

@@ -0,0 +1,23 @@
+require 'xsd/mapping'
+require 'enumsample.rb'
+
+module EnumsampleMappingRegistry
+  Registry = ::SOAP::Mapping::LiteralRegistry.new
+
+  Registry.register(
+    :class => HobbitType,
+    :schema_ns => "urn:org.example.enumsample",
+    :schema_type => "hobbit.type",
+    :schema_qualified => false,
+    :schema_element => [
+      ["name", ["SOAP::SOAPString", XSD::QName.new(nil, "name")]],
+      ["age", ["SOAP::SOAPInt", XSD::QName.new(nil, "age")]]
+    ]
+  )
+
+  Registry.register(
+    :class => HobbitNameType,
+    :schema_ns => "urn:org.example.enumsample",
+    :schema_type => "hobbit.name.type"
+  )
+end

data/sample/marshal/enum/marshal.rb

@@ -0,0 +1,9 @@
+require 'enumsample_mapper'
+
+mapper = EnumsampleMapper.new
+
+t = HobbitType.new(HobbitNameType::Frodo, 51)
+
+xml = mapper.obj2xml(t)
+puts xml
+p mapper.xml2obj(xml)

data/sample/payload/basicauth/client.rb

@@ -0,0 +1,10 @@
+require 'soap/rpc/driver'
+
+# SOAP client with BasicAuth requires httpclient.
+# http://raa.ruby-lang.org/project/httpclient/
+drv = SOAP::RPC::Driver.new('http://localhost:7000/', 'urn:test')
+drv.wiredump_dev = STDERR if $DEBUG
+drv.options["protocol.http.basic_auth"] <<
+  ['http://localhost:7000/', "admin", "admin"]
+
+p drv.add_method('echo', 'msg').call('hello')

data/sample/payload/basicauth/htpasswd

@@ -0,0 +1,2 @@
+admin:Qg266hq/YYKe2
+guest:gbPc4vPCH.h12

data/sample/payload/basicauth/server.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+# SOAP server cannot use WEBrick's httpauth feature for now...
+require 'soap/rpc/standaloneServer'
+
+class Server < SOAP::RPC::StandaloneServer
+  Namespace = 'urn:test'
+
+  class Servant
+    @@counter = 0
+
+    def self.create
+      new(@@counter += 1)
+    end
+
+    def initialize(counter)
+      @counter = counter
+    end
+
+    def echo(msg)
+      "echo from servant ##{@counter} (#{SOAP::RPC::SOAPlet.user}): #{msg}"
+    end
+  end
+
+  def initialize(*arg)
+    super
+    add_rpc_request_servant(Servant)
+  end
+
+  def on_init
+    userdb_file = File.join(File.dirname(__FILE__), 'htpasswd')
+    userdb = WEBrick::HTTPAuth::Htpasswd.new(userdb_file)
+    self.authenticator = WEBrick::HTTPAuth::BasicAuth.new(:Realm => 'auth', :UserDB => userdb)
+  end
+end
+
+if $0 == __FILE__
+  server = Server.new('tst', Server::Namespace, '0.0.0.0', 7000)
+  trap(:INT) do
+    server.shutdown
+  end
+  status = server.start
+end

data/sample/payload/cookies/calc.rb

@@ -0,0 +1,52 @@
+class CookieCalcService
+  def initialize
+    @client_id = 0
+    @value = {}
+  end
+
+  def set(value)
+    @value[get_client_id] = value
+  end
+
+  def get
+    @value[get_client_id]
+  end
+
+  def +(rhs)
+    get + rhs
+  end
+
+  def -(rhs)
+    get - rhs
+  end
+
+  def *(rhs)
+    get * rhs
+  end
+
+  def /(rhs)
+    get / rhs
+  end
+
+private
+
+  def get_client_id
+    if cookie = SOAP::RPC::SOAPlet.cookies.find { |cookie| cookie.name == 'client_id' }
+      cookie.expires = Time.now + 3600
+      client_id = cookie.value
+    else
+      client_id = assign_new_client_id
+      cookie = WEBrick::Cookie.new('client_id', client_id)
+      cookie.expires = Time.now + 3600
+      SOAP::RPC::SOAPlet.cookies << cookie
+    end
+    p "assined client id: #{client_id}"
+    client_id
+  end
+
+  def assign_new_client_id
+    @client_id += 1
+    @client_id.to_s
+  end
+
+end