Equinox Incubator - Provisioning Overview
While there are many possible requirements one could place on a provisioning system, the work here
is focused on creating a robust, extensible provisioning base for Eclipse-based systems on client machines.
We will purposely keep the scope of this work quite narrow but allow for potential extensions and
improvements as we are incrementally successful. Of course, the set of high-level requirements
to be addressed by this workarea will evolve over time. The following is an initial set:
- Multiple Configurations
Many users or systems contain multiple configurations of Eclipse bundles. The provisioning
infrastructure must be able to manage these configurations
- Stand-alone operation
The provisioning system must be able to run as a standalone application and manage/configure Eclipse
systems that are not running at the time.
Given multiple configurations of bundles on a single machine, the provisioning system should
take every opportunity to shared the physical and inmemory storage associated with bundles.
- JRE and root files
We must be able to update the JRE, root files and all other aspects of an Eclipse configuration
The provisioning system itself is an Eclipse-based system and must be able to operate on itself.
- Simple workflows
End-users should follow a set of simple workflows when doing simple operations
The provisioning work should use existing standards as much as possible and where new designs,
approaches, formats or APIs are developed, they should be suitable candidates for standardization.
Of course, the design too will evolve over time. To kick off the effort we have sketched out and prototyped
some ideas. The basis for this design is the desire to factor a provisioning system into constituent parts
and allow those parts to be replaced and reassembled as needed. In particular we have identified the following
high level concepts.
- The provisioning infrastructure on client machines is generally referred to as the agent. Agents
can manage themselves as well as other profiles. An agent may run
separate from any other Eclipse system being managed or may be embedded inside of another Eclipse system.
Agents can manage many profiles (see below) and indeed, a given system may have many agents running on it.
- Profiles are the unit of management in the system. That is, the provisioning infrastructure can manage
individual (or collections of) profiles. Profiles are analogous to Eclipse configuration in some situations.
For now we have chosen to introduce this new term to separate the conceptual profile from the implementation
- Artifacts are the elements that are ultimately provisioned to a profile. For example, Eclipse bundles are artifacts.
- As with the original Update Manager, there is a need for metadata that describes artifacts separate from the actual
artifacts themselves. This allows the provisioning system to reason about profiles hypothetically without
having to actually incur the cost of downloading all the content. Broadly speaking the provisioning metadata envisioned here
takes the form of extensible Installable Units (IUs). As the name implies, IUs describe things that can be installed,
updated or uninstalled. They do not contain the actual artifacts but rather essential information about such artifacts (e.g., names, ids,
version numbers, dependencies, etc). The metadata should allow dependencies to be structured as directed acyclic graphs
without forcing containment relationships between nodes.
- Both metadata and artifacts are organized into repositories. Repository structure, layout and access has long been the source
of much debate and discussion. We do not intend to fight that battle here. Rather, the provisioning system
must be extensible and thus allow for a wide range of repository formats to be represented. The pervasive notion of downloading
or managing repository content is mirroring. Rather than downloading artifacts etc, they are mirrored locally.
- As the name implies transports are the mechanisms by which artifacts, metadata etc are mirrored around the system.
The set of available transports must be extensible and the programmatic interface to transports should allow for progress
monitoring, cancellation and restart as appropriate. The incubator work will focus on a small set of transports (e.g., HTTP)
sufficient to do standard Eclipse install management.
- Directors are responsible for determining what should be done to a given profile to reshape it as requested.
That is, given the current state of a profile, a description of the desired end state
of that profile and metadata describing the available IUs, a director produces a list
of provisioning operations (e.g., install, update or uninstall) to perform on the related IUs.
Directors are also able to validate profiles and assist in the diagnosis of configuration errors. Note that directors
may range in complexity from very simple (e.g., reading a list of bundles from a static file) to very complex. In this
incubator we will create a director sufficient to achieve Update Manager-like function.
- The engine is responsible for determining how to achieve the desired provisioning operations as determined
by a director. Whereas the subject of the director's work is metadata, the subject of the engine's work is the artifacts and
configuration information contained in the IUs selected by the director. Engines cooperate with repositories and transport
mechanisms to ensure that the required artifacts are available in the desired locations.
- During execution the engine traverses through a set of phases (e.g., fetch, install, configurre).
At each phase all the IUs being operated on have an
opportunity to participate in the lifecycle. The mechanism by which they specify their participation is undecided at this point.
- IUs can be stamped with a type. Using this type the engine identifies the touchpoint responsible for marrying
the IU with the related system. For example, an IU of type "Eclipse bundle" would be handled by the Eclipse Touchpoint.
That touchpoint is responsible for putting the bundle in the appropriate spot, adding it to the Eclipse configuration files
and setting any related/described settings. The set of touchpoints is open-ended.
The interactions between some of these concepts are depicted in the view diagram shown below.