Virgo Tools Guide

Ramnivas Laddad

Colin Yates

Sam Brannen

Rob Harrop

Christian Dupuis

Andy Wilkinson

Glyn Normington

Steve Powell

Christopher Frost

Miles Parker

Leo Dos Santos



Copyright © 2012 VMware Inc.

Table of Contents

1. Tooling
2. What's New
2.1. 1.0.0 Release
2.2. 1.0.0 M4
3. Running a Virgo Runtime Environment
4. Server Perspective and Views
4.1. Virgo Perspective
4.3. Virgo Server Projects
5. Server Editor
5.1. Overview Page
5.2. Repository Page
5.3. Bundle Overview Page
5.4. Bundle Dependency Graph Page
5.5. Server Console Page
6. Developing OSGi Bundles
6.1. Resolving Bundle Dependencies
6.2. Editing the Manifest
7. Developing PARs
8. Deploying Applications
9. Installation and Release Notes
9.1. Features
9.2. Installation
9.3. Known Issues
9.4. Migration
9.5. Maven plugin
9.6. Importing Virgo Projects into Eclipse
9.7. FAQ

1. Tooling

Virgo Tools support the Virgo runtime with tools for managing servers, server runtimes, and bundles. The IDE tools build on top of the Eclipse Web Tools Project (WTP) and collaborate with other Eclipse technologies such as the Eclipse Libra project.

Among other things, the Virgo Tools support the creation of new OSGi bundle and PAR projects within Eclipse, and the conversion of existing projects into OSGi bundle projects. Projects can then be deployed and debugged on a running Virgo Runtime from within Eclipse.

2. What's New

2.1 1.0.0 Release


We've added more views and other tools for working with Virgo Runtime instances. See the expanded Tooling Guide for more information on these new features.


In addition to the new Repository View, we've added:

Properties View

The properties view allows you to directly access all of those Virgo Runtime properties that are buried away in one file or another.

Logs View

The logs view gives you direct access to all of the relevant Virgo logs, no matter where they are located.

Virgo Server Projects

To support those new features, Virgo Tooling now maintains a project for each configured Runtime. Because these are Eclipse projects you can use all of the powerful Eclipse IDE tools to explore artifacts installed on the servers. (You shouldn't try to modify these projects directly though.) For example, you can use the JDT Type Hierarchy and Open Type tools.


  • We've addressed a number of significant bugs for the final release.

  • Clarified UI.

  • Improved documentation.

2.2 1.0.0 M4

We've made extensive changes throughout Virgo, focusing on quality and migration, but with a few new features as well.

Improved Server Support

Virgo now supports almost all versions and types of Virgo installs, including older versions of Virgo and Tomcat, Jetty and Kernel installations. Best of all, you can now define servers using a single Server Runtime and the tooling will automatically discover the appropriate server configurations. You can even change server installations and versions for server runtimes without having to maintain any server setttings.


We've provided a number of new features aimed at improving the user experience. We've been giving more transparency and leverage into what's actually happening on the server. Right now, interactions with the server involve frequent shifts back and forth between the Eclipse IDE, the native file system and the command line. Our ultimate goal is to have tools powerful and complete enough that you can work with the server without ever having to move out of Eclipse.

Virgo Perspective

You can now get your own perspective on Virgo. We've organized it to support runtime exploration but it should be usable for general development as well. Please give us feedback on the overall setup; we'll incorporate the feedback in future releases.


When we talked to current users of the Spring Source / Virgo tools, one of the things we discovered is that there were a lot of features that they wanted to have us implement that actually already existed, but in many cases were buried somewhere -- in many cases on a page in the server editor. So we're providing some of the information and tools that are provided in the WTP-based Server Editor as stand-alone views and enriching it. The idea is provide better insight into what's happening on the server side. Some of these features involve significant changes to how server resources are treated and we'd appreciate your feedback on how well they work for your usage scenarios. We'll use these changes as a basis for further enhancements.

Outline View

As a first take at helping users find what they're looking for, we provided an outline view that gives quick access to server artifacts.

Artifacts View

A new view supports transparent access to runtime artifacts. Currently, you can view bundle jars and libraries, but we'd like to support plans, pars, properties and other artifact types as well. But the real news is what we've built behind this -- Virgo runtimes are now exposed as Eclipse projects, giving you full access to the contents of jars, including classes. You can even use JDT tools like the Type view on Server side jar contents.

All of the new views are supported through the Eclipse Common Navigator Framework (CNF), which means that the views are highly configurable, and we've provided buttons to allow you to easily toggle on and off artifact types and present the artifacts in a tree or list view so that you can see all installed jars in one place.

Servers View

And because the views are all supported through CNF, you can easily customize them. For example, currently you can access all of the bundle information from the server view -- but we'll probably disable that by default in the release. In any case, you can set it up anyway you want by adding or removing the content provider. Again please let us know if you think of a way that we can improve the user experience for you.

Documentation and Help

The complete virgo documentation set -- including the Tooling, Programmer and User's Guide as well as the Wiki pages -- is now included as Eclipse Help.

Installation Process

Virgo Tools can now be installed from a single update site location.


  • Extensive bug fixes and re-factorings.

  • All Remaining Spring Dependencies have been removed.

  • Updated to meet Eclipse branding, packaging build and testing standards.

3. Running a Virgo Runtime Environment

After installing the Tools from the update site outlined in the previous section, you will be able to configure an instance of the Virgo Runtime inside Eclipse.

To do so bring up the WTP Servers view (i.e., WindowShow ViewOtherServerServers ). You can now right-click in the view and select " NewServer ". This will bring up a "New Server" dialog. Select Virgo Runtime in the "@runtime.category@" category and click " Next ".

Within the "New Server Wizard" point to the installation directory of the Virgo Runtime and finish the wizard. (The tools will automatically detect the type of server install, so you can point to a Virgo Server for Apache Tomcat, Virgo Jetty Server, Virgo Kernel or any other supported Virgo Runtime.)

After finishing the wizard you should see a Virgo Runtime for the relevant server type in the Servers view.

To start, stop, and debug the created Virgo Runtime instance use the toolbar or the context menu actions of the Servers view.

4. Server Perspective and Views

4.1 Virgo Perspective

The Virgo perspective provides an environment customized to support configuring and running Virgo Runtime Environment instances, including views for working with Virgo Runtimes. To switch to the Virgo Perspective from your current perspective, select WindowShow PerspectiveOther... And select "Virgo".


You can explore the contents of installed servers using the Virgo Server Views. These views are designed to help you get to resources on the server without having to switch to the native file system, and integrate those resources with other Eclipse IDE tools. (You can also use the Virgo views from within other perspectives, of course. Select WindowShow ViewOther... and then open the "Virgo" folder to display them.)

Repository View

The Virgo Repository view allows you to work directly with the contents of installed bundles and libraries on Virgo Runtime instances.

To view resources, select a repository in the Servers View. You can customize what and how they are displayed using the view toolbar buttons.

You can select multiple respositories as well, allowing you to easily navigate and compare resources on multiple servers. You can double-click on items, open them, and even explore class hierchies and other Eclipse features by right clicking on the repository resources.

Hint: In the example below we have selected the Flat Layout and can see that javax.ejb library is present in one Virgo Runtime, but not the other.

Properties View

The Virgo Properties view allows you to inspect the properties of Virgo Runtime instances. Rather then digging through files on the server instance to find the parameters you need to adjust, simply select the server(s) you want to find parameters for, and a list of properties files will be displayed in the editor. To open a file in the appropriate Eclipse editor, just double-click on it. Or open a tree node and double-click on a specific property and the property value will be highlighted for editing.

Hint: Not sure where a given property is even located? You can easily see all properties within a given Virgo Runtime across all properties files, sorted by name. Click the "List" button in the view toolbar. You can even see properties across runtime instances by selecting multiple servers in the Server View.

Logs View

The Virgo Logs view supports easy access to runtime log files. As with the other views, just select the Virgo Runtime instance(s) you are interested in. Then double-click to open the relevant log file.

Console View

The Console view is the same view that is used in the Java and other perspectives. It displays the console activity for the last server instance you launched, assuming that you haven't launched another console hosted process in the mean-time. (This view is not connected to the Server View -- if you want to examine consoles for differnt running servers, click the "Down Triangle" icon in the view toolbar and select the appropriate console.)

4.3 Virgo Server Projects

To support all of the view features, projects are created within your workspace. These are managed automatically and shouldn't be modified, deleted or renamed. But you can explore these artifacts directly from the project and package explorers and with other Eclipse tools.

Hint: For example, you can find out what classes are available on Virgo Servers using the Type and Resource search dialogs. Just select Navigate and enter a search pattern.

5. Server Editor

After successful configuration of an instance of the Virgo Runtime Environment in Eclipse you can use the server editor to configure and explore many different aspects of the Virgo Runtime instance. To open a server editor double-click a Virgo Runtime instance in the Servers view.

5.1 Overview Page

The server overview page is the first page of the editor. Please note that opening of the Editor may take a few seconds as the contents of the local repository needs to be indexed before opening.

See the Web Tools Platform Guide for more information on what the various configuration options do.

5.2 Repository Page

The Repository Browser allows you to see what bundles and libraries are available on the @product.instance and to very easily install bundles and libraries from the remote Enterprise Bundle Repository. To view resources installed on the Server select the "Repository" tab in the server editor.

The left section of the Repository Browser allows the user to run searches against the SpringSource Enterprise Bundle Repository and displays matching results. The search can take parts of bundle symbolic names, class or package names and allows wildcards such as ‘?’ and ‘*’. By selecting the checkbox left to a matching bundle and/or library and clicking the "Download" button it is very easy to install new bundles in the Virgo Runtime. For your convenience JARs containing the bundle source code can be automatically downloaded as well.

Clicking the "Download" button will trigger an Eclipse background job that will download the selected repository artifacts and -- if desired -- the source JARs one after another.

The section on the right displays the bundles and libraries that exist on the server. Bundles with available sources are visually marked. You can very easily download missing source JARs by using the "Install Sources" button. Note that these bundles may or may not be actually "installed" on the Virgo Runtime in the sense that they are known to it -- they may simply exist in the respective directories.

5.3 Bundle Overview Page

To view and control resources actually installed on the Server select the "Bundle Overview" tab in the server editor.

Here you can start, stop, refresh and update bundles, as well as view detailed information about the bundle. Note that information about running bundles cannot be displayed unless the server is actually running. You can refresh the list of bundles by selecting the refresh button in the upper-right-hand corner of the "Bundle Status" section.

Click the "Show dependency graph for bundle" link to bring up the Bundle Dependency Graph page focused on the selected bundle. See the next section.

5.4 Bundle Dependency Graph Page

The "Bundle Dependency Graph" tab takes you to a page where you can visualize the complex relationships between bundles.

You can view package or services relationships by selecting the relevant radio button in the "Configuration" section. The "Incoming" and "Outgoing" controls define how many levels of dependencies are shown. For example, if you select a value of 2 for Incoming, the graph will who items that the selected bundle(s) are dependent on as well as the bundles that those bundles are then dependent on.

Use the search text area in the editor header to select the source bundles for the graph. Wild cards are supported. Click the refresh button to update the bundle graph.

5.5 Server Console Page

The "Server Console" tab takes you to an interactive console for exploring and managing the state of a running server. (This console is different from the "Console View", which displays the log output of running server instances.) Enter text in the "Command" text area and click the "Execute" button or press RETURN to execute the command.

For a list of available commands and how to use them, see the Virgo Shell Command Reference sub-section of the Equinox Console section in the Virgo User Guide

6. Developing OSGi Bundles

The Tools provide functionality that makes developing OSGi bundles, especially the editing of MANIFEST.MF files, easier.

6.1 Resolving Bundle Dependencies

While working with OSGi bundles, one of the most interesting and challenging aspects is defining the package, bundle, and library imports in the manifest and then keeping this in sync with your compile classpath either in Ant and Maven or Eclipse. In most cases you would typically be required to manually set up the Eclipse classpath. Ultimately, the Eclipse compile classpath is still different from the bundle runtime classpath, as normally an entire JAR file is being made available on the Eclipse classpath but not necessarily at runtime due to the explicit visibility rules defined in Import-Package headers.

The Tools address this problem by providing an Eclipse classpath container that uses an Virgo Runtime Environment-specific dependency resolution mechanism. This classpath container makes resolved dependencies available on the project’s classpath but allows only access to those package that are imported explicitly (e.g., via Import-Package ) or implicitly by using Import-Library or Import-Bundle .

To use the automatic dependency resolution, an OSGi bundle or PAR project needs to be targeted to a configured Virgo Runtime Environment instance. This can be done from the project’s preferences by selecting the runtime on the "Targeted Runtimes" preference page.

In most scenarios it is sufficient to target the PAR project to a runtime. The nested bundles will then automatically inherit this setting.

After targeting the project or PAR you will see a "Bundle Dependencies" classpath container in your Java project. It is now safe to remove any manually configured classpath entries.

The classpath container will automatically attach Java source code to the classpath entries by looking for source JARs next to the binary JARs in the Virgo Runtime Environment’s repository. You can also manually override the source code attachment by using the properties dialog on a single JAR entry. This manual attachment will always override the convention-based attachment.

6.2 Editing the Manifest

The Tools provide a Bundle Manifest Editor that assists the developer to create and edit MANIFEST.MF files. The editor understands the Virgo Runtime Environment specific headers like Import-Library and Import-Bundle and provides content assist features while editing source code. Furthermore a Eclipse Form-based UI is also available.

To open the Bundle Manifest Editor right click a MANIFEST.MF file and select "Bundle Manifest Editor" from the "Open With" menu.

Please note that the Virgo Runtime Environment specific manifest headers appear in green color to distinguish them from those headers defined in the OSGi specification. This also makes navigating much easier.

The content assist proposals in the source tab as well as in the UI-based tabs are resolved from the bundle and library repository of an installed and configured Virgo Runtime Environment. Therefore it is important to target the project or PAR to a specific Virgo Runtime instance to indicate to the tooling which bundle repository to use.

If a OSGi bundle project is not targeted to a Virgo Runtime instance, either directory or indirectly via a PAR project’s targetting, the manifest editor will not be able to provide content assist for importing packages, bundles, and libraries.

The Dependencies tab of the Bundle Manifest Editor enables the user to easily download and install bundles and libraries from the SpringSource Enterprise Bundle Repository by using the "Download..." buttons next to the "Import Bundle" and "Import Library" sections.

7. Developing PARs

In Virgo, applications consisting of multiple bundles can be packaged as a PAR.

To create a PAR, right-click in the Package Explorer and select NewProject… . In the dialog that opens select EclipseRTPAR Project and press Next :

In the New PAR Project dialog, ensure the Use default location option is unchecked, enter a suitable name for the project, set the location to a suitable directory, and press Next . For example, the Greenpages sample PAR project would look like this:

In the next dialog, some of the PAR properties are pre-populated. Set the Application Name and the Version as appropriate, then ensure that the Target Runtime is set to Virgo Web Server (Runtime) ... and press Next . For example:

In the next dialog, select the bundles so that they are contained in the PAR and press Finish . For example:

The PAR project is then created.

8. Deploying Applications

Currently the Tools support direct deployment of WTP Dynamic Web Projects, OSGi bundle and PAR projects to the Virgo Runtime from directly within Eclipse.

To deploy an application to the Virgo Runtime Environment just bring up the context menu on the configured Virgo Runtime runtime in the Servers view and choose "Add or Remove Projects...". In the dialog, select the desired project and add it to the list of "Configured projects".


Deploying and undeploying an application from the Virgo Runtime certainly works while the Virgo Runtime Environment is running, but you can also add or remove projects if the Virgo Runtime is not running.

Once an application is deployed on the Virgo Runtime Environment the tooling support will automatically pick up any change to source files -- for example, Java and XML context files -- and refresh the deployed application on the Virgo Runtime.

The wait time between a change and the actual refresh can be configured in the configuration editor of the runtime. To bring up that editor, double-click on the configured Virgo Runtime Environment instance in the Servers view.

9. Installation and Release Notes

9.1 Features

The Virgo Tooling/IDE concept concerns the whole Virgo tooling (that was available inside SpringSource Tool Suite) being put in a separate project. The tooling supports the following:

  • Bundle projects

  • Par projects

  • Plan files/projects

  • Web Bundles

  • Deployment to a Virgo Server in the server view.

9.2 Installation

Install Eclipse

If you're not installing into an existing Eclipse, you'll need one.

  • Eclipse Indigo 3.7.x or Indigo based suite such as SpringSource Tool Suite 2.9.x

  • Eclipse Juno 3.8/4.2

Eclipse JEE Indigo recommended.

Install Virgo

  1. Select Help>Install New Software..

  2. Enter one of the Virgo update sites below.

  3. Select "Virgo Tools" feature and click install.

<span style="color:#FF0000"><b>Note:</b> Select <i>only</i> Virgo Tooling. This is a composite site, and the other features are <i>not</i> designed to work within the Eclipse IDE.</span>

Update Sites

Many users will also want to install the M2E release at: <code>;/code&gt;. (You'll need this to run the greenpages examples.)

9.3 Known Issues

9.4 Migration

From Pre M2 to M4

Server Versions

The good news: We have done away with the need for managing multiple server versions. This also means that we won't have to support multiple WebTools Server Runtimes and Servers which will make adding new servers and variants much easier. See for more details.

The bad news: Any Server Runtimes that you already created for Virgo Server 3.5 will not work -- and you will see nasty exceptions if you try to use them. But since pre-M4 Virgo Tooling didn't work with Virgo Server 3.5 anyway, this should be a moot issue for most people.

What to do: If you have an existing (i.e., created using Virgo IDE installed before 10 March 2012) Virgo Server 3.5 Runtime defined, just delete it and replace it with a new Virgo Runtime in Preferences:Server:Runtime Environments. You'll see that the correct version is discovered automatically. Then, open any Servers that uses the old runtime and select the new one from the Runtime Environment popup menu.

From Spring Source and Virgo 2.x Tooling

Moving from the old tooling to the new requires some changes to your existing projects, these are documented here.

The Bundlor .settings file has a new name ( com.springsource.server.ide.bundlor.core.prefs -&gt; org.eclipse.virgo.ide.bundlor.core.prefs) and the property keys in it have new names as well. Currently these just need to be changed manually (replace com.springsource.server by org.eclipse.virgo) or use the project properties pane to create new settings and delete the old one. (recommended)

The Bundle Dependencies classpath entry has a new name ( com.springsource.server.ide.jdt.core.MANIFEST_CLASSPATH_CONTAINER -&gt; org.eclipse.virgo.ide.jdt.core.MANIFEST_CLASSPATH_CONTAINER). This can be changed manually (in the .classpath file) or in the Java Build Path section of the project properties.

The attributes used to mark folders as test folders have been renamed ( com.springsource.server.ide.jdt.core.test.classpathentry -&gt; org.eclipse.virgo.ide.jdt.core.test.classpathentry). This can be changed manually (in the .classpath file).

The PAR and Bundle nature have been renamed ( com.springsource.server.ide.facet.core.bundlenature -&gt; org.eclipse.virgo.ide.facet.core.bundlenature and ( com.springsource.server.ide.facet.core.parnature -&gt; org.eclipse.virgo.ide.facet.core.parnature)). This can be changed manually (in the .project file).

The format and name of a PAR project changed. Rename .settings/com.springsource.server.ide.runtime.core.par.xml to .settings/org.eclipse.virgo.ide.runtime.core.par.xml. Inside the file rename occurences of com.springsource.server to org.eclipse.virgo.

Snapshot build change: We've made a change in our tooling that will require modifying the org.eclipse.virgo.ide.runtime.core.par.xml file so that it points to the correct par.ecore URI. Rename xmlns:com.springsource.server.ide.par=" http:///com/springsource/server/ide/par.ecore&quot; to "xmlns:org.eclipse.virgo.ide.par=";

Inside the WST settings file ( .settings/org.eclipse.wst.common.project.facet.core.xml) rename occurences of com.springsource.server.bundle to org.eclipse.virgo.server.bundle and occurences of com.springsource.server.par to org.eclipse.virgo.server.par.

Most/all of the conversion should be done by the following script (it has only see marginal testing, use at your own risk): < pre>#!/bin/sh

  1. NOTE1: Run this at your own risk&nbsp;:)

  2. NOTE2: I should quote more dots in sed expressions but I'm lazy.

  3. TODO: Delete old com.springsource files after conversion

if -d &quot;$1&quot; ; then

       echo &quot;Please point me at an eclipse project&quot;&amp;nbsp;; 
       exit 1


  1. Bundlor settings

f="$1/.settings/com.springsource.server.ide.bundlor.core.prefs" [ -f "$f" ] &amp;&amp; (

       echo &quot;$1: Converting bundlor preferences&quot;
       sed -e 's/com\.springsource\.server/org.eclipse.virgo/g' &quot;$f&quot; &amp;gt; &quot;$(echo $f | sed -e s/com.springsource.server/org.eclipse.virgo/)&quot;


  1. convert PAR

f="$1/.settings/com.springsource.server.ide.runtime.core.par.xml" [ -f "$f" ] &amp;&amp; (

       echo &quot;$1: Converting PAR project dependencies&quot;
       sed -e 's/com\.springsource\.server/org.eclipse.virgo/g' &quot;$f&quot; &amp;gt; &quot;$(echo $f | sed -e s/com.springsource.server/org.eclipse.virgo/)&quot;


  1. Fix classpaths

f="$1/.classpath" [ -f "$f" ] &amp;&amp; (

       echo &quot;$1: Converting classpath containers and entries&quot;
       sed -i \
               -e 's/com.springsource.server.ide.jdt.core.MANIFEST_CLASSPATH_CONTAINER/org.eclipse.virgo.ide.jdt.core.MANIFEST_CLASSPATH_CONTAINER/g' \
               -e 's/com.springsource.server.ide.jdt.core.test.classpathentry/org.eclipse.virgo.ide.jdt.core.test.classpathentry/g' \


  1. Fix natures..

f="$1/.project" [ -f "$f" ] &amp;&amp; (

       echo &quot;$1: Converting project natures&quot;
       sed -i \
               -e 's/com.springsource.server.ide.facet.core.bundlenature/org.eclipse.virgo.ide.facet.core.bundlenature/g' \
               -e 's/com.springsource.server.ide.facet.core.parnature/org.eclipse.virgo.ide.facet.core.parnature/g' \


  1. Fix the wst file, could also replace runtime name here

f="$1/.settings/org.eclipse.wst.common.project.facet.core.xml" [ -f "$f" ] &amp;&amp; (

       echo &quot;$1: Converting org.eclipse.wst.common.project.facet.core.xml&quot;
       sed -i \
               -e 's/com.springsource.server.bundle/org.eclipse.virgo.server.bundle/g'  \
               -e 's/com.springsource.server.par/org.eclipse.virgo.server.par/g'  \



9.5 Maven plugin

To support the development of OSGi bundles for Eclipse Virgo with Maven a Maven plugin is available. This plugin is able to start/stop a local Eclipse Virgo instance. Moreover it is possible to deploy/undeploy/refresh bundles via Maven.


In order to use the plugin one has to download the source code from Github&nbsp;and build the binary manually. This can be easily done by executing the following Maven command in the root folder of the plugin where the pom.xml file is located. < pre>mvn clean install</pre> Moreover to generate the documentation just execute the following Maven command (or take the one provided in the repository on Github). < pre>mvn clean&nbsp;plugin:xdoc javadoc:javadoc jxr:jxr site < /pre>


The plugin provides a set of Maven goals that allow different actions.

Goal Description
<code>virgo:start</code> Starts a Virgo instance by executing the provided startup script. <br>
<code>virgo:shutdown</code> Stops a running Virgo instance.
<code>virgo:immediateShutdown</code> Stops a running Virgo instance immediately.
<code>virgo:deploy</code> Deploys an OSGi bundle to a running Virgo instance.
<code>virgo:undeploy</code> Undeploys an OSGi bundle from a running Virgo instance.
<code>virgo:refresh</code> Refreshs an already installed module on a running Virgo instance.
<code>virgo:bundleRefresh</code> Refreshs an already installed OSGi bundle on a running Virgo instance.

Simple example POM

Once the plugin has been build and installed in the local Maven repository it can be used within a Maven project. Following is a simple example of a pom file that uses the Maven plugin.&nbsp; < pre>&lt;project xmlns="; xmlns:xsi="; xsi:schemaLocation=";&amp;gt; &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt; &lt;groupId&gt;org.example.osgi&lt;/groupId&gt; &lt;artifactId&gt;test-bundle&lt;/artifactId&gt; &lt;version&gt;0.0.1-SNAPSHOT&lt;/version&gt; &lt;packaging&gt;bundle&lt;/packaging&gt; &lt;name&gt;OSGi Test Bundle&lt;/name&gt; &lt;properties&gt; &lt;;UTF-8&lt;/; &lt;/properties&gt; &lt;build&gt; &lt;plugins&gt; &lt;plugin&gt; &lt;groupId&gt;org.apache.felix&lt;/groupId&gt; &lt;artifactId&gt;maven-bundle-plugin&lt;/artifactId&gt; &lt;version&gt;2.3.6&lt;/version&gt; &lt;extensions&gt;true&lt;/extensions&gt; &lt;configuration&gt; &lt;instructions&gt; &lt;Bundle-SymbolicName&gt;${project.groupId}.${project.artifactId}&lt;/Bundle-SymbolicName&gt; &lt;Bundle-Name&gt;${}&lt;/Bundle-Name&gt; &lt;Bundle-Version&gt;${project.version}&lt;/Bundle-Version&gt; &lt;/instructions&gt; &lt;/configuration&gt; &lt;/plugin&gt; &lt;plugin&gt; &lt;groupId&gt;net.flybyte.virgo&lt;/groupId&gt; &lt;artifactId&gt;virgo-maven-plugin&lt;/artifactId&gt; &lt;version&gt;1.0.0&lt;/version&gt; &lt;configuration&gt; &lt;virgoRoot&gt;C:/Java/virgo-tomcat-server-3.0.2.RELEASE&lt;/virgoRoot&gt; &lt;/configuration&gt; &lt;/plugin&gt; &lt;/plugins&gt; &lt;/build&gt; & lt;/project&gt; < /pre> More examples can be found in the documentation. Following are some exemplary Maven commands. < pre>mvn virgo:start &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &lt;-- will start a Virgo instance mvn clean package virgo:deploy &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&lt;-- will create an artifact and deploy it to Virgo</pre>

9.6 Importing Virgo Projects into Eclipse

See Eclipse Setup under the Committers tab.

9.7 FAQ

  • How do I turn on (or turn off) automatic Manifest generation? (Bundlor)

Bundlor is not used by default, you must create you own template file and then turn on incremental manifest generation. Right-click your Virgo project, select the Virgo subcategory from the context menu and select Enable (or Disable) Incremental Generation of MANIFEST.MF File. You can also modify this setting from the Overview page of the Bundle Manifest Editor, under the Bundle Actions section.

  • Sometimes I'd like to automatically update my Manifest without having to turn on the automatic Manifest setting. How can I do this?

Right-click your Virgo project, select the Virgo subcategory from the context menu and select Run Generation of MANIFEST.MF File. This command has a keybinding that you may customize through Eclipse's Keys preferences. You can also perform an automatic update of the Manifest from the Overview page of the Bundle Manifest Editor, under the Bundle Actions section.

  • Automatic Manifest generation doesn't appear to picking up changes to my source files.

Sometimes Manifest generation may behave differently depending on whether the tools are configured to scan source folders or to scan output folders. To modify this setting right-click your Virgo project, select properties and select the Virgo -> Manifest Generation subcategory. If Manifest generation isn't working correctly for you, uncheck the "Scan output folders instead of source folders to generate MANIFEST.MF" setting and re-run the Manifest generation. If your Manifest is not being properly generated under either setting, please file a bug.


  • My Virgo project is validating its dependencies against the wrong Virgo runtime! How do I manage server runtimes for my Virgo projects?

If you've deployed your Virgo projects to multiple Virgo runtimes the tools will associate the project with each runtime, but will only validate against one runtime. In order to manage which Virgo runtime your bundle dependencies are validated against, right-click on the project, select Properties and select the Targeted Runtimes category. From this dialog you can give priority to a particular Virgo runtime.


  • How do I deploy a Plan with the Virgo tools?

Deploying a Plan works much the same way as deploying a Bundle or PAR from the tools. Unfortunately, the tools only handle Plan deployment correctly when the Plan refers to items already in Virgo's watched repository directories. If you try to deploy a Plan that references a project in the Eclipse workspace, the tools will fail. One workaround is to copy your workspace bundle(s) into repository/usr or some other watched repository directory. A discussion of this bug and other workarounds is available at

  • How do I create a Web Application Bundle?

To create a web application bundle choose to create a normal bundle project, but on the Bundle Content panel select the additional property entitled "Web Application Bundle". On the Bundle Properties panel enter a suitable context path for the application as the Web-ContextPath.

  • How do I export a Web Application Bundle (WAB)? Export -> Bundle Project produces an incorrect product.

To export a WAB invoke Export -> Web -> WAR File

This can happen after starting VJS clean because VJS is looking for a directory at $KERNEL_HOME/work/tmp but no tmp directory exists. A workaround is to start VJS from the command line without the -clean command, which will create the tmp directory. VJS can then be used from the tools. This bug and workaround are documented at

  • Can I get a deeper look into the state of the server from the Virgo Tools?

Yes! If you double-click a Virgo server runtime in the Servers view, you'll open up the server editor, with several pages of information. The Repository, Bundle Overview, Bundle Dependency Graph, and Server Console pages all give valuable insight into the state of the server. The Virgo perspective also provides several views into the Virgo Repository, Virgo Properties and Virgo Logs. See the Virgo Tooling Guide for more information.

  • I want to install Virgo Tools. Should I install all of this neat looking stuff under Virgo Add-ons?

We really don't recommend doing so (see Install_Virgo). Select only Virgo Tooling and Eclipse will take care of installing anything the tooling relies on.

  • Can I use the Virgo Tools with traditional PDE/Equinox Bundles?

Deploying PDE/Equinox Bundles to Virgo Web Server are not yet supported yet, although exporting the bundles (as Eclipse Plug-in JARs) and manually deploying to Virgo Web Server works. Please show your support on Bugzilla #329198.

Category:Virgo Category:EclipseRT</rev></revisions></page></pages></query></api>