Eclipse TEA (Tasking Engine Advanced)

Primary tabs

Eclipse TEA is a tasking orchestration engine that can be run from within the Eclipse IDE or headlessly. It is immediately concerned with tasks related to building and managing plug-ins for the Eclipse Platform, but is general enough to support other types of tasks and builds.

Eclipse TEA's major component is the so called TaskingEngine. This engine can be created and run both from the IDE, as well as headlessly (with a headless presentation engine – thus the PlatformUI.getWorkbench() DOES work – in case a task requires “UI” but still should run headlessly). This allows to create reproducible and stable TaskChains that can be used by both developers and automated builds to create the same, reproducible results for certain tasks.

The original core of TEA was building of projects. For this, there is a task to compile all projects in a workspace. This task has the power to:

  • Calculate a build graph based on “Require-Bundle” dependencies. It is ignoring “Package-Import” completely (currently). The background here is, that the IDE autobuild seems to invest a lot of time figuring out dependencies based on “Package-Import”, running in circles to find a proper build order for bundles – even if this is not required. SSI Schaefer uses “Require-Bundle” exclusively, as this is the better option for applications with well-determined environment anyway (better validation possibilities of architecture, …). “Package-Import” is only great for frameworks that “don't know” their final environment that they will be running in – as applications typically compose different frameworks to a single application.

    • Each node in this graph represents a Plugin that is to be built. On execution of the graph, every IProject's .build() method is called to do the very same thing as the IDE autobuild. Only the dependency calculation is done outside – the build is still unmodified standard.

    • TEA allows to inject additional nodes into that graph. These nodes can be contributed via extensions, and are basically free to do whatever they want. Some framework is included that allows to create nodes that wait for certain bundles to be built (for instance a code generator), and server as dependency for other nodes (for instance the bundles where code is generated into). The node itself can then execute a certain program in the workspace. Support for integration with the “Eclipse Launch Configuration Generator” (another SSI Schaefer project proposal) is provided.

Apart from this, TEA has a library of a lot of useful tasks that allow to easily build complex applications. For instance, building a product requires only one time setup with TEA. Create templates for a product feature, create a product, and setup the TEA tasks to build this new product. As a starting point, TEA takes the path to a launch configuration template from the “Eclipse Launch Configuration Generator” project. This launch configuration is examined, dependencies are resolved dynamically, and the feature for the product is automatically generated. Afterwards, the product can be exported with a TEA task, and that's it. Versions are taken care of, etc. There is no need for more configuration. This takes a lot of effort from developers when developing in workspaces with multiple different applications/products. At SSI Schaefer, the business application is composed out of multiple (10s of) RCP products that are managed this way.

Along with the core infrastructure, all Tasks in the core library that are not SSI Schaefer specific will be contributed. This includes but is not limited to:

  • Build graph calculation and execution (building a workspace)

  • Generation of features based on launch configurations (see other Project Proposal “Launch Configuration Generator” - this part depends on it).

  • Generation and export of P2 update sites (also based on above generated features).

  • Generation and export of Eclipse RCP Products (.product). Also uses the generated P2 update sites and features.

  • Lightweight Maven (Gradle, ...) repository integration tasks. Used to resolve dependencies and download JAR files to be integrated into a single plugin (quite limited but useful)

  • ...and many more individual tasks...