Mar 08

Since Sun Microsystems started the Java Business Integration specification work, and subsequently started releasing the OpenESB platform and components around 2006, until Sun was acquired by Oracle around 2010, I published a number of blog articles dealing with different aspects of the JBI-based technologies embedded in the OpenESB, GlassFish ESB and Java CAPS/JBI. I lost interest in the topic when Sun acquisition was completed and it became clear to me that the JBI specification will not be supported by Oracle other as part of the legacy Java CAPS/JBI and the GlassFish ESB products. Around the same time there was a fair bit of activity around the OpenESB community aimed at working out whether and how OpenESB can be picked up by the community, perhaps development branch forked so it can be controlled by the community, etc.. Since I did not expect that effort to lead anywhere I stopped following these discussions and eventually OpenESB mailing lists to which I was subscribed disappeared to be replaced by others to which I did not subscribe.

I never went back to my original blog articles to see if they are still implementable and whether the software used in them is still available. Needless to say some articles can no longer be implemented as written and the links to the OpenESB / GlassFish ESB distributions which I provided in my articles no longer lead anywhere useful.

Recently I had an occasion to look at some of the articles and it occurred to me that perhaps they can be updated if OpenESB is available somewhere, so people can still try them. I did put a fair bit of effort into the articles and it is such a waste to have the solutions unimplementable. I went looking for OpenESB distributions to see if they are available, what state they are in, and whether anyone cares. It turned out that LogiCoy (http://www.logicoy.com/) maintains and develops OpenESB, at least one distribution of which is publically available, and I know some of the people at LogiCoy who are working on this platform. I understand from them that a new release, v2.3 (of which a Beta version is available at the community site – http://www.open-esb.net/) will be officially released sometime this month. Once the release is available I will come back to this article to provide the link to it and perhaps to the installation documentation.

In the spirit of “Jacques Brel is Alive and Well and Living in Paris” (http://en.wikipedia.org/wiki/Jacques_Brel_is_Alive_and_Well_and_Living_in_Paris) I decided to have a look at my JBI articles and release updated versions using the OpenESB distribution released to the community by LogiCoy’s. This will happen as time and motivation permit.

In this article I am listing articles which I may get around to updating to work with LogiCoy’s version of OpenESB, and their status (Not started, Updated, Never to be worked on again). This blog entry is available at http://blogs.czapski.id.au/wp-content/uploads/2013/03/OpenESBIsALiveAndWellAndLivingIn…_v0.1.0.pdf.

 

Nov 28

In some specific circumstances, for example when testing high availability and failover scenarios, it may be desirable to make a BPEL process wait for a random amount of time, not exceeding some maximum duration, before continuing.

This Note describes the JavaScript Codelet which, given a maximum duration in Milliseconds, will return a random time up to that maximum duration, as an ISO8601 Duration Literal, suitable for use in the BPEL Wait activity. An example process that uses this Codelet is also developed and discussed.

This Note relies on the material presented in the Blog Entry “GlassFish ESB v2.1 – Using JavaScript Codelets to Extend BPEL 2.0 Functionality”, at http://blogs.czapski.id.au/?p=17.

The document is to be found at http://blogs.czapski.id.au/wp-content/uploads/2010/03/BPEL_WaitRandomDuration_v1.0.1.pdf.

The example project is to be found at http://blogs.czapski.id.au/wp-content/uploads/2010/03/ISO8601DurWait.zip

Tagged with:
Nov 27

The BPEL SE, featured in the GlassFish ESB, the OpenESB and the Java CAPS 6, has the ability to execute JavaScript (ECMAScript) code inline. Why would one do that, you may ask. The answer is: because BPEL, great as it is with XML all over the place and all, can not do everything, and invoking Web Services and POJOs from BPEL for small and simple code adds too much overhead.

Take a date conversion, for example. It takes about 4 lines of Java code to perform date conversion. Doing this in BPEL is too horrible to contemplate. Doing this in JavaScript is not too bad, given availability of ready-made JavaScript scripts that do the job.  The issue is that one cannot invoke Java from BPEL without resorting to a web service or a POJO. Invoking JavaScript, on the other hand, does not require either. Furthermore, JavaScript, in the Netscape days, acquired the ability to embed Java using technology known as LiveConnect.

In this Note we will explore the BPEL SE capability to execute JavaScript code inline. In passing we will also explored the ability of JavaScript to execute Java statements, and through these means to extend BPEL 2.0 with arbitrarily sophisticated functionality, without having to resort to invoking web services or POJOs.

We will introduce 2 Rules which must be followed, and 1 Rule which should be followed, for successful BPEL and  JavaScript integration. We will develop two complete examples of embedded JavaScript code that provides reasonably useful functionality not natively available through BPEL. While the two examples will be fairly trivial it will be clear that more sophisticated functionality can be added following the method introduced in this Note.

Writeup, BPEL_JavaScript_Java_GetProperty_v1.0.2.pdf, can be found at http://blogs.czapski.id.au/wp-content/uploads/2010/03/BPEL_JavaScript_Java_GetProperty_v1.0.2.pdf

Projects, developed in the writeup, in the archive BPEL_JavaScript_Java_GetProperty_v1.0.2_code_bis.zip, are to be found at http://blogs.czapski.id.au/wp-content/uploads/2010/03/BPEL_JavaScript_Java_GetProperty_v1.0.2_code_bis.zip

Jul 30

Every now and then there arises a need to carry out-of-band information alongside the business payload but without disturbing or modifying it. Message Envelope Pattern is the Enterprise Integration Pattern label that is typically applied to solutions that address this issue. How the issue is addressed in practice varies depending on the technology in use. For JMS, for example, JMS Message Properties could be used to carry out-of-band information while the payload would be carried as the JMS payload. Web Services, typically using SOAP over HTTP, can address this requirement through the SOAP Header Extension Mechanism, whereby custom headers can be added to the SOAP Header while the payload is carried in the SOAP Body.

This document discusses construction of a WSDL that supports custom SOAP Header element and BPEL processes that are used to set and get custom header values in JBI and in eInsight. This mechanism is known to work in Java CAPS 5.x, Java CAPS 6 Classic and OpenESB / GlassFish ESB.

It is assumed that the reader is sufficiently familiar with the GlassFish ESB / OpenESB BPEL Service Engine and the SOAP/HTTP Binding Component, and / or Java CAPS Classic eInsight Business Process Manager and eDesigner IDE to be able to build projects without a step-by-step pictorial document.

The document is available here: 01_Handling_SOAP_Headers_in_BPEL_.pdf
The companion archive, containing WSDLs and projects, is available here: 01_Handling_SOAP_Headers_in_BPEL.zip

While the method discussed in this entry is still valid there is now a different treatment of the topic, using NM Properties, “GlassFish ESB v2.x – Reading and Writing arbitrary SOAP Headers in BPEL 2.0 using NMProperties“.

Tagged with:
Jul 05

In some views SOA is represented as a series of 4 layers: Presentation Layer (SOA 1), Business Process Layer (SOA 2), Business Service Layer (SOA 3) and Technical Layer (SOA 4). Typically each layer higher up in the hierarchy consumes services exposed by the layer under it. So the Presentation Layer would consume services provided by the Business Process or Business Service Layers. Service interfaces are described using Web Services Description Language (WSDL), sheltering service consumers from details of service implementation. Web Services are seen as the technical means to implement the decoupled functional layers in a SOA development. Decoupling allows implementations of business functionality at different layers to be swapped in and out without disturbing other layers in the stack.

In this document I will implement a multi-operation Web Service that will allow patient information to be upserted into a database table and will return all patient details for a patient whose Facility+Local ID are specified in the request. This service will be used to populate the patient table and to implement patient lookup portlets, discussed in other writeups in this series. This is a basic Patient Service that hides the specifics of interaction with the patient data store form applications that need to interact with it, by providing a defined interface and web service-based implementation. Thus the data store may change but the service consumers need not. We use the Database BC with select, insert and update operations and Database BC with SQL File-based parameterized SQL prepared statement. We handle null value insertion on missing data. We also use the SOAP/HTTP BC and the BPEL SE.
The business idea is that patients are looked after in various healthcare facilities. Information about patients is stored in a relational database. This information must be inserted, for new patients, and updated, for existing patients, as required. Frequently applications need to search for a patient and display details to human operators. To shelter application developers from the details of the data store the upsert functionality and patient details lookup functionality will be made available as a multi-operation web service.

Walkthrough Document: 02_PatientSvc_GFESBv21.pdf
Companion Archive: 02_PatientSvc_companion_archive.zip

Jul 02

“Progress” notwithstanding, Healthcare environments still extensively use the HL7 v2.x Delimited messages for conveyance of patient and patient-related information between applications. The GlassFish ESB provides support for HL7 v2.x messaging in the form of the HL7 Encoder, which allows conversion between HL7 v2 Delimited and HL7 v2 XML message formats, and in the form of the HL7 Binding Component, which allow connectivity between the GlassFish ESB-based healthcare solutions and healthcare applications that support HL7 over TCP connectivity.

In this document I will walk through the process of generating HL7 v2.3.1 delimited messages from pipe-delimited records containing patient information, sending and receiving HL7 v2.3.1 delimited messages using the HL7 Binding Component, parsing HL7 v2.3.1 delimited messages and writing HL7 v2 delimited messages to a file. To create and process HL7 messages I show how create a custom ADT A04 XML Schema and a custom “any HL7 v2 message” XML Schema. This gives me an opportunity to use the File Binding Component (File BC), the HL7 BC, the HL7 Encoder, the Custom Encoder and the BPEL Service Engine (BPEL SE). This also gives me an opportunity to demonstrate a HL7 v2.3.1 delimited message sender solution and to demonstrate a HL7 v2.3.1 delimited message receiver solution. At the end of the process we will have a file containing HL7 v2 delimited ADT A04 messages, which we will use in related writeups.

Here is the document: 02_PatientSvc_MakeHL7v2DelimDataFromCustomDelimRecords_0.4.pdf

Here is the companion archive containing input files, the output file and the projects: 02_PatientSvc_MakeHL7v2DelimDataFromCustomDelimRecords_data.zip

The writeup document has been updated and version changed to 0.4.

Jun 30

This Quick Note discusses a simple solution to the use case provided by Leonard Barkley. The question goes like this:

“I dont have any idea how to implement BPEL process but the BPEL deployed as a subscriber of a topic. usually I implement the BPEL process and deployed it as web service.”

We produce a simple GlassFish ESB v2.1-based solution which reads a file, sends its content to a JMS Topic and another simple GlassFish ESB v2.1-based solution which subscribes to the same JMS Topic, receives the message and writes it to a file. Both solutions will use BPEL to implement the simple logic, though it is possible to implement both solutions without BPEL, so we have File BC -> BPEL SE -> JMS BC -> JMS Provider (Topic) -> JMS BC -> BPEL SE -> File BC.

Here is the note: QuickNote003_forLeonardBarkley.pdf

Hire is an archive with the project group containing all the projects developed in the Note: JMSTopicSampleProjGrp.zip

As Leonard Barkley pointed out to me, having implemented the sample, the Note is incorrect on Pages 23 and 24. The JMSSubscriber_JMSIn WSDL should use the Receive type, not Send type as the docuent states. The solution still works, it appears, but the configuration as documented is confusing. Thanks Leonard.

Jun 22

In some views SOA is represented as a series of 4 layers: Presentation Layer (SOA 1), Business Process Layer (SOA 2), Business Service Layer (SOA 3) and Technical Layer (SOA 4). Typically each layer higher up in the hierarchy consumes services exposed by the layer under it. So the Presentation Layer would consume services provided by the Business Process or Business Service Layers. Service interfaces are described using Web Services Description Language (WSDL), sheltering service consumers from details of service implementation. Web Services are seen as the technical means to implement the decoupled functional layers in a SOA development. Decoupling allows implementations of business functionality at different layers to be swapped in and out without disturbing other layers in the stack.
In this document I will walk through the process of developing a SOA Composite Application, exposed as a Web Service, which will make available simple business functionality using a multi-operation service. We will use the GalssFish ESB v2.1 infrastructure. The service will use the SOAP/HTTP Binding Component, the Database Binding Component and the BPEL 2.0 Service Engine. This simple service will introduce the components and discuss how a multi-operation web service can be constructed using the GalssFish ESB.
The business idea is that patients are looked after in various healthcare facilities. Frequently applications need to allow selection of a facility and to access facility details for display to human operators. A relational database is used to hold the details of facilities which are a part of the healthcare enterprise. To shelter application developers from the details of the data store facility list and details will be made available as a multi-operation web service. This web service will be used elsewhere to construct a portlet that can be used in an enterprise portal.

The document is available as 01_FacilityService_GFESBv21.pdf

Late breaking news: The MySQL JDBC Driver, which I used in the example, mysql-connector-java-5.1.7-bin.jar, and which is distributed with the GlassFish ESB v2.1, causes connection pool exhaustion and other issues with the example. If you experience these issues pleases download the latest MySQL JDBC Driver, mysql-connector-java-5.1.11-bin.jar as at now, from http://dev.mysql.com/downloads/connector/j/5.1.html and replace the original in domains/domain1/lib/ext.

Jan 01

This Note walks the reader through development of a Java CAPS 6/JBI-based / OpenESB-based solution that addresses a Healthcare-related business problem. The Note elaborates on the healthcare background necessary to get a notion of what is being done and why, and provides detailed steps required to implement and exercise the solution to the business problem.

Updated note, where GlassFsish ESB v2.1 is used instead of Java CAPS 6, is available at 00_HL7_Example_Development_Instructions_Final_1.1.2.pdf

We will use the HL7 Binding Component, the File Binding Component, the JMS Binding Component, the SOAP/HTTP Binding Component, the BPEL 2.0 Service Engine, the JavaEE Service Engine, the HL7 Encoder and EJB-based Web Services in a JBI-based solution.

In the process we will create XML Schema Documents (XSDs), Web Services Description Language Documents (WSDLs), a BPEL 2.0 Business Process, an EJB-based “Implementation First” web service, an EJB- and WSDL-based “Interface First” web service, a bunch of Composite Applications, BPLE 2.0 mapping, BPEL 2.0-based Web Service orchestration, on-the-fly conversion of HL7 version 2.3.1 delimited messages to their XML equivalents. We will get a pretty good exposure to what OpenESB and Java CAPS 6/JBI components look like, how they work and how they can be used to create real business solutions. Above all, we will develop and test a solution that is more sophisticated then the customary “Hello World” examples but not so complex as to take too long to build and become too hard to comprehend by a novice user.

The particular business problem and the particular solution came about because once upon a time there was intent to build a series of related OpenESB projects – HL7 Processor, MDM Processor and IEP Processor – that would:

  • receive HL7 v2.x delimited messages
  • convert HL7 v2.x messages to their equivalent XML format
  • split message stream into ADT A01s, ADT A03s and other
  • convert A01s to an abbreviated Custom Patient XML format
  • convert A03s to an abbreviated Custom Discharge format
  • send Custom Patients to a JMS Queue for processing by a MDM solution
  • send Custom Discharges to a JMS Queue for processing by an IEM solution
  • have the MDM process Custom Patients into a Master Patient Index
  • have the IEP process Custom Discharges to flag excessive length of stay

The MDM Processor and the IEP Processor made it to the Sun CEC 2008 as demonstrations, with associated Tutorials by Tom Barrett, and demonstration recordings by me. The HL7 Processor did not make it. With the appearance of Java CAPS 6 Update 1 more JBI components made it into the officially supported Sun product. While the HL7 BC and the HL7 Encoder did not make it into this Update they will, eventually. Both components are already available from the OpenESB site and can be installed into the Java CAPS 6 Update 1 installation as unsupported components. This is what we will do for this Note.

The complete Note is to be found here.

The archive containing supplementary material you can use to save yourself the trouble of downloading component and, above all else, containing test files with HL7 delimited records, is here.

For these interested in processing HL7 using GlassFish ESB v2.1 there is a blog entry, “GlassFish ESB v2.1, MySQL v5.1 – Make HL7 v2.3.1 Delimited Messages from Custom Delimited Records with HL7 Encoder“, which discusses, amongst other things, how to create a custom HL7 v2 ADT A04 XSD and a “match any” XSD.

Tagged with:
Dec 19

Following the CEC 2008 Conference in Las Vegas, where the Java CAPS Stream saw a bunch of presentations and demonstrations, I am happy to offer screencasts of the three demonstration sessions I recorded for the event.

The GlassFish ESB screencast is the ScreenCast of the CEC 2008 GlassFish ESB Essentials Lab demonstration. This is a recording of the demonstration described in detail by Tom Barrett in
the GlassFish ESB Tutorial and Lab document. The screencast is an extended version of what the CEC audience got to see. In this screencast I use the OpenESB distribution to discuss, design and implement an abbreviated Supply Chain solution
. I use the File BC, the SOAP/HTTP BC, BPEL 2.0 SE, the Custom Ecoder, the XSD Editor, the WSDL Editor, BPEL correlations, BPEL Pick wit Timer, CASA Editor and a bunch of other OpenESB/GlassFish ESB featiures and facilities. Watching the screencast will give you a pretty good idea what the tooling looks like, how easy it is ti use it, how a theoretical requirement can be turned into a practical design and how that design can be implemented and exercised using the tooling and infrastructure you can get free of charge and use as much as you might desire.

Data for the following two screencasts/demonstrations is produced by the solution discussed in the next blog entry, which ought to precede these two.

The Java CAPS 6/Mural Master data Management screencast is the ScreenCast of the CEC 2008 Java CAPS Essentials Master Data Management (MDM) Lab demonstration. This is a recording of the demonstration described in detail by Tom Barrett in the Java CAPS Essentials MDM Tutorial and Lab document. In the screencast I discuss what the Master Data Management (MDM) is, how a Healthcare enterprise might leverage it to improve its business and how the OpenESB or Java CAPS 6 can be used to implement MDM. I use OpenESB to design a Master Patient Index Data Model, implement it with the tool, generate Data Model-based Master Index Data Management Web Application, build an integration solution to feed the MDM solution with transactional data form Hospital Information Systems and build a broadcast processor solution that can be used to send master patient index updates to downstream systems which have a need to be kept in synch with the enterprise view of the patient. One will get a very good idea of what the core Master Data Management is about, how easy it is to create the MDM Application and related integration components using the OpenESB/Java CAPS 6 tooling, and how the business of maintaining master patient index looks and works like.

The Java CAPS 6 / Intelligent Event Processor screencast is the ScreenCast of the CEC 2008 Java
CAPS Essentials IEP Lab demonstration. This is a recording of the demonstration described in detail by Tom Barrett in the Java CAPS Essentials IEP Tutorial and Lab document.The screencast is what the CEC audience got to see. In this screencast I demonstrate how an Intelligent Event Processing (IEP) solution is built and exercised. The solution addresses a Helathcare business problem – it calculates an Average Length of Stay for each patient in a sliding time window, based on data from an ADT A03 HL7 Discharge message, works out which patients’ Length of Stay exceeds average for the patients in the window by 1.5 times, and passes records related to these patients
on while discarding ‘normal’ records.

The AVIs were recorded with Camtasia Studio. You may need a Camtasia Player to playe them on Windows. You could also try getting a Camtasia codec for your platform/player from the Camtasia site.

I had audio quality problems when directly playing the recordings through Mozilla, which used the Quicktime plugin. The best thing to do is to download the recordings and try different players until one works for you.;

Enjoy.

Tagged with:
preload preload preload