Fwd: RE : [fractal] packaging for Fractal

[Eric Bruneton <Eric.Bruneton@xxxxxxxxxxxxxxxxxxxx>]

----------  Forwarded message  ----------

Subject: RE : [fractal] packaging for Fractal
Date: Mercredi 7 Avril 2004 13:51
From: "Vivien Quema" <vivien.quema@xxxxxxxxxxxx>
To: "'Eric Bruneton'" <Eric.Bruneton@xxxxxxxxxxxxxxxxxxxx>

Hi,

> there are also requirements about Fractal packages "installation"
> and "instantiation". For instance, it could be useful to have
> several versions of a component installed simultaneously on a given
> system, or even to have several versions of a component
> instantiated simultaneously in the same JVM (which could differ at
> the interface and/or implementation level).

Indeed, we need a mean to instantiate several versions of the same
component in a JVM. We have started looking at this issue.
More precisely, we try to determine how Rick Hall's Module Loader
 could be used to reach this goal. The fact is that a given component
 must be associated to several modules, so that it will be possible
 to change part of its interfaces and implementation classes.

The problem is to determine:

1) the relation between a component package and modules
2) how these modules can be inserted into Julia's instantiation
framework.

** For the first question, there is no unique relation: the fact is
 that a module should be used to load a set of classes that are seen
 as a unit of reconfiguration (i.e., a set of classes that will be
available/unavailable for loading at the same time).

If the packaged application is not intended to be reconfigured, only
 one module is required, which is not the case otherwise.

** For the second question, we think at this time that modules should
 be used by the generic factory to create the appropriated
InitilizationContext class.

> In addition to the requirements, several questions must also be
> resolved in order to precisely define the packaging system:
>
> - where is the meta information in a Fractal package? Should we put
> everything in the ADL files, with new ADL modules?

This would be nice to be able to use the ADL for this, since this
 would reduce the number of different configuration files...

> - is it necessary to explicitly define what a package "exports" and
> what it "imports" (cf OSGi)? or could this be deduced automatically
> (with a transitive closure operation) from the provided and
> required interfaces of the component, as declared in the ADL files?

We think that this is necessary. It seems difficult to deduce
 everything from the provided and required interfaces. Let's take the
 example of a class that is used by two components (because they
 exchange objects of this type). If this class is not used in the
 interfaces (void foo(Object o);), then it cannot be deduced from the
 ADL.

In such a case, there are two solutions:

1) the class is exported by one component package (say A) and
 imported by another one (say B)
2) the class is imported by both component package and exported by a
library package.

The problem of the first solution is that B cannot be used without A.

> - a Fractal package must include the interfaces provided by the
> components, as well as the classes that implement them, but should
> it also include the interfaces required by these components?

If a package does not include required interfaces, it will not be
possible to instantiate this component "alone".

Dream team ;-)

-------------------------------------------------------