1. Presented by Jinpeng Zhou
A Component-Based Reconfigurable Platform for SOA
Presented by Jinpeng Zhou
CS 2310 Seminar, 12/05/2017

2. Modularity, Standardization，Flexibility，Reusability
Background
SOA
Service Oriented Architecture
A high-level architecture for distributed systems
Service means programs, databases, processes…
Standardized communication
Procedure
Oriented
Object
Oriented
Component
Oriented
Service
Oriented
Modularity, Standardization，Flexibility，Reusability

3. Background SOA How to implement? Service Component Architecture (SCA)
A standard to integrate services
Services as (input & output of) component
Simplify:
Construction
Assembly
coarse-grained
SCA Architecture [1]

4. Background Composite Implementation Export Import
Direct Implementation
(Java)
Connect reference with service

5. Background SCA Assembly based on XML. E.g. [1]: MyApp View Model run

6. Background SCA Problems? Solutions Does not define:
Runtime configuration
Runtime reconfiguration
Management of the platform itself
Solutions
A Component-Based Reconfigurable Platform [1] (primary)
FraSCAti [2] (supplementary)
SCA Architecture [1]

7. A Component-Based Reconfigurable Platform
4-level Architecture
Correspond to end-user applications
Application level
Correspond to SCA infrastructure
Kernel level
Personality level
Runtime level
Kernel implement component,
Personality level provide personality to component,
Runtime level assemble components

8. A Component-Based Reconfigurable Platform
4-level Architecture[1]
Kernel implement component,
Personality level provide personality to component,
Runtime level assemble components

9. A Component-Based Reconfigurable Platform
4-level Architecture
Kernel level
Built on FRACTAL component model [3]
Independent from programming languages
Configurable components
Customize execution policy (personality)
Component personality
Controllers: implementing personality
Interceptors: intercepting requests
FRACTAL is a programming language independent component model, which has been specified for the construction of highly configurable software systems. The FRACTAL model combines ideas from three main sources: software architecture, reflective systems, and distributed configurable systems.
Controllers expose their services through control interfaces. Interceptors modify and extend component behaviors when requests are received or emitted.

10. A Component-Based Reconfigurable Platform
4-level Architecture
Personality level
Personality is a structural and run-time feature
How to instantiate, how to activate ... (execution policy)
It varies in Web app, Embedded system, Wireless Sensing …
How to generalize?
Implement meta-level activities

11. A Component-Based Reconfigurable Platform
4-level Architecture
Personality level
Implementation for Meta-level activities
Controller
Description
Wiring
Manage wires: query, create, remove, retrieve
Instance
Instantiate components with different states
Property
Add and recover property values
Hierarchy
Manage sub-components: add, query, delete
LifeCycle
Turn on/off components
Intent
Wire non-functional services to components
Non-functional such as transaction management, security management

12. A Component-Based Reconfigurable Platform
4-level Architecture
Personality level
For example, the Instance Controller needs to query the Property Controller to retrieve the property values to be injected into created instances. As an other example, the Lifecycle Controller needs to trigger instance creations when initializing eagerly a component, and for that, queries the Instance Controller. Eager initialization is an SCA specific concept which states that components should be pre-instantiated before receiving any client request. The resulting collaboration scheme between controllers is captured in a software architecture which is illustrated in Figure
Personality level example [1]

13. A Component-Based Reconfigurable Platform
4-level Architecture
Run-time level
Major components
Description Parser
Personality Factory
Assembly Factory
Flexible configuration process
In charge of instantiating SCA assemblies and components

14. A Component-Based Reconfigurable Platform
4-level Architecture
Run-time level
Description Parser （XML-based descriptor）
SCA Metamodel: categorizes all concepts defined by SCA specification
Arch Metamodel: describes extensions that are not in the specification
SCA Resolver (Eclipse Modeling Framework)
in charge of loading and checking the SCA assembly descriptor and creating the associated run-time model
Generated Runtime model

15. A Component-Based Reconfigurable Platform
4-level Architecture
Run-time level
Personality Factory
Create the personality of components
Generated code depends on
the type of component implementation
Composite, Java, etc.

16. A Component-Based Reconfigurable Platform
4-level Architecture
Run-time level
Assembly Factory
Receive the run-time model and construct the assemblies
Based on the key concepts of the SCA model
visits the run-time model created by the Description Parser and creates the corresponding component assemblies

17. A Component-Based Reconfigurable Platform
4-level Architecture
Run-time level
Internal input
Internal output
Global
output
By default, the FRASCATI platform is bundled with the following plugins:
Languages and models such as JAVA, WSDL, FRACTAL, protocols such as SOAP, HTTP.
Interface Description Languages (supported by the Interface component): Java, WSDL;
Property Description Languages (supported by the Property component): Java, XSD;
Component Implementation Languages (supported by the Implementation component): Java Beans, Spring, OSGi, FRACTAL;
Binding Technologies (supported by the Binding component): communication protocols, SOAP, HTTP,
Runtime level [1]

18. A Component-Based Reconfigurable Platform
4-level Architecture
Run-time level
Flexible configuration Process (Plug-in) N
Final
Config
Start with a minimal configuration including support for Java.
Looks for architecture fragments in the classpath.
Whenever an architecture descriptor frascati.composite is found among the loaded bundles, the bootstrap merges the content of the descriptor.
Once all the architecture fragments have been merged, the bootstrap creates a new instance of the run-time platform based on the merged descriptor.
This version of the platform is then used to instantiate and manage the business application.
Minimal Config
Search
Plugin
Merge
Plugin Y
Setup
New Instance

19. 5-level Architecture FraSCAti Application level Non-functional level
FraSCAti Platform Architecture [2]
5-level Architecture
Application level
Non-functional level
Run-time level
Personality level
Kernel level

20. FraSCAti
The Autonomous Home Control System [2]

21. FraSCAti
The Autonomous Home Control System [2]

22. FraSCAti The Autonomous Home Control System [2] Reconfiguration Script
for Installing a New TV Module
Description of
the Reconfiguration Policy
Implemented in Groovy
this script first brings the application in a quiescent state (line 2), and then creates an instance of the Remote Controller Module component (line 3 - the description of the module is stored in description). This new component is included in the application architecture (line 4) and wired to the Controller component (line 6). Finally, the reference tv is promoted to the enclosing component (line 7) and exposed as a UPnP binding in order to discover and connect to the UPnP TV (line 8). When these steps are completed, the execution of the application can be resumed (line 9).

23. Evaluation : Invocation time of a service call
The proposed platform [1] (left)
FraSCAti [2] (right)

24. Evaluation : Memory consumption
Code Footprint for Different Configurations of FraSCAti [2]

25. Evaluation : Reconfiguration time
Stop the component
Unwiring
Create a new component
Make new wires
Start new component
1,000-times repetition of replacing a component
0.35 seconds

27. Conclusion Take-away Problem: existing SCA is not flexible for runtime
Solution: component-based reconfiguration
Personalize each component
Update communication (wires) and hierarchy (sub-components)
Turn off/on component for reconfiguration
Dynamically construct the whole platform
Performance Issue: reconfiguration requires offline
Benefits for SIS: Cycles/Operators as Services
Runtime config/switch among short/long cycles (fast/slow intelligence)
Cycles: coarse-grained
Behaviors: fine-grained

28. References
[1] Saberi Mohsen. “A Component-Based Reconfigurable Platform for SOA.” International Journal of Computer and Information Technology, Volume 06 – Issue 05, September [2] Lionel Seinturier, Philippe Merle, Romain Rouvoy, Daniel Romero, Valerio Schiavoni, et al.. “A Component-Based Middleware Platform for Reconfigurable Service-Oriented Architectures.” Software: Practice and Experience, 42 (5), pp , [3] Bruneton Eric, Thierry Coupaye, Matthieu Leclercq, Vivien Quéma, and Jean‐Bernard Stefani. “The Fractal Component Model and Its Support in Java.” Software: Practice and Experience, 36, no. 11‐12, pp , 2006.