Although I am not always happy with the online documentation of the Mule ESB I found this article quite good. I have set up our configuration of Mule ESB implementation on several projects this way and it has proved to be working nicely. Although last time I got into the following issue. To use a datasource in my Mule3 project I had configured it like this in my Mule config file:

1
2
3
4
5
6
7

<jdbc:oracle-data-source 
          name="jdbcDataSource" 
          user="${db.username}" 
          password="${db.password}" 
          host="${db.host}" 
          port="${db.port}" 
          sid="{db.sid}" />

However, when I deployed the application on my Mule instance I got the following XML parse exception:

org.xml.sax.SAXParseException: cvc-datatype-valid.1.2.1: ‘${db.port}’ is not a valid value for ‘integer’.

This is caused by the fact that the XML is validated against its XSD before the parameters are resolved. Although I found threads in several forums that described a solution for this issue I chose the following (pragmatic) solution. I decided to configure the datasource like this:

1
2
3
4
5

<jdbc:oracle-data-source 
         name="jdbcDataSource" 
         user="${db.username}" 
         password="${db.password}" 
         url="jdbc:oracle:thin:@//${db.host}:${db.port}/${db.sid}" />

This way the XML validates fine against its XSD and during runtime the parameters are resolved.

As I wrote before it is quite easy to set up a web service proxy with Mule3. in this example I take it a step further and I describe how you can add WS-Security implementation to it. Although in the end this also is quite easy you have to make the correct configuration choices to get everything to work.

The first thing I had to do in my Mule config was to drop the pattern prefix. This took me a while to discover because I think this isn’t very clear in the documentation. Anyway, after that change it is fairly straight forward.

Here is the Mule config I ended up with:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

<?xml version="1.0" encoding="UTF-8"?>
<mule xmlns="http://www.mulesoft.org/schema/mule/core"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:cxf="http://www.mulesoft.org/schema/mule/cxf"
      xmlns:spring="http://www.springframework.org/schema/beans"
      xmlns:http="http://www.mulesoft.org/schema/mule/http"
      xsi:schemaLocation="
        http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/3.2/mule.xsd
        http://www.mulesoft.org/schema/mule/cxf http://www.mulesoft.org/schema/mule/cxf/3.2/mule-cxf.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.mulesoft.org/schema/mule/http http://www.mulesoft.org/schema/mule/http/3.2/mule-http.xsd">
 
    <flow name="create-client">
        <http:inbound-endpoint address="http://localhost:8080/create-client">
            <cxf:proxy-service/> 
        </http:inbound-endpoint>
        <http:outbound-endpoint address="http://localhost:8081/create-client">
            <cxf:proxy-client>
                <cxf:outInterceptors>
                    <spring:bean class="org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor">
                        <spring:constructor-arg>
                            <spring:map>
                                <spring:entry key="action" value="Timestamp Signature" />
                                <spring:entry key="user" value="${signature.user}" />
                                <spring:entry key="signaturePropFile" value="ws-security.properties" />
                                <spring:entry key="passwordCallbackClass" value="nl.redstream.adapter.MyKeystorePasswordCallback"/>
                            </spring:map>
                        </spring:constructor-arg>
                    </spring:bean>
                    <spring:bean class="org.apache.cxf.interceptor.LoggingOutInterceptor" />
                </cxf:outInterceptors>
            </cxf:proxy-client>
        </http:outbound-endpoint>    
    </flow>
    <flow name="get-client-status">
        <http:inbound-endpoint address="http://localhost:8081/get-status">
            <cxf:proxy-service>
                <cxf:inInterceptors>
                    <spring:bean class="org.apache.cxf.interceptor.LoggingInInterceptor" />
                    <spring:bean class="org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor">
                        <spring:constructor-arg>
                            <spring:map>
                                <spring:entry key="action" value="Signature" /> 
                                <spring:entry key="signaturePropFile" value="ws-security.properties" />
                            </spring:map>
                        </spring:constructor-arg>
                    </spring:bean>
                </cxf:inInterceptors>
            </cxf:proxy-service>
        </http:inbound-endpoint>
        <http:outbound-endpoint address="http://localhost:8080/get-status">
            <cxf:proxy-client />
        </http:outbound-endpoint>    
    </flow>
</mule>

As you can see I have added two flows. The first flow is ‘create-client’. I receive the incoming call from my own ‘inside’-application and add a signature and timestamp to it before I forward it to the ‘outside’ service.
The second flow works the other way around: I receive a signed message from the ‘outside’ client app and I need to validate this before I pas the message to my ‘inside’ application. To create the signature I need the password for to make use of my private key in the keystore. To supply this password I simply implemented the PasswordCallbackHandler that returns the corresponding password by looking it up in a property file. For more info about configuring the WS-security with CFX see here and also I found this entry about Apache WSS4J quite handy.
The security property file that is referred to in my Mule config file contains the following:

1
2
3
4

org.apache.ws.security.crypto.provider=org.apache.ws.security.components.crypto.Merlin
org.apache.ws.security.crypto.merlin.keystore.type=JKS
org.apache.ws.security.crypto.merlin.file=/KeyStores/redstreamKeystore.jks
org.apache.ws.security.crypto.merlin.keystore.password=myPassword

For both flows I added the logging interceptor which is quite handy during testing and developing to see what is received and sent out. In the next post I will show how to generate the keystores and configure SoapUI to test the proxy manually.

Last week I optimized the deployment process of a number of Mavenized projects. I noticed that the way I automated the project was not yet (fully) known by the developers. This is why I decided to write this blogpost.

It appeared to be a true eyeopener for the developers.

This example assumes that you have a local instance of Apache Tomcat 7.x running.

First, create a new project using Maven:

mvn archetype:create -DgroupId=nl.redstream.demo
                     -DartifactId=simplewebapp
                     -DarchetypeArtifactId=maven-archetype-webapp

Add the Cargo plugin to the pom.xml (inside the <build> tag)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<plugins>
    <plugin>
        <groupId>org.codehaus.cargo</groupId>
        <artifactId>cargo-maven2-plugin</artifactId>
        <version>1.1.2</version>
        <executions>
            <execution>
                <phase>deploy</phase>
                <goals>
                    <goal>deployer-redeploy</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <container>
                <containerId>${mule.deploy.containerId}</containerId>
                <type>remote</type>
            </container>
            <configuration>
                <type>runtime</type>
                <properties>
                    <cargo.server.settings>${mule.deploy.serverId}</cargo.server.settings>
                </properties>
            </configuration>
        </configuration>
    </plugin>
</plugins>

The Cargo plugin is attached to the deploy lifecycle phase of Maven. Which means that the deployer-redeploy goal will be executed whenever you type: mvn deploy. The plugin uses the defined configuration at runtime. I used the depoyer-redeploy goal, because this goal will deploy your app if it is not yet deployed, and undeploy first when it is already deployed. More info on the Cargo plugin here.

The properties will be resolved from your settings.xml in which we have defined several profiles: one for each target environment (i.e. develop, test, qa).

Here’s an example for a development environment (you can add the profiles for the other target environment yourself):

Add the following (inside the <profiles> tag) to your ~/.m2/settings.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<profile>
    <id>develop</id>
    <properties>
        <mule.deploy.containerId>tomcat7x</mule.deploy.containerId>                
        <mule.deploy.serverId>develop</mule.deploy.serverId>
    </properties>
    <activation>
        <activeByDefault>false</activeByDefault>
            <property>
            <name>env</name>
            <value>dev</value>
            </property>
    </activation>
</profile>

Also, add a definition with id=develop (inside the <servers> tag):

1
2
3
4
5
6
7
8

<server>
    <id>develop</id>
    <configuration>
        <cargo.remote.uri>http://localhost:8080/manager/text</cargo.remote.uri>
        <cargo.remote.username>deploy</cargo.remote.username>
        <cargo.remote.password>deploy</cargo.remote.password>
    </configuration>
</server>

The trick here is to add the Cargo configuration to the server definition. The defined properties are used by Maven to automagically deploy your webapp. In this demo I used localhost, but it could also be a remote host.

Note that I used a username and password for the deployment process. Add these in your $CATALINA_HOME/conf/tomcat-users.xml:

1

<user username="deploy" password="deploy" roles="manager-script"/>

Note: user _must_ have the manager-script role!

Now, all that’s left is deploying your application by executing mvn clean deploy -Denv=dev. The property env=dev will activate the correct profile in your settings.xml and resolve the earlier mentioned properties. BUT, the deploy phase requires a distributionManagement tag in your pom.xml. Mine looks like this (PS: I use JFrog Artifactory):

1
2
3
4
5
6
7
8
9
10

<distributionManagement>
    <repository>
        <id>artifactory</id>
        <url>http://dev.foobar.local:8080/artifactory/libs-release-local/</url>
    </repository>
    <snapshotRepository>
        <id>artifactory</id>
        <url>http://dev.foobar.local:8080/artifactory/libs-snapshot-local</url>
    </snapshotRepository>
</distributionManagement>

After you’ve added this to your pom, you’re ready to deploy your application.

Result:

...
[INFO]
[INFO] --- cargo-maven2-plugin:1.1.2:deployer-redeploy (default) @ simplewebapp ---
[INFO] [mcat7xRemoteDeployer] [/Users/pprins/projects/sandbox/simplewebapp/target/simplewebapp.war] is not deployed. Doing a fresh deployment.
[INFO] [mcat7xRemoteDeployer] Deploying [/Users/pprins/projects/sandbox/simplewebapp/target/simplewebapp.war]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.569s
[INFO] Finished at: Fri Oct 07 13:20:24 CEST 2011
[INFO] Final Memory: 7M/554M
[INFO] ------------------------------------------------------------------------

Goto: http://localhost:8080/simplewebapp et voila: your web app!

A redeploy would look something like this:

...
[INFO] --- cargo-maven2-plugin:1.1.2:deployer-redeploy (default) @ simplewebapp ---
[INFO] [mcat7xRemoteDeployer] Redeploying [/Users/pprins/projects/sandbox/simplewebapp/target/simplewebapp.war]
[INFO] [mcat7xRemoteDeployer] Undeploying [/Users/pprins/projects/sandbox/simplewebapp/target/simplewebapp.war]
[INFO] [mcat7xRemoteDeployer] Deploying [/Users/pprins/projects/sandbox/simplewebapp/target/simplewebapp.war]

In this post I show you how I setup a little test to see if and how easy I could manage to route the traffic to and from a web service through Mule ESB. The business case for this is an issue that one of our customers ran into when using web services. In a program hundreds of calls are done in a relative short period. Most of the time this isn’t a problem but sometimes vague issues occur. To get a better insight in this issue I want to put Mule in the middle so I can log the request and response and hopefully get a better idea about what is sent across the line. This is called the Web Service Proxy pattern and is commonly used to validate and audit the web service calls. For more background info about this pattern see this article.

To get started I downloaded the Mule Standalone edition here and installed it. That isn’t very hard, just untar the thing and set the MULE_HOME property. Go to the bin directory and give ‘./mule’ and off you go (except for a warning when running on MacOS 64-bit, but it doesn’t seem to harm so far…):

To create a test web service I setup a MockService in SoapUI. Like this:

All you need is a WSDL available. I just picked one from a previous project for testing purposes. With this MockService started you can fire your SOAP requests and will receive a (predefined) response from the MockService:

Next step is create a new Mule project (I still favor Maven above the Mule Studio):

• create new Maven project with

mvn mule-project-archetype:create -DartifactId=WSProxy -DmuleVersion=3.1.2

• Set up the WS Proxy

To create WS Proxy I followed the description here
Note: to make use of the pre-defined ‘pattern’ you must add the following dependency to the pom:

1 2 3 4 5 6

<dependency> <groupId>org.mule.patterns</groupId> <artifactId>mule-patterns-all</artifactId> <version>${mule.version}</version> <scope>provided</scope> </dependency>

My Mule config file looks like this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

<?xml version="1.0" encoding="UTF-8"?> <mule xmlns="http://www.mulesoft.org/schema/mule/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:pattern="http://www.mulesoft.org/schema/mule/pattern" xsi:schemaLocation=" http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/3.1/mule.xsd http://www.mulesoft.org/schema/mule/pattern http://www.mulesoft.org/schema/mule/pattern/3.1/mule-pattern.xsd"> <description> Proxies a Web Service </description> <custom-transformer name="my-transformer" class="nl.redstream.proxy.wsproxy.MyTransformer" /> <object-to-string-transformer name="ObjectToStringTransformer" />   <pattern:web-service-proxy name="my-order-ws-proxy" inboundAddress="http://Pascal-Almas-MacBook-Pro.local:8090/my-order" responseTransformer-refs="ObjectToStringTransformer my-transformer" outboundAddress="http://Pascal-Almas-MacBook-Pro.local:8088/mockDataServiceSoapBinding" /> </mule>

• Fire up the proxy

To run the Mule application just make sure your Mule installation is running and in your project execute the command ‘mvn clean install’
You should see a message in your Mule console like this:

Now we can put the proxy at work by redirecting the SoapUI request to the url: http://Pascal-Almas-MacBook-Pro.local:8090/my-order. It should the be forwarded to the original url and the translator I put in between should output the content to the Mule console:

However if you try this for the first time big chance you will run into this issue (at least I did). To get around this issue modify the soapUI settings like this:

In my previous post I described how you can setup Spring and Hibernate in combination with the MongoDB. In this post I show you how you can write your unit test for this setup including a workaround for the fact that there isn’t an embedded version of MongoDB.

Of course you can check manually if your code works by checking the content of the MongoDB. You can use the MongoDB shell or the REST interface by using ‘curl’ (when using REST make sure you start the database with the ‘–rest’ option). For example see the result of curl 'http://localhost:28017/redstream/logItem/'

pascal@~$ curl ‘http://localhost:28017/redstream/logItem/’
{
“offset” : 0,
“rows”: [
{ "_id" : { "$oid" : "4e1c2ffca0eee881985e04f0" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 0" } ,
{ "_id" : { "$oid" : "4e1c2ffda0eee881985e04f1" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 1" } ,
{ "_id" : { "$oid" : "4e1c2ffda0eee881985e04f2" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 2" } ,
{ "_id" : { "$oid" : "4e1c4289a0ee3d15a8af39d3" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 0" }
],
“total_rows” : 3 ,
“query” : {} ,
“millis” : 0
}
pascal@~$

However, when building software you want your test to be performed automatically so we use JUnit to perform the tests and checks. And I use JUnit to start and stop my local MongoDB instance. Here is how it works (I assume you have the same project setup as I created in my previous post):

• Wire the Spring beans in your test context

I created a SpringContext class for testing purposes:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

package nl.redstream.mongo;   import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;   /** * Only to be used in test classes!! * * @author pascal */ public class MyTestApplicationContext {   private static MyTestApplicationContext testContext = null;   ApplicationContext context = null;   private MyTestApplicationContext() { }   public static MyTestApplicationContext getInstance() { if (testContext == null) { testContext = new MyTestApplicationContext(); testContext.initialise(); } return testContext; }   public void initialise() { context = new ClassPathXmlApplicationContext( new String[]{"spring-config.xml"}); }   public Object getBean(String name) { return context.getBean(name); }   public ApplicationContext getSpringContext() { return context; } }

With this class I can access my Spring beans easily in my Unit tests.

• Write the test class

I use ProcessBuilder to start and stop the local MongoDB instance before the test class is executed. The base Testclass looks like this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

package nl.redstream.mongo;   import org.apache.log4j.Logger; import org.junit.After; import org.junit.AfterClass; import org.junit.Before; import org.junit.BeforeClass;   public class MongoDBTest {   private static final Logger logger = Logger.getLogger(MongoDBTest.class); static Process p = null;   @Before public void setUp() throws Exception { //@Todo Run mongo with a test specific .js file to produce initial data state }   @After public void tearDown() throws Exception { //@Todo Drop database }   @BeforeClass public static void beforeClass() throws Exception { String[] command = new String[]{"/Users/pascal/development/mongodb-osx-x86_64-1.8.2/bin/mongod", "--dbpath", "/Users/pascal/development/mongodb/data", "--rest"};   ProcessBuilder pb = new ProcessBuilder(command);   p = pb.start();   logger.debug("Process started with pid: " + p);   }   @AfterClass public static void afterClass() throws Exception { // Stop mongod process boolean processClosed = false;   Thread.sleep(500); if (p != null) { while (!processClosed) {   try { p.destroy(); processClosed = true; Thread.sleep(500); logger.info(" Process destroyed: " + p.exitValue()); } catch (IllegalThreadStateException itse) { logger.warn(itse); processClosed = false; } } } } }

And the actual test class:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

package nl.redstream.mongo;   import junit.framework.Assert; import nl.redstream.mongo.entity.LogItem; import nl.redstream.mongo.services.LogService; import org.apache.log4j.Logger; import org.bson.types.ObjectId; import org.junit.Before; import org.junit.Test;   public class LogServiceTest extends MongoDBTest {   private static final Logger logger = Logger.getLogger(LogServiceTest.class); private LogService<LogItem> service = null;   @Test public void testCreateAndFindLog() throws Exception {   ObjectId id = null;   for (int i = 0; i < 3; i++) { LogItem log = new LogItem(); log.setMessage("just some text " + i);   id = service.add(log); logger.debug("log.id = " + id); }   LogItem logFound = service.get(id); logger.debug("log = " + logFound.toString()); Assert.assertNotNull(logFound); }   @Before public void setUp() throws Exception { logger.info("setting up test"); super.setUp(); service = (LogService<LogItem>) MyTestApplicationContext.getInstance().getBean("logService"); //@TODO Run mongo with a test specific .js file to produce initial data state } }

• Run it!

The test output shows it ran successfully:

——————————————————-
T E S T S
——————————————————-
Running nl.redstream.mongo.LogServiceTest
DEBUG [main] nl.redstream.mongo.MongoDBTest: Process started with pid: java.lang.UNIXProcess@603b1d04
INFO [main] nl.redstream.mongo.LogServiceTest: setting up test
DEBUG [main] nl.redstream.mongo.services.MongoDBLoggerServiceImpl: Adding a new LogItem instance
DEBUG [main] nl.redstream.mongo.LogServiceTest: log.id = 4e2fc241a0eea3de77684fdf
DEBUG [main] nl.redstream.mongo.services.MongoDBLoggerServiceImpl: Adding a new LogItem instance
DEBUG [main] nl.redstream.mongo.LogServiceTest: log.id = 4e2fc241a0eea3de77684fe0
DEBUG [main] nl.redstream.mongo.services.MongoDBLoggerServiceImpl: Adding a new LogItem instance
DEBUG [main] nl.redstream.mongo.LogServiceTest: log.id = 4e2fc241a0eea3de77684fe1
DEBUG [main] nl.redstream.mongo.LogServiceTest: log = LogItem [id=4e2fc241a0eea3de77684fe1, message=just some text 2, timestamp=null]
INFO [main] nl.redstream.mongo.MongoDBTest: Process destroyed: 12
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.798 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

There is definitely room for improvement, like adding the possibility to run ‘.js’ scripts to set the database in a predefined state in the @Before method of the test class and remove the database in the @After method.
Another thing that bothered me is the ‘Thread.sleep’ that I had to add at some places to make it work. Nevertheless I showed how to setup a basic test case with MongoDB/Spring combination and if you have a better solution please let me know!

One of the requirements we have for one of our Mule ESB implementations is to log the messages that went through the ESB (especially handy during development and testing). There has been written a lot already about logging with Mule so I am not going to discuss that again. In this post I’ll only show you how you can use Spring/Hibernate and MongoDB to store your messages in the MongoDB, because a document-oriented database like MongoDB is a nice fit for this requirement.

The first thing to do is to install MongoDB on your machine (unfortunately it is not yet possible to run it embedded so we use a local instance instead). For installation see this.

After MongoDB is installed we can create a new standard Maven project and modify the generated pom.xml to the following pom.xml.

Next step is the creation of the Hibernate Entity class like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package nl.redstream.mongo.entity;
 
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import org.bson.types.ObjectId;
 
/**
 * Model object 
 * @author pascal
 */
@Entity
@Table(name = "logItems")
public class LogItem implements Serializable {
 
    @Id
    private ObjectId id;
    private String message;
    private String timestamp;
 
    public ObjectId getId() {
        return id;
    }
 
    public void setId(ObjectId id) {
        this.id = id;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(final String message) {
        this.message = message;
    }
 
    public String getTimestamp() {
        return timestamp;
    }
 
    public void setTimestamp(final String timestamp) {
        this.timestamp = timestamp;
    }
 
    @Override
    public String toString() {
        return "LogItem [id=" + id + ", message=" + message + ", timestamp=" + timestamp + "]";
    }
}

As you might notice I have used the ObjectId as primary Id. I was forced to this by bug DATADOC-176 which only recently got fixed.

The Dao and Service object classes that are used to access the MongoDB are:

• BaseDao.java
• AbstractBaseDao.java
• LogItemDaoImpl.java
• LogService.java
• MongoDBLoggerServiceImpl.java

Now wire this all together with the following spring config files:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=
               "http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
    <import resource="spring-mongodb-config.xml"/>
 
    <bean id="logService" class="nl.redstream.mongo.services.MongoDBLoggerServiceImpl">
        <property name="dao" ref="logDao"/>
    </bean>
    <bean id="logDao" class="nl.redstream.mongo.dao.LogItemDaoImpl">
        <property name="mongoTemplate" ref="mongoTemplate"/>
    </bean>
</beans>

and the ‘spring-mongodb-config.xml’ (as described here):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xsi:schemaLocation=
               "http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/data/mongo
                http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">
 
    <!-- Default bean name is 'mongo' -->
    <mongo:mongo host="localhost" port="27017">
        <!-- OPTIONAL: configure <mongo:options /> -->
    </mongo:mongo>
 
    <mongo:db-factory dbname="redstream" mongo-ref="mongo"/>
 
    <bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
        <constructor-arg ref="mongoDbFactory"/>
    </bean>
</beans>

That’s it. Now you have a foundation to start using MongoDB with Spring and Hibernate classes. In the next post I will show how you can test this setup without manually having to start and stop MongoDB.

I got triggered by my previous post to create a process with which I could keep two instances of WordPress in sync. I wanted to see if I could do this with Mule. I came up with the following solution:

• Receive the RSS feed of a new post in Mule flow
• Use the content of the RSS feed to post to the other wordpress instance by using XML-RPC
• Have it running on Mule iON so I don’t have to setup my own Muleserver

So lets start a new Mule iON project. Since I am a big fan of Netbeans I use the Maven based approach (I must admit I have tried to use MuleStudio for this but it didn’t bring me the productivityboost I hoped for).
I created the Mule project with:

mvn org.mule.tools:mule-project-archetype:create -DartifactId=wordpress-copy-service -DgroupId=nl.redstream.mule-ion -Dinteractive=false -Dmodules=rss -DmuleVersion=3.1.1


The Mule config looks like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?xml version="1.0" encoding="UTF-8"?>
<mule xmlns="http://www.mulesoft.org/schema/mule/core"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:http="http://www.mulesoft.org/schema/mule/http"
      xmlns:rss="http://www.mulesoft.org/schema/mule/rss"
      xmlns:spring="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="
        http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/3.1/mule.xsd
        http://www.mulesoft.org/schema/mule/http http://www.mulesoft.org/schema/mule/http/3.1/mule-http.xsd
        http://www.mulesoft.org/schema/mule/rss http://www.mulesoft.org/schema/mule/rss/3.1/mule-rss.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <spring:bean name="xmlRpcHelper" class="nl.redstream.rss.XmlRpcHelper">
        <spring:constructor-arg value="http://www.pragmatic-integrators.com/xmlrpc.php" type="java.lang.String"/>
        <spring:constructor-arg value="UserName" type="java.lang.String"/>
        <spring:constructor-arg value="Password" type="java.lang.String"/>
    </spring:bean>
    <spring:bean name="entryReceiver" class="nl.redstream.rss.EntryReceiver">
        <spring:constructor-arg ref="xmlRpcHelper"/>
    </spring:bean>
    <flow name="poll-and-post">
        <poll frequency="36000000">
            <http:outbound-endpoint address="http://www.redstream.nl/feed/" />
        </poll>
        <rss:feed-splitter />
        <component>
            <spring-object bean="entryReceiver"/>
        </component>
    </flow>
</mule>

As you can see I poll the website ‘www.redstream.nl’ once each 10 hours. The RSS feed I receive is split and sent to my custom made component ‘entryReceiver’. It would be nice to use a XML-RPC endpoint here but this isn’t created yet (and actually I don’t feel like it neither).

The EntryReceiver looks like:

Disclaimer: just wanted to see if it worked, I did not try to build a robust solution that had to work for every WordPress site, so you are warned!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package nl.redstream.rss;
 
import org.mule.api.annotations.param.Payload;
import com.sun.syndication.feed.synd.SyndEntry;
 
public class EntryReceiver {
 
    XmlRpcHelper xmlRpcHelper = null;
 
    public EntryReceiver(XmlRpcHelper helper) {
        xmlRpcHelper = helper;
    }
    public void readEntry(@Payload SyndEntry entry) throws Exception {
 
        // Get the title
        String title = entry.getTitle();
 
        // Check if title exist in current blogs on the new blogsite
       if (!xmlRpcHelper.titleExists(title)) {
            xmlRpcHelper.post(entry);
 
        } else {
            // Skip this post
        }
    }
}

And the bean where the dirty work is done:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

package nl.redstream.rss;
 
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
 
import com.sun.syndication.feed.synd.SyndContentImpl;
import com.sun.syndication.feed.synd.SyndEntry;
 
public class XmlRpcHelper {
 
    private String url;
    private String userName;
    private String password;
    XmlRpcClient client = new XmlRpcClient();
 
    public XmlRpcHelper(String url, String u, String p) {
        this.url = url;
        this.userName = u;
        this.password = p;
 
        XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
        try {
            config.setServerURL(new URL(url));
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        client.setConfig(config);
    }
 
    public boolean titleExists(String title) {
        return getRecentTitles().contains(title);
    }
 
    public void post(SyndEntry entry) {
        StringBuilder content = new StringBuilder("<content><title>").append(entry.getTitle()).append("</title>");
        List<SyndContentImpl> contents = entry.getContents();
 
        for (SyndContentImpl syndContent : contents) {
            content.append(syndContent.getValue());
        }
        content.append("</content>");
        try {
            client.execute("blogger.newPost", new Object[]{"bla", 1,
                        userName, password, content.toString(), true});
        } catch (XmlRpcException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    private List<String> getRecentTitles() {
        List<String> titles = new ArrayList<String>();
        try {
            Object token = client.execute("blogger.getRecentPosts", new Object[]{"bla", 1,
                        userName, password, 10});
 
            Object[] result = (Object[]) token;
            for (int i = 0; i < result.length; i++) {
                titles.add(getTitle((HashMap<String, Object>) result[i]));
            }
        } catch (XmlRpcException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            // return null;
        }
        return titles;
    }
 
    private static String getTitle(Map response) {
        String title = null;
        String content = (String) response.get("content");
 
        if (content != null) {
            title = content.substring(content.indexOf("<title>") + 7,
                    content.indexOf("</title>"));
        }
        return title;
    }
}

One thing that kept me busy for a while was that the first String in the Object array that is supplied with the XmlRpc call may contain anything as long as it contains something. An emptry String “” is ignored in the call and will lead to an invalid Username/Password message.

If all this is in place you can build the project with: ‘mvn clean install’. This will create a zip file in the target directory. This zip file can then be uploaded with your dashboard to your Mule iON instance:

And that’s it! As you can see the two sites ‘www.redstream.nl’ and ‘www.pragmatic-integrators.com’ are know kept in sync (with a max. gap of 10 hrs). Of course the copied post is not an exact clone of the original (I am loosing info about the Author, Categories, etc. and images are referred to at the original location) but it shows that the main idea works!

In a previous post, I mentioned that you could extend the function library in Altova MapForce and add your own functions. In this post I’ll show you (briefly) how to do this using the Java methods from the previous post.

The MapForce documentation only contains a little information on how to add your own custom functions.

The base directory in which you installed MapForce contains a directory called MapForceLibraries. Here, you will find a number of, so called, mff files, which stands for MapForce Functions. Inside, the definition is stored of the functions you are able to select from the library when working on a mapping. We will be using this principle to add an extension of our own. The only thing we need to do, is create such a mff file.

As I already said, the MapForce documentation does not contain a lot of information on this subject. But … what it does include is the XML Schema for the mff file. It is called mff.xsd and it is also located in the MapForceLibraries directory. Open the XML Schema in XMLSpy (or any other XML editor) and select element mapping to get an overview of the library structure. Notice that the XML Schema is well-documented (at least better than the actual MapForce documentation).

We will, briefly, walk through the most important elements. First, element mapping: the root element.

First, element implementations. This element refers to the possible implementations of your extension (e.g. Java, XSLT, C#, etc).

Functions can be grouped, hence the group element. The component element inside describes how your extension should be called. The target describe your input parameters (if any) and output describes your output.

Here’s what an example XML could look like. We used an xslt2 implementation that points to a xslt stylesheet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?xml version="1.0" encoding="UTF-8"?>
<mapping xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="file:///C:/Program%20Files/Altova/MapForce2011/MapForceLibraries/mff.xsd" version="8" library="redstream" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:mf="http://www.altova.com/MapForce/2010/standard">
	<implementations>
		<implementation language="xslt2">
			<setting name="xsltfilename" value="xlst-redstream-library.xsl"/>
		</implementation>
	</implementations>
	<group name="demo functions">
		<component name="greeting">
			<sources>
				<datapoint name="name" type="xs:string"/>
			</sources>
			<targets>
				<datapoint name="result" type="xs:string"/>
			</targets>
			<implementations>
				<implementation language="xslt2">
					<function name="rs:greeting" namespace="java:nl.redstream.XsltUtils"/>
				</implementation>
			</implementations>
			<description>
				<short>result = 'Hello ' + name + ' !'</short>
				<long>Returns friendly message.</long>
			</description>
		</component>
	</group>
</mapping>

The related XSLT file looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="2.0" 
   xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
   xmlns:xs="http://www.w3.org/2001/XMLSchema" 
   xmlns:fn="http://www.w3.org/2005/xpath-functions" 
   xmlns:rs="java:nl.redstream.utils.XsltUtils">
 
   <xsl:function as="xs:string" name="rs:greeting">
      <xsl:param as="xs:string" name="name"/>
      <xsl:value-of select="rs:greeting($name)"/>
   </xsl:function>
 
</xsl:stylesheet>

Once, you’ve created your mff and xslt file, copy them into MapForceLibraries directory (make sure MapForce is not running, otherwise you will not be able to write in that directory). Start Altova MapForce, create a new mapping (implemenation xslt2 and behold … your extension will show up in the Library.

Now, you can drag-and-drop the function onto your mapping.

The resulting XSLT will look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?xml version="1.0" encoding="UTF-8"?>
<!--
This file was generated by Altova MapForce 2011sp1
 
YOU SHOULD NOT MODIFY THIS FILE, BECAUSE IT WILL BE
OVERWRITTEN WHEN YOU RE-RUN CODE GENERATION.
 
Refer to the Altova MapForce Documentation for further details.
http://www.altova.com/mapforce
-->
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
                                              xmlns:xs="http://www.w3.org/2001/XMLSchema" 
                                              xmlns:fn="http://www.w3.org/2005/xpath-functions" 
                                              xmlns:rs="java:nl.redstream.XsltUtils" exclude-result-prefixes="xs fn rs">
   <xsl:output method="xml" encoding="UTF-8" indent="yes"/>
   <xsl:template match="/">
      <dataset>
         <row>
            <column>
               <xsl:for-each select="dataset/row/column">
                  <xsl:attribute name="name" select="rs:greeting(fn:string(@name))"/>
               </xsl:for-each>
            </column>
         </row>
      </dataset>
   </xsl:template>
</xsl:stylesheet>

Unfortunately, you cannot display the results of the customized mapping in MapForce (#featurerequest). Instead, you could use XMLSpy and use the settings from the previous post.

That’s it … enjoy!

Last week I migrated our site and blog to the Cloud. I got triggered by this article. That in the combination with the free account at Amazon’s EC2 was enough for me give it a try.
Now, if you came here via ‘www.redstream.nl’ you are looking at the version hosted at our own server. But if you got here via ‘www.pragmatic-integrators.com‘ you are looking at the version hosted in the Cloud.
After I migrated the site I realized how easy it is to use a server in the cloud and made me wonder why you should ever want your own physical ‘web’server. For the time being I will keep both instances alive so I can compare both solutions.
Now I have to find a way to keep these two instances in sync… That would be a nice use case using Mule iON to stay in the Clouds… I’ll post the solution here as soon as I have worked it out ;-)

Like I posted before Mulesoft has released a new platform: iPAAS. I just went through the starters guide and I am pretty impressed. Of course the use case in the tutorial is very simple but the whole idea of just putting your Mule config into the cloud and it runs sounds good. And I have seen it working (you can check for yourself by submitting text to this url.
Here is a snapshot of the dashboard you get with you Mule iON account:

Although it looks pretty nice at first sight it does raise questions and some topics for further investigation: what about security and in what use cases will this be the best solution? Mulesoft already has answers to those questions (security and use cases) but I am going to find out myself and let you know my opinion. Stay tuned!