xml-soap-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Jean-Noel Gadreau <jngadr...@activcard.com>
Subject RE: Apache C++ SOAP Implementation Proposed Architecture
Date Tue, 08 Aug 2000 22:57:23 GMT
I like the idea of SOAPHeader that you can subclass depending on your needs
and I see how you want to handle that on the client. What I don't see
exactly is how that would work on the server.

When you parse the envelope, what do you do then ? Do you invoke the
HeaderHandlers and PayloadHandlers so that you can put the proper subclasses
in the SOAPEnvelope ?

When does the RPCHandler actually unmarshalls the parameters of the request
? Is it at this time ?
or is it later ?

What I like in your approach is the idea that you can have "header handlers"
that will handle the custom headers. How do you see a fit between this and
the EnvelopeProcessors ? 

Something I don't realaly understand is how the service description
readers/writers interface with the rest. Will there be a "ServiceManager" ?

I would really like to understand how your C++ implementation is working,
because I think it would be good to try to have a common base between the
Java and C++ implementation (at least for the big concepts), so that the
developers don't need to re-learn everything when moving from one to the
other. By this, I don't mean we should copy the existing Java version, but
as it is going to evolve, it would be good to have both implementations go
in the same direction.

I don't think I will have much time to spend on the C++ implementation, but
I will be for sure a user of it !

My $0.02...

Jean-Noel
=============
Jean-Noel GADREAU
Software Engineer, ActivCard Inc.(http://www.activcard.com )
E-mail: jngadreau@activcard.com
Tel (main): 510-574-0100
Tel (direct): 510-574-1736

 


-----Original Message-----
From: James Snell [mailto:jmsnell@intesolv.com]
Sent: Tuesday, August 08, 2000 1:59 PM
To: 'soap-dev@xml.apache.org'; 'soap-user@xml.apache.org'
Subject: Apache C++ SOAP Implementation Proposed Architecture


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)

===


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