Planet NetBeans

Geertjan's Blog: Groovy Makes Web Services Embarrassingly Easy

Wed, 23 Jul 2008 16:33:20 +0000

Meera pointed me to another very cool article she's written, RESTful Web Services in 60 Seconds, and (because I've been in an intensely groovy frame of mind for a few days now), I immediately associated it with my earlier experiments with Groovy and web services, in a blog entry entitled Groovy Web Service from the end of last year, based on some key learnings from the official Groovy web service site, (which has expanded a lot since then, I noticed today). At the time, I needed to hack things quite a bit to get web services to work with Groovy in NetBeans IDE (as honestly recorded in that blog entry).

So, I thought, how do things stand today in terms of Groovy and web services in NetBeans IDE? To be perfectly honest, the improvement couldn't have been much better, aside from the currently incomplete code completion (which is a work in progress still). In fact, I was able to mix and match Matisse with a Groovy web service, although you can't tell from the result:

This is the actionPerformed in the JButton in the Matisse form that you see above:

ShakesWSClient shakes = new
      ShakesWSClient(); private void searchButtonActionPerformed(java.awt.event.ActionEvent evt) { String searchString = shakes.setSearchString(searchTextArea.getText()); resultTextArea.setText(searchString); }

And this is the ENTIRE web service client:

package org.me.hello import groovyx.net.ws.WSClient class ShakesWSClient { def proxy = new WSClient("http://www.xmlme.com/WSShakespeare.asmx?WSDL", ShakesWSClient.class.classLoader) String setSearchString(searchString) { def
      newQuote = proxy.GetSpeech(searchString) return newQuote } }

Really, that's just a bit ridiculous. And I'm sure that the Groovy experts could cut the above code down a few lines and characters further. And I didn't need to hack anything in NetBeans. The Groovy class behaved seamlessly with the Java class.

NetBeans Core QA: Why is 'Build' action grey on new project?

Wed, 23 Jul 2008 14:04:23 +0000

Create new project in NetBeans IDE. Right click the project. The Build and Clean action is always grey out. When you open an old project then it is there. So what is the magic here? Go to project properties, in category Compiling you'll find Compile On Save check box. When checked then the saved file is always compiled when you save it.

Are you interested in more details? Try it in latest builds or read the specification.

Michel Graciano's Weblog: NetBeans 6.5 - Database support refreshed...

Wed, 23 Jul 2008 13:59:38 +0000

The main NetBeans 6.5 feature I have been looking forward to is the new database support. For details about what is coming, look here for details.
For now, we already can use code completion, some features as editable queries result, quick column info on result table and another really cool features. You can see below an image about what is coming...

[Click to enlarge]

BTW, the execution plan will be implemented just for feature versions. If it is important to you, vote for it now here!

Happy coding!

Bistro!: A visit to JUG Ukraine

Wed, 23 Jul 2008 12:46:52 +0000

Call me crazy or workaholic but I took a few hours out of my vacation in Kiev, Ukraine to visit the local JUG.

The meeting was hosted at GlobalLogic (somewhat of a geek's paradise) and was pretty well attended given the last-minute organization. The presentation slides (in English) are here and the full photo album there.

The presentation started with a bit of a challenge as no one was using GlassFish (mainly WebLogic, WebpShere, Tomcat and some JBoss). Given the presentation + Q&A session lasted almost 2 hours, I think it's fair to say that the interest was great. There were many questions during and after the presentation. Here's the refined Q&A:

• OpenESB looks interesting (documentation, NetBeans graphical tooling, ...), but can I use BPEL4People with it?
Unfortunately IBM does not support JBI and to the best of my knowledge, there is no BPEL4People service engine. OpenESB and JavaCAPS do come with a WS-BPEL implementation though.

• What is the Hibernate/TopLink split? (me asking)
- Hibernate: 60%
- TopLink: 40%

• Is the 404 error in the admin console during your demo a bug or a feature ? ;)
It's certainly a bug. Fixed in GlassFish 2.1.

• Can I deploy OSGi bundles on GlassFish v3?
Well, GlassFish v3 is running on top of Felix by default so it can host any OSGi bundle. The question is rather how it can extend the features of GFv3. This is a nice picture to explain the additional metadata required.

• Can GlassFish run on the JRE (not the JDK)? This makes a difference for me in terms of re-distribution.
Provided you don't need to compile JSP's, GlassFish should run fine on top of the JRE, but this has not been extensively tested. Note that creating domains also requires the JDK (although that's not really runtime per say). I'll probably blog more on this, including the legal side to this (yes, you can redistribute the JDK).

• How does GlassFish manage the ClassPath when using JSR 199 (Java Compiler API) to compile JSP's?
The default JavaDoc for this API isn't really helpful. In general, JavaCompiler.getTask(...) gives you the ability to pass a set of options, including a classpath. You may also find this testing API to he helpful in debugging compile issues. Finally, this link explains the performance benefits of using JDK 6's javac API in GlassFish. All is done dynamically now, all you need to do is use Java 6 to run GlassFish.

• Does GlassFish support distributed transactions between multiple JVMs?
Well, if you're talking about WS-Coordination and WS-AtomicTransaction, these are both implemented as part of the Metro Web Services tack which itself is part of GlassFish v2 and above. This enables distributed transactions even with .Net services.

• You claim that Grizzly has very good performance for serving both static and dynamic data. Do you have any benchmark results?
Yes. You probably want to start looking at this original post by Jean-François Arcand. It's a bit old but Grizzly and GlassFish only got better with time!

• How do you move from one version of GlassFish to another? Other products make this pretty painful.
We take compatibility very seriously. It's a company thing (think Java 1.0). With every copy of GlassFish we provide bin/asupgrade which allows you to point to a source GlassFish domain, say GlassFish v1, and a target, say GlassFish v2. The tool will proceed to read the applications, resources, and configuration and recreate them in the target application server. You can achieve similar results with bin/asadmin backup-domain and bin/asadmin restore-domain within a single version of GlassFish.

• Have people started using GlassFish in production? Any more you could share?
Some people (like Wotif.com) have started using GlassFish v1 in production. With the release of GlassFish v2 less than a year ago, we've seen a great level of deployments some (a fraction) is discussed by the users themselves on this blog: http://blogs.sun.com/stories.

• Does GlassFish suffer from the same memory leaks as Tomcat on redeploys?
We've fixed a couple of bug in GlassFish v2 which should make the redeployment of artifacts painless, including on Windows which had a tendency to lock deployed files.

So there you are, this is all the questions I could remember. If you have more, please comment here, I'll add them to the entry.

Adam Bien: "No XML" - Dependency Injection (EJB 3) For Absolute Beginners, or Is Possible To Inject With Less Code / XML?

Wed, 23 Jul 2008 11:18:03 +0000

If you already invested the three minutes working through the post "EJB 3 (@Session) For Absolute Beginners - 3 Minutes Bootstrap, 5 Steps", you can skip the requirements section.

Requirements:

Installled JDK 1.5 (better 1.6)
An IDE of your choice e.g. vi, emacs, netbeans 6.1 (SE or EE), Eclipse Genymede (SE or EE)
@Stateless, @Local, @Entity, @Id Annotations in classpath
An Java EE 5 capable application server of your choice. It will work with Glassfish v1+ (better v2), JBoss 4.2+, WLS 10+ and probably Geronimo (not tried yed)

What is Dependency Injection (DI)?

DI is a fancy term for a simple thing: someone (in this case something -> the EJB 3 container) cares about managing the dependencies for you. You just have to declare the need for it.
EJB 3 is using annotations for this purpose, absolutely NO XML is needed.

Basically: everything which is stored in JNDI can be injected, instead of "looked up".

What is to do:

To inject one Session Bean to another use the @EJB annotation:
@Stateless
public class BookServiceBean implements BookService {
@EJB
private SearchService search;

Common error: you cannot inject classes in EJB 3.0, but only interfaces. This will change in EJB 3.1...
To inject a DataSource, Queue, ConnectionFactory, Mail, SessionContext etc. you will need the @Resource annotation:
@Stateless
public class BookServiceBean implements BookService {

    @Resource(mappedName="jndi/sample")
    private DataSource ds;
To use the persistence, just use the @PersistenceContext annotation:

@Stateless
public class BookServiceBean implements BookService {
@PersistenceContext
private EntityManager em;

How it works:

EJB 3 DI operates in "Convention over Configuration" mode. So in general: in case there is only one possibility - it will be injected.
If there are more than one, you will have to configure manifesting your choice...

The easiest possible start:

...is with Netbeans 6.1 (EE) - download the first choice (139 MB - all included). It will not only install the IDE, but the application server (Reference Implementation: Glassfish RI), sample database etc. Eclipse's Ganymede is good as well, however you will need more projects (one for EJB 3, one for JPA), setup the application server etc. so it takes slightly more time if you are an absolute beginner :-).

Why is it good:

No overhead - the code is as lean as it can be (any suggestions to make it simpler? :-)). The jar contains nothing else, but the interfaces and classes.
It's simple - and sufficient for most use cases.
Is easy to test: the reference can be set in JUnit directly (I will cover this in one of the next posts)
Is configurable - all annotations can be overruled by XML. Even legacy POJOs can be integrated that way. See an extrem example - the deployment of a Swing Table Model as EJB 3 :-).
No vendor lock in: EJB 3 is one and only component model I now, which is vendor neutral, with several available implementations (JBoss, Glassfish, Weblogic, Websphere, openEJB, SAP, Spring Pitchfork, Geronimo + forgotten ones). Google Guice is, however, promising as well. The dependency to EJB 3 spec itself is low - if it does not work for you, you can deploy this "pojos" to something else...
The EJB 3 container is able to monitor (see e.g. Glassfish CallFlow) the whole invocation chain of EJBs. If you are developer: you probably don't care, but your operations :-)

Jun Qian (钱骏) 's Weblog: XAM AutoGen: a tool to automate XAM model generation

Wed, 23 Jul 2008 00:05:52 +0000

XAM (Extensible Abstract Model) is an extensible framework for building domain-specific object model on top of any base models. Many NetBeans modules (such as WSDL Model, Schema Model, XSLT Model, BPEL Model) are built on top of XAM. A XAM-based model is best suited for an IDE like NetBeans because of its IDE-friendly features (unlimited undo/redo, automatic synchronization, document fidelity, etc.), but you are not tied to NetBeans by using XAM.

To create a XAM-based model, one typically starts from the schema describing the domain. It's a very tedious process to generate all the Java interfaces and implementation classes, along with the all plumbing classes (factories, visitors, etc.).

To ease the pain of manual class creation, a tool is needed to auto generate a XAM-based model from a XML schema. This blog entry describes a tool that takes a domain schema as input, and uses Velocity templates to generate a XAM-based model.

This tool doesn't use any popular schema language (such as XML Schema (W3C), or Relax NG.) There are a couple of reasons:

A formal XML schema language is a little bit too heavy. I want to clearly define what is supported and what is not.
In addition to domain typing, I also want to add extra semantics. For example, I want to express an element FOO has an attribute BAR of type URI or QName which refers to another element BAZ in this or even a foreign domain.

The following is the meta schema (the schema for your domain schema) used by this tool:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"             targetNamespace="http://xml.netbeans.org/schema/xamgen"             xmlns:tns="http://xml.netbeans.org/schema/xamgen"
                  elementFormDefault="qualified">                     <xsd:element name="Content">         <xsd:complexType>
                  <xsd:sequence>                 <xsd:element name="Element"  minOccurs="0" maxOccurs="unbounded"/>
                      <xsd:element name="EnumType" minOccurs="0" maxOccurs="unbounded"/>             </xsd:sequence>         </xsd:complexType>    
      </xsd:element>        <xsd:element name="Element">         <xsd:complexType>             <xsd:sequence>
                      <xsd:element name="Attribute" minOccurs="0" maxOccurs="unbounded"/>                 <xsd:element name="ChildElement" minOccurs="0" maxOccurs="unbounded"/>
                  </xsd:sequence>             <xsd:attribute name="name" type="xsd:string" use="required"/>             <xsd:attribute name="className" type="xsd:string"/>
                  <xsd:attribute name="root" type="xsd:boolean" default="false"/>             <xsd:attribute name="virtual" type="xsd:boolean" default="false"/>             <xsd:attribute
      name="base" type="xsd:string"/>             <xsd:attribute name="anyAttribute" type="xsd:boolean" default="false"/>             <xsd:attribute name="anyElement" type="xsd:boolean" default="false"/>        
      </xsd:complexType>     </xsd:element>     <xsd:element name="Attribute">         <xsd:complexType>             <xsd:attribute name="name" type="xsd:string" use="required"/>
                  <xsd:attribute name="type" type="xsd:string" use="required"/>             <xsd:attribute name="reference" type="xsd:string"/>         </xsd:complexType>    
      </xsd:element>     <xsd:element name="ChildElement">         <xsd:complexType>             <xsd:attribute name="name" type="xsd:string" use="required"/>            
      <xsd:attribute name="multiplicity" type="xsd:string" default="n"/>             <xsd:attribute name="ordered" type="xsd:boolean" default="false"/>         </xsd:complexType>     </xsd:element>        <xsd:element
      name="EnumType">         <xsd:complexType>             <xsd:sequence>                 <xsd:element name="Enumeration" minOccurs="0" maxOccurs="unbounded"/>
                  </xsd:sequence>         </xsd:complexType>     </xsd:element>     <xsd:element name="Enumeration">         <xsd:complexType>
                  <xsd:attribute name="value" type="xsd:string" use="required"/>         </xsd:complexType>     </xsd:element> </xsd:schema>

Most of it should be pretty straightforward. Here are a few notes:

Element.root: whether this element is a root element in an instance document in your domain. Multiple root elements in a domain are allowed.
Element.className: you can use this attribute to overwrite the default component class name derived from the element name.
Element.abstract: whether the corresponding component class is abstract.
Element.base: the name of the element whose corresponding domain component class serves as a base class.
Attribute.type: Java type, for example, "String", "boolean", "java.util.List<javax.xml.namespace.QName>".
Attribute.reference: use this if the attribute value references another component in the model.

If you want to reference a component that can be globally identified by QName, use "QName" for the corresponding Attribute.type;
For local reference, you can use "String" or "URI" as Attribute.type. Note that you can define the reference to be something like "elementA/elementB" for a multi-level reference.

Example:

Here is a schema instance describing an example domain:

<Content xmlns="http://xml.netbeans.org/schema/xamgen"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://xml.netbeans.org/schema/xamgen xamgen.xsd">          <Element name="composite"
      root="true">         <Attribute name="name" type="String"/>         <Attribute name="targetNamespace" type="java.net.URI"/>                 <ChildElement name="component"/>
              <ChildElement name="connection"/>     </Element>          <Element name="component">         <Attribute name="name" type="String"/>        
              <ChildElement name="provides"/>         <ChildElement name="consumes"/>         <ChildElement name="property"/>     </Element>          <Element name="endpoint" virtual="true">
              <Attribute name="name" type="String"/>                 <ChildElement name="interface" multiplicity="1"/>     </Element>          <Element name="provides" base="endpoint"/>
               <Element name="consumes" base="endpoint"/>          <Element name="property">         <Attribute name="name" type="String"/>         <Attribute name="value" type="String"/>
              <Attribute name="override" type="OverrideOptions"/>             </Element>          <Element name="connection">         <Attribute name="source" type="javax.xml.namespace.QName"
      reference="consumes"/>         <Attribute name="target" type="javax.xml.namespace.QName" reference="provides"/>     </Element>                    <Element name="interface" virtual="true"/>     
          <Element name="interface.wsdl" className="InterfaceWSDL" base="interface">         <Attribute name="interface" type="java.net.URI"/>     </Element>                  <EnumType name="OverrideOptions">
              <Enumeration value="no"/>         <Enumeration value="may"/>         <Enumeration value="must"/>     </EnumType>         </Content>

Here is a little configuration file:

# XML file describing the domain data model.
domainDataModelFile=DemoDataModel.xml

# Namespace URI for the domain model
namespaceURI=http://www.yourorg.org/xmlns/foo/1.0

# Name of the domain model, such as "WSDL", "Schema", etc.
domainModelName=Foo

# Package name for the base model classes.
modelPackage=org.yourorg.foo.model

# Header file to be included in all the generated Java files.
headerFile=Header.txt

# Your name
author=jqian

The following shows the list of classes this XAM AutoGen Tool spits out when fed with the above domain schema and configuration file:

Usage:

Here is the steps you need to take to use this tool:

Unzip this zip file
Define your domain data model under the config directory.
Configure a few properties in config/config.properties
Run "java -jar XAMGenerator.jar <output_dir>". (The output_dir could be your Java project or NetBeans module project's source directory.)
In your project, add dependency to platform8/lib/org-openide-util.jar and ide9/modules/org-netbeans-modules-xml-xam.jar under your NetBeans directory.

That's it.

I am currently using this tool to auto generate the data model for SCA (Service Component Architecture). Here is the domain schema for the SCA Assembly Model. You can compare it with the original XSD Schemas. Based on my usage, I am going to keep improving this XAM AutoGen Tool . If you have any comments or suggestions, I am all ears.

P.S. I found this NetBeans Velocity plugin along the way. Very nice as a Velocity template viewer, but once you start editing the templates, it's getting a little crazy sometimes.

Geertjan's Blog: Creating a Grails Plugin in NetBeans IDE

Tue, 22 Jul 2008 23:55:12 +0000

Let's create a plugin for Grails. Grails is, after all, modular and pluggable. Here's the ultimate simple Grails plugin, just to give an idea what is involved, from start to finish. The most useful references I have found so far are these:

Between those three, you should have enough to figure things out. I still found it hard, despite those instructions and so to avoid having to figure things out again some time in the future, I'll write absolutely everything here.

Creating the Plugin

On the command line, run this:
```
grails create-plugin SamplePlugin
```
Now you have a Grails plugin. However, at the same time it is just another Grails application, which means you can simply open it in NetBeans IDE. (I.e., there is no import process and no NetBeans artifacts are added to the plugin in order to be able to open it in the IDE.)

So open the plugin in the IDE. The Projects window isn't very interesting, it just shows you the same as you would normally see for Grails applications:

The Files window (Ctrl-2) however, shows a lot more:

Open the "SamplePluginGrailsPlugin.groovy" file and there you see the following:

class SamplePluginGrailsPlugin { def version = 0.1 def dependsOn = [:] def doWithSpring = { // TODO Implement runtime spring config (optional) } def doWithApplicationContext = { applicationContext -> // TODO Implement post initialization spring config (optional) } def doWithWebDescriptor = { xml -> // TODO Implement additions to web.xml (optional) } def doWithDynamicMethods = { ctx -> // TODO Implement registering dynamic methods to classes (optional) } def onChange
      = { event -> // TODO Implement code that is executed when this class plugin class is changed // the event contains: event.application and event.applicationContext objects } def onApplicationChange = { event -> // TODO Implement code that is executed when any class in a GrailsApplication changes // the event contain: event.source, event.application and event.applicationContext objects } }

I.e., you have hooks for integrating your code into meaningful places in the plugin.

Now we'll create code that will let our plugin provide a new "constraint". (If you don't know what that is, you will know by the time you finish reading all this.) To do so, we will need to extend org.codehaus.groovy.grails.validation.AbstractConstraint, in a package within src/groovy:

import
      org.codehaus.groovy.grails.validation.AbstractConstraint import org.springframework.validation.Errors class BestFrameworkConstraint extends AbstractConstraint { private static final String DEFAULT_MESSAGE_CODE = "default.answer.invalid.message"; public static final String NAME = "oneCorrectResponse"; private boolean validateConstraint //The parameter which the constraint is validated against: @Override public void setParameter(Object constraintParameter) { if (!(constraintParameter
      instanceof Boolean)) throw new IllegalArgumentException("Parameter for constraint [" + NAME + "] of property [" + constraintPropertyName + "] of class [" + constraintOwningClass + "] must be a boolean value"); this.validateConstraint = ((Boolean) constraintParameter).booleanValue() super.setParameter(constraintParameter); } //Returns the default message for the given message code in the current locale: @Override protected void processValidate(Object target, Object propertyValue,
      Errors errors) { if (validateConstraint && !validate(target, propertyValue)) { def args = (Object[]) [constraintPropertyName, constraintOwningClass, propertyValue] super.rejectValue(target, errors, DEFAULT_MESSAGE_CODE, "not." + NAME, args); } } //Returns whether the constraint supports being applied against the specified type: @Override boolean supports(Class type) { return type != null && String.class.isAssignableFrom(type); } //The name
      of the constraint, which the user of the plugin will use //when working with your plugin. @Override String getName() { return NAME; } //Validate this constraint against a property value, //In this case, ONLY "Grails" is valid, everything else will cause an error: @Override boolean validate(target, propertyValue) { propertyValue ==~ /^Grails$/ } }

Next, back in the Groovy plugin class that we looked at earlier, hook the above class into the plugin, using the "doWithSpring" closure to do so:
```
def doWithSpring = { ConstrainedProperty.registerNewConstraint( BestFrameworkConstraint.NAME, BestFrameworkConstraint.class); }
```
Now, back on the command line, navigate to within the "SamplePlugin" folder. There, run the following:
```
grails package-plugin
```
Back in the IDE, examine the ZIP file that the above command created:

That ZIP file is your Grails plugin.

Installing the Plugin

Now we will install our plugin in a new application.

First, create a new Grails application by going to the New Project wizard (Ctrl-Shift-N) and choosing Groovy | Grails Application. Click Next and type "SampleApplication" and then click Finish.
After the IDE has finished running the "grails create-app" command for you, you will see the new application open in the IDE. Right-click it and choose "Plugins", as shown here:
In the Grails Plugins dialog, notice that the list gets filled with many potential plugins that you might want to install, from the Grails plugins repository. Instead, we'll install our own. Click Browse and browse to the ZIP file that we created three steps ago and notice that it appears in the text field at the bottom of the dialog:
Click "Install" and then a progress bar appears, ending with the plugin being installed. Notice that you can also uninstall it:
Take a look at your application and notice (in the Files window) what's happened to the plugin. It's been unzipped, plus the ZIP file is still there. And all that's been done in the "plugins" folder. Nothing else has changed, which means that uninstallation is as simple as removing the folder from the "plugins" folder:

Thanks to "convention over configuration", Grails knows exactly where everything is—so that, for example, the "plugin.xml" file that you see above, if found within the folder structure you see above, is the indicator to Grails that a plugin is available for use.

Using the Functionality Provided By the Plugin

Let's now use our plugin. Create a domain class called "Quiz", after right-clicking the "Domain Classes" node and choosing "Create new Domain Class":
Right-click the "Controllers" node and choose "Create new controller". Type "Quiz" and then click Finish. Use the Groovy editor to add one line for adding the scaffolding (and uncomment the other line):
Back in the "Quiz" domain class, add your property and use the "oneCorrectResponse" constraint defined in your plugin, as shown here:

Note: The "oneCorrectResponse" constraint that you see above is the name of the constraint defined in the plugin.
And then add the message to the messages.properties file, which is within the "Messages Bundles" node:
Run the application and you will see that your constraint will prevent anything other than "Grails" from being considered acceptable, when "Create" is clicked below:

Congratulations, you've created, installed, and used your first Grails plugin!

Another Random Developer Blog » NetBeans: Using Spring and Facelets together with NetBeans 6.1

Tue, 22 Jul 2008 20:45:40 +0000

[Read more]

Technorati Tags:: Facelets, GlassFish, Java, MyFaces, NetBeans, Spring

tm's weblog: Hudson as a tool for testing? Yes!

Tue, 22 Jul 2008 14:55:17 +0000

Lots of folks in NetBeans started to use Hudson as a tool for continuous integration, or just for building NetBeans from various clones, or to build test, whatever you can imagine. Just take a look at Deadlock machine and you will see a plenty of NetBeans related jobs. We (NetBeans QE) recently got an idea to utilize Hudson as our testing infrastructure. Yes, NetBeans have a lot of automated tests that are being ran daily and test results are evaluated for potential problems. So you have tests, you have machines, but you still need an infrastructure to connect this together. We chose Hudson, because it's a great tool, and what's really cool - is extensible by various plugins (available on Hudson's web, or you can write your own if you wish). The basic idea was to use Hudson as "master-slave" architecture, where you simply set up on master what do you want to run, and master distributes the work to the slaves, that execute the jobs. More detailed approach to this - configure on master which tests do you want to run on which platforms, and they will get executed on appropriate slaves. And getting one level lower - to achieve this, you have to have something we called generic Ant script, which will provide all the stuff needed to execute test:

Download IDE - the IDE build which will be tested
Download NetBeans Test Distribution - Test Distribution contains binaries of all tests from NetBeans repo.
Run selected tests - Specify which tests from Test Distribution will run in tested IDE

So i wrote and Ant script with plenty of useful targets to provide this functionality (Yeah, by this I learned a lot how to write Ant scrips:-) ). This Ant script is generic, and all the stuff like where to take IDE build, where to take Test Distribution, which tests run, what to do with results etc. are controlled by passing corresponding properties. Once we have this working, the only thing we have to do, is to distribute the Ant script to machine we want to run tests on, and provide some better UI than command line for the main properties, which control the test execution. Therefore me and Max Sauer extended Hudson by Test Run Plugin (sources are not public right now), that enables Hudson to copy our generic Ant script on target slave machines and extends job configuration with our panel for setting properties for testrun. With all this stuff working, people can simply log in on master, select one or more slave machines on which will tests run, configure which build will be tested by which test (through nice GUI :-) ), run the job and take a nap while watching the progress of tests execution on target machines. When test run is finished, you get a nice overview of test results (yes, built-in feature of Hudson).
The main benefits we take from Hudson (aka features we really like):

Master-slave architecture - you can have various machine with various architectures/OS added into testing farm.
JUnit results processing - nice HTML, results trends, charts,...
Scheduler - triggering of testrun by another job (which can listen e.g. if new production build is available), or "cron-like" settings.
Email notification - send email if tests do not pass.
SCP plugin - we can send test results to remote machine that can parse them and store into DB.
Authentication - simply configure and point Hudson to your LDAP server, really out of box functionality.
Multiple JDK installations - specify location where are JDKs located and voila - you can run whole matrix of tests - one axis is JDKs, second is platform.
...many many others:-)

And conclusion? Hudson is not only contentious integration tool, it can be almost whatever you like.

NetBeans for PHP: Feature freeze was reached

Tue, 22 Jul 2008 13:25:06 +0000

Our team has reached the feature freeze for NetBeans 6.5. It means we will concentrate mainly on stabilization, bug fixing and improving performance. And this is where you can really help us. How? Try a development build or NetBeans 6.5 M1. NetBeans 6.5 M2 is planned to be published on Aug 11th, so it will be a good idea to switch to it then.

If you find any bug or you have feature and enhancement requests, enter them in Issuezilla (you have to be log in). We always appreciate it. And don't forget to include additional information such as the build number, OS etc. This information can be easily copied from the About dialog.

Although we are in the stabilization phase, minor improvements are still possible. We are trying to create superb PHP IDE and you can help us enormously. Just let us know what you think. Also feel free to write your opinions, suggestions here or discuss it on users@php.netbeans.org mainling list. Subscribing is easy, just send an empty email to users-subscribe@php.netbeans.org.