xml-soap-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From James Snell <jmsn...@intesolv.com>
Subject RE: Apache C++ SOAP Implementation Proposed Architecture
Date Tue, 08 Aug 2000 21:29:07 GMT
Basically, the approach that I'd like to see is that the transport binding
(server side) is completely arbitrary.  The SOAP components are developed
completely independent of the transport listener.  This way, if you decide
to use the components within an Apache Mod or within a IIS ISAPI extension,
etc, you still have access to the same functionality... no dependency on a
single server implementation.  

As for how the server would access the system, that's pretty easy, once the
server has received the SOAP Envelope, an instance of the SOAPEnvelope
object is created by loading the received data into an EnvelopeWriter
object.  The SOAPEnvelope is then passed off to the MessageDispatcher object
for processing.  From there, MessageHandlers and HeaderHandlers are invoked
to perform the actual work.  

- James

-----Original Message-----
From: Octav Chipara [mailto:ochipara@cse.unl.edu]
Sent: Tuesday, August 08, 2000 2:16 PM
To: 'soap-dev@xml.apache.org'
Cc: 'soap-user@xml.apache.org'
Subject: Re: Apache C++ SOAP Implementation Proposed Architecture



On Tue, 8 Aug 2000, James Snell wrote:

> Here's what I'm thinking in terms of the class architecture for an Apache
> C++ SOAP implementation (I've already started on it, but I'd like to get
> some validation from the group before I put too much work into it)


Please talk a little bit more on what you propose to be going on the
server side. I would like to know what you think the binding from the
server is going to be ... and how you will interface with a webapplication
from something like rpcrouter ...

- Octav

> 
> ===
> 
> 
> SOAP Envelope Objects
> -------------------------------------
>           	EnvelopeWriter
> 		Creates and builds an instance of the SOAPEnvelope object
> 
>           	EnvelopeReader
> 		Parses and Reads an instance of the SOAPEnvelope Object
>           	SOAPEnvelope
> 		Represents any Valid SOAP V1.1 Envelope
> 
> 	SOAPHeader
> 		Base Class representing any valid SOAP V1.1 Header element.
> Any extensions to the SOAP implementation based on extended SOAP Headers
> would derived from the SOAPHeader Object.  For example, if you wanted to
add
> security support into the SOAPEnvelope based on SOAP Headers then you
would
> derive a SOAPSecurityHeader class from the SOAPHeader class, etc.  I'll
give
> more details on this later.
> 
> 	SOAPPayload
> 		Base Class representing any valid SOAP V1.1 Payload.  Works
> the same way as the SOAPHeader.  The SOAPPayload object can be used
directly
> to edit/read the payload of the SOAP Envelope, or you can derive new
classes
> from the SOAPPayload to create Message specific payload handlers.  For
> example, if you intend to use SOAP for RPC, then you might derive a
> SOAPRPCPayload class from SOAPPayload and add methods such as "setMethod"
> and "setParameter", etc.
> 
> 
> Transport Objects
> -------------------------------------
> 	EnvelopeTransport
> 		Interface representing the base functionality that all SOAP
> Envelope Transport instances must expose
> 
> 	HTTPTransport
> 		HTTP Based Envelope transport derived from the
> EnvelopeTransport interface
> 
> 	HTTSTransport
> 	SMTPTransport
> 
> Service Description Objects
> -------------------------------------
> 	DescriptionReader
> 		Interface representing the base functionality that all
> DescriptionReader instances must expose
> 
> 	DescriptionWriter
> 		Interface representing the base functionality that all
> DescriptionWriter instances must expose
> 
> 	NASSLReader
> 		Class capable of parsing and reading NASSL documents.
> Through the DescriptionReader interface, the NASSLReader will be capable
of
> generating valid SOAPEnvelope objects
> 
> 	NASSLWriter
> 		Class capable of generating NASSL documents
> 
> 	SDLReader
> 	SDLWriter
> 	SCLReader
> 	SCLWriter
> 
> 
> 
> Dispatcher Objects
> -------------------------------------
> 	MessageDispatcher
> 		The Message Dispatcher is a special object that uses a
> configuration XML document to link the contents of a SOAPEnvelope to a
> specific set of code components (Handlers) specifically designed to handle
> the messages semantics.  For example, a message intended for standard RPC
> use would use a RPCHandler. 
> 
> 
> Handler Objects
> -------------------------------------
> 	HeaderHandler
> 		Interface representing the base functionality that all SOAP
> Header Handlers must expose.  A Header Handler is any component
specifically
> designed to process the semantics of a particular SOAP Header.  Header
> Handlers are linked to a Header through the use of a configuration XML
file
> used by the Message Dispatcher Object
> 
> 	PayloadHandler
> 		Interface representing the base functionality that all SOAP
> Payload Handlers must expose.  A Payload Handler is any component
> specifically designe dto proces the semantics of a particular SOAP
Payload.
> Payload Handlers are linked to a Payload through the use of a
configuration
> XML file use by the Message Dispatcher
> 
> 
> Standard Handler Instances (derived from PayloadHandler)
> -------------------------------------
> 	CRPCHandler
> 		Handles RPC messages to generic C++ classes exposed by DLL's
> 
> 	JRPCHandler
> 		Handles RPC messages to java classes
> 
> 	COMRPCHandler
> 		Handles RPC messages to COM objects
> 
> 	CORBARPCHandler
> 		Handles RPC messagers to CORBA objects
> 
> 


Mime
View raw message