Hi,
Thank you for your reply.
To explain our requirements, here is a very basic example of a use
case. Please let me know if some thing is not clear. You can also
find more information about the principle of the spatio-temporal
component model we are working on in :
https://www.irisa.fr/paris/bibadmin/uploads/pdf/0.21342000%201213723399_paper.pdf
In this paper, you can note that components are not SCA ones.
However, we are applying the same principle on SCA and try to realize
an implementation.
Raymond Feng wrote:
Hi,
Thank you for sharing your thoughts with us. It's indeed a very
interesting usage of Tuscany/SCA. Please see some comments inline.
Raymond
--------------------------------------------------
From: "Hinde Bouziane" <[EMAIL PROTECTED]>
Sent: Wednesday, June 18, 2008 7:04 AM
To: <[email protected]>
Subject: dynamic assembly and deployment in SCA Tuscany Java
implementation
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.
Can you provide us a real-world use case for this theory to help us
better understand the requirements?
Assume the following simplified form of assembly:
A(inA, outA) ; B (inB = inA, outB)
It describes a sequence of execution of two components A and B, where
inX and outX are respectively input and output data of components
(They are realized by
dedicated ports of the form references/services). The arrival of
input data triggers the execution of a task implemented by a
component. Output data are produced by the task. Here I skip
technical details and the spatial dimension as the example should be
sufficient to illustrate our requirements.
For such an assembly our aim is to dynamically deploy components A
and B. That means, we'll change the assembly during the execution.
The principle is similar to what happens in workflows. For the
example a suited behavior is to:
1. creat A.
2. send inA, execute its task A, retrieve outA.
3. remove A - create B.
4. send inB=outA, execute its task B, retrieve outB.
To manage the data movement between A and B, a proxy component is
introduced. So, according to the previous behavior, the assembly at
execution will be:
• At time 0:
• At time 1: A connected to Proxy.
• At time 2: Proxy connected to B.
• At time 3:
Where Proxy is the component receiving the outA data. It is sent to B
after B is created and connected to Proxy. (connection = wiring)
To obtain the suited behavior, we need the ability to dynamically
create new component instances. That means a first API is needed to
be able to dynamically add/remove nodes and a second API is needed to
add/remove new components inside a node without preliminary knowledge
of the content of the node.
For the example, if we assume that we want to have A, Proxy and B in
different nodes, we want to be able to programmatically do some thing
like:
1. Creat Node_A, create Node_Proxy
2. Execute A ...
3. create Node_B, connect Proxy to B, remove Node_A
4. Execute B ...
--> With the SCA/Tuscany Java we can add nodes, but I would like to
know if it is possible to remove preliminary knowledge of the node by
the domain. In particular, that is because both the content of a node
and the machine on which I the node will be launched are not known
before launching the application and the domain. If it is possible,
Can you please direct me what I have to do.
Or if we assume that we want to have A, Proxy and B inside the same
node:
1. Create Node, add A and Proxy in Node
2. Execute A ...
3. add B in Node, connect Proxy to B, remove A from Node
4. Execute B ...
--> Here I would like to create an empty node (so, an empty
composite) in which I can add/remove components, I'm quite lost in
realizing that. I saw the node2-impl sources with the possibility of
updating a node content but I don't know exactly how to proceed, if I
have for example to provide in all cases an XML description of nodes
before the execution of an application. Because that is problematic
for us if we want to decide about the placement of nodes and their
content during the exection.
I respond inline now to your reply :
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.
Actually, we only need the following information to execute a SCA
composite application:
1) The deployable top-level composite (resolved in the SCA domain)
2) A collection of SCA contributions (archives containing artifacts,
such as a JAR or ZIP) which are required by the composite.
1+2 is the install image and it's the input to the node. The node
will be responsible to run the composite application.
ok,
* 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.
The domain also knows about the contributions by URL.
yes
* A node looks like a container encapsulating one or more
components. These components are grouped inside a composite
representing the node.
Node is modeled as a composite at this point. It configures the base
URIs for the bindings. The node also references the deployable
composite.
yes.
* 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).
Components are defined in composite, not node. It should be
potentially possible that a node only picks a subset of the
components in the deployable composite.
I mean "included" in the node, sorry.
* 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.
Not necessarily. The domain is more an administrative concept. We
have a web-based domain manager in Tuscany today. It's
responsibility is to build/resolve the install image. The install
image can be then saved to an XML file so that it can be loaded
without the presence of the domain manager. Even though the domain
manager can provide a button to start a node (push the install image
to a node), the node can pull the install image from a URL (either
live from the domain manager or pointing to a pre-saved file).
The node doesn't have to explicitly register with the SCA domain,
especially for the pull mode.
Is there an example of pull mode usage in the distribution or a
documentation?
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.
I assume you are talking about "wiring" when you say "connection".
The whole composite model is open to use, you can simply create the
deployable composite programmatically.
Do you mean that there exists an API that I can use to connect a
reference to a service rather than having to specify the connexion in
an XML descriptor?
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.
Again, the node is modeled as a SCA composite so you can create it
programmatically too. Just look at the the node composite files in
our store-tutorial.
Yes, probably I'm not clear, sorry. I'm using the concept of node to
realize our use cases for distributed execution. For me, the concept
of node (which is not in the SCA specification) seems to be used for
deployment concern, right? If I have a whole application to deploy,
I'll devide its assembly through nodes descriptions. Because in our
use cases, we aim to decide about deployment during the execution
(for node placement and/or its content) I would like to know if there
is APIs to create empty nodes add/remove within a node and what is
required to be able to do 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?
Node is not a concept in the SCA spec. The domain-level composite
has "include" for each deployable composite added to the SCA domain.
Are you aware of the node2-api, node2-impl and node2-launcher
modules in the code base? It provides a way to create node and
launch it.
Any help/suggestion is welcome. Thank you.
Hinde
Thank you very much for your help;
Hinde
