Blog - Rubicon Red

Industrialized SOA - Where are you? - Part 1

Sun, 05 May 2013 00:00:00 -1000

In my job I have had the privilege of working on some high profile SOA projects but more satisfyingly I have been able to see most of them through to success. This process can be rewarding but it also has its downsides and it is not (unfortunately) all Greenfields and jelly beans. In fact a lot of what I do is fire fighting and it is not easy rescuing projects on the verge of failure. You know the ones I am talking about, right? The toxic ones… the ones that no one wants to touch with a 10-foot pole.

My wife and I were fortunate to be eating an amazing Indian cuisine cooked by my colleague Arun’s wife (some of you may know Arun from his popular blog on Oracle BPM or as the author of Oracle SOA Suite 11g Administrator’s Handbook). This catch up over great food and wine turned out to be an excellent opportunity to really talk about our passion for software delivery; perhaps much to the boredom of our respective partners.

One of the things Arun had mentioned was that he had recently been impressed by Mark Nelson’s musing about SOA Development & Delivery. As a long-time subscriber to Mark’s blog, I was keen to check it out. So after a sound night’s sleep, I was quick to Google ‘RedStack’ and here it was….

http://redstack.wordpress.com/2013/05/01/soa-development-and-delivery/

Short

Sweet

To-the-point

….And it hit home!

While Mark did not say this directly, it seems clear to me that the SOA brand is tainted (in at least some contexts) and people are asking questions…

Is SOA really agile when you need to wait months for a new complex feature to be released and 15 components are impacted by it?
Does BPM really empower the business when your server goes down and the root cause is not easily discoverable?
Is Cloud really a way to lower risk and increase productivity when the elasticity comes with lengthy periods of non-realised benefits, ramp up and confusion?

If this resonates with you, you are at the very least... not alone.

So what is going wrong? Why in some cases, is the buzz seen to be spin, to be vendor marketing; little more than bended truths?

While I obviously don’t know all the answers I’ll take a stab and say it has more to do with maturity levels and insensible decisions then the failings of SOA and its promise.

As novelist Ellen Glasgow once said “All change is not growth, as all movement is not forward.” and with that I hope you’ll allow me to take this opportunity to wax lyrical on Mark Nelson’s gem by way of a few practical tips learnt in the trenches.

Click here to read the full article:

http://blog.rubiconred.com/2013/05/industrial-soa-where-are-you-part-1.html

Unified Workflow with the Oracle BPM Suite

Sat, 17 Nov 2012 00:00:00 -1000

Rubicon Red oneSpot provides an extension to the Oracle SOA and BPM Suite 11gR1; without copying, presents users with a single unified view of all their tasks across multiple workflow platforms.

Business processes represent sets of logically organized activities spanning multiple IT systems, departments, and roles. Some activities are automated and performed by machines, whereas others are manual and performed by people.

In a typical enterprise, these processes are fragmented and buried across multiple applications (such as Oracle eBusiness Suite, SAP, Peoplesoft, Siebel and custom apps), making processes rigid and hard to change.

Oracle BPM and SOA Suite 11gR1 is the next generation solution that allows businesses to define and implement end to end business processes that integrate these process fragments together, allowing processes to be easily reconfigured to meet the evolving requirements of the business

Human Tasks (or workflows) are a fundamental part of any business process as they provide the channel for communication between business processes and there participants.

Whilst Oracle BPM provides a comprehensive workflow solution, the process fragments that execute in the existing IT systems, often require users to perform certain tasks like acting on requests pending approval or flagging a manual fulfillment as complete. Each of these applications includes its own workflow engine, which creates and manages tasks for the part of the business process that it covers.

As a result, business users regularly have to log into multiple applications, to determine which tasks the have assigned to them at any one time. This means it’s impossible for a user to get a single view of all their tasks, or allow there manager to easily monitor or managing outstanding tasks for all their employees.

Rubicon Red oneSpot an extension to the Oracle SOA and BPM Suite, presents users with a single unified view of all their tasks in one spot. This is achieved through the use of a Virtual Task Repository (VTR); which is designed to be connected to multiple workflow task stores and present users with a single integrated view of all tasks assigned to them.

Form within oneSpot a user can open a "virtual" task and work on it as if it were a local task, with all actions / updates performed on the task executed againt the real task in the source workflow application.

All tasks have a common set of attributes; and enable standard operations to be performed against them in a common way, as well as allowing comments, attachments, etc. to be stored against them.

Conclusion
No one should have to open multiple browser windows / applications to check their workflow tasks, so oneSpot allows you to track all your tasks in one view and instantly lets you know when new tasks arrive.

Reading compressed files with Oracle Service Bus

Mon, 27 Feb 2012 00:00:00 -1000

A reasonably common B2B interface convention is to compress the contents of exchanged files, to reduce the impact on network traffic and archiving requirements (see Figure below). Although Oracle Middleware does not support such interfaces “out of the box,” it is reasonably straight-forward to piece together a simple adapter using existing tools.

This recipe will guide you through a sample implementation of a proxy service which polls a directory for XML files compressed using the gzip utility.

Gzip is a data compression software application, most commonly encountered as the version implemented by the GNU Project. Gzip only natively supports the compression of one file at a time (although of course that file may itself be the combination of several smaller files), and has a simple format consisting of compressed binary content between a standard header and footer.

J2SE includes a standard library of compression/decompression utilities in the java.util.zip package, which, among other things, includes functionality for working with the gzip data compression algorithm.

Getting ready...

Oracle Enterprise Pack for Eclipse

This recipe assumes the use of an existing OSB Configuration project within the OSB Workshop for development so ensure that you have installed and familiarised yourself with it prior to beginning.

Test Data

Prior to beginning this recipe, you will want to prepare some test data, consisting of XML files compressed using gzip.

How to do it...

Writing the Java method

Before jumping into creating anything for OSB, you’ll first need a java library which handles the extraction.

Start up Eclipse and switch to the Java perspective.

Right-click in the Project Explorer area and select New > Java Project.

Name the project GzExtractor and then select Next.
Select the Libraries tab and click Add External JARs....

Select com.bea.core.xml.xmlbeans_2.2.0.0.jar from the modules subdirectory of your Oracle middleware installation and click Open.

Click Finish in the Add External JARs dialog, and then Finish again in the New Java Project dialog box.
Right click on the new project and select New->Class.

Set the package to com.rubiconred and the class name to GzExtractor. Leave everything else as default and then click Finish.

Replace the contents of the new file GzExtractor.java with the code below.

package com.rubiconred;

import org.apache.xmlbeans.*;
import java.io.*;
import java.util.zip.GZIPInputStream;

public class GzExtractor
{

public static XmlObject processFile( Object param )
throws IOException, XmlException
{

byte[] bytes = (byte[])param;
if (bytes != null)
{

InputStream input = new ByteArrayInputStream(bytes);
InputStream gzipInput = new GZIPInputStream(input);

Writer writer = new StringWriter();
char[] buffer = new char[1024];

try {

BufferedReader reader = new BufferedReader( new InputStreamReader(gzipInput, "UTF-8") );

int n;
while ((n = reader.read(buffer)) != -1)

writer.write(buffer, 0, n);

}
finally {

gzipInput.close();

}

// return the contents of the file
return XmlObject.Factory.parse( writer.toString() );

}
else
{

// input parameter is null, return null
return null;

Incorporating the Jar File

The following steps explain how the java method created above can be incorporated into an OSB project.

Switch to the Oracle Service Bus perspective.
If you don’t have one already, create a new OSB Configuration Project and a new OSB project within it. Name the project GzFileAdapter.
Right click on the GzExtractor Java project and select Export->Export....

Select Java->JAR file and then click Next.

Provide the export destination as GzFileAdapter/GzExtractor.jar and then click Finish.

Right click on the GzFileAdapter OSB project and select Import->Import....

Select File System in the General category and then click Next.

Select the com.bea.core.xml.xmlbeans_2.2.0.0.jar XMLBeans library from the modules subdirectory of your Oracle middleware installation, as used earlier in the Java project, and then click Finish.

Right click on GzExtractor.jar in the Project Explorer and select Oracle Service Bus -> Modify Jar Dependencies from the context menu.

Select the XMLBeans library, then click Add, then OK.

Creating the Proxy Service

The next step is to create the file adapter, as a binary file-based message proxy service, from the Oracle Service Bus IDE.

Right-click on the GzFileAdapter OSB project in the Project Explorer and select New -> Proxy Service.

Name it GzFileAdapter and click Finish.
In the General tab of the Proxy Service editor, select Message Service as the Service Type.

In the Messaging tab, select Binary as the Request Message Type. Leave the Response Message Type as None.

In the Transport tab, select file as the Protocol and provide a directory name where you would like to poll for files from as the Endpoint URI.

In the File Transport tab, customise the adapter to suit. In this example, we’ll select a file mask of *.gz as well as configuring an archive Post Read Action and specifying all the necessary Directory file destinations.

Defining the message flow

The next step is to incorporate a call to the GzExtractor java library into the Proxy Service Message Flow.

Start by dragging a new Pipeline Pair from the Design Palette into the Message Flow editor.

Add a new Stage to the Request Pipeline and name it Extract GZIP.

Drag an Assign Action into the new Stage.

In the Properties tab for the Assign action, provide the Expression as $body/ctx:binary-content and the Variable as gzBinaryContent.

Drag a new Java Callout Action from the Design Palette to just under the Assign action.

In the Properties tab for the new Java Callout, select Browse next to the Method field.

Select GzExtractor/com.rubiconred.GzExtractor.processFile.
Select the Expression for the only parameter and specify $gzBinaryContent.

Specify the Result Value variable as payload.

Testing the implementation

To test the new file adapter, you can place a GZIP’d file in the input directory and confirm the contents are read successfully following these steps:

Create a new ReportingStage below the GZIP Extract Stage and drag a new Log Action in.

Set the Log Expression as $payload and the Annotation as “GzFileAdapter message payload”.

Change the Severity to Error so that it is guaranteed to appear on your weblogic’s console output.
Deploy the service to your server.
Copy a GZIP’d text file to the input directory you specified earlier.
Observe that the contents are written to the console.

Email Notification with SOA Suite 11g

Tue, 14 Feb 2012 00:00:00 -1000

Oracle SOA Suite 11g supports a number of different notification channels through the User Messaging Service (UMS). This blog provides a step-by-step guide for configuring and testing email notification. Once email notification has been configured, emails can be sent from SOA Suite components such as BPEL processes and Human Tasks. For this example, Gmail will be used as the mail server.

Configuring Email Notification

To support email notification from SOA Suite 11g the UMS email driver and workflow notification properties to be configured with the mail server details. This can be done through the Enterprise Manager Fusion Middleware Control console (e.g. http://localhost:7001/em) as follows:

Navigate to the Email Driver Properties page available under User Messaging Service > usermessagingdriver-email
Update the following properties according to your mail server configuration:

OutgoingMailServer - The SMTP hostname
OutgoingMailServerPort - The SMTP port
OutgoingMailServerSecurity - The type of security (e.g. SSL)
OutgoingUsername - The mail user account
OutgoingPassword - The mail user password
Click Apply to save the changes.
Right-click on soa-infra under SOA and navigate to the Workflow Notification Properties page available under SOA Administration.
Set the Notification Mode to 'Email' and enter the default values which you wish to use for from, actionable and reply to email addresses.
Click Apply to save the changes to the workflow notification properties.
Restart the SOA server for the changes to take effect. If you are using Gmail or any other mail server that requires SSL you will need to perform the steps in the next section. In this case, you may wish to hold off on restarting the server before these steps are performed. This will save you the trouble of having to restart twice.

Import the SSL Certificates to the Java Keystore

Before SOA Suite can send emails with Gmail there are some SSL certificates that will need to be imported. This step can be ignored if sending from an alternative mail server that does not require SSL.

Download the Gmail IMAP and SMTP certificates. This can be done with OpenSSL (Unix / Windows) by running the following from command prompt:

```
openssl s_client -connect host:port
```

where Gmail SMTP host:port is smtp.gmail.com:465
where Gmail IMAP host:port is imap.gmail.com:993

Create a new file for the SMTP and IMAP certificates using the content between BEGIN CERTIFICATE & END CERTIFICATE
Use the Java Keytool to import the two certificates into a new or existing keystore. The keytool executable is available under the JAVA_HOME/bin directory. The following command can be used to import a certificate:
- ```
keytool -import -alias AliasName -keystore KeystoreLocation -file CertificateLocation
```
- When prompted, enter a password for the keystore.
Add the following system properties to the WebLogic server startup arguments:
```
-Djavax.net.ssl.trustStore=CertificateLocation
-Djavax.net.ssl.trustStorePassword=CertificatePassword
```
This can be done in Arguments field available under the Server Start tab for the SOA Server (e.g. soa_server1) in the WebLogic Administration Console (e.g. http://localhost:7001/console) or by adding the properties to the DOMAIN_HOME/bin/setDomainEnv.cmd (or setDomainEnv.sh). For example:
```
set EXTRA_JAVA_PROPERTIES=%EXTRA_JAVA_PROPERTIES% -Djavax.net.ssl.trustStore=%WL_HOME%\server\lib\gmail-keystore.jks -Djavax.net.ssl.trustStorePassword=changeit
```
Start the SOA server (or restart it if it is already running).

Testing Email Notification

Now that we have configured outbound email notification, we want to test our configuration easily without having to create a BPEL process or human task to do this. Fortuntately, we can do this from Enterprise Manager Fusion Middleware Control.

Right-click on soa-infra under SOA and navigate to the Human Workflow page available under Service Engines.
Select the Notification Management tab.
Click Send Test Notification
The Send Test Notification dialog box should now appear. Enter the email subject, content, to address and be sure to select 'Email' for the channel. Click Send. Once the email has been sent, you should receive a value of 'SENT' for Response. You can now close the dialog box.
Ensure that the email has been received.

Troubleshooting

If you encounter an issue with the outgoing email notification, it is a good idea to check the SOA server log for error messages. There are log files available at:

DOMAIN_HOME/servers//logs/.log
DOMAIN_HOME/servers//logs/.out
DOMAIN_HOME/servers//logs/-diagnostic.log

Furthermore, it is a good idea to tick the UMS email driver debug flag.

Listed below are some common errors with their solution:

Error Message: javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

Diagnosis: There is an issue with the SSL certificate.

Remedy: Ensure all of the steps have been followed as described in "Import the SSL Certificates to the Java Keystore". Also make sure that the mail server certificates in the Java Keystore have not expired. You can ensure a fresh copy of the certificates are downloaded by executing the openssl s_client -connect command followed by the host and port details for the mail server.
Error Message: ORABPEL-31023 - Cannot send email notification to address. The address is being marked as invalid and no further notification would be sent to this address.

Diagnosis: Due to a number of previous failed send attempts to an email address, SOA Suite has added the address to the Bad Address List thus preventing subsequent sends to this address from failing. The previous failed attempts may been caused by a configuration issue.

Remedy: Remove the email address from the Bad Address List. This can be done by selecting View Bad Addresses from the Notification Management page in Enterprise Manager. When the Bad Address List dialog box is displayed, remove the email address from this list.
Error Message: No matching drivers found for sender address

Diagnosis: The UMS Driver for the appropriate channel is configured with a specific list of SenderAddresses, and the message sent by the application has a Sender Address that does not match.

Remedy: Make the Sender Address blank. This will ensure that all outbound messages will be sent regardless of the sender address.

Caching Service Responses with OSB

Mon, 13 Feb 2012 00:00:00 -1000

Over the course of a complex service orchestration, it may be useful or necessary to query the same set of configuration data for an entity or process multiple times during and/or between executions. Where retrieving this configuration data involves interfacing with an external system or database, there can be reasonably significant I/O and network latency overheads associated which create bottlenecks in a service’s execution.

A popular technique for eliminating such bottlenecks is the concept of caching results, keeping a copy in memory paired with the key of the original request in case the same request is made again. The assumption of course is that configuration data changes infrequently enough to make these “old” results still valid for use for some time after the first query.

Oracle offers a distributed in-memory cache in a product called Coherence. Coherence features fast and reliable performance, redundancy across clustered servers, an intuitive API and many options for customising how it uses and retains information.
Coherence is also packaged as a component of the Oracle Weblogic server and its functionality is incorporated into Oracle Service Bus.

This recipe will walk you through caching the responses from a business service using OSB.

Getting Ready...

Oracle Service Bus 11g

This recipe assumes you have already configured an OSB environment on which to deploy the service.

Oracle Enterprise Pack for Eclipse

This recipe assumes the use of an existing OSB Configuration project within the OSB Workshop for development so ensure that you have installed and familiarised yourself with it prior to beginning.

External Service

Prior to beginning this recipe, it is assumed that you already have access to the service you wish to cache.

If you wish to follow along exactly with the “Fruit info” example in these instructions you will require an Oracle database and a copy of the JCA database adapter used in the example. You can obtain a copy of this, along with the database schema creation scripts from the following URL:

FruitInfo-Database-and-JCA-Adapter.zip

You will need to execute the database schema creation script, and then create a corresponding connection factory on your weblogic administration server identified by “jndi.cf.cookbook”.

How to do it...

Check the server configuration

In order to allow caching, the OSB weblogic server must be appropriately configured. Log into the OSB Administration Console and confirm the setting.

Direct a web browser to http://localhost:7001/sbconsole/
Log in using a system administrator account (by default, weblogic).
Select Global Settings from the Operations menu.
Confirm that Enable Result Caching is check (by default, it should be).

If it is not enabled, complete the following steps to enable it.

Click the Create button in the top left. Check the Enable Result Caching option and then click Update.
Click the Activate button, type a Description of the change and then click Submit.

Create the Business Service

In order to cache results using OSB, the first thing you need to do is wrap the service you wish to cache using an OSB Business Service. If you’ve done this already, skip ahead to the next section "Configure the Business Service".

If you don't have one already, create a new OSB Configuration Project.
Create a new OSB Project.
Add a subfolder for the business service and create a new OSB Business Service, configured to wrap the service you wish to cache the responses from. For example, for the provided "FruitInfo" example:

Import all the files from the “Database Adapter” folder provided into a subfolder called fruitinfo_db.
Right-click on the fruitinfo_db.jca adapter definition and select Generate Service.
Accept the defaults and click OK.

Configure the Business Service

This is the key configuration step.

Open your Business Service file for editing (the .biz file).
Select the Message Handling tab.
Expand the Advanced Settings.
Check the Supported box next to Result Caching.
Select the Duration radio button to indicate that cached results should expire after a set duration.
Key in the amount of time you’d like for the Duration. (In this example we’ve chosen 5 minutes to make it easy to test).
Click on the link next to Cache Token Expression.
From the variable structures on the right, locate the appropriate request operation and drag the key field from your request over into the text field on the left.
Manually add /text() to the end of the expression to ensure that the contents of the node are used as the cache key.
Select OK and then save all changes.

Expose using a Proxy Service

If you haven’t already done so, you will need to expose your Business Service via an OSB Proxy Service.

Right click on the OSB Project and select New-> Proxy Service giving it an appropriate name. This will be the external facing service which wraps your cached service. Open the service for editing. For the simplest implementation you can pass the payload straight through by re-using the WSDL from the business service.
Select WSDL Web Service as the Service Type.
Browse
In the resulting dialog browse to the WSDL of the business service and select its port.
Click OK.
When prompted to change the transport configuration, select No to retain the HTTP transport.
Select the Message Flow tab.
Drag a Route Node across into the flow.
Drag a Routing Action into the Route Node.
Select the Routing Action to bring up the Properties tab.
Click Browse next to Service.
In the resulting dialog, navigate to the business service which encapsulates the caching mechanism.
Click OK.
Ensure that the correct operation is invoked in the Properties tab.
Save all changes.

You’re done! You can now use the Proxy Service to access your cached business service operation.

Testing and confirming the Cache

Deploy and test your service. Then complete the following steps to confirm the caching behaviour.

Navigate to the OSB Console at http://localhost:7001/sbconsole and login.
Select Project Explorer from the main menu on the left.
Navigate to the OSB Project you just created.
Click on the Debug symbol to test the Proxy Service.
In the resulting window, select the cached operation. Note that the other operations will not correctly route.
Modify the payload to specify the key for your request. In this example we chose “Apple”.
Call the service by clicking Execute.
Confirm the response.

Now modify the state of your reference data. E.g. in our example we will modify the database entry for “Apple” to have color “Green”.
Re-run the same Proxy Service test and note the response.

The color in the database is “Green”, yet the service still returns “Red”. This is because the result was successfully cached.

Wait for the cached result to expire and then call the proxy service again with the same test to confirm that it will eventually refresh the result.

How it works...

As you have seen, caching using Coherence in OSB is very simple to activate and use. The following figure illustrates what is going on behind the scenes.

Because for most cases Coherence will be able to retrieve the result from the in-memory grid on the same application server, there will be no latency introduced by network or database I/O. This should greatly reduce the response time of your service, assuming frequent requests for the same data are made.

There's more...

More complex cache tokens

Your desired cache token key may not be as straight forward as selecting the contents of a single, predictably placed node.
It is worth noting that the Cache Token may be specified as any expression you like, using the XQuery functional programming language.
XQuery has a rich syntax for constructing queries, including the use of many system libraries with common functions such as numeric operations and string manipulation.

Clear the cache explicitly

It might be that you can’t risk the cache becoming stale under certain circumstances. If that is the case, rather than using a time parameter to manage the lifetime of the cached responses, mark critical requests with an additional flag and select XQuery Expression in the expiration time options to test for the existence of this flag.

Dynamic Split-Join in OSB

Tue, 31 Jan 2012 00:00:00 -1000

As part of implementing a web service it is often necessary to delegate to a number of independent subtasks. For a synchronous service, carrying out these tasks sequentially may take an unacceptable amount of time causing the client to time out waiting on the service. Therefore the preferred approach is to process all independent tasks in parallel and consolidate the results.

This pattern is referred to as a “Split-Join” and comes in two flavours:

“Static” in which the subtasks are always the same. For example, in planning a holiday one needs to book both a flight and accommodation, each of which represents an independent subtask which may be completed in parallel.
“Dynamic” in which there are a variable number of subtasks, to be determined at runtime. For example, to complete an internet shopping order a bookstore must query each book before confirming the total price, but has no way of knowing how many different items will be required prior to reviewing the order.

This recipe will guide you through a sample implementation of the second example using Oracle Service Bus.

Getting Ready...

Oracle Enterprise Pack for Eclipse

Although it is possible to develop for the Oracle Service Bus using only the Web Console interface, for a fully featured IDE (including support for version control, source code editing plug-ins, lower latency and independence of development environments) it is generally preferable to use the OSB Workshop perspective of the OEPE.
This recipe assumes the use of an existing OSB Configuration project within the OSB Workshop for development so ensure that you have installed and familiarised yourself with it prior to beginning.

Target Operation

Prior to beginning this recipe, you will need to prepare the target WSDL operation which will be invoked to process individual items. In the example, this will be the priceCheck operation of the Book service, which determines how much each should cost.

Schema and WSDL

You should always finalise the service contract prior to beginning development.
If you wish to follow along exactly with these instructions you will require a copy of the schema and WSDL files used in the example. You can obtain a copy of these, as well as a mock implementation of the Book service from the following link: BookStore.zip

How to do it...

Creating the Split-Join

If it doesn’t exist already add an OSB Project (in this example, BookStore) to your OSB Configuration Project and then create a sub folder within called SplitJoin.
Right click on this new subfolder and select New -> Split-Join from the context menu.
Enter a descriptive filename (e.g., getTotalPriceSplitJoin) and then click Next.
Expand the project structure to select the “parent” operation used to invoke the split-join (e.g., BookStore.wsdl -> BookStoreBinding -> operation: getTotalPrice) and then click Finish.

A new flow will appear in the main editing window.

Editing the flow

Select the root node and expand its properties by clicking on the small triangle on its left. Select the request variable and click Edit....
Rename the variable to match the parent operation (e.g., getTotalPrice). This will help prevent ambiguity later on.
Similarly, rename the response variable (to e.g., getTotalPriceResponse).
Drag an Assign action over from the Design Palette, to between the Receive and Reply nodes.
Label the new scope as Initialisation and the Assign Action as Assign output variable.
Click on the new Assign action. In the properties tab below, select the Variable as the payload of the parent operation’s response (e.g., getTotalPriceResponse.payload).
Next, click on the link. Provide XML similar to the following and then click OK.

Note in the above example the aggregate total has been initialized to 0.

Drag a For Each construct from the Design Palette to just below the Initialisation scope.
Click on the new For Each construct. In the Properties tab, set the Counter Variable Name to counter and the starting value to 1. Click on the ellipses next to Final Counter Value to launch the expression editor.
Select the XPath Functions tab, and drag the count function out into the Expression text area.
Click on the Variable Structures tab and expand the request structure to find the recurring element (e.g., the book id) on which the split should be based. Drag it out to replace the place-holder $arg-nodeset and then click OK to complete the expression.
Drag an Invoke Service action into the loop’s Scope. Label it per the “child” service and operation you intend to loop over (e.g., Book.priceCheck).
In the Properties tab below, select the Operation category. Click Browse, select the child operation (e.g., Book.proxy -> priceCheck), and click OK.
Select the Input Variable category in the Properties tab. From the Message Variable dropdown select Create Message Variable.... Provide the name of the child operation (in our example, priceCheck) as the Name and then click OK.
Use the same method to create and set the Output Variable (e.g., as priceCheckResponse).
Drag an Assign Action to the start of the Loop Scope and label it as Extract Individual Request.
Select the Assign Action. In the Properties tab, set the Variable as the request payload of the child operation (e.g., priceCheck.payload) and then click the link.
Use the expression editor to generate each individual request using the $counter index defined earlier. For example:


 {$getTotalPrice.parameters/id[xs:integer($counter)]}

Following the Invoke Service Action, apply any aggregate logic. For our BookStore example, we would add a Replace Action with the following properties:

XPath: ./totalPrice
Variable: getTotalPriceResponse.parameters
Expression: xs:float($getTotalPriceResponse.parameters/totalPrice) + xs:float($priceCheckResponse.parameters/price)
Replace node contents

Save your progress by select File -> Save from the menu.

Wrapping the service

Before the Split-Join can be used in a proxy service, it must first be encapsulated in a standard OSB Business Service.

In the Project Explorer on the left, right-click on the Split-Join file and then select Oracle Service Bus -> Generate Business Service.
Accept the default name and location, and click OK.

The business service is now ready for use in any OSB Proxy Service. Test it out.

How it works...

Refer to the more completely labelled version of the Split-Join message flow above for an end-to-end, annotated view of the final solution. Procedurally, the pseudo-code for the BookStore example might look to be (just going by the annotations) as follows:

Operation getTotalPrice( book_list ):
 totalPrice := 0
 for each id in book_list
 loop
 total_price := total_price + Book.priceCheck( id )
 end loop
 return total_price

The key difference is that the For Each section has a property called “Parallel” set by default to yes (Note, if desired, this can be set to no to force sequential execution). This instructs Oracle Service Bus to execute all (or as many as it has threads) iterations of the Loop scope within the For Each statement concurrently.

Readers paying close attention will also have noticed that the For Each block does not actually iterate over the book IDs directly; rather the OSB determines the number of Loop scopes simply by counting the number of id nodes and then assigning each scope a different $counter variable integer between 1 and that total count. So a more accurate representation of the pseudo code would be as follows:

Operation getTotalPrice( book_list ):
 totalPrice := 0
 for counter in 1 .. size(book_list)
 thread concurrently
 total_price := total_price + Book.priceCheck( book_list[counter].id )
 end thread
 return total_price

Performing this addition in parallel allows the BookStore service to compute the total much faster, dividing the total time of priceChecks by the number of concurrent threads.

There's more...

The recipe above represents a reasonably standard, cookie-cutter implementation of how one would use the Split-Join feature of Oracle Service Bus to iterate over a dynamic sequence of identical elements in a list. It should be enough to get you started on any similar problem; however it only scratches the surface of the possibilities for what can be accomplished with a Split-Join message flow.

Fault Handling

Without appropriate Error Handling logic, the first fault thrown by a service invocation within any one of the Split-Join’s threads will re-raise in the Split-Join and halt the entire message flow.
In order to prevent this, “Catch” clauses need to be added to the scope of each thread as follows:

Right-click on the loop’s scope and select Add Catch.
Select the new Catch block, label it with the name of the Fault you wish to catch and then review the Properties tab below.
Click on and assign any name you like (the default is simply soapFault which should be fine).
Select Define Fault and enter the Fault Name and Namespace of the fault you expect to catch.
Drag in a new Scope below the Catch and add any mitigation Actions as necessary to resolve the Fault. It may be appropriate to do nothing, simply log the error, or perhaps aggregate a default value into the total All variables available within the normal scope are also available to you within the Catch block.
Repeat the steps above for each expected Soap Fault.
Optionally, add a Catch All clause to capture any unexpected Faults.

Other aggregation logic

Rather than simply summing up numerical values, you can aggregate the results of service calls any way you like. A common example is appending the results to a dynamic sequence using an Insert Action.

More service calls

Note that you are not limited to a single Invoke Service Action. Multiple “child” operations may be invoked sequentially or in parallel.
In fact the premise of a “Static” Split-Join is that instead of using a For Each loop, you would use an explicit Parallel construct (see Flow Control in the Design Palette) and drop a different Invoke Service Action into each lane.
Any combination of flow constructs desired can be layered to create complex concurrent processing systems within a single Split-Join Message Flow.

Conflicts

With any software system involving multi-threading, there is always a possibility of Deadlocks or Conflicts. Although variables within a Split-join message flow are protected from these scenarios, Oracle Service Bus does not provide any built-in mitigation tools for external systems.
It is outside the scope of this discussion to prescribe how one might resolve concurrent update issues in external systems; however designers and developers should always be aware when there is such a possibility and take appropriate action.

Continuous Delivery (or putting agility back into SOA)

Thu, 11 Aug 2011 00:00:00 -1000

One of the key principles of SOA is that systems are no longer built to last, but rather built to change.

The promise being, that if you follow SOA principals, it will not only enable you to more rapidly implement new solutions through re-using existing functionality, but also reduce the time it takes to modify and adapt existing SOA based solutions in response to ever changing business requirements.

Being able to adapt to changing business requirements is not only important once a system has gone live but is equally important during development. Too often projects experience significant delays due to changes during implementation; a SOA-based approach provides a way to manage this change and help mitigate the risk of project delayed due to change.

Yet, the reality is often different. Often we come across projects that are struggling to get from development into System and Integration Testing (SIT), or beyond SIT into production.

As Jez Humble puts it in his book Continuous Delivery

the most important problem that we face a software professionals is this: if somebody thinks of a good idea, how do we deliver it to users as quickly as possible?

Now if we follow SOA principles, then the design and implementation (i.e. writing code) should be optimized, however what SOA doesn't address is how we build, deploy, test and finally released that code into production.

And this seems to be an area that has been largely ignored by the vast majority of SOA projects, which are still following a manual, resource intensive and highly error prone process that requires someone to piece together all the relevant components, compile and package them before deploying the end result into a test environment; and then run a series of tests to validate the build. Once over this hurdle the next step is to deploy, configure and test the build in each environment that it must progress through before it reaches production.

We’re not making this statement likely; at Rubicon Red we have had the privilege of working with over 100 Oracle SOA success stories, including helping to rescue many failing projects. This gives us a pretty big sample in which to gauge the overall level of maturity in the industry when implementing SOA projects.

In addition, we have recently run a series of workshops entitled “Breaking through the SOA Glass Ceiling” (we are planning another series so let us know if you are interested in attending). One of the biggest issues that customers were facing was the complexity of deploying a new release into production (another being to successfully manage and monitor a solution once in production).

At the core of the issue, was the resource intensive nature of building and testing software, meaning this tended to be carried out infrequently, so often developers would work in isolation for days, weeks (or even months) before integrating different components.

The result?

Code shared between multiple people and frequent changes often introduce a lot of integration complications, dependency bugs etc. The longer these bugs remain undiscovered, the more effort it takes to troubleshoot and fix, resulting in significant project delays.

Yet, continuous integration and testing (the first part of continuous delivery) has shown to reduce the risk of project delays, providing better visibility into the overall progress and state of the software development, as well as less issues once deployed into production.

It has also been shown to provide a significant return on investment, due to the impact of finding and fixing integration bugs early in the development process; which saves both time and money over the lifespan of a project.

It is precisely for these reasons that continuous integration and testing as a practice is being widely adopted within the software industry; so you would expect that with SOA which is all about integration to be at the front of the queue!

Now Rubicon Red was founded with the vision of providing Oracle Fusion Middleware customers, a robust SOA adoption methodology incorporating agile development and KPI based governance. So the establishment of best practice around Continuous Delivery has always been a central pillar in our strategy.

We have been using Continuous Integration and Testing internally for some time now, and have extended our platform to provide support for Continuous Delivery. We have recently introduced this to a number of our customers, and the feedback has been incredibly positive.

So much so, that one of our customer suggested that we write a series of blogs about what we have done, to hopefully inspire others as well as share some of the lessons learnt. So expect to see a few more blogs on this topic over the coming months.

In addition, I would love to receive feedback from anyone else on this topic. Particularly if you are implementing (or at least trying to) CIT or Continuous Delivery, what are some of the obstacles you have faced (both technical and organizational) as well as any tips you have to succeed. Many thanks. Matt

GWT: Working with Google Calendar using gwt-gdata

Tue, 02 Aug 2011 00:00:00 -1000

A recent showcase for one of our products included basic integration with Google Calendar through GWT. Here we aim to present a simple step by step guide to achieving basic interaction with a Google Calendar through GWT.

Google allows access to Calenader via the Data API, available as a library for .NET, Java, JavaScript, PHP and Python clients. We will use the gwt-gdata API, which is a GWT wrapper for the JavaScript Data API.

Our demo application

Users of our application will be able to:

authenticaticate to a calendar
query the events in a calendar
create, delete and edit calendar events
view a read only (public) version of the calendar

1. Setting up

1.1 Calendar

We will need to create a calendar to work with against your google account. If you do not have an account, you can create one here (https://www.google.com/accounts/NewAccount?service=mail).

Creating a new Calendar:

Sign in to calendar (calendar.google.com) using your google account.
Click on Add under your list of available calendars.

Give your calendar a name - GWTCalendar for example.
Select "Make this calendar public".
Optionally under Share with specific people enter the google accounts of additional users that should have authenticated access to the calendar. Set their permissions to Make changes AND manage sharing. This step configures the users that will be able to create and edit events in the calendar. If no additional google accounts are added, only the google account that owns the calendar will be able to create/edit events.

Finally click Create Calendar.

1.2 Development Environment

This tutorial assumes you have Eclipse & the GWT plugin installed and ready to create GWT projects.

create a new GWT project for the sample Calendar application
download gwt-gdata-2.2.1.zip from http://code.google.com/p/gwt-gdata/
extract gwt-gdata.jar from the archive and add it to the project build path
make sure your project inherits the module com.google.gwt.gdata.GData
append the following line to your .gwt.xml file:

2. Getting a view of our calendar

To start with, let's get a read only view of the calendar displaying in our application. Whenever we make changes to the calendar we can refresh this view and see the result of our work immediately.

Under "My calendars" in the main home page of your calendar, click on the dropdown next to our newly created "GWTCalendar"
Select the "Calendar Settings" options
Under "Embed This Calendar" copy the URL in the "src" attribute from the iframe snippet. This is the URL to the public view of our calendar. You can paste it in a browser window to verify.
We will display a view of the calendar in an iframe - create a Frame with the calendar URL as source.

Add the following code to your EntryPoint class:

// Your calendar URL here!!

private static final String CAL_PUBLIC_URL = "https://www.google.com/calendar/embed?src=phihl3hmbh48lq5ml3ek9cj19o%40group.calendar.google.com&ctz=Australia/Brisbane";

private Frame googleCalendar = new Frame(CAL_PUBLIC_URL);

Let's display that calendar:

public void onModuleLoad() {

googleCalendar.setWidth("500px");

googleCalendar.setHeight("500px");

RootPanel.get().add(googleCalendar);

}

If you run the project you should be able to see the calendar we just created:

3. Setting up our UI

Let's proceed by setting up the UI controls we will need for interacting with the calendar.
We will be creating a simple event that has a title, start date and end date. So let's create a vertical panel with a text box for the title, and two date pickers specifying the start and end dates for our event. We'll also need a button which when clicked creates our event. Add the following code to your EntryPoint class:

private TextBox eventTitle = new TextBox();

private DatePicker startDate = new DatePicker();

private DatePicker endDate = new DatePicker();

private Widget createNewEventPanel(){

VerticalPanel createPanel = new VerticalPanel();

createPanel.add(new Label("Title:"));

createPanel.add(eventTitle);

createPanel.add(new Label("Event Start Date:"));

createPanel.add(startDate);

createPanel.add(new Label("Event End Date:"));

createPanel.add(endDate);

createPanel.add(new Button("Create Event",new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

//TODO create the event with the given title and duration

}

}));

return createPanel;

}

When editing our event, we will be able to change the title or remove the event entirely. To do that we will need a textbox to specify the URL of the event we would like to edit (more on this later), a textbox for the new title, and two buttons - Update and Remove. The following code creates a simple panel consisting of those controls. Add it to your EntryPoint class.

private TextBox newTitle = new TextBox();

private TextBox eventUrl = new TextBox();

private Widget createEventEditPanel(){

VerticalPanel editPanel = new VerticalPanel();

editPanel.add(new Label("Event URL:"));

editPanel.add(eventUrl);

editPanel.add(new Label("New Event Title:"));

editPanel.add(newTitle);

editPanel.add(new Button("Update", new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

//TODO update the event given by the URL

}

}));

editPanel.add(new Button("Delete", new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

// TODO delete the event given by the URL

}

}));

return editPanel;

}

Let's pull it all together and display our UI controls. Modify the onModuleLoad() method as follows:

public void onModuleLoad() {

HorizontalPanel controlsPanel = new HorizontalPanel();

googleCalendar.setWidth("500px");

googleCalendar.setHeight("500px");

controlsPanel.add(googleCalendar);

controlsPanel.add(createNewEventPanel());

controlsPanel.add(createEventEditPanel());

controlsPanel.setSpacing(10);

RootPanel.get().add(controlsPanel);

}

If we run the project again our application should now look something like this:

4. Authenticating to Google Calendar

We are ready to start interacting with our calendar. The first step in our application should always ensure that we have the GData Calendar API loaded. If the API is not loaded we load it. This requires a slight refactoring. Firstly, we extract the contents of our onModuleLoad() method to a new method - loadModule():

public void loadModule(){

HorizontalPanel controlsPanel = new HorizontalPanel();

googleCalendar.setWidth("500px");

googleCalendar.setHeight("500px");

controlsPanel.add(googleCalendar);

controlsPanel.add(createNewEventPanel());

controlsPanel.add(createEventEditPanel());

controlsPanel.setSpacing(10);

RootPanel.get().add(controlsPanel);

}

Next, we rewrite onModuleLoad() so that it checks for the presence of the calendar API. If it is absent we load the API by a call to GData.loadGDataApi(). At this stage we need to provide an API key from google (available freely from http://code.google.com/apis/gdata/signup.html). For the purposes of the demo, you could use the key supplied, but you should get your own for a real application. Note the asynchronous nature - we need a Runnable which will complete at some time in the future. Only once the Runnable has completed can we proceed loading our application as in the code below:

public final static String GDATA_API_KEY = "ABQIAAAABGWvCfqj7yJHpNUWKnPf8xS33zGBuY57s7EfWCbD5ZXtDEt-shSPCo3EL0Dtuj-0TG3CmT93zHHI9Q";

public void onModuleLoad() {

if (!GData.isLoaded(GDataSystemPackage.CALENDAR)) {

GData.loadGDataApi(GDATA_API_KEY, new Runnable() {

public void run() {

loadModule(); // Load application

}

}, GDataSystemPackage.CALENDAR);

} else {

loadModule(); // Load application

}

Before interacting with our calendar, we must authenticate to it (either as the google account that owns the calendar, or one of the users we decided to share it with in step 1.1. To this end, the GData API uses AuthSub authentication, made available to us via the User class. When we execute the login() method of the User class, our user is taken to a standard Google login page where they can authenticate with their Google account. The user is then prompted to allow our application permission to use data (the calendar) associated with their Google account. Permission must be granted if we are to proceed successfully. We wrap the authentication step in a simple method:

private void doAuthSubLogin() {

AuthSubStatus status = User.getStatus(calendarUrl);

if (status != AuthSubStatus.LOGGED_IN) {

User.login(calendarUrl);

}

We'll also slightly tweak loadModule() to ensure that the user has logged in to the calendar service before proceeding:

public void loadModule(){

doAuthSubLogin();

// Page refreshed while logging in - no need to initialize the page further

if (User.getStatus() == AuthSubStatus.LOGGING_IN) return;

HorizontalPanel controlsPanel = new HorizontalPanel();

googleCalendar.setWidth("500px");

googleCalendar.setHeight("500px");

controlsPanel.add(googleCalendar);

controlsPanel.add(createNewEventPanel());

controlsPanel.add(createEventEditPanel());

controlsPanel.setSpacing(10);

RootPanel.get().add(controlsPanel);

}

5. Accessing our calendar

We're finally ready to start playing with our calendar. But how do we access it? Under the hood, the GData API interacts with the calendar by sending/receiving Atom or JSON-C feed messages. Fortunately we don't need to worry about that and the GWT API abstracts the details away from us. However, because the calendar is in effect an Atom/JSON feed, it and its events are accessed through an identifying URL. A calendar can be accessed via a URL such as the one below. For more info on the calendar URL structure see [4].

http://www.google.com/calendar/feeds/CALENDAR_ID/private/full

...where CALENDAR_ID identifies the calendar of interest. You can find your CALENDAR_ID in "Calendar settings" for each calendar (see the screenshot in step 2 of this post). Let's put that URL somewhere where we can reuse it (in the EntryPoint class):

// Use YOUR OWN calendar ID in here!

private static String calendarUrl = "http://www.google.com/calendar/feeds/phihl3hmbh48lq5ml3ek9cj19o@group.calendar.google.com/private/full";

5.1 Inserting calendar events

Next, we'll create a class which in essence will wrap (think Facade pattern) some of capability of the GData CalendarService class for the purposes of accessing a calendar with a specific URL. I've decided to go with the somewhat generic name of GoogleCalendarUtils. Our class will have only two member fields - the calendar URL, and an instance of CalendarService which contains all calendar capabilities. The calendar URL will be passed in, to identify the calendar we are working with, and we'll create our own instance of the CalendarService. Create a new class called GoogleCalendarUtils, and add the following code:

private String calendarUrl;

private CalendarService calendarService;

public GoogleCalendarUtils(String calendarUrl){

this.calendarUrl = calendarUrl;

this.calendarService = CalendarService.newInstance("GWTGoogleCalendarDemoApplication");

}

We'll add a simple method for creating calendar events with just a title, start and end dates by creating the createCalendarEventEntry() method as below:

private CalendarEventEntry createCalendarEventEntry(String title, Date startDate, Date endDate){

CalendarEventEntry eventEntry = CalendarEventEntry.newInstance();

eventEntry.setTitle(Text.newInstance());

eventEntry.getTitle().setText(title);

When when = When.newInstance();

when.setStartTime(DateTime.newInstance(startDate));

when.setEndTime(DateTime.newInstance(endDate));

eventEntry.addTime(when);

return eventEntry;

}

Note that you can create events that are much more complex and detailed, by examining the composition of the CalendarEventEntry class (you can additionally add event locations, participants, recurrence, etc - in essence everything you can do with a google calendar). However, for simplicity we'll stick to a date range and a title. No doubt you will have noticed this method uses the GData types like Text and When to create the event object. These are simply GWT wrapper types that map to XML Atom/JSON elements which are used under the hood.

Let's proceed by creating a way to insert new events into our calendar. This is simple: we call createCalendarEventEntry(), and pass the resulting event to the calendar via the CalendarService instance we have (in GoogleCalendarUtils). We expose this operation via the insertCalendarEvent() method, which provides a callback that we will use to update the UI.

public void insertCalendarEvent(String title, Date startDate, Date endDate, CalendarEventEntryCallback callback){

CalendarEventEntry eventEntry = createCalendarEventEntry(title, startDate, endDate)

calendarService.insertEntry(calendarUrl, eventEntry, callback);

}

Next, we should update our UI code to read those fancy input controls we created earlier and create a calendar entry for us. Let's revisit the createNewEventPanel() method. We created a button for new events, however left the event handler empty. Now it's time to actually do something in there. Update your createNewEventPanel() method so it now looks like this:

private Widget createNewEventPanel(){

VerticalPanel createPanel = new VerticalPanel();

createPanel.add(new Label("Title:"));

createPanel.add(eventTitle);

createPanel.add(new Label("Event Start Date:"));

createPanel.add(startDate);

createPanel.add(new Label("Event End Date:"));

createPanel.add(endDate);

createPanel.add(new Button("Create Event",new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

String title = eventTitle.getText();

Date start = startDate.getValue();

Date end = endDate.getValue();

// Use an instance of our CalendarService wrapper for our calendar.

GoogleCalendarUtils ourCalendar = new GoogleCalendarUtils(calendarUrl);

// Call the insert method we defined, and pass a callback to handle the response

ourCalendar.insertCalendarEvent(title, start, end, new CalendarEventEntryCallback() {

@Override

public void onSuccess(CalendarEventEntry result) {

Window.alert("The event " + result.getTitle().getText() + " was added to the calendar");

// Refresh the static view of the calendar if we are successful

googleCalendar.setUrl(googleCalendar.getUrl());

}

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed to insert an event in the calendar..");

}

});

}

}));

return createPanel;

}

Try running the project now. Enter a title and select a start and end date for the event. Click Create Event. You will have run into a strange exception, something like:

com.google.gwt.core.client.JavaScriptException: (Error): An image of the same domain is required on this page for authenticated reads and all writes.

For some mysterious reason, the fix is exactly as given in the error message. Our HTML page must have an image displayed originating from our domain for the GData Calendar API to work. All I know about this is that there is some workaround in browser behaviour that Google utilizes to call out to their services. If anyone knows more I would love to learn the exact details as to the why and how, so please leave a comment below. Anyway, let's make this error go away. Find and add any image to your project, and link to it in your GWT project HTML document. In tribute to Google greatness and mystery I will include the Google Logo (http://www.google.com/images/logo_sm.gif). Practically speaking this can be any image, even a 1x1px dot hiding in some corner. Remember, we must serve up the image from our domain and not just link to it. So we download it, add it to our project, and link that way. I am lazy, so I will put mine in the /war directory, right next to the html document hosting our app. We then display the image in the HTML document:

Try running the project now. Create a new event by selecting a start and end date, and entering a title in the boxes. Click Create Event to add the event to the calendar.

Everything works! If you are still in disbelief about our image trick, go back to the HTML doc and comment out the tag, rerun the project and see it crash and burn.

5.2 Accessing the events in our calendar

Since all operations with the calendar are done via a URL, it would be good to display the URLs for each of our events. Let's add a method to GoogleCalendar utils to do this:

public void getEvents(CalendarEventFeedCallback callback){

// Simply forward the caller's callback to our CalendarService instance

calendarService.getEventsFeed(calendarUrl, callback);

}

Let us also add a way to display our calendar events as a list in our application. We'll use the method below any time we want to update our list of calendar events. We'll add it to our EntryPoint class:

private FlexTable eventsDisplayTable = new FlexTable();

private void displayCalendarEntries(CalendarEventEntry[] entries){

eventsDisplayTable.clear();

eventsDisplayTable.setText(0, 0, "Event Title");

eventsDisplayTable.setText(0, 1, "Event URL");

for(int row = 0; row < entries.length; row++){

// Display the event's title

eventsDisplayTable.setText(row+1, 0, entries[row].getTitle().getText());

// Display the event's URL

eventsDisplayTable.setText(row+1, 1, entries[row].getEditLink().getHref());

}

And we will add a way to query our events via:

private void getAllEvents(){

GoogleCalendarUtils calendar = new GoogleCalendarUtils(calendarUrl);

calendar.getEvents(new CalendarEventFeedCallback() {

@Override

public void onSuccess(CalendarEventFeed result) {

displayCalendarEntries((CalendarEventEntry[])result.getEntries());

}

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed getting calendar events..");

}

});

}

Further, let's provide a single method that updates both our calendar view and the list of events all at once. We add updateCalendarView() to our EntryPoint class:

private void updateCalendarView(){

// Refresh the iframe displaying our calendar

googleCalendar.setUrl(googleCalendar.getUrl());

getAllEvents();

}

Once more we modify our loadModule() method, this time to add a vertical layout panel in order to place the list of events at the bottom of our page. Change loadModule() in EntryPoint so it is now:

public void loadModule(){

doAuthSubLogin();

// Page refreshed while logging in - no need to initialize the page further

if (User.getStatus() == AuthSubStatus.LOGGING_IN) return;

HorizontalPanel controlsPanel = new HorizontalPanel();

googleCalendar.setWidth("500px");

googleCalendar.setHeight("500px");

controlsPanel.add(googleCalendar);

controlsPanel.add(createNewEventPanel());

controlsPanel.add(createEventEditPanel());

controlsPanel.setSpacing(10);

// Add a vertical layout to our page - events list at bottom

VerticalPanel vp = new VerticalPanel();

vp.add(controlsPanel);

vp.add(eventsDisplayTable);

// Get all events that exist when the application loads

updateCalendarView();

RootPanel.get().add(vp);

}

If we run our project now, a table of event names and URLs appears below our view of the calendar.

5.3 Editing a calendar event

Next, we would like to be able to edit calendar events. We can achieve this in a three step process:

firstly we need to obtain the event via its URL
then we apply our changes
and lastly we update it back to the calendar

In our simplified scenario, we will simply rename the event using the following method which we will add to GoogleCalendarUtils:

public void renameEvent(final String eventUrl, final String newTitle, final Callback callback){

// Get the event via its URL

calendarService.getCalendarEntry(eventUrl, new CalendarEntryCallback(){

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed to access calendar service.");

}

@Override

public void onSuccess(CalendarEntry result) {

// Once we have the entry, change it

Text title = Text.newInstance();

title.setText(newTitle);

result.setTitle(title);

// Update the calendar with our changes

calendarService.updateEntry(eventUrl, result, callback);

}

});

}

What remains is to hook up the inputs in our UI that we created earlier (remember the New Event Title textobx and the Update button). We will update the createEventEditPanel() method in our EntryPoint class to read in the new event title, and add an event handler to the Update button which will call GoogleCalendarUtils.renameEvent() with the new name. As a quick and dirty solution, we will identify the event that we want to modify by copying the event URL from the display table below our calendar view and pasting it into the Event URL text box. With the URL in there, we can type in the new event title we would like to use - I used Updated Event, and upon pressing the Update button our request will be pushed to our calendar. The updated version of createEventEditPanel() is:

private Widget createEventEditPanel(){

VerticalPanel editPanel = new VerticalPanel();

editPanel.add(new Label("Event URL:"));

editPanel.add(eventUrl);

editPanel.add(new Label("New Event Title:"));

editPanel.add(newTitle);

editPanel.add(new Button("Update", new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

GoogleCalendarUtils ourCalendar = new GoogleCalendarUtils(calendarUrl);

// Rename the event and handle the result

ourCalendar.renameEvent(eventUrl.getText(), newTitle.getText(), new Callback() {

@Override

public void onSuccess(CalendarEntry result) {

Window.alert("Event update success!");

// When we are done, update our view

updateCalendarView();

}

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed updating calendar event..");

}

});

}

}));

editPanel.add(new Button("Delete", new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

// TODO delete the event given by the URL

}

}));

return editPanel;

}

5.4 Deleting a calendar event

The last operation we set out to achieve was the ability to delete a calendar entry. This follows a very similar process to editing an event:

we need to obtain the event via its URL
we then delete it through CalendarService

We'll add a deleteEvent() method to GoogleCalendarUtils, which performs the above operations for us. The callback enables us to notify our caller of the outcome resulting from the delete operation.

public void deleteEvent(String eventUrl, final Callback callback){

// Obtain the calendar event of interest

calendarService.getCalendarEntry(eventUrl, new CalendarEntryCallback(){

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed to access calendar service.");

}

@Override

public void onSuccess(CalendarEntry result) {

// and delete it

result.deleteEntry(callback);

}

});

}

As before we need to wire in the delete operation in our UI. Again we'll have to paste the URL of the calendar we want to delete into the Event URL textbox, and we'll set up the Delete button so that it calls out to GoogleCalendarUtils.deleteEvent() when it is clicked. As with edit previously, we achive this by adding the click handler for the Delete button in the createEventEditPanel() method in our EntryPoint class:

private Widget createEventEditPanel(){

VerticalPanel editPanel = new VerticalPanel();

editPanel.add(new Label("Event URL:"));

editPanel.add(eventUrl);

editPanel.add(new Label("New Event Title:"));

editPanel.add(newTitle);

editPanel.add(new Button("Update", new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

GoogleCalendarUtils ourCalendar = new GoogleCalendarUtils(calendarUrl);

// Rename the event and handle the result ourCalendar.renameEvent(eventUrl.getText(), newTitle.getText(), new Callback() {

@Override

public void onSuccess(CalendarEntry result) {

Window.alert("Event update success!");

// When we are done, update our view

updateCalendarView();

}

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed updating calendar event..");

}

});

}

}));

editPanel.add(new Button("Delete", new ClickHandler(){

@Override

public void onClick(ClickEvent event) {

GoogleCalendarUtils ourCalendar = new GoogleCalendarUtils(calendarUrl);

// Rename the event and handle the result

ourCalendar.deleteEvent(eventUrl.getText(), new Callback(){

@Override

public void onSuccess(CalendarEntry result) {

Window.alert("Event delete success!");

// When we are done, update our view

updateCalendarView();

}

@Override

public void onFailure(CallErrorException caught) {

Window.alert("Failed deleting calendar event..");

}

});

}

}));

return editPanel;

}

If we now run the application, copy the URL from Updated Event into the Event URL box, and click Delete the event should be deleted.

6. More on Google Calendar

If you would like a closer look into the gwt-gdata API, I suggest going through the sample project included in the zip file we downloaded in step 1.2.
You could also look at the documentation for the Java/JavaScript APIs to discover more of the capability.
If you are interested in a front end calendar implementation check out gwt-cal (http://code.google.com/p/gwt-cal/). You could potentially use this with the GData APIs to build your own front end for Google Calendar.
Look through the reference list below for more resources.
Use Google and experiment!

7. References

[1] Calendar GData API - http://code.google.com/apis/calendar/data/2.0/developers_guide.html

[2] GWT wrapper for GData API: gwt-gdata - http://code.google.com/p/gwt-gdata/

[3] More on google calendar authentication: AuthSub - http://code.google.com/apis/accounts/docs/AuthSub.html

[4] More on calendar feeds and URL structure: Data API Atom Reference - http://code.google.com/apis/calendar/data/2.0/reference.html

8. Source

You can download my version of the EntryPoint class GoogleCalendarUtils in the zip file below:

Using GWT MVP with multiple views on the page

Wed, 20 Jul 2011 00:00:00 -1000

The Issue:

When developing a GWT app with the MVP approach it is common to make use of Activities and Places as described in the developer guide

Under this approach an ActivityManager makes use of an ActivityMapper which you define in order to respond to PlaceChangeEvents by running the relevant Activity. The Activity is passed a reference to an AcceptsOneWidget panel which is typically a container for the entire application. The Activity is responsible for constructing the application view and setting it into this container.

The potential pitfall of this approach is that every time a new activity is run we clear out the entire application view and reconstruct everything from scratch. If your application is composed of multiple distinct regions, for example a Menu and a Content area, and the view for each region can change independently of the other, then you will be forcing the browser to do extra unnecessary work to rebuild the DOM with the Menu region, even though only the Content region has changed.

A Possible Solution:

The solution is presented in two stages

1) Examine a simple approach that will allow for multiple regions on a page to be managed and changed independently of one another.

2) Explore a way to dynamically remove regions that are not required in a given context (e.g. removing the menu region when on the login screen)

We will use this simple example application layout

We will first define our application layout giving each region it's own AcceptsOneWidget panel.

appContainer = new DockLayoutPanel(Unit.PX);
mainContent = new ScrollPanel();
leftMenu = new ScrollPanel();
banner = new SimplePanel();

appContainer.addNorth(banner, 50);
appContainer.addWest(leftMenu, 300);
appContainer.add(mainContent);

For each region that we want to be able to update the view independently of the other regions (the menu and the content region) we will define a new ActivityMapper and ActivityManager

ActivityMapper contentActivityMapper = new ContentActivityMapper(clientFactory);
ActivityManager contentActivityManager = new ActivityManager(contentActivityMapper, eventBus);
contentActivityManager.setDisplay(mainContent);

ActivityMapper menuActivityMapper = new MenuActivityMapper(clientFactory);
ActivityManager menuActivityManager = new ActivityManager(menuActivityMapper, eventBus);
menuActivityManager.setDisplay(leftMenu);

Note that a different panel is set into the display of each ActivityManager.

Because both managers share an EventBus, both ActivityMappers will be called whenever a PlaceChangeEvent is fired. Since each manager should only run a new activity in response to a subset of the possible Places in your app, we will make some changes to the mapper so that it only responds to the Places that affect the given region. By having the mapper hold a reference to its currently executing Activity, it can just return this same activity whenever a Place change it is not interested in gets fired. This will have no affect as the currently executing Activity will not be run again.

public class MenuActivityMapper implements ActivityMapper {

    private Activity currentActivity;

    @Override
    public Activity getActivity(Place place) {
        if (place instanceof MainMenuPlace)
        {
            return new MainMenuActivity();
        } else if (place instanceof SubMenuPlace) {

return new SubMenuActivity();

} else {

//Some other content Place that we aren't interested in
return currentActivity;

}

That completes the first stage. Now say we want to allow the menu region to be hidden when the user is at the login screen and just use the content region to display the login view.

Create a new panel HideableScrollPanel which extends ScrollPanel. Set the menu to use the new panel instead of ScrollPanel. HideableScrollPanel will take as input the parent DockLayoutPanel container and the expected size of the panel when it is displayed. Override the setWidget method so that it will minimize the panel if null is set.

public void setWidget(IsWidget activityWidget) {
        Widget widget = Widget.asWidgetOrNull(activityWidget);
        if (widget == null)
        {
            parent.setWidgetSize(this, 0);
        } else {
            parent.setWidgetSize(this, size);
        }
        super.setWidget(widget);
    }

Now you can define a HideActivity which when run simply sets the AcceptOneWidget panel it is passed a value of null. If the AcceptOneWidget panel is an instance of your HideableScrollPanel then the panel will be removed from the screen. When a LoginPlace change is received the MenuActivityMapper should return a HideActivity.

Deploying Hudson on Weblogic

Fri, 08 Jul 2011 00:00:00 -1000

During the past few months, we have been setting up hudson on our servers to automate our GWT and SOA builds, testing and deployments to Weblogic.

Using the helpful wiki page provided on the hudson wiki and thank you to Maxence Button's blog post, this is a step by step installation guide to get Hudson 2.0.1 deployed on to Weblogic 10.3.4.0.

Due to Weblogic's class loading structure, if the hudson.war is directly deployed, the application will fail to startup. This is to because there are jar conflicts between Hudson and Weblogic. To get around the issue, we use the FilteringClassLoader mechanism so that specific hudson jars get priority in the classpath over Weblogic's jars.

1. Download hudson.war

Download hudson.war from hudson downloads.

2. Create a directory structure for the new hudson.ear

hudson/
 |_____ META-INF/
         |_____ application.xml
        |_____ weblogic-application.xml
 |_____ hudson.war

Note: This step will not work correctly on MacOSX as it will generate .DS_STORE files within the folders.

3. Edit application.xml

Enter the following into application.xml

"1.0"encoding="UTF-8"?>"1.0"encoding="UTF-8"?>
 
"http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_5.xsd"
version="5">
 
"hudson">
hudson.war
/hudson
 
"http://java.sun.com/xml/ns/javaee"

4. Edit weblogic-application.xml

Enter the following into weblogic-application.xml

"1.0"encoding="UTF-8"?>
xmlns:wls="http://www.bea.com/ns/weblogic/weblogic-application"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/javaee_5.xsd
http://www.bea.com/ns/weblogic/weblogic-application >

 

webapp.encoding.default

UTF-8

package-name>org.apache.*package-name>

package-name>javax.xml.stream.*package-name>

package-name>org.dom4j.*package-name>

Weblogic needs this because (unlike JBoss, Tomcat, Jetty et. al) Weblogic will not load the JARs in the WAR before the Weblogic installed JARs, and usually the resulting error is that there is an old version of Ant 1.7 in scope, instead of Ant 1.8.x as Hudson wants. There is also a conflict with stax-api-1.0.1.jar for the javax.xml package listed.

5. Package into an enterprise application archive

Inside the hudson directory, at the same level as META-INF and hudson.war, run the following unix commands or zip the contents of the directory and then rename to hudson.ear

[server]$ zip -r hudson *
[server]$ mv hudson.zip hudson.ear

Note: Do not zip the hudson folder directly, this will not work. Zip the contents of the hudson folder.

6. Deploy the hudson.ear to the Weblogic server:

Note: remember to delete any old Hudson WAR or EAR deployments first.

7. Use Hudson

The application will deploy to http://serverName:port/hudson.

e.g. http://localhost:10090/hudson

Troubleshooting

If you run into certain java exceptions after deployment (see below for an example). Try removing the hudson working directory (In linux, this is in /.hudson) and redeploying the hudson.ear file

org.jvnet.hudson.reactor.ReactorException: org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed. (Caused by org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed.) (Caused by org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed. (Caused by org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed.)) at org.jvnet.hudson.reactor.Reactor.execute(Reactor.java:246) at hudson.model.Hudson.executeReactor(Hudson.java:727) at hudson.model.Hudson.(Hudson.java:630) at hudson.model.Hudson.(Hudson.java:569) at hudson.WebAppMain$2.run(WebAppMain.java:248) Caused by: org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed. (Caused by org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed.) (Caused by org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed. (Caused by org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed.)) at org.apache.commons.logging.impl.LogFactoryImpl.newInstance(LogFactoryImpl.java:543) at org.apache.commons.logging.impl.LogFactoryImpl.getInstance(LogFactoryImpl.java:235) at org.apache.commons.logging.impl.LogFactoryImpl.getInstance(LogFactoryImpl.java:209) at org.apache.commons.logging.LogFactory.getLog(LogFactory.java:351) at org.springframework.context.support.MessageSourceSupport.(MessageSourceSupport.java:42) at org.springframework.context.support.AbstractMessageSource.(AbstractMessageSource.java:63) at org.springframework.context.support.ResourceBundleMessageSource.(ResourceBundleMessageSource.java:57) at org.acegisecurity.AcegiMessageSource.(AcegiMessageSource.java:34) at org.acegisecurity.AcegiMessageSource.getAccessor(AcegiMessageSource.java:41) at org.acegisecurity.providers.dao.AbstractUserDetailsAuthenticationProvider.(AbstractUserDetailsAuthenticationProvider.java:72) at hudson.security.AbstractPasswordBasedSecurityRealm$Authenticator.(AbstractPasswordBasedSecurityRealm.java:175) at hudson.security.AbstractPasswordBasedSecurityRealm.createSecurityComponents(AbstractPasswordBasedSecurityRealm.java:68) at hudson.security.SecurityRealm.getSecurityComponents(SecurityRealm.java:387) at hudson.security.HudsonFilter.reset(HudsonFilter.java:134) at hudson.model.Hudson.setSecurityRealm(Hudson.java:1999) at hudson.model.Hudson$14.run(Hudson.java:2420) at org.jvnet.hudson.reactor.TaskGraphBuilder$TaskImpl.run(TaskGraphBuilder.java:147) at org.jvnet.hudson.reactor.Reactor.runTask(Reactor.java:260) at hudson.model.Hudson$4.runTask(Hudson.java:708) at org.jvnet.hudson.reactor.Reactor$2.run(Reactor.java:187) at org.jvnet.hudson.reactor.Reactor$Node.run(Reactor.java:94) at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:909) at java.lang.Thread.run(Thread.java:619) Caused by: org.apache.commons.logging.LogConfigurationException: org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed. (Caused by org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed.) at org.apache.commons.logging.impl.LogFactoryImpl.getLogConstructor(LogFactoryImpl.java:397) at org.apache.commons.logging.impl.LogFactoryImpl.newInstance(LogFactoryImpl.java:529) at org.apache.commons.logging.impl.LogFactoryImpl.getInstance(LogFactoryImpl.java:235) at org.apache.commons.logging.impl.LogFactoryImpl.getInstance(LogFactoryImpl.java:209) at org.apache.commons.logging.LogFactory.getLog(LogFactory.java:351) at org.springframework.context.support.MessageSourceSupport.(MessageSourceSupport.java:42) at org.springframework.context.support.AbstractMessageSource.(AbstractMessageSource.java:67) at org.springframework.context.support.ResourceBundleMessageSource.(ResourceBundleMessageSource.java:59) ... 17 more Caused by: org.apache.commons.logging.LogConfigurationException: Invalid class loader hierarchy. You have more than one version of 'org.apache.commons.logging.Log' visible, which is not allowed. at org.apache.commons.logging.impl.LogFactoryImpl.getLogConstructor(LogFactoryImpl.java:385) ... 24 more