Saturday May 28, 2011

Using QBrowser v2 with WebLogic JMS for 10.3

WebLogic Server does not include a convenient tool to browse JMS destinations. Freely downloadable QBrowser version 2 tool, with some configuration, can be used to provide easy to use functionality to work with WebLogic JMS destinations. This article discusses how QBrowsers should be configured to work with the JMS destinations managed through the WebLogic Server 11g (10.3), which was the current version at the time this article was written.

The original article is available at http://blogs.czapski.id.au/2011/05/using-qbrowser-v2-with-weblogic-jms-for-10-3

Oracle SOA Suite 11g B2B HL7 v2 Inbound to WebLogic JMS Queue

I notice that people used to the eGate/Java CAPS way of doing things, when looking at migrating to the SOA Suite for HL7 messaging, are trying to reproduce the pattern "HL7v2AdapterJMS Queue". This is not necessary when using SOA Suite but can be done if one insists. This article walks through the process of implementing this pattern using Oracle SOA Suite 11g R1 PS3.

The process will follow these steps:
1. Obtain and configure the QBrowser tool for JMS browsing
2. Obtain and configure the HL7 Sender tool
3. Create two WebLogic JMS Queues to be used in the solution
4. Create and deploy a HL7 v2 Inbound Trading Partnership Agreement
5. Submit HL7 v2 messages and inspect them in the corresponding JMS Queue
6. Repeat steps 4 and 5 for another inbound stream

The original article, which can be found at http://blogs.czapski.id.au/2011/05/oracle-soa-suite-11g-b2b-hl7-v2-inbound-to-weblogic-jms-queue, demonstrates that Oracle SOA Suite B2B HL7 infrastructure can be configured to receive message streams over multiple inbound MLLP channels and deliver each stream to a distinct JMS destination, much as eGate and Java CAPS solutions used to do.

Wednesday Jan 27, 2010

Recording of a dmonstration of the "GlassFish ESB v2.2 Field Notes - Exercising Load Balanced, Highly Available, Horizontally Scalable HL7 v2 Processing Solutions"

In the blog entry "GlassFish ESB v2.2 Field Notes - Exercising Load Balanced, Highly Available, Horizontally Scalable HL7 v2 Processing Solutions" I present the GlassFish ESB v2.2-based load balanced, highly available, horizontally scalable solution for HL7 v2.x delimited messaging, using both the HL7 Binding Components, Web Services and JMS in request/reply mode. The one and a half hour recording of me discussing and demonstrating this solution is available as a Flash Movie (SWF), "GFESB_LB_HA_Demo_Session SWF " through the blog article Recording of a dmonstration of the “GlassFish ESB v2.2 Field Notes – Exercising Load Balanced, Highly Available, Horizontally Scalable HL7 v2 Processing Solutions” at http://blogs.czapski.id.au/2010/01/recording-of-a-dmonstration-of-the-glassfish-esb-v2-2-field-notes-exercising-load-balanced-highly-available-horizontally-scalable-hl7-v2-processing-solutions

Tuesday Jan 05, 2010

GlassFish ESB v2.2 Field Notes - Exercising Load Balanced, Highly Available, Horizontally Scalable HL7 v2 Processing Solutions

It seems frequently assumed that architecting and deploying Highly Available (HA) solutions requires Application Server and/or Operating System clustering. When it comes to SOA and Integration solutions this is not necessarily a correct assumption. Load Balanced (LB) and Highly Available HA) SOA and Integration solutions may not require that degree of complexity and sophistication. Frequently, protocol, binding component, JBI and architectural application design properties can be exploited to design highly available solutions. Testing LB and HA solutions requires infrastructure consisting of multiple hosts and the ability to “crash” hosts at will. With virtualization technologies available now it is far easier to use multiple virtual machines then to use physical machines. It is also easier and potentially less destructive to “crash” virtual machines then it is to do so with physical machines.

In this Note a heterogeneous, non-clustered collection of hosts will be used to implement and exercise three load balanced, highly available GlassFish ESB-based solutions. The environment consists of a number of independent “machines”, which are not a part of an Operating System Cluster. Each “machine” hosts a GlassFish Application Server. Application Servers are independent of one another and are not clustered. This is to demonstrate that load balanced, highly available, horizontally scalable solutions, based on the GlassFish ESB software alone, can be designed and implemented.

The specific class of solutions to which this discussion applies is the class of solutions which:
1.    are exposed as request/reply services
a.    HL7 messaging with explicit Application Acknowledgment
or
b.    Request/Reply Web Services
or
c.    JMS in Request/Reply mode
2.    implement business logic as short lived processes
3.    are
a.    atomic
or
b.    are idempotent
or
c.    tolerant of duplicate messages
Classes of solutions with characteristics different from these named above require different approaches to high availability and horizontal scalability, and are not discussed here.

In this Note only high availability and scalability of receiver solutions is addressed. This aspect is the focus because a failure to process a message by a receiver may result in message loss –generally a bad thing.

Paradoxical as it may sound; senders are special cases of receivers. Just as a receiver is triggered by arrival of a message so too is a sender. Making sure that the sender trigger message does not get lost is much the same as making sure the message a receiver receives does not get lost. This means that the same considerations apply to senders and to receivers.

This note discusses an exercise involving an example load balanced, highly available, horizontally scalable healthcare environment, processing HL7 v2 messages. Discussion includes customization of generic GlassFish ESB v2.2 VMware Virtual Appliances for a specific Load Balancing and High Availability exercise and deploying ready-made GlassFish ESB solutions. The exercise for HL7 BC-based, Web Service-based and JMS-based highly available, load balanced, and horizontally scalable receivers, processing HL7 v2.3.1 messages, will be conducted and discussed.

At the end of the Note we will have three GlassFish ESB VMware Appliances with GlassFish ESB v2.2 Runtime infrastructure, ready to use for further GlassFish ESB Load Balancing and High Availability exercises.

The reader will be convinced, one hopes, that for the applicable class of GlassFish ESB-based solutions, load balancing and dynamic failover without message loss work. For that class of solutions this provides for high availability and horizontal scalability without resorting to Application Server or Operating System clustering.

The article is available at http://blogs.czapski.id.au/2010/01/glassfish-esb-v2-2-field-notes-exercising-load-balanced-highly-available-horizontally-scalable-hl7-v2-processing-solutions

Wednesday Jul 16, 2008

Java CAPS 6, Using JCA, Note 2, Batch Inbound, through Batch Local File to JMS

Java CAPS 6 has the 5.x compatibility infrastructure which allows one to import 5.x projects right into Java CAPS 6, build, deploy and run without changes. One can also develop repository-based projects in Java CAPS 6 – that’s the 5.x-style projects.  This is the old way of developing Java CAPS solutions – still good and valid.


If one were to decide to not use the old way there is the JBI infrastructure, which allows development of solutions that use BPEL Service Engine, XSLT Service Engine, IEP Service Engine, Java EE Service Engine, etc., and a variety of Binding Components. The implication is that business logic is implemented in BPEL 2.0, which is used to orchestrate other services and resources, including interaction with external systems through Binding Components. This is the new way of developing Java CAPS solutions – 100% compatible with the Open Source OpenESB project since it uses the OpenESB project-developed container and components.


Someone might ask “so what happened to eGate?”. “eGate” meaning Java Collaboration Definition-like logic components, eWays and the JMS messaging backbone.


While the facility seems underadvertised/downplayed, Java CAPS 6 provides a number of 5.1 eWay-based JCA Adapters and a moderately easy means of developing JCA Message-Driven Beans that can use these adapters to implement JCD-like logic components and, effectively, eGate-like solutions that do not use BPEL or the JBI infrastructure.


This Note discusses and illustrates the implementation of a JCD-like integration solution that retrieves a file from the local file system and writes its content to a JMS destination. This requirement I have seen and heard of being implemented in 5.x many times by many customers.


The JCA Message-Driven Bean, the piece of JCD-like Java logic, will be triggered by a Batch Inbound Adapter (what one would have called the Batch  Inbound eWay in 5.1), will read the content of the file using the Batch Local File Adapter (eWay) and will write the payload as a string to a JMS destination. The batch Inbound Adapter will be configured to use a regular expression to match the name of the file. Once it finds the file it will rename the file by prepending the GUID to the name and will pass the new name, the original name and the directory path to the Java code. This is exactly what the 5.1 Batch Inbound does. The JCA MDB will use the new name, the original name and the directory path to dynamically configure the Batch Local File Adapter to retrieve the file content and rename the file (post transfer) to the original name with some string appended to indicate that the file was processed. This, too, is exactly what one would do in a 5.1 JCD in the same circumstance. Once the payload is available the JCA MDB will use the JMS OTD to send it, as a TextMessage, to a JMS Queue.  Again, this is something that a 5.x JCD would do.


In effect, this Note describes and illustrates the process of re-creating a 5.x Java Collaboration Definition using Java CAPS 6, but instead of using the repository-based approach it is using JCA MDBs and JCA Adapters.


Complete text of the Note is in 02JCA-BInboundThroughBLFToJMS.pdf

Tuesday Oct 23, 2007

Java CAPS 5.1.3 Dynamic JMS Selectors

Java CAPS solutions can selectively retrieve messages from JMS Destinations using static selector expressions, configured in Connectivity Maps. This configuration is performed at design time and is static - to change a selector value requires that the solution is re-built and redeployed.

 This extract, from the "Java CAPS Basics ..." book, discusses and illustrates dynamic use of JMS Selectors in Java Collaboration definitions.

This extract, from the "Java CAPS Basics ..." book, discusses and illustrates the use of dynamic JMS Selectors to implement a correlation mechanism without the use of eInsight correlations.

About

In this Blog I post abstracts of articles / writeups / notes on various aspects of Java CAPS and SOA Suite including solutions, discussions and screencasts. The links to the referenced material are included in the bodies of the abstracts.

Search

Categories
Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today