Dear All,
I'm a post-doc working on implementing an abstract
spatio-temporal component model on top of SCA/Tuscany Java
implementation v. 1.2. The main particularity of the model is that it
offer an assembly approach, based on describing spatial (provides/uses)
and temporal (data-flow and control flow) dependencies between
components. In this implementation, components are SCA components. The
assembly of components follows a dynamic approach. That means, the
structure of an application is modified during the
execution. Components are added/removed/connected/disconnected,mainly
depending on temporal dependencies.
Independently of the particular usage of SCA/Tuscany implementation
for this work, we are facing some issues regarding dynamic
creation/removal of components for execution on distributed
resources. We aim to find a help to resolve these issues.
Before I cite encountered issues. I would like just to mention what I
understand from the usage of SCA/Tuscany to execute an application on
distributed resources. If I'm wrong, please do not hesitate to
correct me.
* To execute an application in SCA a set of XML descriptors have to be
provided to describe: components and connections, nodes hosting
components, domain content.
* The domain has a view of (or part of) the application structure and
its deployment through nodes. The domain is responsible to find a
service when this latter is asked.
* A node looks like a container encapsulating one or more
components. These components are grouped inside a composite
representing the node.
* The set of defined nodes determines the deployment and placement
constraints of components (example: if tow components are defined
inside a node, they will be created within the same JVM).
* To execute an application, a domain is first launched. Second, nodes
are launched on targeted machines. Each node registers itself in the
domain. Last, the execution can be launched for example by a client
program invoking services on deployed components.
Encountered problems with some suggestions to try resolving some of them:
Issue 1. Component connections: there is no API provided to the user
to connect components. Connections are done by the runtime from
assembly descriptions. So there is no direct way for the user to
connect dynamically ports (references/services). For our
requirements, I adopted a solution to define a service with
connect/disconnect operations on a user side port (reference) rather
than define a reference port. Thanks to such methods I can pass a
service reference to the user component, which in reality realizes a
connection. The principle is similar to what we can find in other
component models like CCM.
Issue 2. Deployment/placement for distributed execution: Components
within a node and nodes are statically specified. The concept of node,
like it is realized, requires a whole application assembly to be
divided through node descriptions and to know execution resources in
advance. That also means that the hierarchy of an assembly should be
broken by the user when for example sub-components are to be deployed
on different machines. That can be tedious to do for the user and a
strong dependency between assembly and deployment is created. It can
be fine if an assembly is kept unchanged for different execution on
different resources. In this direction, if there is a way to create
"empty" nodes on which it is possible to add/remove components, part
of the issues can be resolved to avoid for example splitting an
assembly through nodes. I saw the Node implementation and there is no
API allowing that.
Issue 3. Behavior when a service is requested: The domain is aware
about the services provided by components. These services are known
thanks to nodes registration. However, it seems that the registration
is not sufficient to find a service. The knowledge of node placement
(host on which it is launched) is also required. That is why a host is
specified in a node XML descriptor. In addition to the problems cited
in Issue 2, that represents an issue for dynamic deployment. Why nodes
registration is not sufficient to be able to find a service? If a node
can pass its placement information to a domain when it registers
itself, it should be possible to avoid the need of static description
of node placement. Isn't it the case? And if the concept of empty
nodes (see Issue 2) is considered, are XML descriptors of nodes still
necessary? Is the proposal feasible by light extensions or
modifications of the SCA Tuscany Java implementation?
Issue 4. Dynamic addition of nodes: Is it possible to add dynamically
a node definition in the domain? I'm revisiting the SCA
specification and in which there is a notion of Domain-level
composite. It seems to allow adding/removing nodes in this way, but
I'm not sure. Can that be a solution? if yes, is it supported in
SCA Tuscany? Otherwise, is the support of dynamic addition/removal of
nodes can be easily feasible?
Any help/suggestion is welcome.
Thank you.
Hinde
