The Message

How to Setup RabbitMQ Message Broker with Kaazing WebSocket Gateway - AMQP Edition

2012-03-08T23:01:00.000-08:00

If you want to try the Kaazing WebSocket Gateway - AMQP Edition with RabbitMQ, take a look on the following steps...

If you are trying this setup on a Mac, make sure you have Erlang already installed otherwise have a look on my previous post on How to Install Erlang on Mac OS X Snow Leopard.

Install RabbitMQ

- Download RabbitMQ from http://www.rabbitmq.com/download.html

- Extract the file to the desired directory

- Navigate to RabbitMQ installation directory and run the following command:

$ sbin/rabbitmq-server

If RabbitMQ is started correctly you should see a message similar to the following:

Activating RabbitMQ plugins ...

********************************************************************************
********************************************************************************

0 plugins activated:


+---+   +---+
|   |   |   |
|   |   |   |
|   |   |   |
|   +---+   +-------+
|                   |
| RabbitMQ  +---+   |
|           |   |   |
|   v2.7.1  +---+   |
|                   |
+-------------------+
AMQP 0-9-1 / 0-9 / 0-8
Copyright (C) 2007-2011 VMware, Inc.
Licensed under the MPL.  See http://www.rabbitmq.com/

node           : rabbit@yoda
app descriptor : /Applications/Kaazing/kaazing-websocket-gateway-amqp-3.2.0/rabbitmq_server-2.7.1/sbin/../ebin/rabbit.app
home dir       : /Users/Marcelo
config file(s) : (none)
cookie hash    : AYkkciNJ6lsr2dyADBN8ww==
log            : /Applications/Kaazing/kaazing-websocket-gateway-amqp-3.2.0/rabbitmq_server-2.7.1/work/rabbitmq/rabbit@yoda.log
sasl log       : /Applications/Kaazing/kaazing-websocket-gateway-amqp-3.2.0/rabbitmq_server-2.7.1/work/rabbitmq/rabbit@yoda-sasl.log
database dir   : /Applications/Kaazing/kaazing-websocket-gateway-amqp-3.2.0/rabbitmq_server-2.7.1/work/rabbitmq/mnesia/rabbit@yoda
erlang version : 5.9

-- rabbit boot start
starting file handle cache server                     ...done
starting worker pool                                  ...done
starting database                                     ...done
starting codec correctness check                      ...done
-- external infrastructure ready
starting plugin registry                              ...done
starting auth mechanism cr-demo                       ...done
starting auth mechanism amqplain                      ...done
starting auth mechanism plain                         ...done
starting statistics event manage                      ...done
starting logging server                               ...done
starting exchange type direct                         ...done
starting exchange type fanout                         ...done
starting exchange type headers                        ...done
starting exchange type topic                          ...done
-- kernel ready
starting alarm handler                                ...done
starting node monitor                                 ...done
starting cluster delegate                             ...done
starting guid generator                               ...done
starting memory monitor                               ...done
-- core initialized
starting empty DB check                               ...done
starting exchange, queue and binding recovery         ...done
starting mirror queue slave sup                       ...done
starting adding mirrors to queues                     ...done
-- message delivery logic ready
starting error log relay                              ...done
starting networking                                   ...done
starting direct_client                                ...done
starting notify cluster nodes                         ...done

broker running

Install and Run Kaazing WebSocket Gateway - AMQP Edition

- Download and install Kaazing WebSocket Gateway - AMQP Edition

- Navigate to the Kaazing WebSocket Gateway installation directory and start it using the following command:

$ bin/gateway.start

Open your web browser of choice and navigate to http://localhost:8001 then select DEMOS on top menu.

At this point, you should be able to run any of the demos available using RabbitMQ as the backend messaging system.

Installing Erlang on Mac OS X Snow Leopard

2012-03-05T16:42:00.000-08:00

I'm working with a customer who is using the Kaazing WebSocket Gateway - AMQP Edition with RabbitMQ and while his install was pretty straightforward on Windows 7 I thought the same would be applicable to my case (a Mac user). Well, to summarize the process, it was quite of a challenge to get everything working, not from the complexity perspective but for the number of steps involved in the process to get the environment running starting from the point that RabbitMQ depends on Erlang to run. So, that was the first step... Installing Erlang on Mac OS X

Here are the steps I had to take:

- Download and install Apple Xcode 4.3 from Apple's AppStore (yeah, you read it right!)

- The tricky part here was to enable Command Line Tools which is not selected by default in Xcode. To do that, go to Xcode Preferences --> Downloads --> Components and install Command Line Tools. It's just another 170MB over the already downloaded 1.35GB of Xcode :)

- Download Erlang latest release from http://www.erlang.org/download.html

- Extract the Erlang package (i.e. tar -xvf otp_src_R15B.tar) and navigate into the recently created directory

- Run ./configure

- Run ./make

- Run sudo make install

Hope this help you to get your project going...

Quick Start with the Kaazing WebSocket Gateway in Less Than 6 Minutes

2012-02-27T08:55:00.001-08:00

One of my colleagues at Kaazing just recorded a very nice tutorial on how to get started with the Kaazing WebSocket Gateway using the extreme powerful JMS Edition.

It only takes a few minutes to download, install, start up, and try out the Kaazing WebSocket Gateway. So, it's really worth it...

You can take a peek here: http://vimeo.com/36919680

Enjoy...

Moving On...

2012-02-27T08:51:00.000-08:00

Well, it has been a while since I updated this blog and there are many reasons just to say that I wasn't motivated enough to write anything lately. Some personal issues as well as another job change associated with a short vacation contributed to the delay but the good part is that I'm back and really happy with how the year is shaping up.

It seems to be that all personal stuff is sorted out and I also have decided to join Kaazing as a Solutions Architect. Kaazing is the first Enterprise-grade Web Communications Platform leveraging HTML5 WebSockets designed for real-time, massive scalability and providing reliability necessary for companies to deploy those kind of solutions over the web.

If you're not familiar with HTML5 and WebSockets and I'd recommend you to take a look on the following presentation available at http://www.infoq.com/presentations/WebSockets-The-Web-Communication-Revolution.

Stay tuned for more...

Getting Started with Apache Camel (Video)

2011-12-27T11:55:00.000-08:00

In this video demonstration, published on the FuseSource YouTube channel, you're going to see how to get started with Apache Camel (FUSE Mediation Router) on a real world scenario working with a Composed Enterprise Integration Pattern (FUSE EIP).

The video demonstration talks about a Book Shop example application that receives a message from a JMS source, in this case Apache ActiveMQ / FUSE Message Broker and then split the message according to number of orders available in the message, then based on the content the message is going to be routed to different web services endpoints (provided by Apache CXF / FUSE Services Framework), after that the requests to the web services are then aggregated through the Apache Camel aggregator component and finally the resulting message is sent to a response JMS queue.

Enjoy the ride...

Virtual and Composite Destinations with Apache ActiveMQ

2011-11-30T22:47:00.001-08:00

Apache ActiveMQ / FUSE Message Broker has a feature called Virtual Destinations that are logical destinations (queues or topics) mapped to one or more physical destinations.

There are many benefits for using Virtual Destinations with ActiveMQ but basically you can forward messages from one JMS destination to many destinations (mixing queues and topics if you want), route messages to target destinations based on message headers (a.k.a broker-based message routing) and create highly-available load-balanced durable subscribers.

As an example, looking in the diagram above, you can have a Virtual Destination called q1, where applications will send messages to as they do to any other regular queue, and then the message will get propagated to a real physical queue called q1, to a real queue physical queue called Q2 and also to a topic called T1.

The example above is called Composite Destinations and the idea behind it is to map a Virtual Destinations to a hard-wired collection of physical destinations. From the JMS client application perspective there is nothing you'll need to change since all the configuration happens at the broker level.

So, let's look on what need to be done to work with Virtual and Composite Destinations with ActiveMQ.

The diagram above represents the idea of having producer P sending messages to a queue called CompositeQueue.q (it doesn't have to be called that way).

That queue is rooting messages to a topic called Topic.a and a queue called Queue.b.

All of the required configuration is done in the ActiveMQ XML configuration file. Below, there is snippet of the broker configuration file where the above example is configured.

<broker...>

<compositeQueuename=“CompositeQueue.q">

<topicphysicalName=“Topic.a"/>

<queuephysicalName=“Queue.b"/>

</forwardTo>

</compositeQueue>

</virtualDestinations>

</virtualDestinationInterceptor>

</destinationInterceptors>

</broker>

The interesting thing here is that you can mix queues and topics without making any changes in the client code and this is not part of the JMS specification.

You can also extend that to use composite topics pretty much on the same way… Below you'll find a similar broker configuration to use Virtual Topics:

<broker...>

<virtualTopicname=“VirtualTopic.A"/>

<queuephysicalName="FOO"/>

<topicphysicalName="BAR"/>

</forwardTo>

</virtualDestinations>

</virtualDestinationInterceptor>

</destinationInterceptors>

</broker>

So, with a simple change in the ActiveMQ broker configuration you can dramatically change the way

the system works and extend it to your needs without changing the client application.

Load-balanced Ordered Message Processing with Apache ActiveMQ

2011-11-25T16:46:00.001-08:00

On my previous post (Preserving Message Order with Apache ActiveMQ) we took a look on what would be necessary to preserve message order using Apache ActiveMQ (FUSE Message Broker). We then explored on the ActiveMQ capabilities called Exclusive Consumers.

But, Exclusive Consumers bring one disadvantage that is having active consumers not doing anything (actually not consuming messages) and that may be not the desired behavior. So, let's take a look on how ActiveMQ (FUSE Message Broker) can help to avoid that situation and explore what capabilities and/or techniques are available to process messages in order when multiple consumers are active.

ActiveMQ has a feature called Message Groups which is the way to load balance multiple active consumers listening to the same queue while preserving message order. ActiveMQ will then group messages on the queue and it will guarantee that all messages of a particular group arrive in order on the same consumer.

So, to give you an example, let's say we're processing records about drivers (adding new drivers, updating drivers' information, processing speed tickets, revoking tickets, etc). You definitely don't want to process the revoke information before the ticket record because that would cause a lot of problems when the ticket doesn't exist yet and the application will try to update its information. Then, to solve that problem we could group messages by driver's license number and then let the message broker process them accordingly. Now, from the global sense the messages may not be processed in order but from the important business application sense of related messages they are delivered in the preserved order.

In the picture below, messages addressed with the same JMSXGroupID, in this case "GRP1" and "GRP2", will be pushed to a unique consumer, in other words, Consumer A will get messages that contain the JMSXGroupID equals to GRP1 and Consumer B will get messages that contain the property JMSXGroupID equals to GRP2.

In summary, ActiveMQ will correlate messages based on the property JMSXGroupsID and will deliver those to the same consumer.

On a side note, messages without a group (meaning messages with no value specified in the JMSXGroupID header property) will be distributed (load balanced) among active consumers as they would be in the normal ActiveMQ queue message processing.

But, how to implement message groups?

Very simple… the only thing you have to do is to set the JMSXGroupID property on the client producer before you send the message with whatever value you want to use for correlation. The broker itself will take care of everything else for you.

Here is a snippet of a Java client producer creating a JMS Text Message and then setting the JMSXGroupID property:

Message message = session.createTextMessage(“<foo>hey</foo>”);

message.setStringProperty(“JMSXGroupID”,“Msg_group_1”);

In the example above, all messages in the queue with JMSXGroupID set to Msg_group_1 will be directed exclusively to a single consumer.

How the messages reach the correct consumer then?

Well, the message broker maintains an internal hash map with the Group IDs and the consumers receiving messages for that specific group.

The consumer will then receive messages for that group until it drops the connection or a producer closes the message group by sending a message with a property called JMSXGroupSeq containing the value of -1 (minus one). That's going to be the flag telling the message broker that the group is no longer needed and the reference in the hash table can be removed.

For new message groups, the broker does a random selection of the active consumers and then start placing messages on that consumer.

So, to illustrate how to close a group, the following code shows the Java producer client closing the Msg_Group_1:

Message message = session.createTextMessage(“<foo>bar</foo>”);

message.setStringProperty(“JMSXGroupID”, “Msg_group_1”);

message.setIntProperty(“JMSXGroupSeq”, -1);

producer.send(message);

Then, if another message is sent to the same message group ID, the message broker will handle that as a new message group randomly assigned to a new consumer.

Preserving Message Order with Apache ActiveMQ

2011-11-17T09:35:00.001-08:00

There are some use cases and business scenarios where you have to process messages in order. Basically, when multiple consumers receive messages from a queue and process them in parallel, message order is not preserved.

Apache ActiveMQ has the capability to process messages in order using a feature called Exclusive Consumers. With Exclusive Consumers all messages from a single queue are processed by only one consumer (other consumers listening on the same queue will take over if the exclusive consumer fails).

So, fundamentally the diagram below shows how Exclusive Consumers work where Consumer A and Consumer B are both listening to the same queue but only the Consumer A is consuming messages from it.

The Exclusive Consumer feature is configured at the consumer level, so at the code level you have to explicitly say what queue you're listening in and also say you're an an exclusive consumer.

Here is a piece of code showing how to set the Exclusive Consumer:

queue = new ActiveMQQueue(“TEST.QUEUE?consumer.exclusive=true”);

That's very simple and still powerful…

But, there's more to that! You also have the choice to set a priority for each consumer.

One way to ensure that high-priority applications get messages to process is to set the consumer priority. When multiple consumer request exclusive access to a queue, the consumer with the highest priority is selected by the broker.

So, another case for Exclusive Consumer priority is the machine speed you have available. You may want to give a higher priority for consumers deployed on faster machines and set the priority according to the resources you have available.

To set the Exclusive Consumer priority all you have to do is set another option on the consumer code like the below configuration:

queue = new ActiveMQQueue(“TEST.QUEUE?consumer.exclusive=true&consumer.priority=10");

The diagram below shows how the consumer priority would play with these settings.

One disadvantage of Exclusive Consumers is that you have active consumers doing nothing but we are going to cover how ActiveMQ helps you avoid that situation on a future post.

Stay tuned!

We're hiring!

2011-11-10T08:50:00.001-08:00

Do you have a technical background and also love the exciting sales world?

Do you like to be in front of the customers discussing technical architecture, new business opportunities and helping them solving the most complex integration problems?

Are you based in Europe (preferably in London)?

Do you want to work for a fast growing company in the open source integration and messaging business?

Well, the time has arrived… FuseSource is looking for a Solutions Engineer to join our team and be part of a very strategic group within the company.

The detailed job description is here: http://fusesource.com/careers/#SE but you can also contact me if you want to talk about it :)

Let's enjoy the ride together...

LinkedIn Veterans Hackday 2011

2011-11-07T17:07:00.000-08:00

A little different topic today but for a really good cause. I really appreciate all the effort that the military personnel has been putting together and I have heard many stories from a few and also some scary ones from the war zone which is not fun at all. That's the reality of the world we live in and while we can't (yet) stop the war, we can improve the life of the ones being part of that.

Today, I found that LinkedIn is promoting a Veterans Hackday and honestly there is nothing better than being able to use your skills to give something back to those that sacrifices their lives every day.

So, I decided to use my tech skills and hack a little project that will benefit our veterans. I honestly can't do all of that by myself and I'm counting on those from the San Diego, CA area that are available and want to work together on this over the weekend.

As I just started organizing this, I don't have an idea yet but I'd be glad to start designing something as soon as possible and then do the coding later in the week.

If you want to hack something together, please reach out and let's work together on this patriotic project...

JMS and Database Integration with Apache ServiceMix, Camel and ActiveMQ

2011-10-26T14:45:00.000-07:00

I've been asked to create a simple project to demonstrate how Apache ActiveMQ, Camel and ServiceMix could be used in the same integration context. Then, for the specific customer I was talking to, I decided to create something related to the world they were used to.

This example will process messages as they are delivered on an input queue and I thought that XML would be a good format to also demonstrate how to parse the payload and generate an SQL statement before hitting the database.

In summary, for each message going to the input queue, we're going to create a record in the database table and then generate a response message on the output queue.

I'm assuming you're already have Apache ServiceMix downloaded and installed in your machine. If not, it's time to download it… I recommend you to just go to http://fusesource.com/downloads/ and download FUSE ESB.

I'm also assuming that you already have Maven installed but if not feel free to download and install it from maven.apache.org

Here are the steps to create this short and simple demonstration:

1) Download and install MySQL database from http://dev.mysql.com/downloads/
You can use the default test database that's shipped with MySQL and the only thing you have to do is to create a table to insert test records. To do that, connect to the database and run the following SQL statement:

CREATE table PARTNER_METRIC(partner_id int, time_occurred DATE, status_code int, perf_time long);

2) Install the following features in ServiceMix:

features:install camel-jdbc
features:install camel-jms

3) Install commons-dbcp bundle:

osgi:install -s mvn:org.apache.servicemix.bundles/org.apache.servicemix.bundles.commons-dbcp/1.2.2_6

4) When you do this you will receive a bundle id, e.g. 229. Enable dynamic imports on this bundle so that it can pick up the appropriate database driver.

dev:dynamic-import 229

5) Using ServiceMix hot deploy feature to deploy the MySQL JDBC driver:

cp /Applications/MySQL/mysql-connector-java-5.1.18/mysql-connector-java-5.1.18-bin.jar  /Users/mjabali/Fuse/apache-servicemix-4.4.1-fuse-00-08/deploy/

Then you can verify that the driver gets deployed correctly with the following command:

karaf@root> list |grep -i mysql

and you should get a message similar to the following:

[ 227] [Active     ] [            ] [       ] [   60] Sun Microsystems' JDBC Driver for MySQL (5.1.18)

6) Download the source files of this sample and extract them on the directory of your choice. So, let's review the JMS and Database connection settings in the following resource files:

$PROJECT_HOME/src/test/resources/sample/RiderAutoPartsPartnerTest.xml
$PROJECT_HOME/src/main/resources/META-INF/spring/beans.xml file

These are the same file albeit named differently. One is used by the bundle and the other by our test case.

We'll be also using the default Apache ActiveMQ instance for the messaging aspect of this tutorial.
To check whether the ActiveMQ is installed, up and running you can run the following command:

karaf@root> osgi:list |grep activemq-broker

and you should see an output similar to this

[  66] [Active     ] [Created     ] [       ] [   50] activemq-broker.xml (0.0.0)

You can see the default broker's definition within the activemq-broker.xml file under $SERVICEMIX_HOME/etc/activemq-broker.xml

The database source definition is on the beans.xml file and you may want to adjust it to reflect the settings on your environment. Here is a copy of the definitions I have on my machine:

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName" value="com.mysql.jdbc.Driver"/>

<property name="url" value="jdbc:mysql://localhost/test"/>

<property name="username" value="root"/>

<property name="password" value="XXXX"/>

</bean>

7) Let's compile the code then… Run the following command on the root directory of the project

mvn clean install -Dmaven.test.skip=true

If the code builds up successfully then you're ready to deploy on ServiceMix.

8) To deploy the bundle into ServiceMix, run the following command:

karaf@root>osgi:install mvn:com.fusesource.fusebyexample/camel-jms-dbase/1.0-SNAPSHOT

A confirmation that the bundle was deployed successfully should be returned to you and a message similar to the follow one should be displayed:

Bundle ID: 228

Then, you are ready to start the bundle and verify if has started correctly. Follow the instructions below to do that:

To start the bundle:


karaf@root>osgi:start <bundle ID>

To verify the bundle has started correctly:


karaf@root>osgi:list |grep <bundle ID>

and then a message like the following should be displayed:


[ 228] [Active     ] [            ] [Started] [   60] Camel JMS Database Example (1.0.0.SNAPSHOT)

You can also immediately turn on the trace logging capability for Camel and get additional output in the ServiceMix log facility. To enable the trace logging just run:

karaf@root>set TRACE org.apache.camel

and then to see the ServiceMix log, run:


karaf@root>log:display

You should be able to see messages with the TRACE identifier similar to the below:


11:46:17,095 | TRACE | tnerRequestQueue | JmsMessageListenerContainer      | ?                                   ? | 94 - org.springframework.jms - 3.0.5.RELEASE | Consumer [ActiveMQMessageConsumer { value=ID:titan.local-54477-1319240594120-6:1:1:1, started=true }] of session [PooledSession { ActiveMQSession {id=ID:titan.local-54477-1319240594120-6:1:1,started=true} }] did not receive a message

9) To test this sample project all you have to do is to send a sample message (there is one included in the $PROJECT_HOME/src/test/resources/sample directory) to the ActiveMQ queue that the Camel route is listening for. You can use any approach you like but writing a JMS Test client is pretty simple and there are tons of examples on the Internet and also available in the ActiveMQ sample directory. You can also use tools like HermesJMS which adds a little UI for you so you don't need to create a test program.

Either way, after sending a message to the partnerRequestQueue (default queue name used on this tutorial) you should see a couple of messages in the ServiceMix console like those below:

karaf@root>  **** toSql returning: INSERT INTO PARTNER_METRIC (partner_id, time_occurred, status_code, perf_time) VALUES ('123', '200911150815', '200', '9876')

 **** fromSql returning: Sample message to be returned on reply queue

You can verify that the values were inserted into the MySQL database running a simple query like:


select * from PARTNER_METRIC;

It is also recommended to check the ServiceMix log to make sure there are no exceptions there.

The sample code for this tutorial is available on GitHub: https://github.com/mjabali/JMS-DB-Sample

I also would like to thank my colleague Susan Javurek for putting an extra effort on this and helping out with the sample code.

UPDATE: I also would like to say a big thanks to Claus Ibsen (@davsclaus) for reminding me that all the manual steps related to OSGi bundles installation could be automated using the feature capability that consists in deploy multiple related bundles into a larger unit of deployment.

Enjoy the ride...

Using Apache Camel for Application Notification

2011-10-21T11:48:00.000-07:00

I was watching a forum thread (http://fusesource.com/forums/thread.jspa?threadID=3433) this week where the use case was not to consume the file content but rather the file name. That seems to be an interesting use of Apache Camel because most of people used the Camel File Component to consume the contents of the file and then do some kind of processing on top of that (routing, web services invocation, ftp, bean execution, database interaction, etc).

What brought my attention to this specific use case is that the important information here was the file name and not the content of the file. Given that the file itself was pretty large (around ~1GB) it would be a nightmare to handle all of that in memory on a Camel route or any other middleware available out there. But, this use case is really about notifying other systems or applications that a large file is available to be processed outside the route (think about a file being available for download for example) and the reason to only care about the file name is that information could be part of the URL generated during the processing of the Camel route.

So, basically the Camel route was watching the file system for files generated, then grabbed the file name and then notify another system or application (or even the end user i.e. e-mail) that the file was ready to be consumed. I've recreated below the Camel route generated by default in the sample project to illustrate how to do that.

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:camel="http://camel.apache.org/schema/spring"

xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

<camel:camelContext xmlns="http://camel.apache.org/schema/spring">

<camel:package>com.fusesource.fusebyexample</camel:package>

<camel:route>

<camel:from uri="file:src/data/?noop=true"/>

<camel:setBody>

<camel:simple>header.CamelFileName</camel:simple>

</camel:setBody>

<camel:log message="The message contains ${body}"/>

<camel:choice>

<camel:when>

<camel:simple>${body} == 'message1.xml'</camel:simple>

<camel:log message="Going to UK message"/>

<camel:to uri="file:target/messages/uk"/>

</camel:when>

<camel:otherwise>

<camel:log message="Going to Other message"/>

<camel:to uri="file:target/messages/others"/>

</camel:otherwise>

</camel:choice>

</camel:route>

</camel:camelContext>

</beans>

Of course, if you want to try that out, the project is available at: https://github.com/mjabali/FileNameBasedRouter

Enjoy the ride!

FuseSource Community Day in San Francisco, CA - November 17th

2011-10-17T13:43:00.000-07:00

Thirsty for information about Apache Camel? Hungry to learn more about Apache ActiveMQ in production environments? Keen to know more about the Business Impact of Open Source Software...

Don't miss the opportunity to hear from Rob Davies (CTO of FuseSource, PMC Member, Founder and Committer on Apache ServiceMix and ActiveMQ and also the co-author of ActiveMQ in Action) and James Strachan (Creator of Groovy, member of the Apache Software Foundation and co-founder of Apache Camel). You'll be also hearing from architects, consultants and developers using those technologies in real world applications and what problems they were able to solve.

Not enough for you?!?! The FuseSource Community Day will be held at a really nice venue in downtown San Francisco called Thirsty Bear (661 Howard St., San Francisco, CA 94103).

For more information, visit the event web page: http://form.fusesource.com/sanfrancisco2011

I hope to see you all there...

Using HTTP-based endpoints with Apache Camel

2011-10-14T12:11:00.000-07:00

On a recent discussion, a partner was trying to use Apache ActiveMQ HTTP Transport Connectors to receive HTTP requests from a non-JMS Web application and asked me what I would think it could be a good approach to the use-case. Analyzing the use case, which needs a synchronous multi-step execution I suggested that they took a look in the Apache Camel Jetty component instead of Apache ActiveMQ and that was surprisingly easier to setup and maintain then the original approach.

While there is nothing wrong with the approach they thought about I think that Apache Camel would give them a more powerful setup to what they were looking for.

So, here is a sample configuration, that I created as a demo project, using Apache Camel Jetty component enabling HTTP endpoints.

In our Apache Camel route definition (using the Spring XML approach in this case) we'll have to define the Jetty endpoint similar to this:

where we basically specify the address we'll be consuming HTTP requests. There are many options we can use to fine tuning the Jetty component but we'll keep it with only the required information for simplicity.

Then, the next step is going to be a regular approach to any other route we have developed so far. In this example, we're going to use a LOG component and then a custom Process pointing to a simple Java bean where we perform the processing of every request.

The log component above will be displaying a header name called 'bookid' and then the Java bean (listed below) will be taking care of the request:

package com.fusesource.fusebyexample;

import org.apache.camel.Processor;

import org.apache.camel.Exchange;

public class myBookService implements Processor {

public void process(Exchange exchange) throws Exception {

// Grab the booked header value

String bookId = (String) exchange.getIn().getHeader("bookid");

// send a html response

exchange.getOut().setBody("<html><body>Book " + bookId + " is Camel in Action.</body></html>");

}

The last thing we need to add to our Apache Camel context file is the bean definition which could be simply like the line below:

That's all we need... To test the integration use case described above, we can simply run the Camel route, open any web browser and hit the following URL:

http://localhost:8888/myBookService?bookid=91942

where the Camel route will log the following in the console:

HTTP LOG INFO HTTP REQUEST: 91942

and the web browser will display the result of the Java bean processing with the following:

If you want to use a simple HTML form, here is something to easily test the Camel route...

<html>

<body>

Book ID: <input text name="bookId"/>

</form>

</body>

</html>

I've also included the test HTML form on the source code package of this configuration available here:

https://github.com/mjabali/Jetty-Sample

Enjoy the ride!

FuseSource Training in Brazil

2011-10-13T15:08:00.000-07:00

Since the FuseSource Brazilian tour a couple of weeks ago I've been getting more and more questions about what's next for the region. Well, here is the next step... We're going to deliver an Apache ActiveMQ training class on Nov, 16-17 in São Paulo and an Apache ServiceMix with Camel training class on November, 18-19 also in São Paulo. We are still working to get a nice venue for the training in case you wonder where this is going to happen.

I've personally been involved in the FuseSource training and I can guarantee you that's a lot of fun and tons of good information.

Here is the URL with information about the training classes: http://fusesource.com/enterprise-support/open-enrollment/ but if you have any questions please don't hesitate to contact me through this blog, Twitter (@mjabali) or e-mail (marcelo@fusesource.com).

Hope to see you there...

Apache ActiveMQ Enhancements to JMS

2011-10-05T08:33:00.000-07:00

The JMS (Java Message Service) specification is very well-known for those working with messaging platforms but it has been around for quite some time and honestly not getting updates lately which gives a lot of room for enhancements and extensions.

As you can imagine Apache ActiveMQ goes beyond the JMS spec and implement lots of cool things where you can gain more in functionality, performance and scalability.

Starting from the top ConnectionFactory object, ActiveMQ has its own called ActiveMQConnectionFactory, as other JMS providers also create their own specific factories, ActiveMQ enhances the JMS with some settings that you can activate right away with little configuration and definitely see gains in performance. Of course, when you optimize for performance, most of the time, you have the trade-off of more CPU utilization but I think CPU cycles are getting really cheap when comparing with network bandwidth and disk I/O.

Here is a list of things you can use to optimize performance extending the JMS specification with Apache ActiveMQ:

disableTimeStampsByDefault - it sets whether or not you're going to include the Time Stamp in the message header. The story behind this is that when you create a JMS message (actually when you call the send() method) we have to make a call to the system kernel to get the time stamp. This setting could save you a trip to that level and save you some time optimizing performance if the time stamp is not required in your messaging application.

copyMessageOnSend - The Java Message Service specification says that inside the send method we have to make a deep copy of the message object before sending it from the client to the broker. Setting the copyMessageOnSend property to false (default is set to true) will save you a cycle as the client won't make that copy of the message saving local resources.

useCompression - I think the property name here is self explanatory... but the ActiveMQ client will compress the message payload before it goes to the broker. So, the question is why not to use compression all the time and send smaller messages over the wire? Well, in order to compress the message payload you're going to spend CPU time and then the point is CPU vs. I/O. It's a trade-off that you may have to consider... in other words, you'll have to consider spending more CPU to compress the message or more bandwidth sending larger messages. Personally, I believe (and have seem) that if you have the chance to use compression you definitely should.

objectMessageSerializationDefered - Imagine that you're sending an Object Message and you're using an embedded broker for example (client and broker running on the same JVM). What this feature really enables you to do is that you tell the client to delay the object serialization as long as it can until it needs to hit the wire or store the message on disk. Basically, everything inside the same JVM should not be serialized as marshalling and unmarshalling objects can also be expensive.

useAsyncSend - Let's say you're sending NON_PERSISTENT messages to the broker which is equal to non-blocking call with no immediate acknowledgement and in fact it's ver fast but still not reliable messaging.
On the other hand, you can also use PERSISTENT messages which is going to be a blocking call from the client to the broker. So, one of the things you can do is to set useAsyncSend to true (default is false) and then change the behavior of PERSISTENT delivery mode to be asynchronous and no acknowledgement would be expected. In reality, the send() method will return immediately giving you more performance because it reduces the time that the message producer waits for the message to be delivered. Keep in mind that this setting can possibly cause message loss but that's another trade-off that you have to consider when designing your messaging infrastructure.
This is a good approach if you can tolerate some message loss... typically on systems where the most updated information (last message) is always what you care about or when you have a reconciliation process in place to catch those conditions.

useRetroactiveConsumer - This feature allows you to work with limited window of memory topics where you can configure a policy to deliver let's say for example the last 10 messages sent to the topic, the last 5MB of data that went through to that topic or simply the last message sent to the topic... and all of that without the need of durable subscribers :-)
This is actually far more lightweight than using durable subscribers and it's really easy to configure and very easy to use.
Finally, since this is not JMS standard, of course, it's not set by default.

For a complete list of ActiveMQ enhancements to the JMS specification see the ActiveMQ product documentation.

I hope this helps you to push the go-faster button in your messaging infrastructure.

FuseSource Tour in Brazil

2011-10-03T09:58:00.000-07:00

I had the pleasure to spend a week in Brazil doing a FuseSource Tour in two of the major cities... Sao Paulo and Rio de Janeiro. It's pretty clear that the Open Source community is growing really fast and the integration and messaging opportunities are hot.

Unfortunately, I couldn't visit all of the prospective partners and customers that had contacted us because we couldn't find a single empty spot on the agenda but I think the tour was an amazing experience and I'm pretty I'll back in the near future for more fun with the techies.

Some of the things I realized while traveling throughout Brazil is that the traffic is really crazy and made me remember some other cities like Los Angeles or Mexico City... You have to be really creative in terms of logistics to be able to meet more than two customers in the same day especially in Sao Paulo.

Food was a big surprise and it was pretty good either in Sao Paulo or Rio and I met nice and friendly people all over the place... Gotta keep up on the workout front to shed some extra pounds!

On the business side, I've met mostly customers in the financial sector and partners that already use Apache technologies like ActiveMQ, Camel, CXF and ServiceMix and I was able to have a good tech talk with them while discussing some architectural aspects as well as development techniques.

While talking to a couple of big banks in Sao Paulo, it sounded to me that companies are realizing the value and maturity of, for example, Apache ActiveMQ where their are not only reducing licensing costs but also exploring features that other messaging products don't offer at this point.

Of course, the reliability and extensibility as well as high performance are key factors for all of these organizations and ActiveMQ is/is going to be part of their architecture.

Sao Paulo Subway System

Then, on the second part of the week (more precisely in Rio de Janeiro), I visited a telecom company who's using ServiceMix as part of their core engineering systems and I was happy to discuss patterns and features they are using and also some things they can do to improve it in the next rollout.

Rio de Janeiro's Sugar Loaf

Interesting enough, all of the developers and architects I had the pleasure to talk to were really amazed with Apache Camel and there are tons of use cases where they see possibilities of writing a couple lines using either Java DSL or Spring XML Configuration rather than several lines of code where they need to manage everything from the connection to the business logic. What everybody really liked during the Camel demos is the abstraction layer that Camel provides where you concentrate on the business logic and not on the details of the implementation. Gotta a comment that we're now "High-tech plumbers" connecting all of the enterprise applications with the simplicity and power of Camel, ActiveMQ, CXF and ServiceMix.

But, the best moment was when I did an Apache ActiveMQ, Camel, CXF and ServiceMix overview presentation in one of the largest companies in the country for 100 developers and technical folks. I was really impressed on how excited they got after the talk and Q&A and they are really looking forward to apply the discussed topics on their projects right away. The same presentation should be the core of a webinar that I'm planning to do in December... a quick overview about the technology and how FuseSource has been helping customer/partners to successfully work with those Apache projects from conception to deployment.

To celebrate the successful talk, next morning I went for a run at Ipanema's beach where I ended up with the view below... Simply amazing...

Ipanema's Beach

Well, I'm really looking forward to continue to work with organizations in Latin America and come back soon...

Using the MINA component in Apache Camel

2011-09-12T11:48:00.000-07:00

You may find yourself trying to solve an integration problem where one of the systems doesn't "talk" anything else other than TCP/IP or UDP/IP. At that point, you may start thinking about writing your own socket server or look for one in the Internet or even create your Camel component to do that.
Well, that's where the Apache Camel MINA component comes really handy and you don't need to reinvent the wheel.

Camel MINA is a transport component working with Apache MINA which is a network application framework that provides event-driven asynchronous API over various transports such as TCP/IP and UDP.

A very common use case is to deploy camel-mina as a proxy in a Camel route and then do whatever is needed with the data like converting it to the appropriate format for example.

To give you an example, here is something you can do easily to test how camel-mina can help you:

Using the FUSE IDE create a new FUSE Project and then open the default camel-context.xml file under $PROJECT_HOME/src/main/resources/META-INF/spring if it's not open for you.

You can simply remove the default route created in the project and start with a new one.

Add a new Route. Right-click on the canvas and then select Add --> Route.

Then, add a new Endpoint, Right-click on the canvas and then select Add --> Endpoints --> Endpoint.

Go to the Properties panel and add the following to the Uri field:

mina:tcp://localhost:8888?textline=true&sync=true

Here is a screenshot of the configuration in the FUSE IDE:

In this example, we're creating a MINA consumer endpoint that listens on port 8888, using the textline codec and sync means that we'll be using a synchronous exchange where the client can read a response from the MINA component.

To add a little more fun to this sample, you can add a simple bean to, for example, convert the payload to upper case. Really simple stuff but you get the idea as that step could be dropping that message into an ActiveMQ queue, executing another Camel component, etc.

So, here is a simple Java class to do that:

public class MyTcpMsgHandler {

public String myTcpMsgHandler(String msg){

return msg.toUpperCase();

}

Last development step is going to be adding the new Java bean into the route. To do that, right-click on the canvas and go to Add --> Endpoints --> Bean. Go to the Properties panel and then configure your recently create bean. Here is a sample configuration:

That's it! All the steps necessary to create your Camel route using camel-mina are there!

Here is a screenshot of what we just did with the complete route:

So, if you want to test that route (there are many ways to do that) you'll need a client to connect to that endpoint exposed by our route.

Here is a very simple client to test it:

package com.fusesource.fusebyexample;

import java.io.*;

import java.net.*;

class TCPClient{

public static void main(String argv[]) throws Exception{

String sentence = null;

String modifiedSentence;

boolean clientUp = true;

BufferedReader inFromUser = new BufferedReader( new InputStreamReader(System.in));

Socket clientSocket = new Socket("localhost", 8888);

DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());

BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

while(clientUp = true){

sentence = inFromUser.readLine();

outToServer.writeBytes(sentence + '\n');

modifiedSentence = inFromServer.readLine();

System.out.println("FROM SERVER: " + modifiedSentence);

if(modifiedSentence.equals("STOP")){

clientSocket.close();

System.out.println("Stopping TCP Client...");

System.exit(0);

}

Don't forget to include camel-mina dependency in your POM file before you deploy your Camel route.

Next, let's test our route. Right-click on your camel-context.xml file and then select Run As... --> Local Camel Context. Watch the FUSE IDE console for any issues being reported or for a successful deployment. You can also run the Camel route manually by executing the following command:

$ mvn camel:run

Also, run the sample client which opens a prompt for you to type a message. Type for example "apache camel rocks!" and you should see a reply back like this: FROM SERVER: APACHE CAMEL ROCKS! as the result of our processing of the message by our bean.

This sample demonstration code is also available on GitHub: https://github.com/mjabali/MinaSample

Enjoy the ride!

How to Enable ActiveMQ Web Console on ServiceMix 4.4

2011-08-19T10:48:00.000-07:00

A few days ago I was helping an Apache user getting the ActiveMQ Web Console up and running on ServiceMix 4.4. At first instance, it seems to be a trivial setting but it's a little bit tricky.

Out of the box, every ServiceMix instance comes with an embedded ActiveMQ JMS (Java Message Service) broker. This feature makes it easy to communicate between Camel routes using persistent messages and also to distribute messages over multiple instances using clustering or load balancing.

The ActiveMQ Web Console feature is included in any ActiveMQ distribution and you'll probably want to have it installed in ServiceMix as well to make sure you can monitor your JMS broker.

So, the first thing you have to do is to install the war feature running the following command:

karaf@root> features:install war

Then you can do run the following command to install the ActiveMQ Web Console:

karaf@root> features:install activemq-web-console

This command will install and start the web console automatically with an embedded broker which you can access going to the following URL: http://localhost:8181/activemqweb

But that brings the first issue... Once you have the default embedded ActiveMQ broker running then the Web Console will fail to start since it also tries to start an instance of the ActiveMQ basically on the same port number. It's quite frustrating to install a feature on ServiceMix and not be able to test it or execute it right away.

So, to configure the ActiveMQ Web Console to connect to the default embedded broker you have to do a little extra configuration change but that should be straightforward.

Go to $SMX_HOME/etc and edit the system.properties file then add the following details:

webconsole.type=properties

webconsole.jms.url=tcp://localhost:61616

webconsole.jmx.url=service:jmx:rmi:///jndi/rmi://localhost:1099/karaf-root

webconsole.jmx.user=smx

webconsole.jmx.password=smx

Save it and (re)start ServiceMix. That should be enough to get the ActiveMQ Web Console connected to the default embedded broker in ServiceMix.

If you don't want to monitor the default embedded broker but want to stick with the instance that the Web Console starts for you then all you will have to do is to uninstall the default embedded ActiveMQ broker with the following command:

karaf@root> features:uninstall activemq-broker

and then restart ServiceMix. This way there will be no conflicts on the ActiveMQ port number anymore.

I hope this helps to clarify some of the issues out there...

Enjoy the ride!

Throttler Enterprise Integration Pattern Demo

2011-08-13T12:25:00.000-07:00

The second video demonstration posted to the FuseSource website describes the Throttler EIP (Enterprise Integration Pattern) pattern and shows you how you can achieve that with Camel and the Fuse IDE.

So, take a look on the video below to understand more about the pattern.

Enjoy the ride!

Endpoint Browsing and Route Tracing with Fuse IDE

2011-08-13T12:17:00.000-07:00

This week two 5-minute demos were posted to the FuseSource website. The first one describes how to do endpoint browsing and route tracing with Fuse IDE.

I've linked the video here too, so you can take a look on these features.

Enjoy the ride!

Reducing Spring Dependency with Apache Camel 2.9

2011-08-09T14:17:00.000-07:00

Claus Ibsen (@davsclaus) brilliantly blogged about a new fundamental change on Apache Camel 2.9. Basically, the goal is to reduce the dependency of the Spring framework JAR files in the core components of Camel and other components where they are used.

You can read more about this exciting change on Claus' blog entry http://davsclaus.blogspot.com/2011/08/apache-camel-29-reduced-dependency-on.html

Enjoy the ride!

New Fuse IDE 2.0 Release

2011-08-04T11:05:00.000-07:00

We recently announced (http://fusesource.com/press-releases/fusesource-press-release-8-2-2011/) a new release of the Fuse IDE (http://fusesource.com/products/fuse-ide/).

Now at version 2.0, the Fuse IDE (an Eclipse plugin) builds on a visual environment that enables developers to "drag-and-drop" the integration and mediation components needed to connect several systems and applications. I'd like to give you some highlights of this very exciting release.

Additionally to the already known features (http://fusesource.com/collateral/112/), here is what's included:

Endpoint browsing – which makes it easy to see and inspect the available messages on endpoints or JMS queues

Message drag and drop – from an endpoint or JMS queue to any Camel endpoint or JMS destination to quickly try out integration scenarios
JMX explorer – tailored to view Fuse integration applications

Graphical viewer – displays all brokers, queues, topics, Camel endpoints, and Camel routes available in a remote JVM

Route tracing – step through each version of each message to see how message headers and bodies change as they move through routes

So, don't wait to try out these new features... download the new Fuse IDE, provide feedback and we can make it even better!

Enjoy the ride!

Using Apache Camel to Monitor SNMP-enabled devices

2011-07-21T12:47:00.000-07:00

I've been working with a hardware manufacturer company this week that wanted to use Apache Camel to get information about SNMP-enabled (http://en.wikipedia.org/wiki/Simple_Network_Management_Protocol) devices.

As you may know, Apache Camel has a SNMP component (http://camel.apache.org/snmp.html) able to poll devices or receive SNMP traps.

Here is a very simple Camel route example that we used to get started with the camel-snmp component:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<package>com.fusesource.fusebyexample</package>

</route>

</camelContext>

</beans>

So, the snmp-camel component has many configuration options but you basically have to provide the following:

snmp://hostname[:port][?Options]

Additionally, you have the following options:

On our example, we added the following (additionally to the hostname and port number of the host we wanted to get information from) to test the configuration:


protocol=UDP - You can either use UDP or TCP protocols

type=POLL - You can enter POLL or TRAP to define whether the camel component is going to poll the device for info and create a listener for SNMP trap events

delay=10 - Frequency you want to poll the device for information

oids=1.3.6.1.2.1.1.3.0 - In this particular example, we setup the OID which retrieves the amount of time the device is up (http://www.oid-info.com/get/1.3.6.1.2.1.1.3.0)

The last piece of our Camel route was just a log component because we wanted to see what was coming back from the device. That's all!

We also used the FUSE IDE to rapidly test the scenario we wanted and that was pretty straightforward. The FUSE IDE can be downloaded from (http://fusesource.com/products/fuse-ide-camel/).

Don't forget to include camel-snmp as a dependency in your pom.xml file if you're using Maven which
should be like this:

<groupId>org.apache.camel</groupId>

<artifactId>camel-snmp</artifactId>

<version>${camel-version}</version>

</dependency>

Enjoy the ride!

Calling Web Services with Apache Camel

2011-07-08T11:30:00.000-07:00

Web Services are very important components of most (if not all) of the integration projects these days. The Web Services architecture make them extremely useful for distributed applications and they are often associated with Service-Oriented Architecture (SOA).

Calling Web Services from Apache Camel is pretty simple yet powerful and Camel uses Apache CXF (http://cxf.apache.org).

Apache CXF provides you many options to build Web Services (JAX-WS Annotated Services from Java, JAX-WS Annotated Services from WSDL, JAX-WS Providers, Simple Frontend and JavaScript).
Additionally, there are three major types of services (SOAP, REST and CORBA). For more information, check this web page http://cxf.apache.org/docs/how-do-i-develop-a-service.html.

JAX-WS (Java API for XML Web Services) specification defines annotations that allow you to tell CXF how your POJOs should be represented on the web.

Basically, there two types of web services development with Apache CXF:

Contract-first development - Recall that WSDLs define what operation and types a web service provides. This is often referred to as web services contract, and in order to communicate with a web service, you must satisfy the contract. Contract-first development means that you develop a WSDL file and then generate stub Java class implementations using a tool like Apache CXF.

Code-first development - The other way to develop web services is by starting out with a Java class and then letting the web service framework handle the job of generating a WSDL contract for you. In this case, Apache CXF will be in control of what the contract will be.

To configure the CXF component URI in Camel there are two main ways that you can do that:

Configuring Using the URI Options - The most simple way (and the one will be using for demo purposes) where you pass inline parameters to the component. Here is the format you have to specify:


cxf://<service_address>[?options]

The options available for the CXF component are available here: http://camel.apache.org/cxf.html

Referencing a Bean - Using this approach, you have to specify a bean containing the configuration. You have much more power and flexibility than configuring CXF via URI options but it also requires more work on your side. You can configure things like CXF interceptors, JAX-WS handlers and the CXF bus but we're going to cover that on a different blog post. To configure the CXF component referencing a bean the URI is something like this:

cxf:bean:beanName where the beanName specifies the ID of the CXF endpoint bean defined in your Spring XML file.

So, to give you a taste of what's going to be a simple project calling Web Services with Apache Camel here is the step-by-step procedure:

I'll be using the FuseIDE for that but the artifacts generated are pretty much the same if you choose the Maven approach.

Here is what you need:

- Eclipse IDE (Eclipse Helios 3.6.2)
- Apache Maven (3.0.3)
- FuseSource Camel IDE (http://fusesource.com/products/fuse-ide-camel/)

Then, create a new Fuse IDE project and select the Camel Archetype and type the Group Id, Artifact Id and Package name for your project then click Finish.

As I've explained before on my previous post (http://marcelojabali.blogspot.com/2011/06/file-batch-splitter-with-apache-camel.html) the default Fuse IDE project comes with a sample configuration that you can remove for the purpose of this demonstration.

Create a new Camel XML File (camelContext.xml) and then create a new route.

Drag and drop an endpoint from the palette and also a log component. Connect them and make sure you save your project. You should see something like the picture below:

Edit the URI property of the Endpoint to be: file:src/data?noop=true

Edit the Message property of the Log component to be: ${body} and the Logging Level to INFO

You should be able to run this route now which is going to display the content of files under the src/data directory in your project in the Camel log. It's always a good practice to make sure every step in your route runs consistently and without any problems.

To run the Camel route (if you're using the FuseIDE) just right click int the Camel XML file and then select Run As... Local Camel Context.

If everything executed correctly you should see the content of the files in the Eclipse console and you're ready for the next step.

Add another Endpoint to your route. Connect the Log component to the new created Endpoint.

The recently added Endpoint is going to be our CXF component. We're going to use a sample Stock Quote Web Service available at http://www.webservicex.net/WS/WSDetails.aspx?CATID=2&WSID=9

Click on the Endpoint and then add the following to the URI:


cxf://http://www.webservicex.net/stockquote.asmx?wsdlURL=src/main/resources/META-INF/stockquote.wsdl&serviceName={http://www.webserviceX.NET/}StockQuote&portName={http://www.webserviceX.NET/}StockQuoteSoap&dataFormat=MESSAGE

Here are the options being used on this simple call:

cxf://http://www.webservicex.net/stockquote.asmx - Endpoint definition (cxf) and then the required service address

wsdlURL=src/main/resources/META-INF/stockquote.wsdl - The location of the WSDL file

serviceName={http://www.webserviceX.NET/}StockQuote - The service name this service is implementing, it maps to wsdl:service@name

portName={http://www.webserviceX.NET/}StockQuoteSoap - The port name this service is implementing, it maps to wsdl:port@name

dataFormat=MESSAGE - The data type messages supported by the CXF endpoint (default is POJO)

The last step in the route to be implemented is a Log component to display the Web Service response. To do that, just add another Log and connect the CXF component to it.

Edit the Message property of the Log component to be: ${body} and the Logging Level to INFO

Your route should be similar to the following:

Save the project.

For reference, here is the whole route:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:cxf="http://camel.apache.org/schema/cxf"

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

http://camel.apache.org/schema/spring

http://camel.apache.org/schema/spring/camel-spring.xsd">

<to uri="cxf://http://www.webservicex.net/stockquote.asmx?

wsdlURL=src/main/resources/META-INF/stockquote.wsdl&

serviceName={http://www.webserviceX.NET/}StockQuote&

portName={http://www.webserviceX.NET/}StockQuoteSoap&

dataFormat=MESSAGE"/>

</route>

</camelContext>

</beans>

Before you test it make sure you change the values of the sample messages (under src/data) to the following:

message1.xml:

<?xml version="1.0" encoding="utf-8"?>

<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">

<soap12:Body>

</GetQuote>

</soap12:Body>

</soap12:Envelope>

message2.xml:

<?xml version="1.0" encoding="utf-8"?>

<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">

<soap12:Body>

</GetQuote>

</soap12:Body>

</soap12:Envelope>

This is the SOAP format that the web service is expecting and we're not doing any message transformation here so far.

At this point, you're ready to go and you just need to run the Camel route as explained before.

After you run the route, you should see two messages being displayed in the Eclipse console with the content of the files you just edited and then two responses from the Web Service showing the stock value of AAPL and GOOG.

The sample code is available at https://github.com/mjabali/CXF-Sample

Enjoy the ride!

File Batch Splitter with Apache Camel and FuseSource Camel IDE

2011-06-08T19:42:00.000-07:00

The Splitter from the EIP patterns allows you split a message into a number of pieces and process them individually.

To implement that EIP pattern using Apache Camel and FuseSource Camel IDE is very simple. Here is what you need:

1) Eclipse IDE (Eclipse Helios 3.6.2)
2) Apache Maven (3.0.3)
3) FuseSource Camel IDE (http://fusesource.com/products/fuse-ide-camel/)

After you install and configure the tools mentioned above, start creating a new Fuse IDE Project.

Select the Camel Archetype and type the Group Id, Artifact Id and Package name for your project then click Finish:

At this point you should have a sample Camel project and artifacts available for you. The default Camel project gives you another EIP, the Content-Based Router (http://camel.apache.org/content-based-router.html). You can open the camelContext.xml under the META-INF/spring directory and remove the Camel components available there since we're going to implement a different EIP (right-click and then Delete).

To start creating the File Batch Splitter sample project, right-click in the canvas of the camelContext.xml file and select Add > Route. We're now ready to start building our process. Right-click inside the Route rectangle and select Add > Endpoints > Endpoint.

Then, right-click again and select Add > Routing > Split. Finally, right-click and select Add > Endpoints > Endpoint. Now, click on the first created Endpoint and draw a line to the Split component. Do the same thing between the Split component and the second Endpoint.

You can also click on the Automatic Layout icon available in the Eclipse top menu bar to automatically adjust your route diagram.

Now, you have added all necessary components and should have something similar to the following picture.

You can now configure each component to execute the tasks needed to conclude the File Batch Splitter sample project. Basically, we'll consume files from one directory in the file system (an XML file with multiple records), split each record in the XML file into a new file in the file system.

To do that, click on the first endpoint and go to the Properties tab where you can see the details of each component. In the Uri field, type: file:src/data?noop=true

Highlight the Split component and type the condition you want to generate new records from the input file. In this case, we're going to use the following: //club/person as a XPath expression.

And then, highlight the final endpoint and type the following in the Uri field: file:target/output?fileName=${date:now:yyyyMMddHHmmssSSSSS}.xml
We're using a dynamic file name based on the current date to avoid conflicts and/or overriding the original files. So, every record gets a new file name when Camel creates the file.

Before we execute our Camel project, we need an input file under the src/data directory. Here is the content of a sample file to use:

<?xml version="1.0" encoding="UTF-8"?>
<club>

<firstName>Marcelo</firstName>

<lastName>Jabali</lastName>

<city>San Diego</city>

</person>

<firstName>Scott</firstName>

<lastName>Cranton</lastName>

<city>Boston</city>

</person>

</club>

The step before we execute the project is to configure how to run it. There are a couple different ways to run it but basically you can configure everything in Eclipse. Just go to Run > Run Configurations and then under Local Camel Context you can create a new configuration just pointing to the camel-Context.xml file. Click Apply and then Run.

If everything was configured correctly you should be able to see two XML files under the src/output directory containing a person record each (don't forget to refresh the view).

You also have the option to execute that project through Maven on the command line. Just navigate to the root directory of the project and type:

>mvn camel:run

That does the same thing that we executed under the Eclipse IDE.

If you want to download the files and play with the samples the project files are available on GitHub (https://github.com/FuseByExample/FileBatchSplitter)

Enjoy the ride...

An Alternative Method to the Request-Reply Pattern for Message-Driven Application Configuration

2011-05-27T16:55:00.000-07:00

On a recent ActiveMQ forum discussion, I presented an alternative to a common problem that I've seen more and more people running into.

I've seem some companies using JMS - Java Message Service to provide application configuration based on the client profile. So, basically when the application starts, it connects to a JMS broker and then request its information. The application then receives all information necessary like settings, connections URLs, what destinations to read from and send to, etc.

That's a very smart way to dynamically provide that kind of information and be able to make changes on the fly if necessary.

You can transparently add and remove new features on the backend systems, change destinations, change server URLs, without performing any major update on the client side.

What I also have noticed is that most of the people uses the JMS request-reply mechanism to achieve that which is a good way to do it but can cause some side effects and problems during the client-broker communication once the client application will be waiting for a response from the another application through the JMS broker.

So, one alternative way to do that without the request-reply mechanism in place is employing the traditional point-to-point messaging model.

Using point-to-point messaging techniques you can load the necessary configuration message to an ordinary queue and the client applications can read the necessary information from there.

The client can instead of consume the message from the configuration queue, just browse the queue, which means that the client reads the message but doesn't remove it, so other client applications can benefit from the same configuration message as well.

You also have the ability to load multiple configuration messages to the configuration queue with different message headers where the clients could use the JMS message selector capability to get the right message.

When you need to update the configuration message you can consume that message administratively (simply connect a JMS client and consume the message would be the most simple way to do that) and then load the most updated information where the client applications can start reading from.

You can also take a different approach and create a queue for each client application profile you have but that may not be the best way to do it if you have a large installation base as it will certainly consume more resources on the broker.

Lastly, you can implement something really creative if you implement a Camel route to provide the client application configuration but I'll cover that on another post.

In summary, the idea here is to avoid the risk of the replier application not being able to respond in a timely fashion (it maybe be busy or offline) or consuming too many resources on the JMS broker with the request-reply pattern.

How to Configure GMail's filters to Move Messages from Your Inbox

2011-05-13T10:14:00.000-07:00

I've been using GMail for almost a month now and honestly I really liked. It's really fast and has lots of good features and extensions.

One of the things I was not really sure I was getting everything out of it was Filters. GMail's Filters allow you to manage the flow of incoming messages where you can automatically label, delete, forward, etc.
As much as I like the label feature where you visually see what "category" the message belongs to I was not able to manage that properly and since I'm now on paternity leave my inbox started flooding once I could not keep up with the tons of emails I get subscribing to many mailing lists as they all show up on my Inbox.

So, how can you apply the filters feature to move messages to other folders automatically? Where is the magic button? Actually, there is no magic button but a magic checkbox on the filter setting.

When you create a new filter, you first select the search criteria (from, to, etc) and then you choose the action you want to take for that message category.

The first option on the Choose Action panel is Skip the Inbox (Archive It) and that's the missing part here. Check that checkbox.
Now you just have to tell GMail where to move those messages. Check the Apply the label checkbox and then select the label you want.

That will give you exactly the Move To behavior and your Inbox will be much cleaner.

CamelOne

2011-05-03T20:50:00.000-07:00

Are you interested in Open Source integration and the benefits it brings to the table? So, here is my advice to you... FuseSource is sponsoring a great conference called CamelOne which is going to be held at the Westin Arlington Gateway in Washington, DC between May 24-26, 2011.

We have a great lineup of speakers and you should definitely go there and listen to them, interact with other users and have fun!

Don't forget to bring your ActiveMQ in Action and/or your Camel in Action books to get them signed.

See you there!

Click on the image below for more information...

Quick Access to Mac Dictionary

2011-04-25T17:13:00.000-07:00

Sometimes you want to know the word definition but don't want to navigate to a website to know what it really means. So, here is keyboard shortcut that will help you a lot faster to get what you need.

1) Hover your mouse pointer over the word you wish to be defined (works in Safari, Mail and other Apple apps). I haven't tried in all of them yet.

2) Press control + Apple Command + D. The word will be highlighted and a Dictionary pop up box will show in the screen with the word definition.

3) Click anywhere in the screen to get rid of that pop up box.

There is also another approach to this using a very cool app called Alfred. Alfred is a must-have productivity tool that lets you automate a lot of things. You can also use Alfred to give you the word definition by just calling the Alfred utility (I use control + space bar) and then typing define and the word you want. The word definition should be presented on the screen for you.

Alfred has so many functions (no need to say that I'm a big Alfred fan already) but that would be a topic for another post.

How to Show Hidden Files in Finder

2011-04-18T16:07:00.000-07:00

Just found this great tip on David Valeri's blog (http://davidvaleri.wordpress.com/2010/12/23/how-i-learned-to-stop-worrying-and-love-os-x-for-java-development/#more-118). If you ever wonder how to show hidden files in Mac OS X Finder here is the procedure to enable it:

Open a new Terminal (/Applications/Utilities/Terminal) window and type:


defaults write com.apple.Finder AppleShowAllFiles TRUE

and to disable it:


defaults write com.apple.Finder AppleShowAllFiles FALSE

Don't forget to restart Finder after you enable/disable this setting.

Rebooting...

2011-04-14T10:26:00.000-07:00

While it has been an incredible ride at OpenSpan so far, I've decided to take a different route on my career and come back to the integration and messaging space. I'll be joining FuseSource as a Solutions Consultant next week.

FuseSource provides enterprise support for its open source core products, Apache ServiceMix, ActiveMQ, Camel and CXF, as well as providing products to better enable production deployment and management around those projects like the new FUSE IDE for Camel.

I'd like to take a moment to thank all the great minds at OpenSpan and wish them the best. I know that sometimes it's hard and disappointing to see someone that you trust and have lots of confidence on just go but this new opportunity in my life is well aligned with what I envision for the future.

On the other hand, I'm extremely excited to join another fast-growing company and also to be back into the integration & messaging space where most of my background is after more than 10 years working with Progress Sonic products.

There are many aspects that motivated me to make an early move and I really hope I can prove all of them to be true.

I'll be transitioning the content of this blog to more enterprise integration, open source, java and other topics and I hope you follow along.

The Power of the Contextual Help

2011-04-08T14:08:00.000-07:00

I spent this week onsite in Baltimore helping a customer architect some automation scenarios where the goal of this exercise was not only to reduce the average handling time of the contact center agents but also make them more productive and provide better customer service.

One of the issues we identified during the discovery phase of this project was the lack of ability of the users to recognize customers with flagged accounts or important alerts to need to be reviewed when get in touch with the contact center.

The current system provides a black triangle image close to the right corner of the screen while the account information is on the left corner. Ha! Don't get me wrong but who in the world designed a condition like that?
Something that has to be brought to the agent's attention in black on a gray background. Nah! It's not gonna work.

Frankly, now I understand why these agents were not able to check that alert and keep that in mind during the call or take action according to the information provided there. They couldn't see it. Agents working all day long taking calls and in front of their computers with the exact same applications all day start not recognizing small changes. It's a fact! You gotta do something better and give them a better experience if you want to have a better customer service.

So, we fixed that issue... and more than that... We didn't change a line of code on their systems.
OpenSpan has a very nice capability to recognize when a control (button, image, textbox, dropbox, etc) is created, changed, clicked or whatever happens with it.
OpenSpan also has a method called ShowToolTip which works for Windows and Web applications.
The quick solution to the issue described here was to combine these two OpenSpan capabilities.
To give you some details, when the agent was getting the account information for the call we setup an event "listening" for the alert image creation on the screen. As soon as we recognize that condition we then read the Outer HTML property of that image because that would be the text displayed on our tooltip and finally display the tooltip for 10 seconds. In a non-intrusive way we brought the agent's attention to where we needed so they could see the alert without clicking on anything and kept working on their call without any interruption.
What colors we decided to use??? Well, we decided to do it in OpenSpan Orange-like and since we were in Baltimore why not to say that was an Orioles sponsored tool tip.

It came out similar to this:

There are so many use cases for an implementation like that. From process guidance to bringing the agent's attention to certain aspects and everything in between.

If you're interested about the tooltip capability take a look on the OpenSpan Online Documentation available here.

How to Add Items from Comboboxes to Windows Forms

2011-03-31T12:15:00.000-07:00

On a recent PoC (Proof-of-Concept) I had to add items from two comboboxes to a Windows Form combobox. Here is a simple solution to that:

1. Highlight the combobox control in Object Explorer and click the Explore Component Properties button at the top of the Object Explorer.

2. You should see the list of properties available for the combobox control. Select the "Items" property and then select Configure Type to see Properties and Methods of the combobox.

3. Select the Methods you would like to use and then click OK. The methods you selected will appear in the Object Explorer. I've added Items.AddRange(Object[] items) to add an Array of items Commonly used methods are:

4. Then on my Automation I just added the AddRange method to be populated by the combobox from a Windows Application. Something similar to the following:

I just did the same thing for the other combobox items I wanted to add to my Windows Form combobox and ended up with all of them in one single control.

How to Change the Default Drag And Drop Behavior for Properties, Methods or Events

2011-03-29T15:59:00.000-07:00

There are some cases during a project you're constantly working with the same control and you want to change the default behavior when you drag and drop it from the Object Explorer. Well, here is what you have to do to change the default behavior in OpenSpan Studio (MS-Visual Studio plugin):

1. Select the control type you want and click Configure Type. Here is an example for a button.

2. The Button Control Configuration pops up and now you can select the property, event or method you want to be the default behavior. For the button control the "Click" event is the default behavior.

3. Select the new configuration you want to be the default behavior, right-click on it and then select Set As Default Member.

In the example above I've set the PerformClick method to be the default behavior.

The next time I drag and drop a button to the automation it will be the PerformClick method instead of the Click event.

How to Speed Up Mouse Tracking on Mac OS X

2011-03-28T11:20:00.000-07:00

Sometimes I feel that my mouse tracking is not fast enough but when I check its settings on System Preferences it's already set to the maximum possible speed. Here is a very simple (and fast) solution to that problem.

Open Terminal.app (/Applications/Terminal)

Enter the following command:


defaults read -g com.apple.mouse.scaling

That should return the current speed of your mouse tracking as an integer. Mine was 5 and I want to update it to 10. Here is how I did it...

To change the speed of your mouse tracking you can simply run the following command:


defaults write -g com.apple.mouse.scaling your_mouse_speed

where your_mouse_speed is the speed you want to set to your mouse tracking.

Then you'll have to Log Out or restart your Mac to see the changes take effect.

UPDATE: As reported by the reader Squished Spider, if you update your settings using the approach above and perform any changes to the Mouse settings using Mac OS System Preferences later then the system will override everything you did and it will revert them back to the slow mouse behavior even though you've set it to the maximum speed.

Happy Birthday Twitter!

2011-03-25T18:32:00.000-07:00

I'm a big fan of Twitter and from the business perspective I see a lot possibilities and use cases where Twitter could add a lot of value. This week Twitter is celebrating its 5th anniversary and I came across this post from one of the founders (Biz Stone - @biz) and I think the video they put together is just amazing... Check it out! http://blog.twitter.com/2011/03/happy-birthday-twitter.html

OpenSpan Application Usage Events

2011-03-24T13:42:00.000-07:00

OpenSpan is innovating again and customers/partners are now able to enjoy another great capability. In a new release, OpenSpan is including new events capabilities for monitoring application usage metrics for all applications on the desktop without touching them. Yeah! You got that right... No need for application interrogation, no need for touch the applications you want to get metrics from. That's an amazing opportunity to understand more about patterns and metrics from the user's desktop.

There are now three categories of events that OpenSpan can work with: Application Usage Events, Application Detail Events (Generic), Custom Business Events.

Application Usage Events

With minimal configuration and no application interrogation required, deploy OpenSpan to user desktops and immediately begin collecting high-level application usage and interaction metrics for all applications running on the user’s desktop. This new capability provides unprecedented insight into user experience and productivity, enabling next generation time & motion studies of both before and after process improvements.

Application Detail Events

Application Detail Events are used when you want to capture more detail for specific applications than what is provided by Application Usage Events. With Application Detail Events, you can capture individual events (i.e. click, text change, copy, paste, key-press, etc.) and data values associated with any application object (field, button, checkbox, etc.) on any screen within an application. This capability provides “clickstream-level” granularity. For example, you might use Application Usage Events to determine how many copy/paste events are occurring in each application. Then you enable Application Detail Events to determine which fields (by name) are being copied. Application Detail Events are configurable by application and enable selection from over 30 distinct object types and on average over 10 events per object type. To capture Application Detail Events, interrogation and filter configuration is required for each application, which typically takes only a few minutes to configure per application.

Custom Events

Custom Business Events (or Custom Events) provide the ability to define and instrument complete workflows and processes spanning one or several applications. Event names are user-defined and Custom Events can be configured to contain any additional data you wish to collect or capture. In addition to capturing performance metrics and detailed process timing information, Custom Events can include conditional logic and can be used to generate alerts. Custom Events are also commonly the interface point and published from OpenSpan to partner CEP, WFM, BAM and BPM solutions.

Desktop Events with OpenSpan and Oracle CEP - Part 3

2011-03-22T15:33:00.000-07:00

Having started the Oracle CEP successfully was the goal for the second part of this tutorial. Now, we're going to start building a sample OpenSpan automation to send messages through the JMS interface we created previously and push events from the desktop application to Oracle CEP.

28. Go to OpenSpan Studio (or MS-Visual Studio with OpenSpan plug-in installed) and create a new project. Select OpenSpan Project and name it OpenSpan_OCEP_Tutorial

29. Add a new Windows Form. Add a label, text box and button to your recently created Windows Form. You should have something similar to the following picture:

30. Go to Automation1 (Add a new Automation if you don't have one) and drag a MessagePublisher component from the Toolbox (Add the component to the Toolbox if it's not available for you). Make sure it's set to Global.
31. Highlight the messagePublisher1 component and go to the Properties panel. Select the MessageVendorType and set the Message Connection Properties to connect to the Oracle WebLogic instance we configured on the Part 1 of this tutorial.

You have to provide the following information:

 
Host: localhost
Port: 7001
Connection Factory Name: osevents_queue_cf
Queue Name: osevents_SampleQ1
Queue Type: Queue
Username: (your username to Oracle WebLogic)
Password: (your password to Oracle WebLogic)
Session Mode: AUTO_ACKNOWLEDGE
Make sure you update the connection information to Oracle WebLogic if you haven't followed the tutorial and changed that information along the course of it.

32. Let's initialize the messageProducer1 component when we start the project. To do that, add an OpenSpan.Runtime.RuntimeHost/ProjectStarted Event component from the Toolbox.

33. Next, add the messagePublisher1 (Start Method) to the Automation1 and then connect OpenSpan.Runtime.RuntimeHost/ProjectStarted to the messagePublisher1. You should end up with something similar to the following:

34. Add the submit button click event, the text box value and messageProducer1 (Send Method) to the Automation1 canvas. Create the message workflow connecting submit button click to the message producer. Set the text of the message connecting the text box value to the msgText variable on the message producer. Your automation should look like this:

35. Run the project, type something on the text box of the Windows form and click Publish.

36. When you click Publish on the Windows form , a JMS message is dispatched from the OpenSpan Runtime to the Oracle WebLogic JMS provider, that message is stored on the osevents_SampleQ1 queue until it's consumed by the listener on the Oracle CEP project configured on Part 2 of this tutorial. The message content is then displayed on the Oracle CEP console.

37. That message is displayed on the Oracle CEP Console because the query running against the events is simply selecting all events sent to the helloInputChannel.

The HelloWorldBean then gets the text of the message's body and print it.

Feel free to modify the query running against the events published to this Oracle CEP project or the bean printing the messages to experiment different behaviors.

This concludes the Desktop Events with OpenSpan and Oracle CEP. I hope you could follow along and this tutorial could give you a good start point to work with OpenSpan and CEP engines. Please don't hesitate to contact me if you have any questions or comments.

UPDATE: The source code of this project is available at http://dl.dropbox.com/u/10511857/OCEP_OpenSpan_Tutorial.zip

How to re-enable Mac Mail plugins after Mac OS X upgrade

2011-03-21T17:45:00.000-07:00

I just upgraded my machine to Mac OS X (10.6.7) and unfortunately the plugins I have installed with Mac Mail stopped working one more time. I'm a big fan of GrowlMail, TruePreview and LetterBox and have been using them for a long time.
If you search on the Internet, you're going to find tons of references to this issue that affects Mac Mail plugins when you update your Mac. I haven't written that procedure on my notes and kept googling it every time I faced such situation. Well, I came across a very well written note that I think it's worth mentioning about how to fix that issue and decided to share it

How to re-enable Mac Mail plugins after updates

I hope you find it useful as well.

Desktop Events with OpenSpan and Oracle CEP - Part 2

2011-03-21T16:26:00.000-07:00

On the first part of this tutorial we walked through the steps of Oracle WebLogic JMS configuration. This is a very important step since it's the base underlying communication system between the major components for the integration between the applications part of this demonstration.

9. Assuming that everything works fine on the infrastructure side of the project you’re now ready to start developing your Oracle CEP application. Go to Oracle Enterprise Pack for Eclipse (Start Menu > Oracle WebLogic > Oracle Enterprise Pack for Eclipse).

10. Create a new Oracle CEP Application Project. Go to File > New > Other > Oracle CEP > Oracle CEP Application Project.

11. Name the project OpenSpan_Tutorial and leave all other fields as default.

12. Click Next.

13. On the New Oracle CEP Application Project select “Create an Oracle CEP Application using an application template” and choose Hello World as the template.

14. Click Finish.

15. At this point you should have an Oracle EPN similar to this:

16. Right-click at the OpenSpan_Tutorial canvas and select New… Adapter. Name it jmsAdapter.
17. Go to the config.xml file under the META-INF\wlevs\ directory and add the following configuration:


<jms-adapter>
<name>jmsAdapter</name>
<jndi-provider-url>t3://localhost:7001</jndi-provider-url>
<destination-jndi-name>osevents_SampleQ1</destination-jndi-name>
<user>weblogic_username</user>
<password>weblogic_password</password>
<session-transacted>false</session-transacted>
</jms-adapter>

The above configuration tells the Oracle CEP application to connect to the JMS Provider configured under Oracle WebLogic.

18. Go back to the OpenSpan Tutorial EPN and remove the connection between the helloWorldAdapter adapter and the helloworldInputChannel.

19. Add a connection from the jmsAdapter to the helloworldInputChannel.

20. Right-click on the jmsAdapter component and choose Go to Assembly Source. Add the following to the helloworld-context.xml file


<wlevs:adapter id="jmsAdapter" provider="jms-inbound">
<wlevs:listener ref="helloworldInputChannel" />
<wlevs:instance-property name="converterBean" ref="eventAdapter"/>
</wlevs:adapter>

You’ll also need to add the following bean definition:

<bean id="eventAdapter"class="com.bea.wlevs.example.helloworld.HelloWorldBean"/>

21. Go to the HelloWorldBean java class and add the following imports:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.TextMessage;
import com.bea.wlevs.adapters.jms.api.InboundMessageConverter;
import com.bea.wlevs.adapters.jms.api.MessageConverterException;

22. Change the HelloWorldBean class to implement InboundMessageConverter. To do that, change the class signature to be:


public class HelloWorldBean implements StreamSink, InboundMessageConverter {

23. Then, implement the following required method:


public List convert(Message message) throws MessageConverterException, JMSException {
javax.jms.TextMessage textMessage = (TextMessage) message;
System.out.println("Message Processed: " + textMessage.getText());
return null;
}

24. Save and close all files.

25. Your Oracle EPN should be similar to the following picture:

26. It’s time to deploy your project. Go to the Servers view. Right-click on your Oracle CEP v11.1 instance, click on Add and Remove, select the OpenSpan Tutorial and click on Add. Click Finish.

27. Your project should be deployed successfully and you should see a message similar to this on the Eclipse console:


<Mar 18, 2011 9:43:50 PM EDT> <Notice> <Deployment> <BEA-2045000> <The application bundle "OpenSpan_Tutorial" was deployed successfully to file:/D:/Oracle/Middleware/user_projects/domains/ocep_domain/defaultserver/applications/OpenSpan_Tutorial/OpenSpan_Tutorial.jar with version 1300499030501> 
<Mar 18, 2011 9:43:51 PM EDT> <Notice> <Spring> <BEA-2047000> <The application context for "OpenSpan_Tutorial" was started successfully>

Moving to a Cloud-Based Lifestyle

2011-03-19T22:13:00.000-07:00

I got a new laptop from my company (OpenSpan) some time ago and as much as I'm a Mac fan, and have been using the Apple hardware for quite some time, the company's standard is Lenovo and MS-Windows.

I try to spend as much time as I can on my Mac but the new laptop is really powerful (Lenovo W510 Intel Core i7 Q720 1.60Ghz, 8GB RAM, Win7 64-bit, 500GB HD) and a huge part of my job is done on virtual machines. Well, Virtual Machines use a lot of disk space, CPU and memory. Sometimes, I also need to run two VMs at the same time which it's kind of impossible with my Mac these days. I have a MacBook Pro Intel Core 2 Duo 2.16Ghz, 4GB RAM, MacOS Snow Leopard and there is no way to upgrade memory on this machine.

So, to be able to work from my Mac on the days that I don't need to spend hours developing or testing something on my VMs but also don't loose the ability to have all of my files updated on the next day when I need or want to log in to my Windows laptop and be ready to go I found that moving to a cloud-based lifestyle would be very appropriate.

Starting with my e-mails, both personal and work related, I have all of them on stored on the server and this approach seems to be fine since I can access them from whatever device I want.

For the files that work with every day like presentations, spreadsheets, virtual machines, text files, pictures, music, etc I have upgraded my Dropbox account to the Basic one which gives me 50GB of storage and that's enough for the most important files that I need to share between the devices I need. Of course a huge clean up process was needed before I move my digital life to this approach. It has been working fine so far and I don't think I want to go back to way it was before copying files manually all over the place and sometimes having problems when I forgot to copy an important presentation to the machine I would be using next day.

Additionally, most of the applications I use every day are "cloud-friendly" and don't require any intervention to continue to work independently of the device I'm logged in to...

Here is a short list:
Note Capturing + To Do - Evernote (Mac and PC)
Instant Messaging - Adium (Mac) and Digsby (PC)
Social Networking - TweetDeck (Mac and PC), Chatter (Mac and PC)
VoiP - Skype (Mac and PC)
E-Mail, Calendar and Address Book - MS-Outlook (PC) and Mail, iCal, Address Book (Mac)
Browser - Safari (Mac) and Chrome (PC)
RSS and News Feed - Mail (Mac) and FeedDemon (PC)

Last but not least there is another important aspect to mention here about the regular backup strategy I used to have. Since Dropbox also keeps a copy of my files I have restructured my strategy to weekly backups instead just in case something really bad happens to DropBox.

If you are interested in take an approach like this, there are several resources on the web pointing you to smart uses of Dropbox and similar approaches to the one I took...

Here are some links to what I found during my research:

Lifehacker: Dropbox Syncs and Backs Up Files Between Computers Instantaneously
Use Dropbox for More Than Just File Syncing

I don't think there is a right or wrong approach but I believe the right approach is the one that works for you.

Desktop Events with OpenSpan and Oracle CEP - Part 1

2011-03-18T16:03:00.000-07:00

Oracle’s Complex Event Processing Engine can be used to monitor large volumes of real-time data feeds but how do you enable your existing applications to trigger and react with the CEP engine?

With OpenSpan Events you can quickly and easily monitor any application or set of applications on a user’s desktop - including Windows, Web, Java, mainframe, cloud-based, virtualized or Citrix-hosted applications - without modifying the original applications. All events and associated data can be sent in real-time to Oracle CEP, as well as stored in an Oracle or other central database for analysis using OpenSpan Analytics, Oracle Hyperion or any other BI or reporting tool.

Here is a step-by-step guide to get you started with OpenSpan Events with Complex Event Processing (CEP) technology. Part 1 of this tutorial is going to cover Oracle WebLogic JMS setup.

1. Download and Install Oracle WebLogic 11g R1 (http://www.oracle.com/technetwork/middleware/weblogic/downloads/index.html)

2. Download and Install Oracle Complex Event Processing 11gR1 (http://www.oracle.com/technetwork/middleware/complex-event-processing/downloads/index.html)

3. Configure Oracle CEP plugin on Eclipse Galileo shipped with Oracle WebLogic 11g R1 (http://download.oracle.com/docs/cd/E14571_01/doc.1111/e14301/ide_intro.htm#CHDGBGGA)

4. Start your Oracle WebLogic instance (Start Menu > Programs > Oracle WebLogic > User Projects > base_domain > Start Admin Server for WebLogic Server Domain). Wait for the confirmation the server is up and running. You should see a message on the log similar to the following:

<mar 18, 2011 2:58:30 PM EDT> <notice> <weblogicserver> <BEA-000360> <server started in RUNNING mode>

5. Log in to WebLogic Server 11g Administration Console pointing your web browser to http://localhost:7001/console.

6. Click on JMS Modules under Services > Messaging. By default, Oracle WebLogic creates a JMS Module called SystemModule-0. If you don’t have it, you’ll have to create one. Click on SystemModule-0.

7. You also have to create new Queues for the sample configuration where the message exchange between the desktop applications and the Oracle CEP server is going to happen. Click on New and then select Queue. Click Next and give it a name of osevents_SampleQ1. Click Finish. Repeat the process to create another Queue called osevents_SampleQ2.
You also have to create a new connection factory object that's used to create connections for JMS clients. Name your new connection factory object osevents_queue_cf with the same JNDI name.

8. To test your recently created configuration you may want to configure a few JMS clients to send and receive messages to/from these queues. I'd recommend you taking a look on the bottom of the following resource for a pretty nice and straightforward client configuration available at http://redstack.wordpress.com/2009/12/21/a-simple-jms-client-for-weblogic-11g/.

How to Declare Variables in MS-SQL Server Management Studio

2011-03-17T14:50:00.000-07:00

Most of the projects I work on have some kind of database interaction and some of them require variables to be the passed to the queries at runtime.

I typically test my queries against the database using Microsoft SQL Server Management Studio and being able to use variable on my queries there is a big help.

Here is a quick hint to use variables with MS-SQL Server Management Studio:


-- Database to use
USE OSBC;

-- Declare the variable you need
DECLARE @AcctNumber varchar;

-- Set the value of the variable
BEGIN
SET @AcctNumber = 1
END

-- Run the query testing the paramenters
select * from contacts 
WHERE AccountNumber = @AcctNumber

Here is a screenshot of my test:

Pretty simple stuff yet useful...

How to Create Code-Based OpenSpan Solutions

2011-03-17T13:39:00.000-07:00

OpenSpan Studio and its counterpart MS-Visual Studio plugin do a pretty good job when you have to integrate applications where you don’t have the source code available, service-enabled applications and/or exposed APIs. Having all the properties, events and methods graphically available make the development effort much easier than coding from scratch.

But, let’s say you’re an avid developer and feel pretty good handling code. Well, here is something you would really appreciate then. OpenSpan 4.5 has the capability of write automations directly in C#, VB or other .NET languages.

This is really powerful when you have the source code available and you want to drive your automations from a .NET-based application. Also, this approach would make the deployment sometimes simpler than the traditional approach.

Here is an example of code-based automation project:

1. Create a new .NET project. In this example we’ll be using a Visual C# project as the base project. Then, name it CodeBasedDemo.
2. You don’t the auto generated Form1.cs so feel free to remove it from your project.
3. In the same solution, create a new Empty OpenSpan project and name it CodeBasedOSDemo. Make sure you set the Solution field to Add to Solution instead of creating a new one.

4. Your solution should be similar to the following Solution Explorer image:

5. Now, it’s time to interrogate the required applications. We’re going to use a Windows-based application and a Web-based application for the purpose of the sample project. We’re not going to cover the interrogation process in details but feel free to take a look on the OpenSpan Online Help for more information. The OpenSpan Online Help is available at http://help.openspan.com/

6. After interrogating the two sample applications (MyCRM Windows-based application and the Web-based Fedex.com website) you should have something similar to the following in the Object Explorer panel:

Windows-based application

Web-based application

7. You’re now ready to dive into the code-based solution once everything we needed from the OpenSpan side is completed at this point. But before you start typing real code, make sure you import the right references to your .NET C# project. You may reference the same ones that OpenSpan automatically add when you interrogated the Windows and Web based applications.

8. Make sure you also add the CodeBasedOSDemo (the OpenSpan project) as a reference to your .NET C# project.
9. Right-click on your OpenSpan project and Build it to make all the necessary assemblies available to the parent project.
10. Open the Program.cs class file and create instances of the OpenSpan interrogated applications:

11. You’re ready to start interacting with the interrogated controls. Some of the possibilities like checking the state of checkboxes, making fields read-only, copying the required fields when the user take actions on any of the running applications, etc are listed on the commented code below:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace CodeBasedDemo
{
static class Program
{
//Create instances of the MyCRM and Fedex objects
static CodeBasedOSDemo.MyCRM myCRM = new CodeBasedOSDemo.MyCRM();
static CodeBasedOSDemo.Fedex fedex = new CodeBasedOSDemo.Fedex();

/// 
/// The main entry point for the application.
/// 

[STAThread]
static void Main()
{
//Start Applications
myCRM.Start();
fedex.Start();

//Make some fields Read-Only
myCRM.txttxtCreditLimit.ReadOnly = true;
myCRM.txttxtAccountBalance.ReadOnly = true;

//Handle the Do Not Call checkbox behavior
myCRM.cbDo_Not_Call.Click += new EventHandler(cbDo_Not_Call_Click);

//Handle the OK button click
myCRM.btnOK.Click += new EventHandler(btnOK_Click);
//Handle the Click on the Last Tracking Number label
myCRM.lblLast_Tracking_.Click += new EventHandler(lblLast_Tracking__Click);


Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run();
}

// Close the Applications and shutdown the running instance
static void btnOK_Click(object sender, EventArgs e)
{
if(myCRM.IsRunning)
myCRM.Stop();
if(fedex.IsRunning)
fedex.Stop();
Application.Exit();
}

// Copy the Last Tracking Number from the MyCRM application
// to the text area on the Fedex website, perform the click on
// the Track button and return the Delivery Date to the Notes field
// on the MyCRM application. By the way, 3 lines of code to do that.
static void lblLast_Tracking__Click(object sender, EventArgs e)
{
fedex.textArea1.Text = myCRM.txttxtLastTrackNum.Text;
fedex.Track.PerformClick();
myCRM.txttxtNotes.Text = "Delivered Date: " + fedex.txtDeliveredDate.Text;

}

// Show or Hide the Phone field depending on the status of 
// the Do Not Call checkbox
static void cbDo_Not_Call_Click(object sender, EventArgs e)
{
if (myCRM.cbDo_Not_Call.Checked)
myCRM.txttxtPhone.Hide();
else
myCRM.txttxtPhone.Show();

}
}
}

12. Set the CodeBasedDemo project as the startup project of your solution

13. When you finish coding your automations, copy the .dll files under the CodeBasedOSDemo\bin\Debug directory to CodeBasedDemo\bin\Debug
14. Build the solution and run it.

If you have any problems building the solution take a look on the first few lines of the exception as it can point you to probably missing libraries in your project.

The sample code for this tutorial is also available here: Code-Based Demo Source

Getting Started with OpenSpan Events (without the server infrastructure)

2011-03-16T11:42:00.000-07:00

So, you have heard about OpenSpan and its capabilities to collect and manipulate events from the user's desktop. Well, some people have been asking me if there is any way to start playing with OpenSpan Events without building the whole infrastructure behind it. Short answer: Yes. Instead of waiting for someone to create a database, setup the tables, install OpenSpan Events Server, figure out the transport layer (HTTP/S, JMS, etc), take a look on this short tutorial to see how can you collect events locally to make sure you're getting the information you want before you hit the server...

1. Start OpenSpan Studio (Or MS-Visual Studio if you’re using the plugin)

2. Go to File > New > Project and Create a new Empty OpenSpan Project

3. Name your project “Local Events Demo” and leave all default information selected

4. You should end up with something similar to following picture:

5. Go to Project > Add New Item and select Windows Application. I’m using a sample Windows Application and I will name it MyCRM

6. Now you have to tell OpenSpan Studio where to look for that application. Go to Properties panel and select the Path to your application executable.

7. After you select the Path to the Windows Application executable, you are ready to start interrogating your application. Click on the Start Interrogation button on the application interrogation form. If you need / want more information about the OpenSpan interrogation process please take a look on the OpenSpan Online Help here or send me your questions.

8. If the interrogation process started successfully you should see your Windows application up and running. It’s now time to select the controls that you want to get events from. To do that, drag the bulls eye icon over the control you want and then release the mouse.

9. After the interrogation process you should see the controls of the Windows application (buttons, checkboxes, text fields, etc) displaying green checkmarks next to them on the Object Explorer panel. That means you have successfully interrogated that application and should be able to proceed.
Click on the Stop Interrogation button and save the project (File > Save All).

10. On the Object Explorer, click on the high level object and then go to the Properties panel. You’ll have to change two properties:
a. MonitoredEvents – That specifies which controls and events should be monitored.

Let’s select Button (Click)…

Check Box (CheckStateChanged)…

and Text Box (TextChanged, Cut, Copy and Paste).

b. MonitorEventsMode – Specifies the type of the event monitoring to perform. Set that to InterrogatedControls.

11. Go to Project menu item and then choose Add New Item again. Select Global Container and leave the default name.

12. Go to the OpenSpan Studio Toolbox and select SampleConnector from the Events section.

If the SampleConnector component is not available, you have to select Tools menu, Select Choose Toolbox Items and then select SampleConnector (HINT: you can use the Filter feature to the get faster results as you may have lots of items to add).

Click OK

Drag and Drop the SampleConnector to the Global Container 1 canvas.

13. To configure the SampleConnector, highlight it and then go to the Properties panel.

Change the values to the following:

FileDelimiter – Comma
FilePath – C:\Temp\localEvents.csv
LogFileHandling – OverwriteExistingFile
LoggingEnabled – True

14. Save the project (File > Save All).
15. Run the project. Debug menu item and then Start Debug or simply hit the green arrow on the OpenSpan Studio icons menu.
16. Click on a few buttons, change the text of text fields, copy/paste text from different text fields, mark/unmark check boxes and then stop the project.

Here is a screenshot of my Windows application:

17. Go to the location you have setup the SampleConnector to record the events file and open the localEvents.csv file. You should see something similar to the following table (I’ve cleaned up the data because OpenSpan collects all events and that could be a lot ☺ ):

I hope this helps you to get started with OpenSpan Events...

How to Disable Mac Mail.app Inline Image Attachments

2011-03-16T08:48:00.000-07:00

If you need to disable (or enable) inline images on Mac OS X Mail.app to view them as attachments, here is what you have to do:

Go to Terminal (Applications > Utilities > Terminal) and then type:

defaults write com.apple.mail DisableInlineAttachmentViewing -bool true

But, if you already have that set up on your system and want to go back, just run the following:

defaults write com.apple.mail DisableInlineAttachmentViewing -bool false

After any of the below commands don't forget to restart Mail.app

How to switch windows within the same application in Mac OS X using keyboard shortcut

2011-03-15T16:08:00.000-07:00

Just found out how to switch windows within the same application in Mac OS X using keyboard shortcuts. The default behavior when you press Apple + Tab is to switch between applications but if you want to switch to the same application but a different window (let's say you have multiple Web browsers open) all you have to do is press Apple + ` (` is located left to the 1 key and on top of Tab key). Simple!

Ok... I gave up...

2011-03-15T15:59:00.000-07:00

Not the best way to start a blog (I know) but I've been thinking about blogging and the content to start one for a long time and I just figured out that would be better to keep the context of my posts around Information Technology and computer-related stuff...

I've been for a long time on Twitter, LinkedIn and Facebook but blogging is kind of new to me. Well, we all have to start somehow, right? Here is my first stab at this where I plan to share useful information about things that I find on the road (when traveling to customer's sites), articles from the Internet or something that I've in mind that someone can reuse out there.
So, I gave up holding the idea of start blogging...

By the way, my name is Marcelo Jabali and I've been working with technology since 1998. Most of my work is around systems integration, Service-Oriented Architecture and application design and architecture. I'm also a Mac fan and all things Apple.

Stay tuned for more... Feel free to contact me, right comments, send questions and let's enjoy the Wonderful World of blogging and sharing information together!