Skip to main content

Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.

Jump to: navigation, search

Difference between revisions of "Equinox/p2/Getting Started"

< Equinox‎ | p2
(Steps to using the agent)
(61 intermediate revisions by 8 users not shown)
Line 1: Line 1:
__TOC__
+
As of Eclipse project build I20080305 (shortly before Eclipse 3.4/[[Ganymede]] M6), the Eclipse SDK contains a new provisioning system called [[Equinox/p2]]. p2 replaces Update Manager as a mechanism for managing your Eclipse install, searching for updates, and installing new functionality. This document will help you getting started with p2.  If you want to explore some of the capabilities of p2 that are not exposed to end users in the Eclipse SDK, see also [[Equinox_p2_Getting_Started_Admin_UI|Equinox/p2/Getting Started Admin UI]].
  
== Overview ==
+
== p2 user interface ==
  
What is the first thing that you would expect to do with some provisioning code - install something, of course! This section is to guide you through a happy-path using equinox provisioning to install an Eclipse SDK.
+
In the workbench, p2 replaces the '''Help > Software Updates''' menu entry from Update Manager. The resulting dialog shows the features that are installed, and the features that are available to install. You can add additional update sites by clicking '''Manage sites''' in the '''Available features''' pane.  Or, simply drag and drop a URL link in a browser to the '''Available features''' pane.  For example, dragging this link (http://download.eclipse.org/eclipse/testUpdates) will add the eclipse test updates site.  Select any set of available features and click '''Install''' to install them into the current running system.
  
There are four basic concepts that will help you understand the install:
+
[[Equinox/p2/Update UI Users Guide]] provides more information about how the UI works.
  
* '''Agent''' - the program that will perform the install. In general, the provisioning agent could appear in various forms - a standalone application, a silent install demon, a perspective in the ide. We will use the [[Equinox p2 Admin UI Users Guide | Admin UI application]] to do our install. Note that this Admin UI will not be what regular users will experience.
+
You must modify the p2 UI code if you want to [[Equinox/p2/Getting Started#Running the p2 UI from a self-hosted workbench|Run the p2 UI in a self-hosted workbench]].
* '''Metadata''' - the information about what can be installed. The metadata is used by the agent to analyze dependencies and perform the installation steps. Metadata lives in one or more repositories.
+
* '''Artifacts''' - the actual bits that will be installed. There are various kinds of artifacts that are processed differently during the install. Associated metadata determines how a given artifact is processed. Artifacts live in one or more repositories. The metadata and artifacts generally come from different repositories and may be widely distributed.
+
* '''Profile''' - in the most simple form, a profile is the location where the bits will be installed. The term 'profile' is not a very good term and probably will disappear from end user concepts (there's a bug about this), but it is the term we are using for now.
+
  
== Steps to using the agent ==
+
== p2 basics ==
  
In this example, we will be installing a 3.4M5 SDK. Versions prior to M5 no longer work with the Eclipse test site. The example uses the windows-based agent, but other platforms are available on the [http://download.eclipse.org/eclipse/equinox/ Equinox download site].
+
=== Disk layout ===
  
=== Step 1 - Downloading the agent ===
+
Before [[Equinox/p2|p2]], many Eclipse users circumvented Update Manager and installed new plug-ins by dumping them in the ''eclipse/plugins/'' directory and restarting with the -clean command line argument. There are many drawbacks to this "wild west" approach that we won't get into here, but suffice it to say that this approach to installation is not recommended. Although p2 will detect plug-ins added directly to the ''plugins'' folder (with an associated startup performance cost), alterations to plug-ins installed by p2 in this directory is '''not''' supported. If you manually remove a plug-in installed by p2, or attempt to replace with a different version, p2 will not detect it and may be broken. 
  
The Admin agent application is available from the  [http://www.eclipse.org/downloads/download.php?file=/eclipse/equinox/drops/S-3.4M5-200802071530/equinox-p2-agent-3.4M5-win32.zip Equinox download site] - click the link and you should see (Firefox)
+
The short rule of thumb is: if you added something manually, you can remove it manually. If you installed via p2, you should uninstall via p2. The shorter rule of thumb is: don't mess with the plugins folder if you can avoid it. p2 provides a new dropins folder that is much more powerful and allows separation of content managed by p2 from content managed by other means (described below).
  
    [[Image:AgentDownload.jpg]]
+
When you install a p2-enabled Eclipse application, you will notice some new files and directories that didn't exist before. Here is a subset of a typical Eclipse install tree with some of this new content highlighted:
  
The zip file is ~11 MB. Download it and unzip it anywhere on a writable local drive. The result of this step is that you will have a directory (equinox.p2) containing the agent:
+
  eclipse/
 +
    configuration/
 +
      config.ini
 +
      '''org.eclipse.equinox.simpleconfigurator/'''
 +
        '''bundles.info'''
 +
    '''dropins/'''
 +
    features/
 +
    '''p2/'''
 +
    plugins/
 +
    eclipse.exe
 +
    eclipse.ini
 +
    ...
  
    [[Image:ProvDirectory.jpg]]
+
The file '''bundles.info''' contains a list of all the plug-ins installed in the current system.  On startup, all the plug-ins listed in this file are given to OSGi as the exact set of plug-ins to run with.
  
=== Step 2 - Exploring the agent ===
+
Any extra plug-ins in the ''plugins'' directory or elsewhere are ignored. If you really want to force Eclipse to startup with a particular set of bundles installed, you could manually edit this file to have the contents you need. However, unless you're just hacking around or testing, editing this file is '''not recommended'''. However, it's useful to know about this file so you can see exactly what is installed in the system you are running. Typically, p2 is the interface between this file and the rest of the world. Clients initiate provisioning requests to p2 via API, the GUI or some of the facilities described below, and as a result p2 may install or uninstall bundles from the OSGi runtime by updating the bundles.info file.
  
Double-click on the eclipse.exe and the Admin UI will come upIt looks something like ''(resized to fit here)'':
+
The new '''dropins''' folder is where you can drop in extra plug-ins if you don't want to use the p2 user interface. See the [[Equinox/p2/Getting_Started#Dropins|dropins]] section for more detailsFor backwards compatibility, p2 will also detect extra plug-ins dropped into the ''plugins'' directory, and install any discovered bundles into the system.
  
    [[Image:InitialRCPAgent.jpg]]
+
Note that the above tree is just a sample layout of an Eclipse-based application. Very little of this structure is actually guaranteed to take this shape.  The configuration directory can be stored separately from the rest of the install using the -configuration command line argument.  The bundles and features may be in a shared [[Equinox/p2/Getting_Started#Bundle pooling|bundle pool]] elsewhere on disk. The eclipse.ini and eclipse.exe files may be branded with different names. The p2 directory may also be stored elsewhere when a single management agent is configuring multiple applications. In short, you should never write code that makes assumptions about the relative placement of files and directories in an Eclipse install.
  
Note that you see here all four concepts:
+
=== Dropins ===
  
# Agent - the main window.
+
Provisioning operations should generally occur using the p2 UI, or by invoking [http://help.eclipse.org/ganymede/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/p2_director.html p2 tools] or APIs. However, there are situations where scripts need to install plugins and features via file system operations, and have the new content dynamically discovered by the system either at startup, or while running. To support this kind of low-level manipulation of the system, p2 supports the notion of ''watched directories''. A watched directory is a  place where a user or script can drop files and have them discovered by p2. Various policies can be applied to watched directories to configure when they are checked for new content, and whether to eagerly install discovered content.
# Metadata - the exposed '''Metadata Repositories''' view.
+
# Artifacts - the hidden '''Artifact Repositories''' view.
+
# Profiles - the '''Profiles''' view.
+
  
The Metadata Repositories view is empty, so first let's add a repository on eclipse.org which contains metadata for the Eclipse SDK, and other goodiesYou can do this from the popup menu in the Metadata Repositories view.
+
The Eclipse platform ships with a default watched directory called ''dropins''. The dropins folder is configured to be scanned during startup, and for changes to be immediately applied to the running systemThus the dropins folder can be used much like the ''plugins'' directory was used in the past.  
  
    [[Image:SelectAddRepository.jpg]]
+
A subtle twist on old behavior here is that plug-ins and features added to the ''dropins'' folder are properly installed into the system rather than being forced in. This means p2 has an opportunity to confirm that the new plug-in doesn't conflict with other installed plug-ins, and it can even go out and fetch any missing prerequisites of the newly dropped in plug-ins. This also means you can later use the GUI to install extra functionality that depends on the plug-ins in the ''dropins'' folder, since p2 knows about them and can reason about their dependencies. In other words, new plug-ins installed via the ''dropins'' folder behave exactly like plug-ins installed via the user interface. Note that updating plug-ins which are located under the ''dropins'' folder using the p2 UI will result in the updated plug-ins being saved under the main eclipse/plugins and eclipse/features folders and not under the ''dropins'' hierarchy as siblings to the older versions of the plug-ins, as might be expected.
  
 +
==== Supported dropins formats ====
  
You'll see a dialog that lets you add a URL (or a local directory or jar file).  We're going to use a test update site on eclipse.org (http://download.eclipse.org/eclipse/testUpdates/).  (This may take awhile, we're working on the performance here)...
+
The dropins folder supports a variety of layouts, depending on the scale of your application and the desired degree of separation of its parts. The simplest layout is to just drop plug-ins in either jar or directory format directly into the dropins folder:
  
     [[Image:AddMetadataRepo.jpg]]
+
  eclipse/
 +
     dropins/
 +
      org.eclipse.core.tools_1.4.0.200710121455.jar
 +
      org.eclipse.releng.tools_3.3.0.v20070412/
 +
        plugin.xml
 +
        tools.jar
 +
        ... etc ...
 +
    ...
  
Once the repository has been added, you should see something like this:
+
You can also drop in the traditional Eclipse application or extension layout directly in the dropins folder:
  
     [[Image:RCPAgent.jpg]]
+
  eclipse/
 +
     dropins/
 +
      eclipse/
 +
        features/
 +
        plugins/
  
 +
If you have various different components being dropped in, and you want to keep them separate, you can add an additional layer of folders immediately below the dropins folder that contain traditional Eclipse extensions:
  
The Profiles view shows the Equinox Provisioning UI profile. This is the profile defining the install location for the Admin UI app you are running. If you right click on the list item and  select properties, you will see some information about this profile:
+
  eclipse/
 +
    dropins/
 +
      emf/
 +
        eclipse/
 +
          features/
 +
          plugins/
 +
      gef/
 +
        eclipse/
 +
          features/
 +
          plugins/
 +
      ... etc ...
  
    [[Image:AgentProfileProperties.jpg]]
+
Finally, you can add link files as in the traditional Eclipse links folder:
  
If a Metadata repository or a Profile is not empty, then you can expand it to see the installable units (which are really installed units) in the profile. A preference is available to show only the installable units which are a Group; the default for this preference is true. Expanding to show the groups will give you something like this:
+
  eclipse/
      
+
     dropins/
    [[Image:ExpandedInstallableUnits.jpg]]
+
      emf.link
  
Now, we'll switch to the Artifact Repositories view.  It is empty because you have not yet added an artifact repository. 
+
==== Debugging dropins ====
  
The metadata repository you added describes what software is available, while the artifact repository contains the actual software that will be downloaded.  These repositories don't have to be located at the same URL, but they can be.
+
If you are attempting to use dropins, but your bundles are not being found, first ensure <tt>org.eclipse.equinox.ds</tt> and <tt>org.eclipse.equinox.p2.reconciler.dropins</tt> are marked to auto-start.
  
The server on eclipse.org has the metadata and artifacts in the same location, so you can add an artifact repository using the same URL we used for the metadata repository (by using the popup menu in the Artifact Repositories view)Once the repository has been added, you should see the actual artifacts in the Artifact Repository view:
+
Resolution errors with dropins are silently ignoredTo enable useful logging messages, place the following tracing options in your <tt>.options</tt> file:
 +
<source lang="text">
 +
org.eclipse.equinox.p2.core/debug=true
 +
org.eclipse.equinox.p2.core/reconciler=true
 +
</source>
 +
and then run with "<tt>-debug path/to/.options</tt>"
  
    [[Image:Artifacts.jpg]]
+
=== Bundle pooling ===
  
=== Step 3 - Creating a new profile ===
+
Prior to p2, each Eclipse application had its own private ''plugins'' directory where the application's software was kept.  This had the drawback that systems with two or more Eclipse-based applications installed ended up with significant duplication of software and other artifacts. Furthermore, the common pieces had to be upgraded separately for each application, often resulting in slow downloads of software already available elsewhere on the local system.
  
You will need to decide where you want to install the SDK and create a profile for that location. In the profile view, right click and select 'Add profile...':
+
To escape from this duplication problem, p2 natively supports the notion of bundle pooling. When using bundle pooling, multiple applications share a common ''plugins'' directory where their software is stored. There is no duplication of content, and no duplicated downloads when upgrading software. A Windows system configured to use bundle pooling would have a layout something like this:
  
     [[Image:SelectNewProfile.jpg]]
+
  Application1/
 +
     configuration/
 +
      config.ini
 +
      ... other configuration files for Application1...
 +
    Application1.exe
 +
    Application1.ini
 +
  Application2/
 +
    configuration/
 +
      config.ini
 +
      ... other configuration files for Application2...
 +
    Application2.exe
 +
    Application2.ini
 +
  ...
 +
  Documents and Settings
 +
    Username
 +
      .p2/
 +
        org/eclipse.equinox.p2.core
 +
        org/eclipse.equinox.p2.director
 +
        org/eclipse.equinox.p2.engine
 +
        org/eclipse.equinox.p2.touchpoint.eclipse
 +
          plugins/      <-- shared bundle pool
  
then fill in the appropriate data in the Profile properties dialog:
+
With this layout, all the software is stored in a single ''plugins'' directory outside of the application install area.  p2 takes care of ensuring that the bundles needed by the various applications in the system are present in the bundle pool.
  
    [[Image:NewProfile.jpg]]
+
=== Installer ===
  
The meanings of many of these properties are advanced, so don't play with the default settings unless you want to explore error conditions!
+
There is now an [[Equinox/p2/Installer]] that will install the Eclipse project SDK. The installer supports both traditional standalone installs, and installs using [[Equinox/p2/Getting Started#Bundle pooling|bundle pooling]].
  
=== Step 4 - Doing the install ===
+
== Running the p2 UI from a self-hosted workbench ==
  
The '''sdk''' group is near the bottom of the list of group installable units in the repository, so scroll down until '''sdk''' is in view. There may be multiple versions of the sdk availableIf so, find the one you are interested in.
+
We do not yet support a properly configured, self-hosted p2 system (see {{bug|224658}}). This means that if you run a self-hosted workbench, the launched Eclipse will not be p2 awareThe p2 UI will notice this and tell you that it cannot open.
  
'''NOTE: Due to [[https://bugs.eclipse.org/bugs/show_bug.cgi?id=208143 bug 208143]] you should install the 1101-0010 version of the SDK IU.'''
+
If your desire is simply to develop or otherwise play with the new UI, and you don't care that the self hosted workbench is not provisioned, you can load the '''org.eclipse.equinox.p2.ui.sdk''' project and change  this code in '''ProvSDKUIActivator'''.
  
The Admin UI supports two ways of initiating an install: 1). you can right click on the '''sdk''' group, select Install..., then choose the profile in the resulting popup dialog; or 2). you can drag&drop the '''sdk''' group onto the profile. Let's do d&d since it is easier (the little smudge over SDK is the drop cursor):
+
  ProvSDKUIActivator.ANY_PROFILE = true;
  
    [[Image:DropSDK.jpg]]
+
This will allow you launch the UI, but please note that the UI will be operating on the installation profile of the '''host workbench'''.
  
You will see a progress indicator while the agent figures out what needs to be downloaded.  Next, you will be shown more detail about what is to be installed, such as the size of the artifacts needed.  (We'll be showing more information here as the project evolves, such as license information or detail). 
+
== Interaction with legacy Update Manager ==
  
    [[Image:InstallDialog.jpg]]
+
In Eclipse platform version 3.4, the old Update Manager still exists under the covers for backwards compatibility. You can even re-enable the old Update user interface by enabling the "Classic Update" capability on the General > Capabilities preference page.
  
Click the install button, and the install will start (assuming you have network connectivity org.eclipse.download, no firewall issues, etc):
+
However, users will rarely have a need for enabling Update Manager, because p2 is able to install from any update site that was designed for Update Manager. Add the update site you want to use by dragging a URL from a browser into the '''Available Features''' page in the '''Help > Software Updates ''' dialog. The features from that site will be added to the available features list, and from there you can install them into the system.
  
    [[Image:InstallProgress.jpg]]
+
=== Links Folder ===
  
Anecdotally, the install takes slightly less time than the download of a corresponding Eclipse SDK zip (one datapoint: 21 minutes for equinox provisioning install vs. 23 minutes for download of the zip).
+
Update Manager supported the notion of an eclipse/links folder, where *.link files could be dropped in to connect extensions to an Eclipse-based application. For backwards compatibility the links folder is supported by p2 with the same behavior. This is really just a subset of the functionality available in the [[Equinox/p2/Getting Started#Dropins|Dropins]] folder.
  
=== Step 5- After the install ===
+
== Removing p2 ==
 +
[[Equinox/p2/Removal]] describes the steps to completely remove p2 from the platform and revert to using the original Eclipse Update Manager.  In addition, for Eclipse project 3.4 builds, there is a link on the right hand side of the download page called "Eclipse Classic Update Manager". This gives a link to a script that can be used to remove p2 from any Eclipse SDK, platform binary, or platform SDK build.
  
The install will finish with a whimper, not a bang, as the progress dialog disappears and the new profile you created is populated with the groups and installable units that are now installed into the profile:
+
Removing p2 from the Eclipse SDK is no longer supported in [[Galileo]] (3.5) or later. However, the platform itself is not tied to any particular provisioning technology, so applications are free to choose an alternative provisioning system (or none) depending on their requirements.
 
+
    [[Image:AgentPostInstall.jpg]]
+
 
+
The directory you chose for your profile location will look like this, before running the eclipse you just installed:
+
 
+
    [[Image:InstalledSDK.jpg]]
+
 
+
=== Step 6- Installing the end user UI ===
+
 
+
The Agent UI is really intended for system administrators and power users who want to browse and manage the applications they have installed.  A typical end user of an Eclipse-based application doesn't want to be exposed to all these concepts of metadata, artifacts, profiles, and IUs. They just want to install, run, and update their software. 
+
 
+
For this purpose, there is a p2-based end user UI intended for dropping into an Eclipse application.  Once you have installed the SDK, you can install this end-user UI by dragging the "userui" group from the metadata repository into the profile that you just installed the SDK into.
+
 
+
    [[Image:InstallUserUI.jpg]]
+
 
+
 
+
Now, when you start up the SDK, there will be a new menu entry (Help > Software Updates (Incubation), that you can use to manage and update the running application.
+
 
+
You can find out more about this UI in [[Equinox p2 Update UI Users Guide]]
+
 
+
== See also ==
+
 
+
If you encounter bugs, or would like to enter enhancement requests for this work, please use the Equinox Incubator category in [https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Equinox Bugzilla].  You can add the prefix "[prov]" to the subject line of the bug report to help us with bug triage.
+
 
+
For more detailed information, visit one or more of the following pages:
+
 
+
* [[Equinox p2]] Top level site for the provisioning work going on in Equinox.
+
* [[Equinox p2 Admin UI Users Guide]] For additional information about the agent UI you just used.
+
* [[Equinox p2 Update UI Users Guide]] Information about the "end user" UI that can be dropped into an SDK (or any other Eclipse RCP application).
+
* [[Equinox p2 Console Users Guide]] For OSGI geeks who enjoy starting and stopping bundles.
+
* [[Equinox p2 Getting Started for Developers]] For developers who want to create applications that extend or exploit equinox provisioning.
+
  
 
[[Category:Equinox p2|Getting Started]]
 
[[Category:Equinox p2|Getting Started]]

Revision as of 05:19, 27 February 2013

As of Eclipse project build I20080305 (shortly before Eclipse 3.4/Ganymede M6), the Eclipse SDK contains a new provisioning system called Equinox/p2. p2 replaces Update Manager as a mechanism for managing your Eclipse install, searching for updates, and installing new functionality. This document will help you getting started with p2. If you want to explore some of the capabilities of p2 that are not exposed to end users in the Eclipse SDK, see also Equinox/p2/Getting Started Admin UI.

p2 user interface

In the workbench, p2 replaces the Help > Software Updates menu entry from Update Manager. The resulting dialog shows the features that are installed, and the features that are available to install. You can add additional update sites by clicking Manage sites in the Available features pane. Or, simply drag and drop a URL link in a browser to the Available features pane. For example, dragging this link (http://download.eclipse.org/eclipse/testUpdates) will add the eclipse test updates site. Select any set of available features and click Install to install them into the current running system.

Equinox/p2/Update UI Users Guide provides more information about how the UI works.

You must modify the p2 UI code if you want to Run the p2 UI in a self-hosted workbench.

p2 basics

Disk layout

Before p2, many Eclipse users circumvented Update Manager and installed new plug-ins by dumping them in the eclipse/plugins/ directory and restarting with the -clean command line argument. There are many drawbacks to this "wild west" approach that we won't get into here, but suffice it to say that this approach to installation is not recommended. Although p2 will detect plug-ins added directly to the plugins folder (with an associated startup performance cost), alterations to plug-ins installed by p2 in this directory is not supported. If you manually remove a plug-in installed by p2, or attempt to replace with a different version, p2 will not detect it and may be broken.

The short rule of thumb is: if you added something manually, you can remove it manually. If you installed via p2, you should uninstall via p2. The shorter rule of thumb is: don't mess with the plugins folder if you can avoid it. p2 provides a new dropins folder that is much more powerful and allows separation of content managed by p2 from content managed by other means (described below).

When you install a p2-enabled Eclipse application, you will notice some new files and directories that didn't exist before. Here is a subset of a typical Eclipse install tree with some of this new content highlighted:

 eclipse/
   configuration/
     config.ini
     org.eclipse.equinox.simpleconfigurator/
       bundles.info
   dropins/
   features/
   p2/
   plugins/
   eclipse.exe
   eclipse.ini
   ...

The file bundles.info contains a list of all the plug-ins installed in the current system. On startup, all the plug-ins listed in this file are given to OSGi as the exact set of plug-ins to run with.

Any extra plug-ins in the plugins directory or elsewhere are ignored. If you really want to force Eclipse to startup with a particular set of bundles installed, you could manually edit this file to have the contents you need. However, unless you're just hacking around or testing, editing this file is not recommended. However, it's useful to know about this file so you can see exactly what is installed in the system you are running. Typically, p2 is the interface between this file and the rest of the world. Clients initiate provisioning requests to p2 via API, the GUI or some of the facilities described below, and as a result p2 may install or uninstall bundles from the OSGi runtime by updating the bundles.info file.

The new dropins folder is where you can drop in extra plug-ins if you don't want to use the p2 user interface. See the dropins section for more details. For backwards compatibility, p2 will also detect extra plug-ins dropped into the plugins directory, and install any discovered bundles into the system.

Note that the above tree is just a sample layout of an Eclipse-based application. Very little of this structure is actually guaranteed to take this shape. The configuration directory can be stored separately from the rest of the install using the -configuration command line argument. The bundles and features may be in a shared bundle pool elsewhere on disk. The eclipse.ini and eclipse.exe files may be branded with different names. The p2 directory may also be stored elsewhere when a single management agent is configuring multiple applications. In short, you should never write code that makes assumptions about the relative placement of files and directories in an Eclipse install.

Dropins

Provisioning operations should generally occur using the p2 UI, or by invoking p2 tools or APIs. However, there are situations where scripts need to install plugins and features via file system operations, and have the new content dynamically discovered by the system either at startup, or while running. To support this kind of low-level manipulation of the system, p2 supports the notion of watched directories. A watched directory is a place where a user or script can drop files and have them discovered by p2. Various policies can be applied to watched directories to configure when they are checked for new content, and whether to eagerly install discovered content.

The Eclipse platform ships with a default watched directory called dropins. The dropins folder is configured to be scanned during startup, and for changes to be immediately applied to the running system. Thus the dropins folder can be used much like the plugins directory was used in the past.

A subtle twist on old behavior here is that plug-ins and features added to the dropins folder are properly installed into the system rather than being forced in. This means p2 has an opportunity to confirm that the new plug-in doesn't conflict with other installed plug-ins, and it can even go out and fetch any missing prerequisites of the newly dropped in plug-ins. This also means you can later use the GUI to install extra functionality that depends on the plug-ins in the dropins folder, since p2 knows about them and can reason about their dependencies. In other words, new plug-ins installed via the dropins folder behave exactly like plug-ins installed via the user interface. Note that updating plug-ins which are located under the dropins folder using the p2 UI will result in the updated plug-ins being saved under the main eclipse/plugins and eclipse/features folders and not under the dropins hierarchy as siblings to the older versions of the plug-ins, as might be expected.

Supported dropins formats

The dropins folder supports a variety of layouts, depending on the scale of your application and the desired degree of separation of its parts. The simplest layout is to just drop plug-ins in either jar or directory format directly into the dropins folder:

 eclipse/
   dropins/
     org.eclipse.core.tools_1.4.0.200710121455.jar
     org.eclipse.releng.tools_3.3.0.v20070412/
       plugin.xml
       tools.jar
       ... etc ...
   ...

You can also drop in the traditional Eclipse application or extension layout directly in the dropins folder:

 eclipse/
   dropins/
     eclipse/
       features/
       plugins/

If you have various different components being dropped in, and you want to keep them separate, you can add an additional layer of folders immediately below the dropins folder that contain traditional Eclipse extensions:

 eclipse/
   dropins/
     emf/
       eclipse/
         features/
         plugins/
     gef/
       eclipse/
         features/
         plugins/
     ... etc ...

Finally, you can add link files as in the traditional Eclipse links folder:

 eclipse/
   dropins/
     emf.link

Debugging dropins

If you are attempting to use dropins, but your bundles are not being found, first ensure org.eclipse.equinox.ds and org.eclipse.equinox.p2.reconciler.dropins are marked to auto-start.

Resolution errors with dropins are silently ignored. To enable useful logging messages, place the following tracing options in your .options file:

org.eclipse.equinox.p2.core/debug=true
org.eclipse.equinox.p2.core/reconciler=true

and then run with "-debug path/to/.options"

Bundle pooling

Prior to p2, each Eclipse application had its own private plugins directory where the application's software was kept. This had the drawback that systems with two or more Eclipse-based applications installed ended up with significant duplication of software and other artifacts. Furthermore, the common pieces had to be upgraded separately for each application, often resulting in slow downloads of software already available elsewhere on the local system.

To escape from this duplication problem, p2 natively supports the notion of bundle pooling. When using bundle pooling, multiple applications share a common plugins directory where their software is stored. There is no duplication of content, and no duplicated downloads when upgrading software. A Windows system configured to use bundle pooling would have a layout something like this:

 Application1/
   configuration/
     config.ini
     ... other configuration files for Application1...
   Application1.exe
   Application1.ini
 Application2/
   configuration/
     config.ini
     ... other configuration files for Application2...
   Application2.exe
   Application2.ini
 ...
 Documents and Settings
   Username
     .p2/
       org/eclipse.equinox.p2.core
       org/eclipse.equinox.p2.director
       org/eclipse.equinox.p2.engine
       org/eclipse.equinox.p2.touchpoint.eclipse
         plugins/      <-- shared bundle pool

With this layout, all the software is stored in a single plugins directory outside of the application install area. p2 takes care of ensuring that the bundles needed by the various applications in the system are present in the bundle pool.

Installer

There is now an Equinox/p2/Installer that will install the Eclipse project SDK. The installer supports both traditional standalone installs, and installs using bundle pooling.

Running the p2 UI from a self-hosted workbench

We do not yet support a properly configured, self-hosted p2 system (see bug 224658). This means that if you run a self-hosted workbench, the launched Eclipse will not be p2 aware. The p2 UI will notice this and tell you that it cannot open.

If your desire is simply to develop or otherwise play with the new UI, and you don't care that the self hosted workbench is not provisioned, you can load the org.eclipse.equinox.p2.ui.sdk project and change this code in ProvSDKUIActivator.

 ProvSDKUIActivator.ANY_PROFILE = true;

This will allow you launch the UI, but please note that the UI will be operating on the installation profile of the host workbench.

Interaction with legacy Update Manager

In Eclipse platform version 3.4, the old Update Manager still exists under the covers for backwards compatibility. You can even re-enable the old Update user interface by enabling the "Classic Update" capability on the General > Capabilities preference page.

However, users will rarely have a need for enabling Update Manager, because p2 is able to install from any update site that was designed for Update Manager. Add the update site you want to use by dragging a URL from a browser into the Available Features page in the Help > Software Updates dialog. The features from that site will be added to the available features list, and from there you can install them into the system.

Links Folder

Update Manager supported the notion of an eclipse/links folder, where *.link files could be dropped in to connect extensions to an Eclipse-based application. For backwards compatibility the links folder is supported by p2 with the same behavior. This is really just a subset of the functionality available in the Dropins folder.

Removing p2

Equinox/p2/Removal describes the steps to completely remove p2 from the platform and revert to using the original Eclipse Update Manager. In addition, for Eclipse project 3.4 builds, there is a link on the right hand side of the download page called "Eclipse Classic Update Manager". This gives a link to a script that can be used to remove p2 from any Eclipse SDK, platform binary, or platform SDK build.

Removing p2 from the Eclipse SDK is no longer supported in Galileo (3.5) or later. However, the platform itself is not tied to any particular provisioning technology, so applications are free to choose an alternative provisioning system (or none) depending on their requirements.

Back to the top