Cool logo and cool sessions at ESE.

At ESE in a couple weeks we are running both an EclipseRT tutorial and symposium. A full day of runtime fun!  No idea what I’m talking about? EclipseRT is the community of people at Eclipse that are creating and using Eclipse technology in runtime (i.e., non-tooling) scenarios.

Turns out that there are a great number of projects involved and not just the ones in the RT top-level project.  BIRT, EMF, GEF, … all have runtime elements. The RT project itself hosts such leading runtime technology as Equinox (the OSGi and JSR232 reference implementation) EclipseLink (the JPA2 reference implementation), Jetty (very popular embeddable web server) and a host of other great projects like RAP, Riena, Swordfish, ECF, eRCP etc. No wonder we need a whole day to talk about all this.

The day starts with a 4 hour EclipseRT tutorial covering the Equinox, OSGi, server side use, tooling, RAP and single sourcing, Riena and EclipseLink. The tutorial will build on input from previous symposia where nearly everyone commented on the need for a good end to end example of Eclipse in the runtime world. We are using Toast, the example application from the upcoming OSGi and Equinox book and now part of the Eclipse Examples project.

After a full morning of learning, we’ll have a bit of an unconference style symposium to talk about issues and topics in the EclipseRT world. While the direction will depend significantly on who shows up, we hope to cover architecture and how promote integration and adoption, community issues such as release trains, repo organization etc and experience reports from the real world.

Presumably this will all be followed by a number of frosty beverages.

Check out the event wiki page for more information and evolving discussion topics.

Tags: equinox, events, OSGi, rap, riena, syndicate

The RAP team is proud to announce the second milestone for the Helios release.

As Holger already mentioned in his blog post, part of the milestone is a new design option for RAP applications. You can either use it as is or customize it depending on your needs.

Together with the new fancy design, there is also a new Configuration dialog to enable and disable the view actions per stack. Additionally we added an effect called Lightbox which occurs when the dialog is open.

Another thing I’m pretty excited about – the help system. The RAP runtime doesn’t provide everything you need for the whole help system, we just provide the infrastructure to plug in any help system implementation you want. Depending on your needs you can either use a pretty simple implementation or single-source the real help system implementation (org.eclipse.help.ui) yourself (great chance to get involved by the way).

For those of you who are working a lot with tabular data, we now provide cell tooltips on the TableViewer if you use a CellLabelProvider. This enables you to provide tooltips on the fly for all of your table cells.

Looking at this milestone in numbers, we fixed 100 bugs and resolved 36 enhancements – this includes another 23 new APIs that are now available for you. We’re pretty excited about the Helios release and looking forward to the next milestone.

Be sure to check out the whole New & Noteworthy as there are much more details we added in M2!

Tags: fancy, helios, milestone, new and noteworthy, rap, Single Sourcing

I wanted to share something I learned today about JUnit. Some of you may know this, but it was news to me.

My triggering problem was that I was writing some unit-tests which required OSGi to be started up. All my other tests were plain (i.e. non-OSGi) tests. Since I didn’t want to suffer from the startup delay every time I ran the unit tests, I thought about “ignoring” these OSGi dependent tests based on whether I was running plain tests or PDE tests. A bit of googling turned up an interesting feature of JUnit (since 4.4): Assumptions. Assumptions are defined in the Assume class and are basically the exact opposite of JUnit assertions: If an assumption fails, the test automatically passes. This keeps tests from failing when certain preconditions have not been met. Ideally these would be marked as “ignored” or “skipped” but still better than nothing (maybe someone with commit rights to the TestRunner could make this happen).

This neat feature allows us to do the following:

  @Before
  public void setUp() {
    Assume.assumeTrue( Activator.isOsgiRunning() );
  }

Now the tests will only be executed if they are running in an OSGi environment.

If you put this in an abstract base class that all PDE Tests inherit, these will be ignored when running in “plain” mode, for even quicker test runs. In that case be sure to name your @Before method in a unique way so it does not get overridden (and thus nullified) by subclasses.

These assumptions might also be useful for tests known to fail on particular platforms, JREs, runtime environments etc. Another neat addition to my toolbox. The bit of hair in this soup is that JUnit 4 support in Eclipse is a bit lacking, especially when it comes to the PDE build. Some of this is detailed in Bug #153429 which hopefully will be fixed in 3.6. (Hint: Vote!)

Tags: assume, assumptions, junit, pde build, pde test, preconditions, syndicate

In November, the Eclipse Foundation will be hosting EclipseRT Days in Austin and Toronto.

Besides the new logo above, EclipseRT is the portfolio of Eclipse projects that include runtime frameworks used to build and deploy running applications. EclipseRT is based on component oriented development architecture built on the Equinox runtime framework, an implementation of the OSGi standard.

EclipseRT Day is your opportunity to discover what is possible using Equinox and the complementary projects, such as EclipseLink, RAP and RCP. Experts from the EclipseRT community will discuss how you can build applications for embedded devices, desktops and even large scale server applications. IBM, SpringSource and TD Canada Trust will share their experiences of using Equinox and OSGi for their solutions.

In Austin, you’ll hear about topics like Equinox and OSGi, Modular Java Applications with Spring and Building Modular Applications for Embedded Devices.

In Toronto, you’ll hear about about topics like Java Persistence with EclipseLink, Managing your OSGi Runtime with p2 and e4 Overview and Demo.

The event is free, all you need to do is register.

Tags: eclipseRT

The second milestone (M2) of next years’ Eclipse Simultaneous Release called Helios is now available!

I am proud that I am able to announce the availability of the corresponding Helios EPP M2 packages. You can download them from the usual EPP nightly build page www.eclipse.org/epp/download.php.

It’s the first time ever that the EPP packages are available so soon in the yearly release cycle and I think it is a good opportunity to get a lot of early feedback. The Eclipse Platform team did this all the time, but hopefully this will help other projects to get more testing by the community.

Thanks to all that helped to make this happen!

Tags: epp, helios, milestone

Today I want to talk about one of the younger members in the Eclipse family: Jetty. It is great to have such an interesting project on board and it is yet another example of how Eclipse has become more than just an IDE.

What I wanted to with jetty was to create an executable, standalone and self-contained WAR. I first encountered this concept in Hudson. The hudson.war contains an embedded Winstone servlet container, which makes it possible to run the application by executing

java -jar hudson.war

This makes test driving the application really simple. The idea was to do the same with Jetty. Embedding the Jetty runtime in the war proved to be the easy part, as it was just a matter of declaring the jetty dependencies in the maven pom.xml.

The tricky part was telling jetty where to find the war-file to serve. My first try was to hardcode the filename, but that left a foul aftertaste. Finding a solution took quite some time, which is why I am posting this for future reference. This is the Main-Class used to bootstrap Jetty (adapted from the Wicket quickstart archetype):

import org.mortbay.jetty.Connector;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.bio.SocketConnector;
import org.mortbay.jetty.webapp.WebAppContext;
 
public class Start {
 
  public static void main(String[] args) throws Exception {
    Server server = new Server();
    SocketConnector connector = new SocketConnector();
 
    // Set some timeout options to make debugging easier.
    connector.setMaxIdleTime(1000 * 60 * 60);
    connector.setSoLingerTime(-1);
    connector.setPort(8080);
    server.setConnectors(new Connector[] { connector });
 
    WebAppContext context = new WebAppContext();
    context.setServer(server);
    context.setContextPath("/");
 
    ProtectionDomain protectionDomain = Start.class.getProtectionDomain();
    URL location = protectionDomain.getCodeSource().getLocation();
    context.setWar(location.toExternalForm());
 
    server.addHandler(context);
    try {
      server.start();
      System.in.read();
      server.stop();
      server.join();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(100);
    }
  }
}

The interesting bit is the getProtectionDomain()/getCodeSource() part, which tells us the location of the war-file. That’s all there is to it. Presto, executable web-application powered by Jetty in jar.

Edit: Added the import statements as per Tim’s suggestion.

Tags: embedded, executable, hudson, jetty, servlet container, syndicate, war

I was helping a colleague with some Eclipse install issues and was surprised he didn’t know about the ability to revert to a previous install configuration. Equinox p2 makes the revert process sane compared to the old Eclipse Update story. So everyone knows, to revert to a previous configuration of an Eclipse install, this is what you do…

First, open the About dialog and click the Installation Details button:

From the list, you can select a previous configuration and click the Revert button to go back in time:

It’s that simple!

As a bonus in Eclipse 3.6, you’ll be able to compare two configurations to see differences via the Compare button:

Once you do that, you should see a compare dialog with the changes:

Hope this helps!

Tags: p2

The Yoxos team has been really busy as of late. The free Yoxos OnDemand download service is getting lots of new function and with the release of Galileo SR1 last week, the OnDemand repositories have been updated to include all the latest Eclipse bundles.  Thousands of people use the free Yoxos service to reliably get and maintain their Eclipse tooling.  Now they can get the latest Eclipse and thousands of compatible components in one spot!

At the same time as doing all that, we worked to get the Yoxos SecureSource validation process certified by TÜV. Turns out that the TÜV certification is perhaps the news of biggest impact to the community. It means that you can now get thousands of OSGi and Eclipse components that have been validated as trustworthy using a process certified by an internationally recognized standards body.

Most Germans will know TÜV from the inspection they have to do for their cars every two years. TÜV engineers certify cars as roadworthy and safe. But TÜV does way more than that. It is a global organization specialized in testing, inspecting and certifying product safety, quality and usability in many areas. We looked around the office and found the all of these everyday TÜV certified things.

In addition to things impacting your physical safety, TÜV certifies all manner of software including virus checkers and now software component validation processes.

Why is this interesting?

Basically there are whole industries out there that cannot use Eclipse and open source because it’s seen as untrusted. This certification of Yoxos SecureSource means that Eclipse and OSGi can be used in security critical applications or mission critical toolchains where trust and validation are key concerns. More users of Eclipse in more domains means a bigger ecosystems and more adoption. Good news for everyone!

For fun, we looked around the office and found the all of these everyday TÜV certified things and thought it would be cool to run a contest. The first person to correctly identify 5 of the pictured TÜV certified products wins a free lifetime subscription to our new super secret Yoxos product coming out by the end of the year.

Submit your entry by commenting on this post.

Tags: eclipse, galileo, OSGi, securesource, TÜV, yoxos