Grid Computing and XML

Grid Computing and XML

MGT- 5012 Information Systems
Florida Tech University
Instructor William C. Cross
Albee Horne
September 15, 2010

Page 1
Grid Computing and XML

In the World of Technology the choices available for sharing and retrieving data
are growing each passing day. Grid Technology is becoming ever more popular in areas
of Science, Scientific Research, Disease treatment and cure research, Digital Publishing,
and across other industries. In conjunction with Grid Technology, the usage of XML
technology is also on the rise. This paper will define in depth the process of Grid
Computing and XML, the benefits of using both simultaneously, and the future benefits
of using these Technologies.
Grid computing is prominent in the Cancer research field. Researchers at The
Cancer Institute of New Jersey digitized MRIs’, and Cat scans to be analyzed on a
network of computers from independent research facilities comprised of what is
considered Grid Computing. According to a passage from Obrien (2010), “Digitizing
images should enable doctors to diagnose cancers earlier and detect their growth or
shrinkage more accurately during treatment” (p.75). Through the use of this technology
researchers have converted thousands of images pertaining to cancerous tissues and cells
into digital images. These images are retrieved in a manner similar to a virtual
supercomputer based on thousands of volunteers donating un used computer time
Patrizio. A, (2010). This allows Doctors to compare patient’s new images to ones already
in the database to help diagnose and treat cancer. This in turn will also allow a
comparison of previous treatments in respect to patient reaction or outcomes to past
treatments which could help in current and future treatments Obrien (2010).
In conjunction with Grid Computing, another popular trend that ties in with this is
XML (extensible markup Language). The XML used with Grid computing is a document
of tagged info to aide in collaboration with like minded users. These tags are descriptive
in allowing the user to find information quickly, on other scalable systems, other than the
producer of the document. This is where data exchange occurs between users; There are
applications that provide tools which allows manipulation of the XML which means that
changes can be made to the document after its produced from the producer, and ran on
the client or receiver’s system whether it’s the same or a different system all together.
Malaika. S, (2002).

Page 2
 Grid Computing and XML

To go deeper into how this data can be manipulated or how constraints can be set
to prevent manipulation a portion is quoted from Malaika. S, (2002);

Susan: Two features make XML suitable for data exchange between computers
that have not been introduced to each other before:

 The way characters are encoded in an XML document is defined within

the XML itself through an encoding declaration. The encoding declaration tells
the processing software the level of the XML specification that the document
conforms to, and what encoding the document is in, ideally in Unicode.
 Additional constraints on the content of an XML document can be
specified separately in either a:
o Document Type Definition (DTD)
o XML Schema (also an XML document)

DTDs and XML schemas can be placed locally or across the network, and can be
found using the universal notation of URLs.

Software can process a piece of XML in accordance with the XML specification
by consulting the encoding declaration in the XML document itself and optionally
the appropriate DTDs or schemas, if rigorous checking or analysis is required.
The processing software does not need to check with the XML producer (p.1).

In particular, one specific producer (Aptara ) of an application that manipulates

XML code called PowerXEditor (PXE), has been used by publishing industries. The
benefit of this software is that the publishers can upload, edit and revise elements of the
book. These elements can be the look of and feel of the text, figures, tables, or any other
unique aspects of that text. The book is then sent to a paging program where the book is
printed. This is all done in digital format, and the application is accessed through a
browser via the internet, allowing anytime access, to all parties involved; Please reference
appendix 1 for a similar example of the code and its output.
Due to the benefits provided by Grid Computing, numerous commercialization
efforts have been extended across industries to support this effort. The benefits incorporated
from Grid Computing include Fallenstein.C, & Joseph, J.(2004);

Page 3
 Grid Computing and XML

 Acceleration of implementation time frames in order to intersect with the

anticipated business end results.
 Improved productivity and collaboration of virtual organizations and respective
computing and data resources.

 Allowing widely dispersed departments and businesses to create virtual

organizations to share data and resources.

 Robust and infinitely flexible and resilient operational infrastructures.

 Providing instantaneous access to massive computing and data resources.

 Leveraging existing capital expenditures investments, and operational expenditure

investments, which in turn help to ensure optimal utilization and costs of
computing capabilities.

 Avoiding common pitfalls of over provisioning and incurring excess costs.

(p. 1)
Increased internet access has fueled many technological advances, and as internet access
increases, along with the use of mobile devices, both Grid Computing and the usage of XML
enabled documents, will continue to expand. According to Morley. M, (2010),
Thirdly, the use of XML based document standards in 2010 is likely to grow
much faster in emerging markets than in other countries around the world. There
have been a couple of false starts with regards to XML adoption levels in China.
For example and in a 2007 survey by the Odette automotive industry association
found that many companies would continue to use a hybrid of western EDIFACT
and home grown XML based EDI document standards. The influx of western
companies into these regions in recent years is helping to educate these businesses
of the importance of using standards to exchange B2B related documents.  As
companies get a better understanding of the use of the EDIFACT standards and
how EDI documents are structured, I would expect more XML document
standards to be created.  These countries typically have thousands of very bright
university graduates who will be able to develop new XML based document
standards with ease. Combined with the growth in the use of hosted or internet

Page 4
 Grid Computing and XML

based B2B standards I believe that 2010 will start to see an increased level of
interest in developing new internet based XML standards for B2B document
exchange.

From the research presented in this paper Grid Computing, makes things easier and
cheaper. This appears to be the case with XML too. Grid Computing has made a breakthrough in
the Medical Research arena. Through Grid Computing hardware costs are cut, through the
utilization of idle systems. This type of computing is reaching out across industries and continues
to grow as demand increases.
XML documents allow content to be delivered more flexibly and at a lower cost. This
gives companies like publishers the ability to print their products quickly and to get them to
market much sooner.
To reiterate my previous statement, it’s plain and clear that increased internet access has
fueled many technological advances, and as internet access increases, along with the use of
mobile devices, both Grid Computing and the usage of XML enabled documents, will continue
to expand.

Page 5
Grid Computing and XML

References

Fallenstein, C, & Joseph, J.(2004).Introduction to Grid Computing Retrieved September

14, 2010 from;
http://www.informit.com/articles/article.aspx?p=169508&seqNum=3

Malaika. S, (2002) Meet The Experts: Susan Malaika on XML Standards and Grid
Computing. Retrieved September 14, 2010 from;

http://www.ibm.com/developerworks/data/library/techarticle/0211malaika/0211m

alaika.html

Morley. M, (2010) B2B e-Commerce from 2010-2020 Retrieved September 14,

2010 from;
http://www.gxs.com/resources/thought_leadership/next10years/b2b_on_emerging
_markets.htm

O’Brien, J. & Marakas, G. (2010) Introduction to information systems 15th addition

Patrizio. A, (2010) IBM Volunteers Help Locate Anti-Cancer Drugs Retrieved September

14, 2010 from;

http://www.cioupdate.com/news/article.php/3888281/IBM-Volunteers-Help-
Locate-Anti-Cancer-Drugs

Page 6
 Grid Computing and XML

Appendix

Appendix 1

flow of the program through the BPEL components:

BPEL Logical Flow Diagram

The logical flow of the program is:

1. The JMSClient, through ActiveMQConnectionFactory, connects to the topic named
"demo.org.servicemix.source" and sends a text message containing the message.soap file.
2. myComponent, being a subscriber of the topic "demo.org.servicemix.source," receives the message.
3. The myComponent implementation class, JmsServiceComponent, sends the message over the
ServiceMix bus to the PxeBpelEngine by executing its onMessage() method. The destinationService
property defines the destination of the message. NOTE: the destinationService property is found in
the servicemix.xml file.
4. PxeBpelEngine sends a response back to myComponent through the ServiceMix bus,
the NMR.
5. myComponent uses the jmsTemplate bean to publish the message.

Page 7
Grid Computing and XML

Component or Description
Bean ID
jbi 6. jbi is the "id" of the JBI container and provides the basic infrastructure
services for myComponent. During initialization, several singletons are
instantiated: transactionManager, broker, jmsFactory, and jbi. Also, take
note of the properties installationDirPath and deploymentDirPath defined
in servicemix.xml. ServiceMix automatically installs components found in
jmsTemplate uses the jmsFactory bean to get a connection to the port
associated with the JMS topic called "demo.org.servicemix.source." The
message is published on the "demo.org.servicemix.source" topic.
7. JMSClient, being a subscriber of topic "demo.org.servicemix.source,"
receives the message.
8. The response is printed on the console.
Typical output looks like the following:
ServiceMix ESB: 1.0

Loading ServiceMix from file: servicemix.xml

[INFO] XmlBeanDefinitionReader - -Loading XML bean definitions from
file C:\exist\servicemix\servicemix-1.0.1\examples\bpel\servicemix.xml]
[INFO] CollectionFactory - -JDK 1.4+ collections available
[INFO] CollectionFactory - -Commons Collections 3.x available
[INFO] FileSystemXmlApplicationContext - -Bean factory for application
context
[org.springframework.context.support.FileSystemXmlApplicationContext;h
ashCode=110
2920]:
org.springframework.beans.factory.support.DefaultListableBeanFactory
defining beans
[jndi,broker,transactionManager,jmsFactory,jbi];
root of BeanFactory hierarchy[INFO] FileSystemXmlApplicationContext -
-5 beans defined in application context

[org.springframework.context.support.FileSystemXmlApplicationContext;h
ashCode=1102920]
[INFO] FileSystemXmlApplicationContext - -Unable to locate
MessageSource with name 'messageSource': using default
[org.springframework.context.support.DelegatingMessageSource@18e2b22
]
[INFO] FileSystemXmlApplicationContext - -Unable to locate
ApplicationEventMulticaster with name 'applicationEventMulticaster':
using default
[org.springframework.context.event.SimpleApplicationEventMulticaster@1
3caecd]
[INFO] DefaultListableBeanFactory - -Pre-instantiating singletons in
factory
[org.springframework.beans.factory.support.DefaultListableBeanFactory
defining beans [jndi,broker,transactionManager,jmsFactory,jbi]; root of
BeanFactory hierarchy]
[INFO] DefaultListableBeanFactory - -Creating shared instance of singleton
bean'jndi'
[INFO] DefaultListableBeanFactory - -Creating shared instance of singleton
bean 'broker'

Page 8
Grid Computing and XML

[INFO] SpringBrokerContainerFactory - -Loading ActiveMQ broker from

configuration: class path resource [activemq.xml]
[INFO] ActiveMQBeanDefinitionReader - -Loading XML bean definitions
from class path resource [activemq.xml]
[INFO] ActiveMQBeanFactory - -Creating shared instance of singleton
bean 'broker'
[INFO] ActiveMQBeanFactory - -Creating shared instance of singleton
bean 'memoryManager'
[INFO] ActiveMQBeanFactory - -Creating shared instance of singleton
bean 'derby-ds'
[INFO] ActiveMQBeanFactory - -Creating shared instance of singleton
bean 'mysql-ds'
[INFO] BrokerContainerImpl - -ActiveMQ 3.1-M6 JMS Message Broker
(ID:el2tong-1095-1129854563062-0:0) is starting
[INFO] BrokerContainerImpl - -For help or more information please see:
http://www.logicblaze.com
[INFO] JDBCPersistenceAdapter - -Database driver recognized:
[apache_derby_embedded_jdbc_driver]
[INFO] DefaultJDBCAdapter - -Could not create JDBC tables; they could
already exist. Failure was:
CREATE TABLE ACTIVEMQ_MSGS(ID INTEGER NOT NULL,
CONTAINER VARCHAR(250), MSGID VARCHAR(250), MSG BLOB,
PRIMARY KEY ( ID ) )
Message: Table/View 'ACTIVEMQ_MSGS' already exists in Schema 'APP'.
SQLState: X0Y32 Vendor code: 20000
[INFO] DefaultJDBCAdapter - -Could not create JDBC tables; they could
already exist. Failure was:
CREATE TABLE ACTIVEMQ_TXS(XID VARCHAR(250) NOT NULL,
PRIMARY KEY ( XID )) Message: Table/View 'ACTIVEMQ_TXS' already
exists in Schema 'APP'. SQLState: X0Y32 Vendor code: 20000
[INFO] DefaultJDBCAdapter - -Could not create JDBC tables; they could
already exist. Failure was:
CREATE TABLE ACTIVEMQ_ACKS(SUB VARCHAR(250) NOT NULL,
CONTAINER VARCHAR(250) NOT NULL, LAST_ACKED_ID
INTEGER, SE_ID INTEGER,
SE_CLIENT_ID VARCHAR(250), SE_CONSUMER_NAME
VARCHAR(250), SE_SELECTOR VARCHAR(250), PRIMARY KEY (
SUB, CONTAINER )) Message: Table/View 'ACTIVEMQ_ACKS' already
exists in Schema 'APP'. SQLState: X0Y32 Vendor code: 20000
[INFO] DefaultJDBCAdapter - -Could not create JDBC tables; they could
already exist. Failure was:
ALTER TABLE ACTIVEMQ_MSGS ADD EXPIRATION BIGINT
Message: Column 'EXPIRATION' already exists in Table/View
'APP.ACTIVEMQ_MSGS'. SQLState: X0Y32 Vendor code: 20000
[INFO] JournalPersistenceAdapter - -Opening journal.
[INFO] JournalPersistenceAdapter - -Opened journal: Active Journal:
using 2 x 20.0 Megs at: ..\var\journal
[INFO] JournalPersistenceAdapter - -Journal Recovery Started.
[INFO] JournalPersistenceAdapter - -Journal Recovered: 0 message(s) in
transactions recovered.
[INFO] TcpTransportServerChannel - -Listening for connections at:
tcp://el2tong:61616
[INFO] BrokerConnectorImpl - -ActiveMQ connector started:

Page 9
Grid Computing and XML

TcpTransportServerChannel@tcp://el2tong:61616
[INFO] BrokerContainerImpl - -ActiveMQ JMS Message Broker
(ID:el2tong-1095-1129854563062-0:0) has started
[INFO] DefaultListableBeanFactory - -Creating shared instance of singleton
bean 'transactionManager'
[INFO] DefaultListableBeanFactory - -Creating shared instance of singleton
bean 'jmsFactory'
[INFO] DefaultListableBeanFactory - -Creating shared instance of singleton
bean 'jbi'
[INFO] ActiveMQConnection - -channel status changed: Channel:
TcpTransportChannel:
Socket[addr=localhost/127.0.0.1,port=61616,localport=1096] has connected
[INFO] BrokerContainerImpl - -Adding new client: ID:el2tong-1095-
1129854563062-5:0 on transport: TcpTransportChannel:
Socket[addr=/127.0.0.1,port=1096,localport=61616]
[INFO] JBIContainer - -ServiceMix JBI Container (http://servicemix.org/)
name: defaultJBI running version: ServiceMix.
[INFO] JBIContainer - -Activating component for:
[container=defaultJBI,name=myComponent,id=myComponent]
with service: {uri:fivesight.com/examples/AsyncProcessJBI}JmsService
component:
org.servicemix.components.jms.JmsServiceComponent@1b82d69
[INFO] ComponentContextImpl - -Component: myComponent activated
endpoint: {uri:fivesight.com/examples/AsyncProcessJBI}JmsService :
myComponent
Details
The following table provides more details about the function of each
component and bean in the servicemix.xml file:
the folder specified in the installationDirPath property. It automatically
deploys component-specific artifacts found in the folder specified in the
deploymentDirPath property.
JMSClient This Java standalone program, through the ActiveMQConnectionFactory,
connects to topic "demo.org.servicemix.source." It then creates a text
message from the file message.soap and publishes it to the topic
"demo.org.servicemix.source," then requests and waits for a response. It
eventually prints the response to the console.
myComponent This JMS service component subscribes to the
"demo.org.servicemix.source" topic via its defaultDestinationName
property specified in the servicemix.xml configuration file. Through its
template property, it uses jmsFactory to listen on port 61616 via
ActiveMQConnectionFactory. It is implemented by the
JmsServiceComponent that has an onMessage() method which is called by
ActiveMQ when a message arrives on the topic. This method creates a
normalized message, which is sent over the ServiceMix bus to the
PxeBpelEngine as specified on its destinationService property.
jndi This bean loads up database and transaction manager resources, which will
be used by the other components in the system. More importantly, the JNDI
context must be configured so that PXE can be deployed.
Pxe-install.jar This jarfile is located in the examples\bpel\install directory. It contains
many files, which in turn contain the classes that implement the PXE BPEL

Page
10
Grid Computing and XML

engine. It also has a jbi.xml file, which is used by ServiceMix to install the
PXE BPEL engine as a ServiceMix service-engine component. Note, that in
this file the component type is "service-engine" and the component name is
PxeBpelEngine. When processes are deployed to the PXE engine (see next
row with AsyncProcess-sa.jar), it exposes them as services on the JBI, which
can be referenced by other components as destinationService(s), with
destinationEnpoint(s) - see the servicemix.xml file.
AsyncProcess- This jarfile is located in the examples\bpel\deploy directory. It contains a
sa.jar jbi.xml file, which references the PxeBpelEngine. This ties the processes to
the PXE engine described in the previous section. The jbi.xml file also
references the AsyncProcess-su.zip file, which is also contained in the
AsycnProcess-sa.jar file. This zipfile contains other configuration files and
WSDL files, i.e., pxe-system.xml and resource_X.stream, which describe the
services deployed on the PXE engine.
broker The broker bean uses the activemq.xml file to configure the message broker,
which handles the JMS messages for the components that require JMS
messaging services.
transactionMa This bean is configured to be the default transaction manager for the jbi
nager container. This transaction manager provides transactional services
between the resource adapter (in this case the ActiveMQ resource adapter
provided by the jencks JCA container) and components in the jbi container.
jmsFactory This bean listens on port 61616 and provides a pooled ActiveMQ
connection.

Page
11