And with this change, I’ve suddenly been introduced to the world of JavaHL. So what is JavaHL? Per the previous link, it’s the Java language binding for the Subversion API. On Windows the subclipse project is able to package JavaHL, but not on other operating systems. So that’s why I’ve never had to deal with it before.

Fortunately, after finding out what JavaHL actually is, it’s pretty easy to install on Ubuntu, as you might expect:

sudo apt-get install libsvn-java

This will install JavaHL to /usr/lib/jni as a standard install, and this is where eclipse will look for it by default. If you’ve installed it in a non-standard way, you might want to look at this link regarding overwriting the java.library.path with an eclipserc file.

alter table table drop column;

and got the following error:
1025 – Error on rename of ‘.\\#sql-880_3c’ to ‘.\\ ’ (errno: 150),

Don’t panic.

It’s probably because you’re trying to drop a column that’s a foreign key. Execute this command: SHOW ENGINE INNODB STATUS to debug more. A large text is dumped on the console and if you read carefully, you’re likely to have something similar to: “LATEST FOREIGN KEY ERROR…” The solution is to drop foreign key and any corresponding index before dropping the column.

Here are the steps that you must do

ALTER TABLE <table> DROP FOREIGN KEY <fk>;
ALTER TABLE <table> DROP INDEX <idx>;
ALTER TABLE <table> DROP COLUMN <column>;

Unfortunately, the JBoss folks won’t tell you since they are very busy rebranding, redesigning their websites for the past couple of years (and it’s still so fragmented, I wonder why they just can’t hire a UI designer and a Content Manager. Talk about narcissist JEE programmers). Anyways, I wanted to try the new distribution since it’s getting close to the final release and it implements JPA 2. In case you’ve missed the boat, this is a good place to find out what’s new in JPA 2.

I tried the brute force method first: replace all 3.3.x jars with 3.5 CR2 jars.

Before: 7 jars
ejb3-persistence.jar
hibernate-annotations.jar
hibernate-commons-annotations.jar
hibernate-entitymanager.jar
hibernate3-ast.jar
hibernate3.jar
envers-1.2.1.ga-hibernate-3.3.jar

After: 2 jars
javax.persistence.jar
hibernate3.jar — download from hibernate.org

Now, that’s a good sign. And all other optional and required dependencies (jta, javaassist, swarmcache,c3po, all other cache jars) haven’t changed.

But wait, where can you download javax.persistence.jar? Isn’t that supposed to be ejb3.1-persistence.jar? I’m not sure either. What I’m sure is this: There is no direct download link for the JPA2 api jar anywhere. Try it. Mail me if you find it.

I downloaded an entire GlassFish 3 distribution (JEE 6 reference implementation along with JPA 2) instead. And copied the javax.persistence.jar from its modules folder, instead. So in summary, I replaced the 7 jars with these 2 jars and does it work?

So, far my existing applications haven’t broken. The tests seems fine. And looks like the migration did work. Impressive.

My project has hundreds of tests making use of hsqldb, and getting the new version up and running is no small task. I’ve broken this post into two. The first will be the steps I took to get hsqldb integrated into our maven repository. The second will cover getting hsqldb up and running with our legion of tests.

The first important thing to know when upgrading hsqldb, is that the pre-compiled jar files were built with jdk6. This is probably going to be fine for many, but there are many others, such as myself, who would like to be on jdk6 but work at a client site still using jdk5. It sucks to be me, but oh well.

So the first step for me will be to compile the jars myself with jdk15.

To do this, it’s necessary to have 3 environment variables set, JAVA_HOME, ANT_HOME, and ANT_OPTS. Pretty standard. If you’re on windows, there is a setenv.cmd file in the distributed build directory that you can edit and execute in the cmd shell.

At present, the build.xml contains a small bug for users trying to build the jar with jdk15. The “store” target contains a list of depends attributes:

depends=”switchtojdk11,switchtojdk12,switchtojdk14,switchtojdk16″

To build with jdk15 this must be changed to:

depends=”switchtojdk11,switchtojdk12,switchtojdk14,switchtojdk15″

(I’ve added a bug for this on sf)

Next run the following ant tasks from the hsqldb/build directory:

ant hsqldb;
ant sqltool

This will build the jars to the hsqldb/lib directory.

Next step is to add the jars to my local maven repo.

mvn install:install-file -DgroupId=hsqldb -DartifactId=hsqldb -Dversion=2.0.0 -Dpackaging=jar -Dfile="/Documents and Settings/ujxh744/My Documents/Downloads/hsqldb-2.0.0-rc8/hsqldb/lib/hsqldb.jar"

mvn install:install-file -DgroupId=hsqldb -DartifactId=sqltool -Dversion=2.0.0 -Dpackaging=jar -Dfile="/Documents and Settings/ujxh744/My Documents/Downloads/hsqldb-2.0.0-rc8/hsqldb/lib/sqltool.jar"

and update our main pom.xml with the new version of hsqldb and with a new entry for the sqltool:

<dependency>
<groupId>hsqldb</group>
<artifactId>hsqldb</artifactId>
<version>2.0.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>hsqldb</groupId>
<artifactId>sqltool</artifactId>
<version>2.0.0</version>
<scope>test</scope>
</dependency>

And that’s it. You should be off to the races. Next up I’ll write about some of the sql changes.

One of the lesser known features but extremely powerful is the Drools server that is provides a restful api to access and invoke a rules knowledge base. This is a war available in the Drools binary distribution. You would place the exploded version of this in your server (tomcat 6, in my case) and
— add the following jars in the war: drools-decisiontables.jar, drools-templates.jar, jxl.jar, commons-lang.jar, joda-time.jar

I’m using the same example used in the book. For the source code download here. Copy the following into Drools Server classpath retaining the package structure

— model classes from decision_tables project (droolsbook/decisiontables/bank/model/*)
— model classes from bankingcore project (droolsbook/bank/model/*) retaining the package structure
— add interestcalculation.properties in the classpath (WEB-INF/classes). Add the following
— newInstance = true
— file = -- copy interestcalculation.xls from decision_tables project (drools-book/decision_tables/src/main/resources)

Accessing a restful url with a standard request object that looks like:

<knowledgebase-request>
  <globals>
    <named-fact>
      <id>myglobal</id>
      <fact class="org.drools.server.ExampleFact">
        <carPrice>42</carPrice>
        <carType>Saab</carType>
      </fact>
    </named-fact>
  </globals>
  <inOutFacts>
    <named-fact>
      <id>myfact</id>
      <fact class="org.drools.server.ExampleFact">
        <carPrice>50</carPrice>
        <carType>BMW</carType>
      </fact>
    </named-fact>
  </inOutFacts>
  <inFacts>
    <anon-fact>
      <fact class="org.drools.server.ExampleFact">
        <carPrice>55</carPrice>
        <carType>Audi</carType>
      </fact>
    </anon-fact>
    <anon-fact>
      <fact class="org.drools.server.ExampleFact">
        <carPrice>65</carPrice>
        <carType>Mercedes</carType>
      </fact>
    </anon-fact>
  </inFacts>
  <queries>
    <query-type>
      <args>
        <string>one</string>
        <string>two</string>
      </args>
      <factNames>
        <string>ninsf</string>
      </factNames>
      <queryName>Get named inserted fact</queryName>
    </query-type>
  </queries>
</knowledgebase-request>

You would get a standard response back that looks like this:

<knowledgebase-response>
  <globals>
    <named-fact>
      <id>myglobal</id>
      <fact class="org.drools.server.ExampleFact">
        <carPrice>42</carPrice>
        <carType>Saab</carType>
      </fact>
    </named-fact>
  </globals>
  <outFacts>
    <named-fact>
      <id>ninsf</id>
      <fact class="org.drools.server.InsertedFact">
        <name>one</name>
      </fact>
    </named-fact>
    <named-fact>
      <id>ninsf</id>
      <fact class="org.drools.server.InsertedFact">
        <name>two</name>
      </fact>
    </named-fact>
  </outFacts>
  <inOutFacts>
    <named-fact>
      <id>myfact</id>
      <fact class="org.drools.server.ExampleFact">
        <carPrice>50</carPrice>
        <carType>BMW</carType>
      </fact>
    </named-fact>
  </inOutFacts>
</knowledgebase-response>

Chapter 11 of Michael Bali's book explains an example using a Ruby client. I'm going to explain with a Groovy client, instead.

import groovyx.net.http.*
import groovyx.net.http.ContentType
import groovy.xml.MarkupBuilder

droolsClient = new RESTClient( 'http://localhost:8080/drools-server-5.0.1/' )

def accountStr = new StringWriter()
def account = new groovy.xml.MarkupBuilder(accountStr)
account.'knowledgebase-request'(){
	inOutFacts() {
		'named-fact'() {
			id("account")
			fact(class:'droolsbook.decisiontables.bank.model.Account') {
				type("STUDENT")
				balance("1000")
				currency("EUR")
			}
		}
	}
}

println 'printing xml ... '
println accountStr

resp = droolsClient.post( path : 'knowledgebase/interestcalculation',
						  body : accountStr.toString(),
						  contentType: ContentType.XML,
						  requestContentType: ContentType.XML)

println "printing response ..."
println resp.data

The above code connects to drools server running on tomcat and expects a interestcalculation.properties rulebase, compiles the knowledgebase and fires all rules returning a response. In this example a student with a balance of 1000 EUR is returned with a 1.00 interest rate from the rule.

I ran into several problems while writing this simple groovy class (thanks to Groovy's horrible exception handling). For instance if I use '/knowledgebase/interestcalculation' instead of 'knowledgebase/interestcalculation' I get a strage error:
org.xml.sax.SAXParseException: The element type "HR" must be terminated by the matching end-tag "".

And if you don't provide contentType: ContentType.XML or requestContentType: ContentType.XML, you get a:
java.lang.NullPointerExceptionat groovyx.net.http.HTTPBuilder$RequestConfigDelegate.setBody

Finally, once you get everything sorted out, the combination of a drools restful client and drools server seems to me an ideal solution to develop, deploy and release drools independently from any application. In fact the application need not know about rules or any of its configuration apart from the restful contract. Quite remarkable.

After a whole day of debugging, this is what I found: What could be happening was that the job kicked off immediately at startup while the servlet class loader was still loading all classes and thus causing NoClassDefFoundError. Why is the scheduler unable to run after 10 mins, even though the classes should be loaded by then? I’m not sure but it could be that the failed Scheduler initialization causes repeated failed attempts with the same failed class, rather than looking up for a newly loaded class (jvm implementation?).

I added a startDelay of 6000 (1 minute) and it magically works now in all environments.

What’s surprising still is why are local envs and sandbox not having the same issues. It could be that the timing of classloader loading on local and sandbox env is a tad bit faster? I still have to figure that out …

http://www.twitter.com/reverttoconsole

We’ve gone through several unit testing tools along the way trying to solve some logistical problems. We started with JSUnit, added Selenium, switched from JSUnitt to envjs, and are now using a hybrid approach I’ll describe in detail.

Some of the issues we wanted to address with our testing tools were:

• How easy is it to run the tests?
• How easy is it to debug the tests?
• How easy is it to integrate the tests into our existing continuous integration environment

Most of the tools we used easily met the first two logistical issues, but the last one was not as simple.

The following describes an approach that meets all of the above list (after the jump).

Here is a very simple JavaScript object to test and illustrate the example:

var swineFluIndicator = {
  hasSwineFlu: function(sample) {
    return !!sample.oink ? true : false;
  }
};

If the sample has a property “oink”, the sample is infected with swine flu. Simple.

To test our code in development, we used the Screw.Unit test framework.

We went with Screw.Unit for several reasons:

• Simple to implement- It’s just a JavaScript library
• It generates a simple DOM output, which makes integration easy – I’ll demonstrate later.
• It’s easy to customize, and the framework does not pollute the global namespace at all.
• It’s simple to run and debug.

Here is an example Screw.Unit test of the sample code:

Screw.Unit(function() {
  describe("test whether a given sample has swine flu", function() {
   it("clean sample", function() {
     var swineFluIndicator  = new SwineFluIndicator();
     var testSample = {
       value : '123'
     };
      expect(swineFluIndicator.hasSwineFlu(testSample)).to(be_false);
    });
  });
});

Screw.Unit tests are executed in the browser (so debugging with Firebug is easy, and produce a very simple DOM that’s simple to read:

Writing JavaScript unit tests is pretty easy; now it’s time to integrate them. HtmlUnit have released 2 new versions in 2009 so far that offer unprecedented DOM support via Rhino. With HtmlUnit, our test consists of rendering the page and interpreting the simple DOM results.

Set up the clients and load the page:

WebClient firefoxClient = new WebClient(BrowserVersion.FIREFOX_2);
WebClient ieClient = new WebClient(BrowserVersion.INTERNET_EXPLORER_6);

firefoxClient.setThrowExceptionOnScriptError(true);
ieClient.setThrowExceptionOnScriptError(true);
HtmlPage htmlPage = (HtmlPage) client.getPage(testFile.toURL());

and provide a means of interpreting the page results:

protected void interpretTestResults(final HtmlPage htmlPage) {
        String header = "";
        String heading = "";
        String paragraph = "";
        // returns a list of tests
        List testDivs = (List) htmlPage
            .getByXPath("//*[contains(@class,'describe focused')]");

        for (HtmlListItem htmlListItem : testDivs) {
            List heading1List = (List) htmlListItem.getByXPath("./h1");
            header = heading1List.get(0).getTextContent();
            // returns a list of its divisions; if there are nested
            // describes, there will be multiple its
            List test = (List) htmlListItem
                .getByXPath(".//*[contains(@class,'its')]");
            for (HtmlUnorderedList htmlUnorderedList : test) {
                // if there are no child nodes, this is part of a nested
                // describe
                if (htmlUnorderedList.hasChildNodes()) {
                    List failedItemList = (List) htmlUnorderedList
                        .getByXPath(".//*[contains(@class,'it enqueued failed')]");
                    if (failedItemList.size() == 0) {
                        // successful
                    } else {
                        for (HtmlListItem failedItem : failedItemList) {
                            List describedList = (List) failedItem
                                .getByXPath("./h2");
                            Assert.assertTrue(describedList.size() == 1);
                            heading = describedList.get(0).getTextContent();
                            List errorMessageList = (List) failedItem
                                .getByXPath("./*[contains(@class, 'error')]");
                            for (HtmlParagraph htmlParagraph : errorMessageList) {
                                paragraph += htmlParagraph.getTextContent();
                            }
                        }
                        Assert.fail("Header: " + header + " heading: " + heading + " paragraph: "
                            + paragraph);
                    }
                }
            }
        }
    }

This method takes an HtmlUnit HtmlPage and, using xpath expressions, iterates over the test result DIV tags generated by Screw.Unit. It ignores tests that passed, and focuses on the failed tests. For failed tests it gets the provided information about the test (the it and describes strings), so that we’ll know what test failed and why.

Lastly, rather than write a test for every Screw.Unit test page we write, we made use of JUnit4′s Parameterized test. This way we provide a list of Screw.Unit tests and have the Parameterized test execute a test for each.

Annotate the class:

@RunWith (Parameterized.class)
public class ScrewUnitTest {

Provide a static Collection:
@SuppressWarnings ("unchecked")
    @Parameters
    public static Collection data() {
        Collection fileCollection = new ArrayList();
        Collection fileList = FileUtils.listFiles(new File(HTML_TEST_DIR), extensions, true);
        for (File file : fileList) {
            File[] fileArray = { file };
            fileCollection.add(fileArray);
        }
        return fileCollection;
    }

and a constructor:

public ScrewUnitTest(File file) {
        this.file = file;
    }

Then for every file in the Collection, this.file will be available for reference in the tests. And our JavaScript tests can be easily run by a continuous integration system.

For the impatient: it’s a small jar that lets you compile/run/deploy java instantly, like php. I’ts the real HOT DEPLOY that jvm lacks out of the box.

No more restarting the server, ever again, even after reconfiguring Spring beans.

I used this for a month, and convinced my manager to buy licenses for all. It’s that good.

Posted via email