This sort of request might return a response code of 200 in a more typical web request with perhaps a relevant error message or similar. It felt that within a service – no human action, intervention or response – something a little more informative or appropriate was required such as 422 Unprocessable Entity.

To achieve this I defined an out fault interceptor as follows.

        <jaxws:outFaultInterceptors>
            <bean class="mypackage.MyServiceOutInterceptor"/>
        </jaxws:outFaultInterceptors>

The implementation was rather simple in the end:

public class MyServiceOutInterceptor extends AbstractSoapInterceptor {

    public MyServiceOutInterceptor() {
        super(Phase.SEND);
    }

    public void handleMessage(SoapMessage soapMessage) throws Fault {

        Set<Class<?>> formats = soapMessage.getContentFormats();
        for (Class<?> format : formats) {

            Object content = soapMessage.getContent(format);
            if (isServiceError(content)) {
                ServiceFaultException exception = asServiceError(content);
                soapMessage.put(org.apache.cxf.message.Message.RESPONSE_CODE, exception.getResponseCode());
                break;
            }

        }

    }

    private ServiceFaultException asServiceError(Object content) {
        return (ServiceFaultException) ((Fault) content).getCause();
    }

    private boolean isServiceError(Object content) {
        return (content.getClass().isAssignableFrom(SoapFault.class))
                && (((Fault) content).getCause() instanceof ServiceFaultException);
    }

}

We check that we have a valid error, and then deliberately set the response code for the SOAP message.

The ServiceFaultException class shown above is defined as a web fault using @WebFault and the relevant error message and code is set as required.

So, the merits of returning 422 for an entity that can not be found aside, the above demonstrates how to change the response code returned as a part of a SOAP fault to anything you like.

java.util.UUID.randomUUID().toString();

and set directly either as a field variable on instantiation or sometimes in an interceptor on save.

On a recent project we had to migrate some data across some new entities and needed something outside the application to generate the UUID values for each record. I knew that PostgreSQL supported UUID generation – though I had never used this before – and even has a UUID data type. Getting to the function itself proved a little more challenging as it isn’t actually included on a typical installation and is found within the postgres-contrib package. So, to install…

apt-get install postgresql-contrib
sudo su -c "psql pdrivers < /usr/share/postgresql/8.4/contrib/uuid-ossp.sql" postgres

The above installs the relevant contrib package, and creates the UUID functions from the script within the unpacked contrib directory (substitute version as required). We are also installing the function as a superuser (postgres in this case) as we need a user with the ability to install functions using C code.

To generate UUID values execute as follows:

SELECT uuid_generate_v1();

c1b84d24-90c9-11e0-aa50-33cd7e76d901
e9e3b374-90c9-11e0-8f0f-df46bcf47f20
eea6fba0-90c9-11e0-9ce0-a33175edde97

Some good references on the available functions can be found here with some further info on the package OSSP UUID pages here.

Frankly, I don’t know for sure which particular package was the culprit. There was nothing logged that pointed to any issues – indeed any and all logs I went through indicated all was well. I also could not find a single thing online that resembled what I was experiencing. I have managed my own servers for about 10 years now. I’m far from a competent Linux admin but I usually know enough to get by or just enough to get out of trouble, so I became severely frustrated when a seemingly simple upgrade could result in all my sites being made unavailable.

I started by stripping back my Apache install to next to nothing – which brought back a single static site i set up as a test. Then line-by-line I reintroduced various modules, includes and various directive lines. At the very bottom I had my mod_jk include – which by the way serves over half of my sites.

As soon as I reintroduced mod_jk it dumped. After much fiddling, rebuilding mod_jk, installing from rpm, downgrading packages, tinkering with various mod_jk parameters, using strace on startup (great article on debugging with strace here) I finally put it down to the inclusion of the following:

<Location /*/META-INF/*>
    Deny From All
</Location>
<Location /*/WEB-INF/*>
    Deny From All
</Location>

The above tells Apache as a global directive to disallow any access to the protected Java web application directories WEB-INF and META-INF.

The lines above have been a part of my apache/mod_jk config for as long as I remember. I haven’t yet had a good look as to why the above is no longer acceptable – I’m just relieved to have everything back up. I would have expected Apache to complain about configuration errors, issue the relevant message and fail to start just like it does for most other issues. Not so in this case and furthermore it silently takes down the whole server instance.

I didn’t find any references to this anywhere – perhaps this will help someone equally confused as I was

Uncle Bob of ObjectMentor has posted a quick demo here.

You can download either a WAR file or pre-packaged for your distro including RPMs and Debian packages. Well worth a look.

From a post with the same name, check out this entry from Joel on Software.

Cracker!

Frankly, the case for DTOs is well and truly closed – take a look at Martin Fowler’s entry for a good description of the pattern from his book Patterns of Enterprise Application Architecture. There’s a heap of other references from a simple Google search.

In this light, I was recently directed to a new assembler library by Rob Monie that he described on Back to Front. Its very easy to use and allows you to manage the process of traversing the object graph quite easily relying on convention over configuration techniques. It goes a long way to taking most of the tedioum of providing an assembler and transformation mechanism for your domain and DTO objects. The project is free and open source on Google Code. Definately worth a look.

Check out version 3.1.0 here http://executequery.org
Feedback most welcome. Contributions most welcome.

I do plan for future releases to be more incremental and frequent.