class SOAP::RPC::Router
Attributes
actor[R]
external_ces[RW]
filterchain[R]
generate_explicit_type[RW]
literal_mapping_registry[RW]
mapping_registry[RW]
use_default_namespace[RW]
Public Class Methods
new(actor)
click to toggle source
# File lib/soap/rpc/router.rb, line 37 def initialize(actor) @actor = actor @mapping_registry = nil @headerhandler = Header::HandlerSet.new @literal_mapping_registry = ::SOAP::Mapping::LiteralRegistry.new @generate_explicit_type = true @use_default_namespace = false @external_ces = nil @operation_by_soapaction = {} @operation_by_qname = {} @headerhandlerfactory = [] @filterchain = Filter::FilterChain.new end
Public Instance Methods
add_document_method(receiver, soapaction, name, param_def, opt = {})
Alias for: add_document_operation
add_document_operation(receiver, soapaction, name, param_def, opt = {})
click to toggle source
# File lib/soap/rpc/router.rb, line 125 def add_document_operation(receiver, soapaction, name, param_def, opt = {}) # # adopt workaround for doc/lit wrapper method # (you should consider to simply use rpc/lit service) # #unless soapaction # raise RPCRoutingError.new("soapaction is a must for document method") #end ensure_styleuse_option(opt, :document, :literal) op = ApplicationScopeOperation.new(soapaction, receiver, name, param_def, opt) if opt[:request_style] != :document raise RPCRoutingError.new("illegal request_style given") end assign_operation(soapaction, first_input_part_qname(param_def), op) end
Also aliased as: add_document_method
add_document_request_operation(factory, soapaction, name, param_def, opt = {})
click to toggle source
# File lib/soap/rpc/router.rb, line 143 def add_document_request_operation(factory, soapaction, name, param_def, opt = {}) # # adopt workaround for doc/lit wrapper method # (you should consider to simply use rpc/lit service) # #unless soapaction # raise RPCRoutingError.new("soapaction is a must for document method") #end ensure_styleuse_option(opt, :document, :literal) op = RequestScopeOperation.new(soapaction, receiver, name, param_def, opt) if opt[:request_style] != :document raise RPCRoutingError.new("illegal request_style given") end assign_operation(soapaction, first_input_part_qname(param_def), op) end
add_headerhandler(handler)
click to toggle source
# File lib/soap/rpc/router.rb, line 61 def add_headerhandler(handler) @headerhandler.add(handler) end
add_request_headerhandler(factory)
click to toggle source
header handler interface
# File lib/soap/rpc/router.rb, line 54 def add_request_headerhandler(factory) unless factory.respond_to?(:create) raise TypeError.new("factory must respond to 'create'") end @headerhandlerfactory << factory end
add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {})
click to toggle source
operation definition interface
# File lib/soap/rpc/router.rb, line 102 def add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {}) ensure_styleuse_option(opt, :rpc, :encoded) opt[:request_qname] = qname op = ApplicationScopeOperation.new(soapaction, receiver, name, param_def, opt) if opt[:request_style] != :rpc raise RPCRoutingError.new("illegal request_style given") end assign_operation(soapaction, qname, op) end
Also aliased as: add_method, add_rpc_method
add_rpc_request_operation(factory, qname, soapaction, name, param_def, opt = {})
click to toggle source
# File lib/soap/rpc/router.rb, line 115 def add_rpc_request_operation(factory, qname, soapaction, name, param_def, opt = {}) ensure_styleuse_option(opt, :rpc, :encoded) opt[:request_qname] = qname op = RequestScopeOperation.new(soapaction, factory, name, param_def, opt) if opt[:request_style] != :rpc raise RPCRoutingError.new("illegal request_style given") end assign_operation(soapaction, qname, op) end
add_rpc_request_servant(factory, namespace)
click to toggle source
servant definition interface
# File lib/soap/rpc/router.rb, line 68 def add_rpc_request_servant(factory, namespace) unless factory.respond_to?(:create) raise TypeError.new("factory must respond to 'create'") end obj = factory.create # a dummy instance for introspection ::SOAP::RPC.defined_methods(obj).each do |name| begin qname = XSD::QName.new(namespace, name) param_def = ::SOAP::RPC::SOAPMethod.derive_rpc_param_def(obj, name) opt = create_styleuse_option(:rpc, :encoded) add_rpc_request_operation(factory, qname, nil, name, param_def, opt) rescue SOAP::RPC::MethodDefinitionError => e p e if $DEBUG end end end
add_rpc_servant(obj, namespace)
click to toggle source
# File lib/soap/rpc/router.rb, line 85 def add_rpc_servant(obj, namespace) ::SOAP::RPC.defined_methods(obj).each do |name| begin qname = XSD::QName.new(namespace, name) param_def = ::SOAP::RPC::SOAPMethod.derive_rpc_param_def(obj, name) opt = create_styleuse_option(:rpc, :encoded) add_rpc_operation(obj, qname, nil, name, param_def, opt) rescue SOAP::RPC::MethodDefinitionError => e p e if $DEBUG end end end
Also aliased as: add_servant
create_fault_response(e)
click to toggle source
Create fault response string.
# File lib/soap/rpc/router.rb, line 200 def create_fault_response(e) env = SOAPEnvelope.new(SOAPHeader.new, SOAPBody.new(fault(e, nil), true)) opt = {} opt[:external_content] = nil @filterchain.reverse_each do |filter| env = filter.on_outbound(env, opt) break unless env end response_string = Processor.marshal(env, opt) conn_data = StreamHandler::ConnectionData.new(response_string) conn_data.is_fault = true if ext = opt[:external_content] mimeize(conn_data, ext) end conn_data end
route(conn_data)
click to toggle source
# File lib/soap/rpc/router.rb, line 159 def route(conn_data) # we cannot set request_default_encodingsyle before parsing the content. env = unmarshal(conn_data) if env.nil? raise ArgumentError.new("illegal SOAP marshal format") end op = lookup_operation(conn_data.soapaction, env.body) headerhandler = @headerhandler.dup @headerhandlerfactory.each do |f| headerhandler.add(f.create) end soap_response = default_encodingstyle = nil begin receive_headers(headerhandler, env.header) soap_response = op.call(env.body, @mapping_registry, @literal_mapping_registry, create_mapping_opt) conn_data.is_fault = true if soap_response.is_a?(SOAPFault) default_encodingstyle = op.response_default_encodingstyle rescue Exception => e # If a wsdl fault was raised by service, the fault declaration details # is kept in wsdl_fault. Otherwise (exception is a program fault) # wsdl_fault is nil wsdl_fault_details = op.faults && op.faults[e.class.name] soap_response = fault(e, wsdl_fault_details) conn_data.is_fault = true default_encodingstyle = nil end header = call_headers(headerhandler) if op.response_use.nil? conn_data.send_string = '' conn_data.is_nocontent = true conn_data else body = SOAPBody.new(soap_response, conn_data.is_fault) env = SOAPEnvelope.new(header, body) marshal(conn_data, env, default_encodingstyle) end end
Private Instance Methods
assign_operation(soapaction, qname, op)
click to toggle source
# File lib/soap/rpc/router.rb, line 247 def assign_operation(soapaction, qname, op) assigned = false if soapaction and !soapaction.empty? @operation_by_soapaction[soapaction] = op assigned = true end if qname @operation_by_qname[qname] = op assigned = true end unless assigned raise RPCRoutingError.new("cannot assign operation") end end
call_headers(headerhandler)
click to toggle source
# File lib/soap/rpc/router.rb, line 278 def call_headers(headerhandler) header = ::SOAP::SOAPHeader.new items = headerhandler.on_outbound(header) items.each do |item| header.add(item.elename.name, item) end header end
create_mapping_opt()
click to toggle source
# File lib/soap/rpc/router.rb, line 394 def create_mapping_opt { :external_ces => @external_ces } end
create_styleuse_option(style, use)
click to toggle source
# File lib/soap/rpc/router.rb, line 229 def create_styleuse_option(style, use) opt = {} opt[:request_style] = opt[:response_style] = style opt[:request_use] = opt[:response_use] = use opt end
ensure_styleuse_option(opt, style, use)
click to toggle source
# File lib/soap/rpc/router.rb, line 236 def ensure_styleuse_option(opt, style, use) if opt[:request_style] || opt[:response_style] || opt[:request_use] || opt[:response_use] # do not edit else opt[:request_style] ||= style opt[:response_style] ||= style opt[:request_use] ||= use opt[:response_use] ||= use end end
fault(e, wsdl_fault_details)
click to toggle source
Create fault response.
# File lib/soap/rpc/router.rb, line 353 def fault(e, wsdl_fault_details) if e.is_a?(UnhandledMustUnderstandHeaderError) faultcode = FaultCode::MustUnderstand else faultcode = FaultCode::Server end # If the exception represents a WSDL fault, the fault element should # be added as the SOAP fault <detail> element. If the exception is a # normal program exception, it is wrapped inside a custom SOAP4R # SOAP exception element. detail = nil begin if (wsdl_fault_details) registry = wsdl_fault_details[:use] == "literal" ? @literal_mapping_registry : @mapping_registry faultQName = XSD::QName.new( wsdl_fault_details[:ns], wsdl_fault_details[:name] ) detail = Mapping.obj2soap(e, registry, faultQName) # wrap fault element (SOAPFault swallows top-level element) wrapper = SOAP::SOAPElement.new(faultQName) wrapper.add(detail) detail = wrapper else # Exception is a normal program exception. Wrap it. detail = Mapping.obj2soap(Mapping::SOAPException.new(e), @mapping_registry) detail.elename ||= XSD::QName::EMPTY # for literal mappingregstry end rescue detail = SOAPString.new("failed to serialize detail object: #{$!}") end SOAPFault.new( SOAPElement.new(nil, faultcode), SOAPString.new(e.to_s), SOAPString.new(@actor), detail) end
first_input_part_qname(param_def)
click to toggle source
# File lib/soap/rpc/router.rb, line 219 def first_input_part_qname(param_def) param_def.each do |param| param = MethodDef.to_param(param) if param.io_type == SOAPMethod::IN return param.qname end end nil end
lookup_operation(soapaction, body)
click to toggle source
# File lib/soap/rpc/router.rb, line 262 def lookup_operation(soapaction, body) if op = @operation_by_soapaction[soapaction] return op end qname = body.root_node.elename if op = @operation_by_qname[qname] return op end if soapaction raise RPCRoutingError.new( "operation: #{soapaction} #{qname} not supported") else raise RPCRoutingError.new("operation: #{qname} not supported") end end
marshal(conn_data, env, default_encodingstyle = nil)
click to toggle source
# File lib/soap/rpc/router.rb, line 322 def marshal(conn_data, env, default_encodingstyle = nil) opt = {} opt[:external_content] = nil opt[:default_encodingstyle] = default_encodingstyle opt[:generate_explicit_type] = @generate_explicit_type opt[:use_default_namespace] = @use_default_namespace @filterchain.reverse_each do |filter| env = filter.on_outbound(env, opt) break unless env end response_string = Processor.marshal(env, opt) conn_data.send_string = response_string if ext = opt[:external_content] mimeize(conn_data, ext) end conn_data end
mimeize(conn_data, ext)
click to toggle source
# File lib/soap/rpc/router.rb, line 340 def mimeize(conn_data, ext) mime = MIMEMessage.new ext.each do |k, v| mime.add_attachment(v.data) end mime.add_part(conn_data.send_string + "\r\n") mime.close conn_data.send_string = mime.content_str conn_data.send_contenttype = mime.headers['content-type'].str conn_data end
receive_headers(headerhandler, header)
click to toggle source
# File lib/soap/rpc/router.rb, line 287 def receive_headers(headerhandler, header) headerhandler.on_inbound(header) if header end
unmarshal(conn_data)
click to toggle source
# File lib/soap/rpc/router.rb, line 291 def unmarshal(conn_data) xml = nil opt = {} contenttype = conn_data.receive_contenttype if /#{MIMEMessage::MultipartContentType}/i =~ contenttype opt[:external_content] = {} mime = MIMEMessage.parse("Content-Type: " + contenttype, conn_data.receive_string) mime.parts.each do |part| value = Attachment.new(part.content) value.contentid = part.contentid obj = SOAPAttachment.new(value) opt[:external_content][value.contentid] = obj if value.contentid end opt[:charset] = StreamHandler.parse_media_type(mime.root.headers['content-type'].str) xml = mime.root.content else opt[:charset] = ::SOAP::StreamHandler.parse_media_type(contenttype) xml = conn_data.receive_string end @filterchain.each do |filter| xml = filter.on_inbound(xml, opt) break unless xml end env = Processor.unmarshal(xml, opt) charset = opt[:charset] conn_data.send_contenttype = "text/xml; charset=\"#{charset}\"" env end