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

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

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]

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

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

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]

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

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

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.

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

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

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]

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

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

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.

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

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]

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

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

FraSCAti The Autonomous Home Control System [2]

FraSCAti The Autonomous Home Control System [2]

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).

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

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

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

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

References [1] Saberi Mohsen. “A Component-Based Reconfigurable Platform for SOA.” International Journal of Computer and Information Technology, Volume 06 – Issue 05, September 2017. [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.559-583, 2012. [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. 1257-1284, 2006.