JTeam Blog » Hippo

JTeam en rijksoverheid.nl

Jettro Coenradie — Mon, 05 Apr 2010 14:47:56 +0000

www.rijksoverheid.nl is live. Hoelang geleden het idee achter één rijksbrede website is ontstaan weet ik niet. Hoelang ik nu bij het project betrokken ben weet ik wel.

Het is nu ongeveer anderhalf jaar geleden dat ik ben begonnen als Software Architect bij het project Overheid Nieuws Stijl. Het is een ambitieus project om 16 websites samen te laten komen in één rijksbrede website www.rijksoverheid.nl. Met de eerste live gang zijn er 7 websites over: postbus 51, regering.nl, minaz.nl, minez.nl, minocw.nl, minvws.nl en jeugengezin.nl. Uiteraard moest de meeste content van de websites ook op de nieuwe website terug te vinden zijn.

Vanuit de overheid is er voor gekozen om zoveel mogelijk Open Source software te gaan gebruiken. Ook voor het project Overheid Nieuwe Stijl (ONS) is er gekozen voor meerdere Open Source oplossingen. Naast het gebruik van Open Source software worden zaken als Open Standaarden en ook Open Data belangrijk gevonden. Vooral Open Data wordt door iedereen als zeer positief ervaren. De licentie voor alle content is Creative Commons.

Mocht je meer informatie willen hebben over dit enorme project, dan kun je deze hier vinden.

In deze blogpost wil ik me vooral concentreren op de betrokkenheid van JTeam bij dit ambitieuze project voor de rijksoverheid.

Proof-Of-Concept (Poc)

Voor mij startte het project ergens in September 2009. Samen met twee mensen vanuit de overheid een iemand van Hippo zouden wij het Hippo cms op de pijnbank leggen tijdens een Proof-Of-Concept (PoC). Voor deze PoC was er al veel onderzoek gedaan naar content management systemen, daar is Hippo uitgekomen als de beste keuze voor de eisen van de nieuwe rijksoverheid website. Al tijdens de PoC bleek dat Hippo graag wilde helpen om een succes te maken van dit project. Ze hebben vanuit Hippo tijdens de PoC en uiteraard ook tijdens de rest van het project veel features opgeleverd die wij als rijksoverheid nodig hadden. Tijdens de PoC heb ik geholpen de oplossing te realiseren. Waar nodig ben ik kritisch richting Hippo geweest. Heb soms zelfs om verbeteringen gevraagd. Dit heb ik en uiteraard ook mijn collega’s tijdens het project vaker gedaan. Zo hebben we bugs gerapporteerd, soms ook wat patches gemaakt om de uiteindelijke oplossingen beter te maken.

Een klein onderdeel van de PoC was het importeren van content en beschikbaar stellen van data. Door gebruik te maken van spring-ws en spring integration en een eigen gemaakte hippo connector bleek dit heel goed mogelijk.

Met hard werken is de PoC uiteindelijk geslaagd en konden de plannen voor het echte project worden gemaakt.

De aanbesteding

In afwachting van de aanbesteding is het project team verder gegaan met het maken van plannen en voorbereiden van het project. Nadat JTeam bij een van de 6 partijen hoorde is het team uitgebreid en inmiddels zitten Roberto, Rob en Tom ook in het team. Daarmee hebben we als JTeam een behoorlijke bijdrage geleverd aan de uiteindelijke oplossing.

Open Source

Zoals eerder al gezegd is er de voorkeur om zoveel mogelijk met Open Source te werken. Het is bekend dat we gebruik maken van Hippo als content management systeem. Hippo werkt mee in het project, de samenwerking met Hippo heb ik als zeer prettig ervaren. We houden elkaar scherp en vullen elkaar duidelijk aan qua kennis.

Naast hippo zijn er ook nog andere Open Source technologiën waar we gebruik van maken. De belangrijkste die ik nog wel wil noemen zijn twee spring framework projecten. We hebben spring webservices gebruikt voor het accepteren van nieuwe content en content updates. Het afhandelen van nieuwe content is een complex stuk dat we uiteindelijk oplossen met spring integration. Deze technologiën zijn onmisbaar in het hele content migratie stuk. Daarnaast maken we ook gebruik van de RSS mogelijkheden die het spring framework out-of-the-box ondersteund.

Data migratie

De data van de websites wordt middels een commerciële tool geïmporteerd. Kapow van kapowtech is een gespecialiseerde tool voor het lezen van bestaande websites. Zij spreken vervolgens een door ons gerealiseerde webservice aan om de content in Hippo te krijgen. Dit heeft zich tot nu toe bewezen als zeer efficiënt.

Web richtlijnen

Vanuit het ministerie van Volksgezondheid, Welzijn en Sport zijn een aantal mensen binnen gekomen die veel doen met de web richtlijnen. Twee van hen zijn nauw betrokken bij bij het tot stand komen en dus ook naleven van de web richtlijnen. Ik moet eerlijk toegeven dat ik me hier nooit zoveel mee bezig heb gehouden. Natuurlijk kende ik de basis wel, maar ik heb al best wel aardig wat geleerd van deze mannen. Ik heb begrepen dat we nu al nagenoeg voldoen aan de nieuwe versie van de web richtlijnen die momenteel wordt vastgelegd.

Hosting en infrastructuur

Zonder een goede infrastructuur is het onmogelijk om een goede site op te leveren. We maken al lang gebruik van een specialist op het gebied van infrastructuur. Hij komt van het bedrijf prolocation. Samen met een collega heeft hij mij echt weten te verbazen. De kennis die deze twee gasten hebben is enorm. Heb veel van hen opgestoken.

De hosting ga ik het niet te veel over hebben. Hier is het nodige om te doen. Weet wel dat we er erg veel energie in hebben moeten stoppen om de infrastructuur zo te krijgen dat het voor ons project werkt zoals het zou moeten werken.

Open Data

Ik heb al eerder gezegd dat Open Data erg belangrijk is voor het project. In de huidige versie hebben we nog niet zo heel veel gedaan aan het beschikbaar stellen van data. Het gebruik van Creative Commons is wellicht het belangrijkste. Wel is er gestart met het beschikbaar stellen van rss feeds. Uiteraard zullen hier in de toekomst meer features worden opgeleverd.

Persoonlijk moet ik er nog wel eens aan wennen. Ik was dan ook nogal skeptisch over het initiatief van een andere partij om toch meer feeds aan te bieden. Vanuit het project was men het hier echter helemaal niet mee eens en vond dit juist een mooi initiatief.

http://rijksoverheid.jijendeoverheid.nl/

De mensen

Als laatste wil ik toch nog even in gaan op de mensen die in het project zitten. Ik vind echt dat we een enorm goed team hebben weten te creëren met mensen die overal vandaan kwamen. Ambtenaren en externen gaan samen volledig voor een resultaat dat er mag zijn.

Het resultaat

Super snelle website en een gaaf project.

Wat we binnen dit project voor elkaar krijgen kan alleen met een team, en dat is precies wat we met zijn allen zijn geworden. Ik ben enorm trots op dat ik mee heb mogen werken met dit project en ik denk dat ik nog wel even mee blij werken om ook de volgende fases mee te kunnen maken.

Migrating content with Spring Integration – A real life example

Roberto van der Linden — Wed, 13 Jan 2010 07:38:30 +0000

In one of the projects we need to migrate content from multiple websites into Hippo CMS. One of the interesting parts of this migration is that one of the websites will constantly provide us with updates of the content. Therefore it makes the migration a continuous process.

In this post I will explain how we use Spring Integration to migrate content, handle errors, measure performance and deal with the fact that content could contain references to other content that is not imported yet.

Short Spring Integration introduction

As I cannot explain Spring Integration in a few sentences, I will just focus on the elements that I use in the example. To get a complete overview of the elements I recommend you to read the reference manual.

Message – Generic container for data. It contains the payload which can be any object.
Message Channel – Used for transporting the data between the different elements.
ChannelAdapter – Message Endpoint that enables connecting a single sender or receiver to a channel.
Transformer – Enables the loose-coupling of Message Producers and Message Consumers by transforming a message to another type.
Service activator – The endpoint type for connecting any Spring-managed Object to an input channel so that it may play the role of a service.
Router – Provides a simple way to connect a router to an input channel.
Splitter – Partition a message in several parts, and send the resulting messages to be processed independently.

Getting the content

Before you can start importing the content, you of course need to scrape the content from the different websites. In our case this is done by the guys from Kapow. They provide us with a lot content that is preformatted in XML files so that our import tool can handle the incoming requests. The content is distinguished by the type of document. So for example we could have news, address, a brochure and many more. The different types of documents contain data like images, videos, PDF files and of course text. Each XML file contains an element that represent a unique id for that file. This is used to identify any existing documents in the CMS.

Connecting to the repository

Hippo CMS is created on top of the Apache Jackrabbit repository. We connect directly to the repository using the Hippo Repository Connector that is provided in the Hippo Site Toolkit. This enables us to interact with the repository and provides us the possibility to perform actions like storing, editing and finding nodes.

My colleague Jettro Coenradie has written a blog post that goes more in-depth about connecting to the Hippo Repository.

Process overview

Starting point

As you can see in the image we provide two ways for Kapow to deliver the content. One is via web services and the other one is directly via the file system (as Kapow runs its tool on the same server as the importer). This has few reasons:

Web services provides more flexibility for other applications to connect with the importer tool.
Using the web service will prevent the problem that Spring Integration tries to read the file before it is completely written to the file system.
When the web service is not available, Kapow is still able to write the XML files directly to the file system.

Webservice

Spring Integration provides us with a inbound web service gateway that send a message to a channel that is received from a Web Service invocation.

As you can see in the process overview image, messages that are received from the web service are enriched with the filename and then written to the file system. We have to do this in order to create an XML file (using the transformer) which obviously needs a filename. With the file outbound gateway the XML file is placed in the directory that is scanned for new files.

To make this all work we have to configure in the Spring WS servlet the endpoint mapping that know which request needs to map to our gateway that is configured in our integration context.

When the process is finished with writing to the file system and therefore correctly received by the importer we use a service activator that returns a ResponseMessage with the text “OK”. This response message is received by Kapow.

The endpoint configuration in the web service servlet:

    
        
            
                webserviceGateway
                webserviceGateway

The integration configuration:

Transform file

All the XML files are written to the file system in a given directory. With the inbound-channel-adapter element the files are read from the given directory. You can provide a filter that only accepts the types based on the known suffix. In our case the only files we want to read are XML files. The poller is used to configure how the maximum messages we want per poll and on what interval it needs to scan the directory for new files.

The file-to-string-transformer element transforms, as the name already suggests, a file to a string. This string is then used by the unmarshalling-transformer as input for the unmarshalling process to create JAXB objects.


    
        :         
    









    



    
        
            
        
    
    
        
            nl.jteam.importer.jaxb.news
            nl.jteam.importer.jaxb.address
        
    
    
        
            classpath:/xsd/news.xsd
            classpath:/xsd/address.xsd

Document router

To identify which handler class needs to handle the document that is being imported, we created a router. This router gets the name from the payload and returns this value. This value than can be used to determine the channel to put the message on. So when the name of the payload is News it will use the channel with id News to put the message on.

The configuration:

The implementation of the router class:

public class DocumentTypeMessageRouter {

    public String resolveObjectTypeChannel(Message message) {
        return message.getPayload().getClass().getSimpleName();
    }
}

Handlers

Each document type has his own handler class. This class is responsible for handling all the properties that are relevant for that document.

A document in Hippo CMS is a JCR node in the repository. The handler will create this node if it not already exists. If it does exist it will take that node. Because the content from the XML is the correct content, all properties and child nodes will be removed. So any change that is made to the content via the CMS in that document will be gone. Because we keep the node, references in the repository by other nodes will be intact, but all properties will be recreated by the handler.

For each property the handler will add this to the node or calls another handler that handles that specific property such as an image handler or audio handler class.

Missing links

It could be that a document has references to another document that is not imported yet. This means that the link cannot be created yet. To solve this problem we store for each link that cannot be created a missing link node in the repository. This node contains the information that is necessary to create the link when that document is imported. I will explain later on how the missing links are used when updating content.

When the handler is finished with creating a document in Hippo CMS, it will execute a query that finds all the documents that contain a reference to the imported document or in other words, it will find all missing links that now can be resolved.

Referred documents splitter

The outcome of the query that looks for references to the imported document could return multiple documents of different types. For example, we have imported an address document and that document is referenced by a news item and a press release item. These two documents will each be represented in a ReferredDefinition object. These ReferredDefinition objects contain the information of the missing link node plus the unique repository id (uuid) of the currently imported document.

Spring Integration provides us a splitter that has the capability to partition the message in several messages. The implementation of our splitter receives a list of ReferredDefinition objects. Each message (ReferredDefinition object) will be send to a router that routes the ReferredDefinition object to his appropriate channel.

The configuration:

The referred by message splitter class:

public class ReferredByMessageSplitter {

    public List splitReferredDefinitions(List referedDefinitions) {
        return referredDefinitions;
    }
}

Referred by router

The splitter provides the router with a single ReferredDefinition item. The ReferredDefinition object contains information about the document type that needs to be updated. The implementation of the router is quite simple. It gets the type of the document that needs to be updated and adds the string “Update” to the document type. This combination gives us the name of the channel that is used to put the message on.

The configuration:

The referred by message router class:

public class ReferredByMessageRouter {

    public String resolveItemChannel(ReferredDefinition referredDefinition) {
        return referredDefinition.getPrimaryTypeReferredBy() + "Update";
    }
}

Update handlers

Each document type has just like the normal handlers his own update handler. The update handlers are used for updating content that has a reference to the imported document. The handler receives in ReferredDefinition object which contains the information of the document that contains the reference.

So if we have for example two documents (A and B). B is a news item that contains a field addres and A is an address document. Document B is already imported and has a reference to A. Document B links to document A, but because A was not imported yet, a missing link node for A exists. Now document A is going to be imported, so document B can be updated with a working link. The content handler of A finds the missing link and creates a ReferredDefinition object with the information of the missing link. The update handler finds document B based on his unique id that is also stored in the ReferredDefinition object.

Now that document B is found, the update handler can add the correct property (which is specified in the ReferredDefinition object) to document B with the link to document A. When the link is created, it is no longer necessary to keep the missing link node and will therefore be removed.

Error handling

When importing content errors could occur. We distinguish between two types of errors:

Critical errors – Something is wrong with the XML structure or with the connection to the repository.
Non critical errors – Errors like incorrect content or links that cannot be created.

When a critical error occurs it means that we cannot import that document at this moment. So we have defined an error channel that is used to put the payload on and transform it back to an XML file. That file is than written to a different folder, so that it will not be picked up again by Spring Integration.

With non critical errors it is only necessary to notify a system admin that something went wrong. So in order to do this, we introduced an error collector. This error collector is nothing more than object that contains a list of errors and a little information about the document. This collector is passed through the whole process of importing a document and all errors that occur will be collected. At the end of that process the errors will be mailed to the system admin. Currently this is done after each document, but this will probably change in the future to use some sort of batch mailing.

Performance

With the use of an aspect we send a message to the performanceMonitor channel. When you declare a MessageChannel you can call the method send(..) to send your message to the channel. In our case we create a new StringMessage to send the performance message. The channel is used by the service-activator. The service-activator uses a poller to throttle inbound messages.

The service-activator passes the message to the Log4jMonitorPersister, where it logs the message.

The configuration:

The MonitoringHandlersAdvice class:

@Aspect
public class MonitoringHandlersAdvice {

    private MessageChannel channel;

    @Around("execution(* nl.jteam.importer.handler.*Handler.handleMessage(..)) && args(message)")
    public Object monitorB(ProceedingJoinPoint proceedingJoinPoint, Message message)
            throws Throwable {
        String fileName = (String) message.getHeaders().get("springintegration_file_name");
        Object payload = message.getPayload();

        StopWatch clock = new StopWatch();
        DateTime start = new DateTime();

        try {
            clock.start(proceedingJoinPoint.toShortString());
            return proceedingJoinPoint.proceed(new Object[]{message});
        } finally {
            clock.stop();
            StringBuilder outMessageBuilder = new StringBuilder();
            outMessageBuilder.append(clock.getTotalTimeMillis()).append(";")
                    .append(payload.getClass().getSimpleName()).append(";")
                    .append(fileName).append(";")
                    .append(start.toString("yyyy-MM-dd HH:mm:ss"));
            channel.send(new StringMessage(outMessageBuilder.toString()));
        }
    }

    @Required
    public void setPerformanceMonitor(MessageChannel performanceMonitor) {
        channel = performanceMonitor;
    }
}

The Log4jMonitorPersister class:

public class Log4jMonitorPersister implements MonitorPersister {
    private final static Logger log = LoggerFactory.getLogger(MonitorPersister.class);

    @Override
    public void persist(String monitorEvent) {
        log.info(monitorEvent);
    }
}

Conclusion

I have showed you how we use Spring Integration to migrate XML content to Hippo CMS. As you could see the configuration is relatively simple and when we want to import a new content type, all we have to do is create a handler and wire up the configuration. As always SpringSource provides good documentation that makes is easy work with Spring Integration.

References

Spring Integration: http://static.springsource.org/spring-integration/reference/htmlsingle/spring-integration-reference.html

Some thoughts about the Dutch Government….

Leonard Wolters — Mon, 30 Mar 2009 15:28:39 +0000

As some of you might already noticed, recently a lot of exposure has been granted to the news that the Dutch Government has decided on using Open Source technologies for their new communication platform. Not only Dutch news sites like nu.nl & webwereld announced this news, but even the traditional newspapers and “het Financiele Dagblad” thought this was something to proudly announce to the their readers.

Well, being true Open Source Believers from the early days, JTeam is very pleased that the world out there is finally starting to adopt the Open Source Model. More and more companies understand the value of Open Source technologies (for example iLocal) and are convinced enough to build their business on top of it. And as for now, even the Dutch Government is starting to change. Well that’s a positive thing.

It shouldn’t come as a surprise that JTeam was (and still is) involved in the decision. We empowered the Minestry of General Affairs (Ministerie van Algemene Zaken) and its personnel for about a couple of months and helped them to setup a good development process as well as taught its employees everything they need to know in order to execute this project by themselves. This is also something that pleasantly surprises me. Instead of outsourcing IT projects and lightling candles every day hoping that their development partners will successfully deliver, they’ve become more mature and decided to give a try themselves. Having this knowledge & experience in house will eventually result in better quality and less costs. Why? Because governmental projects are dynamic as well and also require an agile project management methodoly combined with XP development skills. It is questionable if outsourcing partners can deliver the same quality and communication skills as their internal department does. But let’s see how this project (and all related side projects) will eventually end.