Red Hat

Latest Articles

JBoss Tools 4.1 and Red Hat JBoss Developer Studio 7 go GA

posted by Fred Bricon on Jul 23, 2013. jbosstools jbds mobile

On behalf of the JBoss Tools and Developer Studio team, I’m extremely proud to announce the general availability of the JBoss Tools 4.1.0.Final and Red Hat JBoss Developer Studio 7.0.0.GA releases.

JBoss Tools is a set of plugins for Eclipse that complements, enhances and goes beyond the support that exists for JBoss and related technologies in the default Eclipse distribution.

Red Hat JBoss Developer Studio is a fully bundled Eclipse distribution which not only includes the majority of JBoss Tools but also all its needed dependencies and 3rd party plugins allowing for an easy one-click and no-fuss installation.

If you are into doing your own bleeding edge Eclipse plugin assembly, JBoss Tools is for you; if you are more into having something that "Just Works" then JBoss Developer Studio is the way to go.

Installation

JBoss Developer Studio is available with a one-download-installer with everything bundled and configured out of the box.

You can also install JBoss Developer Studio or JBoss Tools from Eclipse Marketplace via "Help > Eclipse Marketplace…"

When installing from Eclipse Marketplace we recommend using a fresh Eclipse 4.3 JEE Bundle since then you’ll have most of the dependencies pre-installed.

SOA tooling for BPEL, Drools, Guvnor, jBPM, ESB, Modeshape, pi4soa, Savara, SwitchYard & Teiid, in future referred collectively as the JBoss Tools or JBoss Developer Studio Integration Stack (JBT-IS or JBDS-IS), are not yet available for this release. They will become available separately later. If you wish to use these today we recommend you continue to use JBoss Tools 3.3 or JBoss Developer Studio 5.0, or try one installing the latest unsupported nightly build from this update site:

http://download.jboss.org/jbosstools/updates/integration/kepler/integration-stack/aggregate/4.1.0/

Performance and stability improvements

JBoss Tools 4.1.0 and JBDS 7.0 are built on top of Eclipse Kepler (e4.3), which brought noticeable performance and stability improvements over the previous Juno version (e4.2). But we also improved the performance in some of our own features (Central, JAX-RS tooling, Web Service testing).

We worked really hard to fix more than 1600 bugs and feature enhancements into this release.

We have so much good stuff this time around, it’s hard to cram everything into a (readable) blog post, so I’ll just present the major features we have here, introduced since JBoss Tools 4.0 and JBDS 6.0. But make sure to read the complete New and Noteworthy for a more detailed and complete overview.

TL;DR: The recurring theme of this release is "HTML5 and mobile development". Burr Sutter made a screencast highlighting several of the new features available in this release :

LiveReload

Probably the coolest new features we have, the new LiveReload server allows you to have your browser automatically refresh when you save your html, javascript and css files.You can just focus on content and functionality and instantly see and use the changes in your browser. If it is hard to imagine how it works, Xavier Coulon made a video showing how to activate and use it (on the right).

You should install a LiveReload plugin/extension into your browser as documented in our What’s New and Noteworthy. If you can’t, don’t worry, keep reading.

LiveReload supports local (i.e. file:// based urls) or content served out from an application server. In the latter case, the browser will reload once the files are published on the application server, especially useful when editing JSF content like xhtml.

You can right-click on files in the Project Explorer view or on modules deployed to a server, to load your Browser with a LiveReload enabled page. This action will setup the LiveReload server for you if it does not already exist :

Our server implements the existing defacto protocol used by the original LiveReload and related plug-ins, meaning any browser, script and tool that works with live reload today should work with our Eclipse implementation of it.

It’s really nice to have instant feedback for HTML5/JS based applications. But wait, it’s getting even better.

Proxying and Open in external Device

If your browser does not have the LiveReload plugin, like Safari or you’re using a mobile device, you would normally manually add a livereload.js loading snippet in every web page. That can be tedious and requires changes to files you might not want to commit to your source repository. It’s alright. Please meet our "LiveReload Proxying" :

LiveReload open in web browser via qrcode dialog

It is enabled by checking "Inject the livereload.js script in HTML pages" in the LiveReload Server configuration. This allows you to proxy your file:// urls and have them served out on localhost:35729/<projectname>/<filepath> (or any other port if you choose so in the LiveReload Server configuration) .

For security reasons, remote connections are disabled by default, so if you want mobile devices to be able to load the page, just enable "Allow Remote Connections".

Now, typing a complex, long url on a mobile device can be tedious, so in order to make your life even easier, we’ve added a "Show In > Web Browser on External device…" menu. This will display a QR code for the LiveReload enabled url. Simply use a QR reader application and have the webpage load on your device. Watch your pages reload as you make the modifications in your IDE, it’s close to black magic!

HTML5/JQuery Mobile Palette

To further improve your HTML5 / mobile development experience, we’ve added a new HTML5 palette with initial support for JQuery Mobile widgets. This palette will show up when you edit HTML5 files (files with <!DOCTYPE HTML> doc type). If it does not show up, it is probably using HTML4 or XHTML content types.

The JQuery Mobile palette features a dialog preview when you click or drag one of the buttons for a component, it lets you see and customize what will be inserted :

Alexey Kazakov recorded a video to show it in action.

BrowserSim goodies

BrowserSim is a mobile web browser simulator, used to test your web pages on mobile devices with a realistic mobile device skin.

Now guess what? your mobile application development experience just scored 11. In this release, we’ve added a bunch of really exciting features, available with a right-click on the device bezel :

synched browsing : open the same web page in 2 different but synchronized browsers. You can test horizontal and landscape modes at the same time or view how layout behaves on different devices simultaneously.
screenshot : easily take screenshots to share your awesome design or nasty bug you want someone to hunt down.
debugging facilities : use Firebug Lite for easy local debugging, or debug remotely using any Weinre compatible server to debug/inspect the application running in BrowserSim.
new skins galore

Please note BrowserSim must be launched with a 32bits JRE (you can now select it in JBossTools > BrowserSim / Cordova preferences) and Safari must be installed on your machine.

Windows 64-bit Visual Page Editor

A long standing issue for our Visual Page Editor was the lack of proper Windows 64-bit XULRunner integration.

Carsten Pfeiffer did an awesome contribution and made this happen. If you’re using Windows 64 bit, and if you follow the JBoss Tools Visual Editor FAQ link, you will be told to try to install XULRunner from http://download.jboss.org/jbosstools/builds/staging/xulrunner-1.9.2_win64/all/repo/

Hopefully you should see the following, before and after installing the proper XulRunner version :

We would love to hear if this works for you on Windows 64-bit or if you still see problems. You can give your feedback on this bug.

Hybrid Mobile via Apache Cordova (Experimental)

If real, cross-platform Mobile application development is your thing, we now have experimental support for developing Hybrid mobile applications with Apache Cordova.

You can create an "Hybrid Mobile" project and test and develop it using the Android SDK and XCode for iOS testing.

This is only available as Experimental in JBoss Tools, not part of Developer Studio (yet)

CordovaSim (Experimental)

To help testing hybrid mobile development we’ve extended our BrowerSim to use Ripple to provide a way to do portable testing (meaning you do not necessarily need Android or XCode installed to do development)

This is only available as Experimental in JBoss Tools, not part of Developer Studio (yet)

Forge integration

The majority of the feedback we got for the awesome integration of Forge into Eclipse was that many preferred to use a wizard over only having access to a "command line style" UI.

We listened to you and added new wizards, to give an Eclipse front-end to the following Forge features:

Generate Entities from existing tables
Generate REST Endpoint from Entities
Scaffold UI (JSF or AngularJS based) from Entities

You will find these wizards - which are Technology Preview as of this release - under "File > New > JBoss Tools":

Make sure you read a detailed description of these wizard in Forge What’s New. Oh and to make it all work, we now embed the Forge 1.3.3.Final runtime.

Please note these wizards are considered Technology Preview, thus, even though they’re included, are not supported in JBoss Developer Studio.

The long term goal is to get a closer integration between Forge and Eclipse. This is a current work in progress with Forge 2, which is now available as an experimental download for JBoss Tools

Arquillian (Experimental)

Arquillian Eclipse is a new JBoss Tools component that makes Java EE integration testing using Arquillian easier. The Arquillian support can be added/removed by right-clicking the project and selecting Configure>Add/Remove Arquillian support.

The project has to be a Maven (m2e) project. The "Add Arquillian Support" action adds the Arquillian nature to the project as well as arquillian artifacts (bom, dependencies, required plugins, profiles …) to the project’s pom.xml. The Remove Arquillian Support removes the Arquillian nature, but doesn’t change the project’s pom.xml.

A new "Arquillian JUnit Test Case" wizard, based on the JUnit Test Case wizard, adds the following to a created class:

@RunWith(Arquillian.class) annotation
the deployment method

Enabling Arquillian support also brings you validation, navigation across arquillian resources, launch configuration… You’ll most certainly want to read a more complete overview of the Arquillian support here.

This is only available as Experimental in JBoss Tools, not part of Developer Studio (yet)

OpenShift

OpenShift Tools received a good deal of improvements, usability wise. Improved UI, more explicit labels where needed, but more importantly:

Git output streaming

Ever since we added OpenShift support to Eclipse we’ve had the problem that EGit did not allow streaming of console output when performing a push.

This mean that when doing a long running push Eclipse would just have a blank console and show "Push in progress".

In Kepler, EGit now includes our contribution of allowing this meaning Git users and OpenShift users can and will get streaming of the console output. You can now see what is going on.

Restart OpenShift Application

We’ve added "Restart" to the UI, allowing you to trigger a node restart for your application in case something bad has happened or you changed a configuration that requires a full node restart.

Create application from a remote repository

Opening the advanced section of the New OpenShift Appliction wizard, you can now create an application directly seeded from a remote git repository (github for instance) instead of forcing you to use git recursive merges locally.

Configure OpenShift markers

OpenShift is using markers to enable or disable features. These markers are hidden files added to the <project>/.openshift/markers directory. You can now add/remove/edit these markers by invoking a wizard from the OpenShift > Configure Markers… menu in th Project- or Package-Explorer.

Application creation logs

When creating applications you want to know about the credentials that OpenShift initially set for you. This is especially helpful and required when you create a jenkins where you get its url and username/password presented. We now display what OpenShift did for you if there’s anything to be noticed for any type of application and/or cartridge.

JBoss Central

JBoss Central, the welcome screen of JBDS / JBoss Tools has a new design. We’ve tried to make it easier for you to get started building new applications, providing more samples, displaying descriptions of what each wizard gives you.

You can also access wizards for features you haven’t installed yet, such as the OpenShift Application. You’ll be prompted to install the required OpenShift Tools feature if you haven’t installed it already.

In the software/update tab, you’ll find we have added VJet, a promising new JavaScript editor, which should help you build, you know, HTML5 and mobile applications.

Servers and runtimes

New server adapters

JBoss EAP 6.1, freely available to developers (you can get it from the JBoss AS download page), now has its own server adapter.
WildFly now also has its own dedicated server adapter. Please note it’s still considered experimental as WildFly itself is not stabilized to this day. We recommend using the latest Alpha-3 release, which fixes some file locking issue on windows and now support JSP development mode.

Better server identification

Servers derived from JBoss AS 7.x (JPP, SOA-P, GateIn), are now properly identified, making searching runtimes easier to setup. We now reuse the stacks.yml descriptor provided by the JBoss Developer Framework to provide downloads of different runtimes and thus providing a consistent experience, as part of the JBoss Way initiative.

Better server management

Server tools now uses the AS 7.x/EAP/WildFly management api, allowing for faster and more reliable (re)starts of servers, as well as better module management (individual module restart, status information).

Tomcat runtime detection (JBoss Tools only)

A new Tomcat runtime feature detection allows you to automatically detect and create tomcat-based servers, after scanning a specified server directory.

Maven Integration++

m2e 1.4.0 and m2e-wtp 1.0.0

JBDS comes with m2e 1.4.0 which brings some performance enhancements, as well as a very convenient Alt-F5 shortcut, to update project configuration, when it’s gone out-of-synch.
we contributed the JBoss JPA/JSF/JAX-RS configurators to the m2e-wtp project at eclipse.org, which just graduated from the Eclipse Incubator into version 1.0.0, adding support to Java EE 7.

In this Kepler release the configuration of these configurators moved under the Preferences > Maven > Java EE Integration.

Automatic Source Lookup for the masses

Ever tasted m2e’s awesome automatic source download but were frustrated when going back to work on legacy, non-maven projects? Then rejoice, we now enable automatic source lookup for all, non-maven java projects.

The automatic Source Lookup feature is based on Maven/m2e. As such, downloaded sources will be stored under your local Maven repository.

Since JDT doesn’t support variables in source attachments (such as M2_REPO), source attachments use absolute (non-portable) paths. It’s ok when the jar is part of a Classpath Library, since the path is stored in your own workspace. But it can become a problem if your jar dependency is listed in your project’s .classpath descriptor, potentially shared with other developers. For this reason, by default, you’ll be warned when a compatible source has been found :

The good news is the source lookup mechanism is capable of fixing bad source attachements, even for Maven enabled projects. If the attached source doesn’t exist (ex. you wiped out your maven local repository or shared hard-coded source attachments in your scm) or doesn’t contain the right source files, it will try to download the proper source.

Maven repository edition

Maven Repositories defined in profiles in your settings.xml (Window > Preferences > JBoss Tools > Maven Integration > Configure Maven Repositories…) can now be edited with the "Edit Repository…" button :

And much more…

There’s not enough room here to list all the great things the team managed to pull. Better JAX-RS tooling performance, JSF 2.2 and updated Deltaspike support, improved web service tester (now using JBoss Wise). So, again, make sure you take a look at the news and screenshots in our What’s New page.

Giving Feedback

Please don’t hesitate to use our forum to ask questions, or, if you have ideas to better improve JBoss Tools / JBDS, or found a bug, then open an issue in our issue tracker.

What’s Next ?

First, some of us are gonna take a tiny bit of rest in the coming weeks. Then we’ll work on a service release, mainly focused on bug fixes, to accompany the Eclipse Kepler SR1 release in september. Hopefully, new features should see the light of day by the end of the year.

Have fun!

Fred Bricon
https://twitter.com/fbricon

show-domain-info: openshift-java-client in a nutshell

posted by André Dietisheim on Aug 24, 2012. OpenShift Java

At JBoss Tools we created a java client that allows you to talk to the OpenShift PaaS: openshift-java-client. The library is already used in the OpenShift tooling in JBoss Tools, the Forge plugin and Appcelerator Titanium Studio's tooling for OpenShift. This blog post will show you how to use okthis API in your very own java programs. We'll develop a command line tool that displays informations equivalent to what you get when running rhc domain show with the OpenShift command line tools: it displays basic informations about your user.

================
        Namespace: andre
          RHLogin: andre.dietisheim@redhat.com
        
        Application Info
        ================
        kitchensink
            Framework: jbossas-7
             Creation: 2012-08-10T11:24:13-04:00
                 UUID: 8ad0d94f39aa4295a0049de8b8b5ef55
              Git URL: ssh:<SOMEID>@kitchensink-andre.rhcloud.com/~/git/kitchensink.git/
           Public URL: http://kitchensink-andre.rhcloud.com/
        
         Embedded: 
             jenkins-client-1.4 - Job URL: https://jenk-andre.rhcloud.com/job/kitchensink-build/

You'll find the sourcecode for this example at github: [https://github.com/adietish/show-domain-info] (https://github.com/adietish/show-domain-info). All the code that is shown in this blog is contained within the Main class.

If you want to dig futher, you'll get a more complete example that includes jenkins in this wiki article.

Openshift-java-client 2.0

The openshift-java-client is a java library that allows java programs to talk to the OpenShift PaaS. It talks to the new OpenShift RESTful service and allows users to create, modify and destroy OpenShift resources: domains, applications, cartridges, etc. It is hosted on github at https://github.com/openshift/openshift-java-client and is available under the Eclipse Public License.

Note: Openshift-java-client 1.x was talking to the legacy service in OpenShift. 2.0 switched to the new RESTful service. The legacy service is not maintained any more and will fade away at some point. Users of the 1.x client should migrate to the 2.0 client. The migration should be pretty much without hassles. Even though 2.0 is a complete rewrite, the API stayed pretty much the same/very close.

Requirements

You need an account on OpenShift. (If you have no account yet, you'd have to signup first)
Make sure you have an OpenShift domain and some applications (to get some meaningful output)

Launch Parameters

To keep the implemenation simple, the program we're about to write, only accept 2 parameters on the command line:

username
password

Launching the program with maven would look like this:

mvn test -Dusername=<username> -Dpassword=<password>

Project Setup

We have to make sure that we have the openshift-java-client available on our classpath. The client library is available at https://github.com/openshift/openshift-java-client. You could clone the repo and build your own jar by telling maven to "mvn clean package". But even simpler is to add it as dependency to your pom.xml, since the client library is also available from central as maven artifact:

<dependency>
          <groupId>com.openshift</groupId>
          <artifactId>openshift-java-client</artifactId>
          <version>2.0.0</version>
        </dependency>

Connect to OpenShift

After we did some basic command line parameter parsing (that we skipped here on puropose) we'd have to get in touch with the OpenShift PaaS. Using the openshift-java-client you'd tell the OpenShiftConnectionFactory to create a connection for you. To create this connection you'll have to provide some parameters:

Server url

First of all you need to give it the url of the OpenShift PaaS. You may either hard code it or ask the OpenShift configuration for it:

new OpenShiftConfiguration().getLibraServer()

The OpenShiftConfiguration class parses the OpenShift configuration files you may have on your machine (~/.openshift/express.conf, C:/Documents and Settings/user/.openshift/express.conf, etc.). Those usually get created once you installed the rhc command line tools. In case you don't have any configuration yet, OpenShiftConfiguration holds some meaningful defaults and points to http://openshift.redhat.com. On the other hand, our configuration class also allows you to override settings by putting them to the system configuration as you would do if you want to switch to the OpenShift LiveCD temporarly. You would then simply add the following to the command line when launching the java virtual machine:

-Dlibra_server=127.0.0.1

Client id

The connection factory also requires you to provide your very own client id. This client id is used when the openshift-java-client talks to the OpenShift REST service. It'll get included in the user-agent string that tells OpenShift what client it is talking to. We use the name of our example, show-domain-info.

Username and Password

Last but not least, you also have to give it your OpenShift credentials, the ones we got from the command-line.

String openshiftServer = new OpenShiftConfiguration().getLibraServer();
        IOpenShiftConnection connection = new OpenShiftConnectionFactory()
          .getConnection("show-domain-info", "myuser", "mypassword", openshiftServer);

Once you have your connection you can get a IUser instance which will allow you to create your domain and applications:

IUser user = connection.getUser();

The first information block involves basic user informations. The username is available from your IUser instance:

System.out.println("RHLogin:\t" + user.getRhlogin());

The other value that we want to display, the domain namespace, is accessible from your OpenShift IDomain. We'll get it from the the user instance and print its id (namespace).

IDomain domain = user.getDefaultDomain();
        System.out.println("Namespace:\t" + domain.getId());

Print the Application Infos

The second portion printed by rhc domain show is reporting your users applications. All OpenShift applications are held in a list within your domain. We simply get the list and iterate over it's entries:

for (IApplication application : domain.getApplications()) {

The required values - name, framework, creation time etc. - are now available within each IApplication instance:

System.out.println(application.getName());
        System.out.println("\tFramework:\t" + application.getCartridge().getName());
        System.out.println("\tCreation:\t" + application.getCreationTime());
        System.out.println("\tUUID:\t\t" + application.getUUID());
        System.out.println("\tGit URL:\t" + application.getGitUrl());
        System.out.println("\tPublic URL:\t" + application.getApplicationUrl() + "\n");

An application may have several cartridges embedded (MySql, Postgres, Jenkins etc.). These cartridges are reported by by the application. We get the list of cartridges and inspect at each of them:

for(IEmbeddedCartridge cartridge : application.getEmbeddedCartridges()) {

We then want to know bout a cartridge's IEmbeddableCartridge, name and url:

System.out.println("\t" + cartridge.getName() + " - URL:" + cartridge.getUrl());

That is it - you now have an app that can talk to OpenShift via its REST API. If you want to do more we also have this article that shows how to perform actual operations against your OpenShift applications.

Hope you enjoy it and let us know what you build with it!