Jump to: navigation, search

WTP/Build/WTP Patches for Release 2.0.2

What is an "official patch"?

Under some circumstance the WTP project may find it desirable to produce a "feature patch" which typically includes exactly one jar, that has a fix for exactly one bug. These are done for bugs which happen to be considered extremely severe or blocking -- but may not even apply to all installs, or all users. So, as a general rule, they are not to be installed by everyone ... but any bugs fixed by patches will be fixed in the next maintenance release, if there is one ... though the exact fix might be different.

While few, it is important to create and apply these in a controlled, repeatable process in order to maintain product level professional quality. For example, it is important to compile with exactly the same compiler, and exactly the same "pre-reqs" that was used to create the original build.


Technical Notes

Normally, only the "releng team" need to mess with patches. There should be very few, very special purpose, handled and produced on a case-by-case bases.

For WTP 2.0.2 these fixes and related files will be released to the R2_0_2_patches stream. (If there is not already such a stream for a component, it will of course have to be created, by branching from the R2_0_maintenance stream). For those projects at the 1.0.2 level (JSF and JPT) the same is true except it's the R1_0_2_patches stream.

We do it this way so the main maintenance branch remains exactly like it was for release. If it is ever decided to do a 2.0.3 release, that will be the time to merge back the patches branch to the maintenance branch (if appropriate).

The map files used during a build will to be pulled from the R2_0_2_patches branch (or R1_0_2_patches). All the maps files have already been branched. So ... those are the branches to release changes to, for patch builds.


There is a special component

wtp-patches2

in the releng.wtpbuilder cvs project that along with special distribution targets

patches2.build
patches2.site
patches2.upload
patches2.tests

will produce patch features that contains a special feature to "host" the plugin. See Eclipse Help for details on patch features.

The patch feature is typically a "brand new" feature, and must be added to a map file (in the patches stream). Of course, if that feature already exists, and another plugin is being added to it, then it only needs the new version released to the patches branch.

These patch features must correspond to the "build component features" since those are the assumed lowest unit by which anyone consumes our features (for example, xml_core.feature.patch ... usually not lower, such as xsd.feature.patch, nor higher, such as wst.feature.patch).

The end-result is

  • a compressed archive (zip file) on http://download.eclipse.org/webtools/patches/2.0.2/
  • a feature and plugin suitable for an update site. These update jars are actually in the same directory as the zip download, but normally not visible from the download web page, but when appropriate will be copied to the official /webtools/updates site.

If it is desired to be generally available to all WTP users (by them using the Eclipse Update Manager), then the update features and plugins have to be copied to the downloads/webtools/updates directory. If update is done, remember to

  1. update the site.xml
  2. recreate the digest
  3. run pack200

Bugs which will be made public on update site must go through PMC Review and typically some regression testing before being put on update site, since in theory any such fixes could effect other adopters/products, so they deserve extra review.

Getting the feature patch in to a build

There is a special feature that drives the patch build:

org.eclipse.wtp.patch.assembly.feature

The feature patch which hosts the fixed bundle needs to be added to this special feature, and all released to the releng project (maps) in the patches branch.

The patch build is not done automatically but must be started manually from the "force build" button on the dashboard.

Conventions

  1. Remember to increment the service field of any plugins by +1.
  2. The version of the feature patch should "match" the feature version it corresponds to (e.g. 2.0.2.qualifier).
  3. update the features.properties file so it lists the bug that is fixed by the patch.
  4. update or provide a buildnotes_x file that lists the bug fixed by the patch.

Reminders

These are tips on avoiding problems that have been hit before. They are especially problematic, since everything may appear to work fine, but then various install or update manager scenarios will not work.

  1. The patch feature must "requires" the feature that it is patching, including all 4 fields of the version -- the 'qualifier' field is not computed automatically during the batch build, as other qualifiers are. This won't show up as a problem just unzipping the features and plugins, but will when update manager is used.
  2. Remember to "match" features and patch features ... that is, if a plugin is in another feature, besides the one that the patch feature 'requires', then various paths of using update manager won't work. For WTP, this is most easily accomplished by having patch features which parallel the build component features.
  3. Be positive that the "unpack" attribute of the include plugin element is exactly the same in the original feature, and the patch feature. If it was unpacked in the original, it must be unpacked in the patch. Again, this won't often show up as a problem until much later in the process.

Examples/Samples

You can check out modules from the R2_0_2_patches branch to see existing patch features to use as a starting point.

Questions

Feel free to ask questions on wtp-releng@eclipse.org if there are questions.


Back to WTP Build Process and Procedures