My last talk at Devoxx was the one that perhaps i enjoyed the most and one that I was really impressed by. A lot of neat products based on Groovy were discussed in this talk. They had a lot in common. Besides all being based on Groovy, they also have a very simple installation procedure in common: just download the product, unzip it, and add the executable to the PATH variable. And voilá, you have a command line tool at your disposal linked to the product you downloaded.

The talk was presented by Andres Almiray. All the products he discussed, he demoed by using a text editor and a command line (and sometimes a web browser), which was pretty cool. It furthermore emphasized the simplicity of working with the different products. Like Andres did in his presentation, I will focus this blog on Grails, Griffon and Gradle and only give a short summary of the other products.

Grails

First up was maybe the most widely known product in the Groovy eco-system. Grails is a high-productivity web application framework based on Spring, Hibernate and Sitemesh. It’s a widely used framework and currently there are over 600 plugins available for Grails, facilitating the addition of custom functionality (like file uploading or integration with soap or rest services) to your web application.

With Grails you bring Rapid Application Web Development to the table. In no time Andres got a CRUD application up an running.

First he created a basic Grails application

$ grails create-app devoxx

Next, he added some domain classes

$ grails create-domain-class Author
$ grails create-domain-class Book

This created the Author.groovy and Book.groovy class files.

The relation between the two classes Andres added manually by adding the following line of code to the Author class:

static hasMany [books:Book]

With the domain classes in order, we can now create 2 controller classes AuthorController and BookController:

$ grails create-controller Author
$ grails create-controller Book

Now, to enable auto-generation of the view layer of the application based on the domain classes, we have to enable a feature called scaffolding. The following line of code added to the AuthorController takes care of this:

static scaffold = true

Now all is in place for running the application:

$ grails run-app

With scaffolding in place all the views for the CRUD app get auto-generated (as .gsp pages). The run-app command furthermore packages the application and bootstraps TomCat. Now you can reach the application at the following url: http://localhost:8080/devoxx/author.

One additional benefit of using these basic commands to rapidly generate a prototype is that every generated class gets to appear in its own default package, given that Grails is based on the configuration by exception paradigm. Scaffolding is based on templates and all these templates can be customized to fit your needs.

After the basics Andres shows some additional Grails features. All of them very easy to add to the application:

• Adding constraints to domain classes (Grails error messages support i18n);
• Creating a taglib: $ grails create-taglib;
• Launching the Grails console, an interactive playground, similar to the Groovy console: $ grails console
• The grails war command: $ grails war;
• Installing the Grails REST plugin: $ grails install-plugin rest;
• Creating and packaging a custom plugin: $ grails create-plugin / $ grails package-plugin.

Griffon

Griffon is similar to Grails. It’s a high productivity framework for building Desktop applications. Griffon is a relatively new framework. It already has nearly 200 plugins available though.

A lot of the commands in Griffon are similar to the commands used in Grails. Here are some useful commands:

$ griffon create-app devoxx
$ griffon run-app
$ griffon run-applet
$ griffon run-webstart

Views are by convention filed under the view directory in a Griffon project and are named …View.groovy. Griffon uses bindings to couple fields or properties in the view layer to bean properties in the model layer. Here are some code snippets to illustrate:

DevoxxModel.groovy

@Bindable String input
@Bindable String output

DevoxxController.groovy

def copy = {
  // model gets injected by Griffon
  model.output = model.input
}

DevoxxView.groovy

textField(text:bind(target:model,targetProperty:'input'))
textField(text:bind(source:model,targetProperty:'output'))

The controller copy method copies the input property of the model to the output property. Both properties are bound in the view to text fields.

One of the key concerns that’s difficult to manage in Swing applications is threading. And this is something in which Griffon really shines. For example if you have a controller method you want to execute in a thread separate from the UI Thread, you add the following annotation:

@Threading(Threading.Policy.OUTSIDE_UITHREAD)

As an alternative you can make use of the following Griffon methods to execute pieces of code in the threaded manner you want:

• execAsync: execute the code in the UI Thread asynchronously;
• execSync: execute the code in the UI Thread synchronously;
• execOutside: execute the code outside the UI Thread.

Griffon also supports an event mechanism. You can launch an event called Devoxx and include a list of parameters with the following Griffon code:

app.event('Devoxx',[1,2,3])

Like the exec method, there’s also a variant for asynchronous events (app.eentAsync) and one for outside events (app.eventOutside).

A possible event handler could look like this:

def onDevoxx = { n1,n2,n3 ->
println: "Devoxx $n1,$n2,$n3"
}

A lot of the create- commands from Griffon also let you generate artifacts in Java instead of Groovy. Simply add fileType=java to the command. One interesting, though not very surprising, fact to note is that the Java files are a lot bigger compared to the same files generated in Groovy.

Gaelyk

Gaelyk is a lightweight Groovy toolkit for Google App Engine Java. Google App Engine is a so called Platform As A Service and provides a Java 6 Runtime Environment.

Gradle

Gradle is a Groovy alternative to Maven. It’s a tool for building applications. It uses Groovy DSL (Domain Specific Language) instead of XML and adheres to specific Maven conventions.

This is an example of a simple Gradle build file for a java project (compare that to a simple Maven file):

build.gradle

apply plugin: 'java'

This is a build file for a java project that uses the same default conventions as Maven does (like java source files are by default placed in the src/main/java directory).
To build a project based on this build file, simply type:

$ gradle build

When you issue this command, Gradle bootstraps and builds the project. When you issue the command a next time and there are no changes, Gradle is able to recognize this and doesn’t perform an unnecessary second build. You still lose the amount of time needed for bootstrapping Gradle. There’s also an experimental daemon available, so you can go without even the bootstrapping time. Gradle, like Maven, uses configuration by exception. So, like Maven, you can do without the default structure of a project is that doesn’t fit your needs. But you have to add additional configuration code to your build file.

Dependency management in Gradle by default uses Maven repositories. For example, to add a compile dependency for commons-lang, your build file would need these additional lines of code:

repositories {
    mavenCentral()
}

dependencies {
    compile 'commons-lang:commons-lang:2.6'
}

To view a list of dependencies for the current project you can issue the following Gradle command:

$ gradle dependencies

Multiprojects in Gradle are very easy. Assume you have a multi project with two projects multi-core and multi-ext, where multi-ext is dependent on multi-core. You first add a settings.gradle file next to the build.gradle file for the root project:
settings.gradle

include 'multi-core'
include 'multi-ext'

Next you add a dependency on multi-core in the build.gradle file of the multi-ext project. And that’s all there is to it. When you now build the multi-ext project, the multi-core project also gets build. Changes to the multi-core project are also picked up when rebuilding the multi-ext project.

To build a pom file for your current project, issue the following command:

$ gradle install

Like Maven, you can define properties in Gradle in a gradle.properties file.

The open source projects Grails and Griffon both use Gradle as their build tool.

Gant

Gant is a Groovy version of Ant. You have the power of Ant at your disposal but in a Groovy way, thus without the bloated xml.

easyb

easyb is a behavior driven development (BDD) framework. Stories and specifications are written in Groovy. It is comparable to JBehave, which does the same in Java.

Spock

Spock is a testing and specification framework for Java and Groovy applications.

CodeNarc

CodeNarc is an equivalent to the java tools findBugs and checkstyle. It’s a tool for analyzing Groovy code and detecting bugs, coding malpractices and the like. There are plugins available for Grails, Griffon and Gradle.

GPars

Gpars lastly is a framework aimed to simplify concurrency programming in Java or Groovy.

References

• Devoxx Slides
• Griffon Slides
• Grails in Action
• Griffon in Action
• GroovyMag

Exposing your PL/SQL procedures to the outside world is nothing new. Using either mod_plsql or dbms_epg one could easily access those procedures through an URL including some parameters to dynamically generate xml, or some other type of resource.

But, if you wanted to provide a true REST-style service you might run out of options. mod_plsql wasn’t designed to do this. It only treats URL’s having parameters, which need to  correspond with your PL/SQL procedure’s parameters. Other than that, there’s no such thing as a “HTTPRequest” in PL/SQL, which means no reading posted data directly.

So, if you want your service to accept raw postdata, the solution is to use Resource Templates which can be configured within the Apex Listener.
When you have the listener up and running, go to the administration site by navigating to http://server:port/apex/listenerAdmin. Here you will find the Resource Templates tab.

The idea here is to add a specific location to your server and configure handlers, which correspond to  HTTP operations like PUT, POST, GET, DELETE.
For instance , specifing an URI template like getsomeresource/{identifier} automatically maps the “identifier” part of the URL as a variable when calling a SQL statement or a PL/SQL block. Keep in mind that none, one, or more of these variables can be specified in the template, but no optional parameters can be configured.

If you need some additional info like the value of the Accept-Language header sent by a browser as part of the request, you can manualy map these to variables by providing a varaiable name and an alias. The alias corresponds with is the actual name of the header you want to capture.  Using this variable you can generate language specific resources.

In our case, we just want to provide a service on a specific location where some data will be posted to for further processing.
So we create an URI template “processdata” with no further variables. The handler will ofcourse be of type POST.
We need to specify a resource generation strategy, in our case a PL/SQL block.
Here we can have direct access to the POST’s content body and content type send by the requestor using special, built-in variables.

declare
begin
:status := pkg_resource.process(:contentType,:body);
end;

Note that the “status” variable must be mapped to a parameter with a built-in alias value X-APEX-STATUS-CODE. This takes care of sending back the actual HTTP status code in the response header like 201: “resource created”. In this case the status code is the return value of the pkg_resource.process function. In case something goes wrong processing, you can return an appropriate code. For a full list of HTTP status codes see : http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html.
Also note that there’s no need to map the body and content type variables, it’s been taken care of already for you. The “body” will be passed to the PL/SQL procedure as a blob so you can process the data yourself.

Using Apex Listener’s resource templates allow you to generate content based on SQL queries and PL/SQL blocks, returning csv, custom output and JSON representations, so plenty of options to provide REST-style services to expose your database and make integration with other processes or services easier.

Today I was confronted with the following situation: a table with two columns that contained IDs. The content was more or less something like this:

ID ALIAS
1  2
2  1
1  3
2  2

I had to eliminate the records that pointed to themselves (i.e. ID = ALIAS), because it’s a bit silly to say that you’re an alias of yourself.

I also had to eliminate the records that were essentially duplicates. In this example, the record “2, 1″ is functionally the same record as “1, 2″ and thus I didn’t need it.

Could this be solved using SQL only? I suspected it, but couldn’t find a solution fast enough. I called in the help of my colleagues and within minutes Martin Schaap helped me out:

select id, alias
from t
where id <> alias -- that was the easy part
and not exists ( -- here comes the hard part
  select 1
  from t
  where id = t.alias
  and alias = t.id
  and rowid > t.rowid
);

Thanks Martin!

UPDATE: one day later, Frank Dorst (yes, that’s right, our “I once was a developer” CTO) also sent me an elegant, working solution:

select distinct least(id, alias), greatest(id, alias)
from t
where id <> alias;

Kudos to you too, Frank (you still got it )!

In this blogpost I will help you installing the new version of Application Integration Architecture Foundation Pack, which is part of the FMW 11G R1 PS3 ( 11.1.1.4.0)  release.  In a previous blogpost I already explained how to do this on PS2. With the PS3 version you will see, that Oracle improved the installation compared to PS2  and combined with the developer release of SOA Suite PS3 ( the memory footprint is less ) the PS3 version is a big improvement.

Before you can start you need to have a working SOA Suite Ps3 Weblogic domain.  I choose for  the SOA Suite for developers, in this case I have one AdminServer which runs it all.

The second thing you need to check in the Weblogic console, if all the Resource Adapters are installed and running. In my case I need to target the OracleApps Adapter to the AdminServer.

Download the AIA Foundation Pack. The AIA Service Constructor can be downloaded from JDeveloper, so you can skip this for now. Extract the software and start the installation.

You need to create a new AIA Oracle Home , AIAInstance name and use the JDK of your SOA Suite Middleware home.

Start the SOA Suite Adminserver and provide these Weblogic details in this screen

AIA got its own database schema, provide the details and the sys user / password.

Provide the MDS database schema details of your SOA Suite Domain

You can skip the Oracle Enterprise Repository screen

Here the installation begins, when a step fails you can retry the step , sometimes an another retry is enough and when it fails again you need to take a look at the logs.  You can find these logs in your new  AIA HOME + aia_instances + AIA Instance Name + logs.  When you can’t fix the problem then you can look at the AIA ANT files, these are in the config folder of your AIA Instance Name and try to do it manually.

Next step is to give the Weblogic users the required  AIA roles / groups. Go the Weblogic console and in the myrealm security realms you can add some users and add them to a AIA Role like AIALifecycleUser, AIALifecycleDeveloper and AIAApplicationUser ( CAVS)

Open a browser and go to http://XXXX:7001/AIA/faces/aiaHomeLogin.jspx to see if eveything is working, In PS3 even the setup page is working.

The last step is to configure JDeveloper 11g PS3, Go to the JDeveloper update screen and select the AIA Service Constructor.

And add the aia.jar to the SOA part of the JDeveloper preferences window, located in jdeveloper/lib folder.

That’s all

Nieuwegein, February 2011 – Whitehorses, a Gold level member of Oracle PartnerNetwork (OPN) has achieved OPN Specialized status for Oracle Service-Oriented Architecture (SOA).

To achieve a Specialized status, Oracle partners are required to meet a stringent set of requirements that are based on the needs and priorities of the customer and partner community. By achieving a Specialized distinction, Whitehorses has been recognized by Oracle for its expertise in delivering services specifically around Oracle SOA Suite 11g through competency development, business results and proven success. Oracle SOA Suite 11g is an integrated, best-of-breed suite that helps customers rapidly design and assemble, deploy and manage, highly agile and adaptable business applications.

Frank Dorst, CTO of Whitehorses: “We strongly believe in the power of IT. Information technology makes real change possible and that does not always have to mean huge investments. We distinguish ourselves by clearly defined improvement projects, with involvement of both IT and business in which collaboration with customers is essential. Achieving Specialization is our confirmation that we are doing well. It continues our long relationship with Oracle and gives our customers the confidence to work with a qualified party. ”

“Whitehorses has proven knowledge and experience to meet OPN Specialization status in Oracle SOA Suite 11g,” said Bas Diepen, senior manager of Alliances and Channels at Oracle. “They know how to keep changes small and simple, no matter how big projects are. We are pleased that the investment they have made in gaining knowledge and Oracle skills, is now reflected in achieving this Specialized status.”

Whitehorses, founded in 2001, specializes in integrating systems, processes and data with an expertise in Oracle and Java Platform, Enterprise Edition (Java EE). By addressing the problems in the infrastructure directly in small, manageable steps Whitehorses helps companies improve their business. To do so they make innovative use of IT and have a clear focus on achieving visible results.

——

About Oracle PartnerNetwork
Oracle PartnerNetwork (OPN) Specialized is the latest version of Oracle’s partner program that provides partners with tools to better develop, sell and implement Oracle solutions. OPN Specialized offers resources to train and support specialized knowledge of Oracle products and solutions and has evolved to recognize Oracle’s growing product portfolio, partner base and business opportunity. Key to the latest enhancements to OPN is the ability for partners to differentiate through Specializations. Specializations are achieved through competency development, business results, expertise and proven success. To find out more visit the Oracle PartnerNetwork website.

About Whitehorses
Whitehorses enables businesses and organizations to be agile. Through innovative use of information, they help clients to perform better and to adapt more easily to change. Founded in 2001, they work within a people-oriented culture with a positive vision of information technology. They offer a special blend of the best professionals, modern technology and a smart, targeted approach. Whitehorses specializes in the Oracle platform and use Enterprise Java and other innovative technologies.

Trademarks
Oracle and Java are registered trademarks of Oracle and/or its affiliates.

Connecting to a NTLM web service can be troublesome. This blog post shows the source code of a servlet which converts HTTP calls into HTTPS calls with NTLM. The servlet takes care of the NTLM handshake.

For a customer I needed to create a BPEL process which needed information from a web service that uses NTLM. There are many ways to solve this problem. My colleague used an Authenticator: JAX-WS web service proxy client and HTTP authentication. I followed a different approach. I used the Apache HttpComponents libraries. The idea is to call a servlet as if it is the actual web service. It can be used from any application: e.g. BPEL process or soapUI. The application can be deployed on any servlet container, e.g. Apache Tomcat or OC4J.

So, what is NTLM? NTLM is a Microsoft authentication protocol. Sometimes this protocol is used by applications delevoped using the Microsoft .Net Framework. The protocol involves a handshake in several steps. NTLM is a proprietary protocol, but it is fairly well documented. How to implement NTLM in a Java client? The answer is Apache HttpComponents. The latest version of Apache HttpComponents (version 4.1 GA) has full support for NTLMv1, NTLMv2, and NTLM2 Session authentication.

Since SOAP usually means sending XML over HTTP Post a Servlet can be used to handle these requests. There is no need to modify the contents of the HTTP Post Message. When handling a SOAP request, just remember to copy the HTTP Headers.

The servlet is part of a web application which contains only one class: NTLMProxyServlet. The libraries of Apache HttpComponents (version 4.1 GA) should be included in the war file. Do not forget to map an URL to the servlet in the deployment descriptor (web.xml).

The code of the doPost method of the class NTLMProxyServlet (implements HttpServlet) is shown below. Please replace the hardcoded values for host, domain, user, url, password:

protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setCharacterEncoding("utf-8");
    PrintWriter out = response.getWriter();

    if(httpclient == null){
        httpclient = new DefaultHttpClient();
        httpclient.getAuthSchemes().register(
                "NTLM", new NTLMSchemeFactory());
        httpclient.getCredentialsProvider().setCredentials(
                new AuthScope("host", 443, "domain"),
                new NTCredentials("user", "password", "host", "domain"));
        httpclient.getParams().setParameter(
                CoreProtocolPNames.USE_EXPECT_CONTINUE, Boolean.FALSE);
        httpclient.getParams().setParameter(
                CoreProtocolPNames.PROTOCOL_VERSION,
                HttpVersion.HTTP_1_1);
        httpclient.getParams().setParameter(
                CoreProtocolPNames.HTTP_CONTENT_CHARSET, "UTF-8");
    }

    HttpPost httppost = new HttpPost(
            "https://host/webservices/getdata.asmx");
    InputStream in = null;

    try {
        in = request.getInputStream();
        Writer writer = new StringWriter();
        char[] buffer = new char[1024];
        Reader reader = new BufferedReader(
                new InputStreamReader(in, "UTF-8"));
        int n;
        while ((n = reader.read(buffer)) != -1) {
            writer.write(buffer, 0, n);
        }
        httppost.setEntity(new StringEntity(writer.toString()));

        Enumeration headernames = request.getHeaderNames();
        while (headernames.hasMoreElements()) {
            String headerName = (String) headernames.nextElement();
            String headerValue = request.getHeader(headerName);
            httppost.setHeader(headerName, headerValue);
        }
        Header h1 = httppost.getFirstHeader(HTTP.CONTENT_LEN);
        if (h1 != null) {
            httppost.removeHeader(h1);
        }
        Header h2 = httppost.getFirstHeader(HTTP.TARGET_HOST);
        if (h2 != null) {
            httppost.removeHeader(h2);
        }
        httppost.setHeader(HTTP.TARGET_HOST, "host");

        HttpResponse httpresponse = httpclient.execute(
                new HttpHost("host", 443, "https"),
                httppost,
                new BasicHttpContext());
        HttpEntity output = httpresponse.getEntity();

        Header[] headers = httpresponse.getAllHeaders();

        for (Header header : headers) {
            if (!header.getName().equals(HTTP.CONTENT_LEN)) {
                response.setHeader(header.getName(),
                        header.getValue());
            }
        }

        if (output != null) {
            out.write(EntityUtils.toString(output));
        }
    } catch (Exception e) {
        e.printStackTrace(out);
    } finally {
        in.close();
        out.flush();
        out.close();
    }
}
private DefaultHttpClient httpclient = null;

If the target server uses self-signed SSL certificates you might want to apply the code in Avoiding the “javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated” with HttpClient.

In order to use use the servlet make a local copy of the WSDL of the target web service and change the port address into the URL of the servlet, e.g.:

<wsdl:definitions>
  [...]
  <wsdl:service name="TargetWS">
    <wsdl:port name="TargetWSSoap12" binding="tns:TargetWSSoap12">
      <soap12:address location="http://localhost:8080/NTLMProxyApp/NTLMProxyServlet" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Use this modified copy of the WSDL in your BPEL process of SoapUI project.

After some rumors earlier, today we saw the first mention of 12c on an official Oracle presentation. C as in Cloud that is.

There is a big emphasis on Cloud this OpenWorld. With Exalogic Oracle releases a “Private Cloud in a Box” and yesterday Larry announced that Oracle is going to offer public cloud services on Linux and Solaris as well.

So we’ll be hearing a lot of cloud from Oracle in the next couple of years.

C is the new G – Cloud is the new Grid.

This Way for Oracle OpenWorld and JavaOne

Sunday, the first official day of Oracle OpenWorld is traditionallyPartner Network Day. A whole day of sessions is planned for Oracle Partners – 10,000 only in the EMEA region –   visiting the conference.

This year the topic was specialization and almost nothing else. Oracle wants their partners to specialize in parts of the total product offering. That makes sense, almost no company is large enough to be able to implement everything  Oracle has to sell.

For active partners the specialization message should not be news. Actually, I must say I’ve heard it all before.  There’s now a new Platinum Partner Level for global partners with over 30 specialization. That does not apply to me and frankly goes a bit against the whole concept of specializing..

There was a whole lot of emphasis on the hardware / software combination as well. And almost a call to action to become Exadata specialized.

I did enjoy the presentation by Oracle’s Andrew Sutherland,  sr. VP for middleware in EMEA, during the EMAE breakout sessions. He  pointed out a number of high priority business challenges organizations in our region must address:

• Realize Process Automation from a business perspective
• Improve Data Center Efficiency to Public Cloud standards
• Implement Information Democracy with application-embedded real-time intelligence for everybody
• Support Social, less structured Processes by combining process management and collaboration

Interesting material to discuss also with our clients. I do see real value.

Oracle OpenWorld, the largest and most important Oracle conference of the year, is getting close. From the 19th until the 23rd of September tens of thousands of IT professionals, business partners and customers will gather in San Francisco to learn, meet and share. And this year, the city will be even more crowded because the JavaOne conference and Oracle Develop are there at the same time.

Whitehorses will be present at OpenWorld 2010, like we were in the previous years. This year our two Oracle ACE’s, Edwin Biemond and Douwe Pieter van den Bos, will present and hosts sessions. I will be there as well to hear more about the direction and future strategies within our middleware, SOA/BPM and integration focus.

We will actively update this blog with our findings. Subscribe to our RSS feed and follow us on Twitter (@whitehorsesnl, @omebos, @biemond, @frank_dorst) for the latest info. In the mean time, you can read our posts from last year and 2008.

Let us know if you’ll be there in the comments or by e-mail. We’d love to meet you in San Francisco.

Google Chrome is becoming a very popular browser and attracting more users every month as you can see on w3cschools.com. As a developer I used to work mainly with Mozilla Firefox because of the great developer extensions Web Developer Toolbar and Firebug. But Google Chrome is also for the developer and even better, it’s built in. You can access the Developer tools of Google Chrome via the menu or via the shortcut Ctrl+Shift+I.

Now the Developer tools window is shown. It has a few categories, I’ll show the ones I use most. The first one is Resources, it gives information on the resources used by the page and you can order them by time or size.

The second one is Scripts. Here you can see all the scripts used on the page and the best part and even debug the scripts.

Last but not least is the Console. This displays the Javascript errors and warnings that occur on the page.

If you want the Developer tools to display in the same window as your browser, simply click the window icon in the bottom left of the screen and it will dock to the main window.

So if you are using Google Chrome as your browser and developing web pages, be sure to check out the Developer tools.