1. tu sca ny 1 The Tuscany Java SCA Runtime 20 August 2006

2. tu sca ny 2 Agenda Overview Architecture Runtime artifacts Assembly processing Bootstrap Wiring

3. tu sca ny 3 Java Runtime Is an SCA implementation Specs at http://www.osoa.org Provides infrastructure for creating service assemblies Heterogeneous services connected through wires Containers for managing service instances and lifecycle Spring, Java POJOs, Groovy Infrastructure for wiring services together Apply qualities of service Sync, non-blocking, callbacks, conversations Framework for mediation Dynamic re-wiring Embeddable in a variety of host environments Standalone, J2EE, OSGi, etc. Leverage qualities of service provided by host Transactions, clustering, fail-over

4. tu sca ny 4 Project Structure API SPI HOST-API Core Base interfaces for interacting with the runtime (eventually will contain management) API for the runtime to interact with its host environment SPI and base classes for extending the runtime The runtime implementation WSDL Important Extensions Launcher Test

5. tu sca ny 5 Agenda Overview Architecture Runtime artifacts Assembly processing Bootstrap Wiring

6. tu sca ny 6 Basic Runtime Artifacts Component Basic unit of executable code Offer services and have references Service A contract for component clients consisting of 0..n operations Services may be local or remote Reference A dependency on a service Component references are wired to services by the runtime Service Reference Wire Component

7. tu sca ny 7 The Runtime is Recursive Components may be Atomic or Composite Composite components contain 0..n components Composite services are exposed over 1..n bindings (e.g. SOAP/HTTP, JMS, RMI) Composite references have 1..n bindings and may target A service exposed by another composite A service outside the SCA system, e.g. “Google search” A composite may contain just a service wired to a references (mediation) Reference Service Composite Component Composite or Atomic Components

8. tu sca ny 8 Runtime Capabilities The runtime is responsible for wiring at the atomic and composite levels Extensions “plug into” this wiring infrastructure Component implementation types SCA Java, Spring, Groovy, JavaScript Binding extensions Web services, JMS, RMI, etc. Enables heterogeneous wiring

9. tu sca ny 9 Assembly Processing The runtime processes service assemblies Serialized using SCA XML vocabulary, SCDL, but can take other forms The load phase processes SCDL and creates an in-memory model The build phase evaluates the model and produces corresponding runtime artifacts (e.g. components, services, references) The connect phase wires references to services loadbuild connect

10. tu sca ny 10 Deployment initiates evaluation of an assembly and wiring Deploy composites or single artifacts (component, service or reference) Deployment Deployer Loads artifacts to create configuration model Loader Builder Connector Creates components, service,s and references from model Connects wiring between references and services Coordinates deployment

11. tu sca ny 11 Configuration Loading Loader StAXElement Loader Loads XML elements from StAX stream ComponentType Loader Loads componentType for an implementation

12. tu sca ny 12 Component Type Loading Loads the component type definition for a specific implementation How it does this is implementation-specific May load XML sidefile (location set by implementation) May introspect an implementation artifact (e.g. Java annotations) … or anything else Composite ComponentType Loader Load SCDL from supplied URL Extract and load SCDL from composite package POJO ComponentType Loader Introspect Java annotations Uses a pluggable “annotation processing” framework to introspect Java classes

13. tu sca ny 13 Annotation Processing Pluggable annotation processors Ability to add new annotations Extend componentType structure @Init @Destroy Magic Property and Reference definitions @Monitor Ability to extend the core programming model e.g., JPA

14. tu sca ny 14 Building Builder creates a runtime component from the configuration model Builder for each implementation type Builder for each binding type (service or reference component) Runtime component manages: Implementation instances Inbound and Outbound wires Every implementation is likely to be different Different artifacts, programming model, … Composite implementation recurses for contained components Re-invokes the Builder for every child

15. tu sca ny 15 Bootstrap Bootstrap process is controlled by Host environment Default process implemented in DefaultBootstrapper Create Runtime Component Create Bootstrap Deployer Deploy System Assembly Locate Application Assemblies Locate System Assembly Deploy Application Assembly Start Server

16. tu sca ny 16 Wiring To understand how wiring works, we need to detail how Components function in the system… Start with Atomic Components and then discuss Composite Components

17. tu sca ny 17 Atomic Component AtomicComponent: the most basic component form Corresponds to the spec concept Offers services, has references and properties Implementation types e.g. Java, XSLT, etc. Are wired Have properties Outbound wireInbound wire Properties

18. tu sca ny 18 Implementation Instances Atomic Components have implementation instances Instances are associated with a scope: e.g. request, conversation, module A SCDL entry defines a Component … association instances of “FooImpl” Foo component

19. tu sca ny 19 Atomic Component Instance Management Atomic components use a ScopeContainer to manage implementation instances Module, HTTP Session, Request, Stateless ScopeContainers track implementation instances by scope id and the AtomicComponent instance identity Instances are stored in an InstanceWrapper which is specific to the component implementation type (e.g. PojoInstanceWrapper.java) ScopeContainer AtomicComponent Collection of instance wrappers keyed by scope id and collection keyed by AtomicComponent

20. tu sca ny 20 Component Implementation Instance Creation ScopeContainer getInstance(this) no instance cached createInstance return instance track and enqueue instance (for destruction) return instance AtomicComponent Instantiate and inject the instance (which will recurse for dependents)

21. tu sca ny 21 Component Wiring Component references are connected to services through wires Two sides InboundWire - handles the source side of a wire, including policy OutboundWire - handles the target side of a wire, including policy The runtime connects inbound and outbound wires, performing optimizations if possible Inbound and outbound wires may be associated with different service contracts Different implementation types “Standard” wires contain invocation chains that have Interceptors and MessageHandlers that perform some form of mediation (e.g. policy) Other wire types exist that, for example, do not perform mediations Outbound wireInbound wire

22. tu sca ny 22 Invocation Chains A wire has an InvocationChain per service operation An InvocationChain may have Interceptors - “Around-style” mediation One-way MessageHandlers Component implementation instances access a wire through a WireInvocationHandler associated with a reference WireInvocationHandlers may (or may not depending on the component type) be fronted by a proxy WireInvocationHandlers dispatch an invocation to the correct chain A wire has a TargetInvoker that is created from the target side AtomicComponent or Reference and is stored on the source wire invocation handler. The TargetInvoker is resposnible for dispatching the request to the target instance when the message hits the end of the target invocation chain. Invocation chains

23. tu sca ny 23 Invocation Overview An invocation is dispatched to the WireInvocationHandler The WireInvocationHandler looks up the correct InvocationChain It then creates a message, sets the payload, sets the TargetInvoker, and passes the message down the chain When the message reaches the end of the chain, the TargetInvoker is called, which in turn is responsible for dispatching to the target Having the TargetInvoker stored on the outbound side allows it to cache the target instance when the wire source has a scope of equal or lesser value than the target (e.g. request-->module) WireInvocationHandler Invocation TargetInvoker associated with the operation Payload Dispatch on target

24. tu sca ny 24 Wires and Implementation Instances The runtime provides components with InboundWires and OutboundWires InvocationChains are held in component wires and are therefore stateless Allows for dynamic behavior such as introduction of new interceptors or re-wiring WireInvocationHandler Implementation instance Proxy Outboundwire held by component InboundWire associated with a service and held by component TargetInvoker may need to resolve the target instance. This may be done by referencing the ScopeContainer

25. tu sca ny 25 Invocation Detail Outbound Interceptor Chain TargetInvoker Outbound Request Channel 1 Inbound Request Channel Request 2 Inbound Response Channel Outbound Response Channel 6 7 Response 3 4 5 1.RequestResponseInterceptor (RRI) dispatches to the outbound request channel (OReqC) 2.RRI dispatches to the inbound request channel (IReqC) 3.MessageDispatcher dispatches to the inbound interceptor chain 4.TargetInvokerInterceptor pulls the TargetInvoker from the message and dispatches to it 5.TargetInvoker dispatches to the target (implementation instance or to some transport) 6.RRI dispatches to the inbound response channel (IRespC) 7.RRI dispatches to the outbound response channel (ORespC) 8.The response is returned back up the outbound channel to the client Inbound Interceptor Chain Note the runtime may optimize invocations not to call interceptors or handlers and possibly dispatch directly to a target (or any combination thereof)

26. tu sca ny 26 Composite Component CompositeComponent: a component which contains child components Corresponds to the spec concept Offers services, has references over bindings Has properties Has inbound and outbound wires associated with Services and References Implementations deal with the specifics of a type, e.g. Spring Reference Service Properties

27. tu sca ny 27 A Composite Example Expose a Spring Bean through a service with a SOAP/HTTP binding and using a reference bound over SOAP/JMS Spring application.xml does not need to be modified Preserves Spring programming model Allows existing Spring applications to be wired in an assembly Services and references are contributed by SCA bindings (e.g. Celtix) Reference Service SpringCompositeComponent Spring Bean

28. tu sca ny 28 Composite Wiring Services and references are “twist-ties” for inbound and outbound wires Services have connected InboundWire/ OutboundWire pairs OutboundInbound OutboundInbound References have connected InboundWire/ OutboundWire pairs Inbound Outbound CompositeComponent AtomicComponent

29. tu sca ny 29 Composite Reference Invocations When a message reaches the end of the outbound reference wire, the TargetInvoker dispatches over a transport In contrast to Component-->Component invocations, where the TargetInvoker would resolve the target implementation instance OutboundInboundOutbound Invoke on transport AtomicComponentComposite Reference