Grid application frameworks have increasingly aligned themselves with the developments in Web Services. Web Services are currently the most popular infrastructure based on Service Oriented Architecture (SOA) paradigm.
There are three core areas within the SOA framework: a set of capabilities that are remotely accessible, communications using messages, and metadata pertaining to the aforementioned capabilities. In this paper, we focus on issues related to the messaging substrate hosting these services; we base these discussions on the NaradaBrokering system. We outline strategies to leverage capabilities available within the substrate without the need to make any changes to the service implementations themselves. We also identify the set of services needed to build Grids of Grids. Finally, we discuss another technology, HPSearch, which facilitates the administration of the substrate and the deployment of applications via a scripting interface. These issues have direct relevance to scientific Gridapplications, which need to go beyond remote procedure calls in client-server interactions to support integrated distributed applications that couple databases, high performance computing codes, and visualization codes.
A Semantic Web Based Approach to
Knowledge Management for GridApplications
L. Chen, N.R. Shadbolt and C.A. Goble
Abstract—Knowledge has become increasingly important to support intelligent process automation and collaborative problem solving in large-scale science over the Internet. This paper addresses distributed knowledge management, its approach and methodology, in the context of Grid application. We start by analysing the nature of Grid computing and its requirements for knowledge support; then we discuss knowledge characteristics and the challenges for knowledge management on the Grid. A Semantic Web based approach is proposed to tackle the six challenges of the knowledge lifecycle – namely, those of acquiring, modelling, retrieving, reusing, publishing and maintaining knowledge. To facilitate the application of the approach, a systematic methodology is conceived and designed to provide a general implementation guideline. We use a real world Grid application, the GEODISE project, as a case study in which the core Semantic Web technologies such as ontologies, semantic enrichment and semantic reasoning are used for knowledge engineering and management. The case study has been fully implemented and deployed through which the evaluation and validation for the approach and methodology have been performed.
component. Process Creation: this component is used to initiate computation on a resource once it has been located and allocated. The DataAccess component is responsible for providing high-sped remote access to persistent storage on disk. The Globus philosophy is not to provide high level functionality, but to develop middleware that can be used as the base for developing a more complex infrastructure on top. In  two services of the Globus Toolkit are introduced that, according to the authors of , are fundamental for Data Grids: secure, reliable, and efficient data transfer and the ability to register, locate and manage multiple copies of data sets. For the efficient high speed data transfer, the GridFTP  is responsible, an extension of the popular FTP with additional features that are required by Gridapplications. The replica management service integrates a replica catalog with the GridFTP transport to provide the creation, registration and management of data sets. The catalog contains three types of objects: The highest level object is the collection, a group of logical file names. A location object contains the information required to map between one logical filename and, possibly several, physical locations of the associated replicas. The third object is a logical file entry. This optional entry can be used to store attribute-value pair information for individual logical files. The operations that can be performed on the catalog are as follows: creation and deletion of collections, locations, and logical file entries; insertion and removal of logical file names into collections and locations; listing of the contents of collections and locations; and listing physical locations of a logical file.
8.1. Deployment of the federation module
To facilitate incremental addition of capabilities to service endpoints one can also configure filters (examples include filters for encryption, compression, logging etc.) in the processing path between the service endpoints. Since the service endpoints communicate using SOAP messages these filters operate on SOAP messages. Several of these filters can be cascaded to constitute a filter pipeline. In Java these filters are referred to as JAX-RPC handlers, in gSOAP they are referred to as plugins; while in Microsoft’s WSE these are referred to as filters. The federation module can be implemented as a filter and configured during the deployment phase of the service in question. Note that this filter strategy while not entail any changes to the service implementations and applications using either specifications. Another deployment strategy is to implement the federation as a proxy, which receives messages and routes mapped messages appropriately.
Xydra-Ontobrew provides an automatic solution to the portlet client generation problem for simple services. However, for Gridapplications that are to be presented to the scientific users, it is often desirable to build a custom interface that is richer in its interactive features. The natural solution is to build a custom client for the service that can be loaded dynamically from the service. There are a few small problems to solve. How does the portal know if a service has a special, dynamically loadable interface? And, if it has one, where is it located?
Community Grids Lab, Indiana University.
As Web Services have matured the interactions that the services have between themselves have gotten increasingly complex and sophisticated. Web services can be composed easily from other services, and these services can be made to orchestrate with each other in dynamic fashion. As web services have become dominant in the Internet and Grid systems landscape, a need to ensure guaranteed delivery of interactions (encapsulated in messages) between services has become increasingly important. In this paper we describe our work with the WSRM specification. Here we describe our support of WSRM and also include an empirical evaluation of the various facets of this specification. We believe this would be very useful for system designers who intend to incorporate support for reliable messaging within their Gridapplications.
Distributed object systems have tended to focus on remote method invocations (the object-oriented equivalent of remote procedure calls). The remote object is intended to be used as if it were a local object: developers program their applications using client stubs that can be treated as local programming objects, but which must in reality make remote calls to the “real” object, often blocking until the method returns. This approach is suitable for tightly coupled environments like enterprise intranets, but it does not scale well to the loosely coupled situation seen, for example, in most Gridapplications that need to run in several different, autonomous locations. SOAs instead focus on the message itself, rather than its invocation. Since interactions are normally stateless, message traffic between two components is assumed to be decoupled.
WSRM provides an XML schema for elements needed to support the reliable messaging framework. The specification provides a SOAP binding for the protocol.
Is a SOAP based protocol, which has an HTTP binding which facilitates acknowledgements and faults to be issued over HTTP responses.
To facilitate incremental addition of capabilities to service endpoints one can also configure filters (examples include filters for encryption, compression, logging etc.) in the processing path between the service endpoints. Since the service endpoints communicate using SOAP messages these filters operate on SOAP messages. Several of these filters can be cascaded to constitute a filter pipeline. Services are generally hosted within a hosting environment also known as a container. The container provides a variety of services which the service implementation can use. For example, a service implementation need not worry about communication details since this necessary functionality would be implemented within a container component such as servlets in the Java J2EE environment. This component in tandem with the container support classes is responsible for packaging data received over the wire into data structures that can be processed by the service implementation. An instance of the web component is typically automatically generated by the container during the deployment phase of the Web Service. This scenario is depicted in Figure 1. It is possible to deploy services without a container. In the simplest case one may simply use the TCP protocol for communications and reconstruct SOAP messages from byte packets received over a socket; a custom deployment component can used to configure filter pipelines.
KEYWORDS: Messaging middleware, Web Services Management, Fault tolerance
Management in distributed systems has gained much importance in recent years. With the increasing complexity of applications, there is a need for effective management of components of the application. Management usually involves common operations such as the ability to control the resource (e.g. start, stop), ability to configure the resource for a specific task and monitor the status (e.g. heartbeat) of the resource. The Web Service community has recently introduced two competing specifications, namely, WS-Management  and WS-Distributed Management  for service-oriented management. The key idea inherent to both these specifications is modeling manageable resources as Web Service endpoints and managing these services by sending an appropriate message to this endpoint. In heterogeneous environment, the ability to manage a resource is restricted by presence of network address translation devices, firewalls and restricted transports. In this paper we address issues related to management and show how we can make management scalable, fault-tolerant.
– During CrossGrid there has been success, if Grid was unloaded – Short responce time, requires low-latency, QoS
– In the future we may be able to pause-reanimate jobs on demand – Necessary feature to support Urgent Computing (EQ, floods, fires) – Middleware has to evolve further, in order to support them well
Lessons from SVG Web Service
keeps the Graphics version of DOM that interfaces with Java2D on client; client captures raw user interface events inside SVG frame; client captures some semantic events (zoom, change URL) in menu-bar
After representing the overall flow, we identify processing steps that have the greatest impact on performance and add details for them. For example, a database query, particularly on a remote computer, usually has a far greater impact on response time and scalability than firewall processing. We also include specific details for processing steps that correspond to the software architecture alternatives we are evaluating. That is, if we want to compare the performance of two alternatives, such as client vs. server processing for form validation, we must represent the processing steps required for form validation in the model. Next we convert the sequence diagrams into a software execution model, add performance specifications, and solve the software execution model to determine the end-to-end response time (without contention delays). The software execution model often identifies problems with Webapplications, particularly when they need to transfer large amounts of data over relatively slow communication lines. After selecting a software architecture alternative that meets performance objectives, we use the system execution model to evaluate technical architecture alternatives and software scalability and capacity requirements.
With a WebMessaging architecture, there are no web servers or web server applications that need to be implemented, deployed and managed other than to serve static content. All application communication uses only a Solace messaging fabric as infrastructure.
Applications address request messages to a well-known topic which identifies the service of interest rather than to a well-known URL which must then be translated by a web server to an internal application name or bridged to an internal messaging system. Messages are sent using the Solace sendRequest() API method rather than using XHR. The reply, along with the associated context for the original request, is returned in a callback or delegate function provided by the application.
The focus on business processes in GRIA provides the key distinguishing feature compared with other Grid middleware platforms, together with the business-orientated approach to trust and authentication. This business emphasis is the key defining feature: commercial business practices have evolved and been refined over many years and are widely understood. By adopting these practices as the starting point for the architectural design, it becomes inherently easier to deploy the GRIA software into existing businesses – both at the technical level and also at the even-more-important cultural and political level.
Abstract— A Web services-based publish/subscribe system has the potential to create an Internet scale interoperable event notification system which is important for Grid computing as it evolves a service-oriented architecture. WS- Messenger is designed to be a Web services-based message broker that can decouple event producers and event consumers and achieve scalable, reliable and efficient message delivery. In this paper, we discuss some challenges that are unique to Web services-based publish/subscribe systems and the key features that distinguish WS-Messenger from other existing message brokers. We then present the architecture and the technology used in WS-Messenger. Performance tests indicate WS-Messenger performs better than the WS- Notification implementation in Globus Toolkit 4 (GT4) and it can be used as a complement to GT4 to improve its scalability.
■ Loading BIRT visualizations into different DIV elements of the web page When the web application first loads, it authenticates with the iHub server and retrieves a JSON formatted list of region and state names.
After using REST API to extract location names from a BIRT data object, this application builds navigation links. When a user selects a link, the REST API generates a report for the selected location if a valid one does not already exist.