Here’s the premise:

A while ago we’ve faced the requirement of load-balancing web services clients based on Apache CXF. Also the clients should automatically fail-over when some of the servers are down. To make it even worse, the list of servers target addresses was to be obtained from external service and updated at runtime. …If we only knew Apache CXF already supports all these features (almost) out of the box?

Well worth remembering for future projects.

So should you, if you are a JBoss developer.

If you aren’t a JBoss developer: what’s holding you back?

I have already admitted to being an SQL Klutz, so having this sort of thing readily at hand is very worthwhile.

Still here it is…Linux booting into a PC emulated in JavaScript inside a browser.

The obligatory screen shot:

It worked for me in IE9, on my iPad 1 and iPhone 4.

What it does do, it does surprisingly quickly: it boots faster than my linux-based NAS…

Even the tcc compiler works!

Sadly, only lo0 exists.

As the developer suggests, this could be a great way of teaching introductory Linux/C.

* Because We Can

For the Open Source Developers’ Conference 2009 I created a number of “mini fliers” that we placed around the conference’s public areas in an effort to attract attendees to come to the Groovy BOF that we were holding.

The first rule of advertising is to get people’s attention. Doesn’t matter how corny your effort is. Hell…the cornier the better!

Thus:

There are many more gems like this in the source document (Microsoft Word format. Ahhh the irony. Please don’t hold it against me…).

Hope these can be useful to someone else.

Enjoy!

Concomitant with my attempts to be a good modern developer, one of the first entries on my Fings Wot I Need To Find Out More About list went something like:

Given that almost all of the actual ‘code’ in my system will be XQuery transformations, how do I unit-test those transformations with JUnit? It is obviously important that I use the weblogic API/Jars, not some external or third-party system.

Roughly six months later I am finally in a position to answer that question!

Took me a few goes (turns out that there are a number of different potential red-herring APIs to filter out and reject, including BEAs xdbc), a number of visits to other people‘s attempts and about 20 messages on the Oracle forum (gotta say I appreciated the comment “I just wanted to praise your discipline and devotion to research and investigation. Kudos!” that I picked up along the way…) but here I am.

This is the Groovy JUnit4 test class, just to prove that it can be done:

package transentia.test

import org.junit.*
import transentia.XQueryTransformer

class XQTest {
  def xqt

  @Before
   void setup() {
    xqt = new XQueryTransformer("xqueries/Messier.xq",
                                 src: new File("xml/Messier.xml"),
                                 str: 'hello, world',
                                 n: 42,
                                 b: true,
                                 dt: new Date(),
                                 f: Math.PI,
                                 nd: null as Date)
  }

  @Test
  void testTransform() {
    xqt.withString { str ->
      println str
    }
  }

  @Test
  void testSlurping() {
    xqt.withString { str ->
      def data = new XmlSlurper().parseText(str).declareNamespace(oth: "http://other")
      assert data.'oth:m'.size() == 5
      assert data.'oth:m'[3].text() == 'Scorpius'
    }
  }

  @Test
  void testParsing() {
    xqt.withString { str ->
      def data = new XmlParser().parseText(str)
      assert data.'oth:m'.size() == 5
      assert data.'oth:m'[4].text() == 'Serpens'
    }
  }
}

Pretty trivial.

This is the XQuery that is under test:

(Strangely, wordpress simply refuses to display this file without barfing. Can’t for the life of me work out why, hence the above is an image. Here’s the real file)

Notice the <destination:m?> bit? That trailing question mark is a BEA extension to the standard XQuery language: “Optional Indicator in Direct Element and Attribute Constructors.” Very useful but not widely advertised/supported (which basically accounts for why it took me 6 months to work out how to handle it).

Next is the XML file:

<?xml version="1.0" standalone="yes" ?>
<MESSIER xmlns="http://transentia">
  <M INDEX="1">
    <CONSTELLATION>Taurus</CONSTELLATION>
    <DESCRIPTION>Diffuse Nebula</DESCRIPTION>
  </M>
  <M INDEX="2">
    <CONSTELLATION>Aqarius</CONSTELLATION>
    <DESCRIPTION>Globular Cluster</DESCRIPTION>
  </M>
  <M INDEX="3">
    <CONSTELLATION>Canes Venatici</CONSTELLATION>
    <DESCRIPTION>Globular Cluster</DESCRIPTION>
  </M>
  <M INDEX="4">
    <CONSTELLATION>Scorpius</CONSTELLATION>
    <DESCRIPTION>Globular Cluster</DESCRIPTION>
  </M>
  <M INDEX="5">
    <CONSTELLATION>Serpens</CONSTELLATION>
    <DESCRIPTION>Globular Cluster</DESCRIPTION>
  </M>
  <M INDEX="6">
    <DESCRIPTION>ONLY FOR TESTING</DESCRIPTION>
  </M>
</MESSIER>

This file is just a tiny amount of fixture data for testing.

The missing <CONSTELLATION> element within the final <M> element should ‘trigger’ the XQuery engine to elide the empty <destination:m /> element that it would normally produce; thus the tests are all expecting 5 elements in the transformed XML, not 6 as in the source.

And now…without further ado…the pièce de résistance:

package transentia

import org.apache.xmlbeans.XmlObject
import org.apache.xmlbeans.XmlOptions
import org.apache.xmlbeans.XmlDateTime
import org.apache.xmlbeans.XmlBoolean
import org.apache.xmlbeans.XmlInteger
import org.apache.xmlbeans.XmlDouble
import org.apache.xmlbeans.XmlString

class XQueryTransformer {
  private final resultXML

  public XQueryTransformer(map, xQueryTransformSource) {

    XmlObject xmlObject = XmlObject.Factory.newInstance()
    XmlOptions options = new XmlOptions()

    options.setXqueryVariables(createOptions(map))

    XmlObject[] results = xmlObject.execQuery(new File(xQueryTransformSource).text, options)

    resultXML = results[0].xmlText(new XmlOptions().setSavePrettyPrint().setSavePrettyPrintIndent(2))
  }

  private createOptions(map) {
    def optionsMap = [:]
    map.each { k, v ->
      switch (v?.class) {
        case Date:
          XmlDateTime dt = XmlDateTime.Factory.newInstance();
          dt.setDateValue(v)
          optionsMap.put(k, dt)
          break
        case Boolean:
          XmlBoolean b = XmlBoolean.Factory.newInstance();
          b.set(v)
          optionsMap.put(k, b)
          break
        case [BigInteger, Integer, Long, Short, Byte, byte, short, int, long]:
          XmlInteger i = XmlInteger.Factory.newInstance();
          i.setBigIntegerValue(v as BigInteger)
          optionsMap.put(k, i)
          break
        case [BigDecimal, Float, Double, float, double]:
          XmlDouble xd = XmlDouble.Factory.newInstance();
          xd.setDoubleValue(v as double)
          optionsMap.put(k, xd)
          break
        case String:
          XmlString string = XmlString.Factory.newInstance();
          string.setStringValue(v);
          optionsMap.put(k, string)
          break
        case File:
          def txt = v.text

          // look for the prologue < ?xml ...?> processing instruction
          def m = txt =~ /(\< \?xml[^>]*\>)/
          if (m.count > 0) {
            def xmlPI = m[0][1]
            txt = """${xmlPI}
${txt[xmlPI.size()..-1]}
"""
          }
          else
            txt = "${txt}"

          // all the messing around with xml processing instruction/adding a new root above is because
          // selectChildren seems to be required. Don't know why...
          optionsMap.put(k, XmlObject.Factory.parse(txt).selectChildren("temp42", "root42")[0])
          break

        case null:
          XmlObject n = XmlObject.Factory.newInstance()
          n.setNil()
          optionsMap.put(k, n)
          break

        default:
          throw new Exception("Unhandled type: ${v.class}")
          break
      }
    }
    optionsMap
  }

  def withString(c) {
    c.call resultXML
  }
}

I’ve said it before and I’ll most likely say it again: love the Groovy switch statement!

A bit of clarification for the ‘File’ case is in order, I guess because it’s quite confusing! I found that I had to wrap a dummy root element around the original root element in order to immediately select only the single child element (the original )…this is why I need to isolate the processing instruction: the opening tag has to go between the PI and the tags. It seemed easiest to do this with simple string manipulation…

Here is the tricky bit…the various jars that need to be placed on the classpath:

oracle.nlsrtl_11.1.0\orai18n-collation.jar
oracle.xdk_11.1.0\xquery.jar
com.bea.core.xml.xmlbeans_2.0.0.0_2-5-1.jar
com.bea.core.xquery.xmlbeans-interop_1.3.0.0.jar
com.bea.core.binxml_1.3.0.0.jar
oracle.xdk_11.1.0\xml.jar
com.bea.core.xquery_1.3.0.0.jar
oracle.xdk_11.1.0\xmlparserv2.jar
com.bea.core.xquery.beaxmlbeans-interop_1.3.0.0.jar
weblogic.server.modules.xquery_10.3.3.0.jar

(Note the ordering: this is what IntelliJ X EAP worked out for me; who am I to argue…)

And to cut out any confusion, here’s what I have in my Intellij project:

C:\DEVELOPMENT\XQueryTester>tree /f /a
Folder PATH listing for volume Bugblatter
Volume serial number is 42E3-A91B
C:.
|   XQueryTester.iml
|
...
|
+---lib
|   |   com.bea.core.binxml_1.3.0.0.jar
|   |   com.bea.core.xml.xmlbeans_2.0.0.0_2-5-1.jar
|   |   com.bea.core.xquery.beaxmlbeans-interop_1.3.0.0.jar
|   |   com.bea.core.xquery.xmlbeans-interop_1.3.0.0.jar
|   |   com.bea.core.xquery_1.3.0.0.jar
|   |
|   +---modules
|   |   \---features
|   |           weblogic.server.modules.xquery_10.3.3.0.jar
|   |
|   +---oracle.nlsrtl_11.1.0
|   |       orai18n-collation.jar
|   |
|   \---oracle.xdk_11.1.0
|           xml.jar
|           xmlparserv2.jar
|           xquery.jar
|
...
|
+---src
|   \---transentia
|       |   XQueryTransformer.groovy
|       |
|       \---test
|               XQTest.groovy
|
+---xml
|       Messier.xml
|
\---xqueries
        Messier.xq

C:\DEVELOPMENT\XQueryTester>

All requisite jars can be found within the OSB 11g installation.

Update 2011 01 01; at least one person has read this and given me some feedback:

I needed to add com.bea.core.antlr_2.7.7.jar to the build path as
well. Maybe it’s because I use Eclipse and not IDEA.

Thanks, Morten!

The proof, as ‘they’ say is in the pudding…

Here’s the passing case:

Now for the failing case (with the ? taken out of the XQuery transformation):

Take a good look at the way the failed assertion is represented in the above screenshot. Something else to love about Groovy!

Hope this helps some other OSB user actually trying to embrace good software engineering practices.

The above isn’t perfect but it’s better than nothing. Use it; improve it; share it. Please let me know what you have done…

Restating something I said in the Oracle SOA Suite forums:

IMHO it is RIDICULOUS that what we are trying to achieve here is not clearly described and supported for OSB.

For something like Apache Camel or Spring Integration testing is a complete no-brainer. For OSB it seems almost impossible to do properly. For me this is a (/one of the) killer points AGAINST OSB.

Its a shame that this is not available from Oracle but then one can’t really expect them to go to all that trouble of carefully crafting a tool like OSB with maximum lock-in potential and then make the APIs openly accessible, can one?
(…and yes I do know the genesis of Apache XMLBeans…)

Ooohhhh…hope I’m not breaking any licensing rules here…don’t want to tangle with Oracle’s lawyers, after all!

I’ve been known to say: “Don’t start a Java application without Spring. Ever.”

The primary reason for this is versatility. I can and have used Spring to:

• Develop various species of plain ‘ole web applications
• Develop webflow-based web applications
• Develop reporting applications incorporating eclipse BIRT
• Develop Swing-based desktop applications (using TeeChart)
• Develop batch processing systems
• Helped develop XML pipeline processing systems (alongside Stylus Studio‘s XML processing framework)
• Develop system integration processing flows
• …and probably a few more bits and pieces…

The Spring-oriented skills I have built up have let me work in a substantially standardized way regardless of the situation.

That’s pretty darned good, if you ask me!

Is this same story true of the obnoxious OSB? No.
Is it true for any implementation of the J(2)EE spec.? No. From any vendor? No.
Is it true for other frameworks like JBoss Seam. No.

Anyone know of any other framework out there offering similar flexibility, ‘cos I’m darned if I do.

The Spring framework isn’t standing still, either…it’s the foundation for both Grails and Griffon. As I have adopted these technologies, my productivity has increased greatly. I am “standing on the backs of Giants.” This is a Really Good Thing.

Let’s add a modicum of “Systems Thinking” here. Rather than wasting time training a multitude of staff in a multitude of (typically short-lived) siloed technologies…some of which are honestly horrid…it makes much more sense to build a solid core of experience with a solid core technology.

Whoops! Here I go advocating a standards-based ICT world…again.

‘Standards.’ “Systems Thinking.” How naive am I!

[...edit...]
Received an email from Manning the publishers a while back:

I know that this is not a scientific measure of ‘goodness’ (if one were even possible), but it speaks volumes to me…

Here’s the blurb:

LogMX is an intuitive and easy-to-use cross platform tool for developers and administrators working with log & trace files.

Neat-o.

Both free and commercial versions exist…

They seem to be finally “getting it.”

As I said before: About Bloody Time! It would have made my life on an earlier project a whole lot easier.