Many modern enterprise applications follow the three-tier architecture. Typical three-tier systems have some nice properties: clients are thin, application states are stored in a database, and the middle servers are stateless. This makes three-tier systems well scalable and manageable. However, it is challenging to implement end-to-end reliable and safe transactions for such applications without violating their nice properties. We present a pragmatic end-to-end transaction protocol which ensures that every issued request will be processed exactly-once by the server(s). The idea is to use client log-based recovery and application server replication. The application server remains stateless; all replicas play the same role and can serve client requests. Therefore, the system is well scalable and the failover is fast.
We present a preliminary proposal towards a CORBA domain facility for e-learning. This proposal may be seen as an initial contribution to the definition of an object-oriented distributed architecture for this domain. E-learning is one of the killer applications in the new information society. Many e-learning systems have been developed, targeted to specific learning scenarios and execution environments. In most cases, properties like interoperability or scalability were not taken into consideration when developing these applications, and as a consequence, systems with similar functionalities were developed again and again. To address this problem, two actions are possible: the standardization of this domain, and the definition of reference models and architectures that facilitate software reuse and the development of scalable and interoperable systems. These two actions complement each other, and our proposal is based on available results from the e-learning standardization process
Middleware mediated transactions (MMT) integrate message-oriented transactions and distributed object transactions. MMT are suggested as an evolutionary and integrative approach to support reliable and flexible interactions between heterogeneous and autonomous components, which is a major challenge in enterprise application integration. MMT offer the ability to combine communication of messages and notifications with conventional transactional object requests. Thus MMT introduce the flexibility of mediated interactions with respect to topology, binding, time-dependencies and content transformation into distributed object transactions. MMT are characterized by coupling modes to control if notifications become visible immediately or are dependent on the transaction status, to include mediators as transaction participants, and to distinguish between message delivery and processing, as well as vital and non-vital participants. Furthermore, coupling modes interrelate different distributed transaction contexts of publishers and subscribers. This paper introduces the concept of MMT and presents two system prototypes implementing MMT, the dependency-spheres middleware service and the X/sup 2/ TS middleware service.
Service providers are looking to computer vendors to provide low-cost, scalable faulttolerant solutions. The prime requirement is to minimise reliance on specialist equipment and techniques for delivering core services. Indeed, an ideal solution would make use of ‘standard’' middleware services (e.g., CORBA services for persistence, transactions etc.). Research results on distributed objects and software implemented fault-tolerance techniques hold the promise of providing such solutions. However, the task of constructing such solutions using general-purpose, low cost components, such as commodity UNIX servers, middleware services etc. is extremely challenging. The central problem is that any software implemented distributed fault-tolerance technique consumes resources (a combination of network bandwidth, processing power and disk storage) that otherwise would be available for normal use. Thus software implemented distributed fault-tolerance techniques must be applied with care. In this tutorial, we will cover basic principles of software implemented fault-tolerance techniques and discuss their application in the construction of reliable distributed applications. Emphasis will be placed on applications in the Internet/Web domain. Mark Little is a Distinguished Engineer/Architect, within HP Arjuna Labs., Newcastle upon Tyne,England, where he leads the Total-e-Transactions team. He joined HP via a series of company acquisitions: Bluestone Software, Arjuna Solutions, of which he was one of the founders. Before joining Arjuna Solutions he was for over 10 years a member of the Arjuna team within the University of Newcastle upon Tyne (where he continues to have a Visiting Fellowship). His research within the Arjuna team included replication and transactions support, which include the construction of an OTS/JTS compliant transaction processing system. Santosh Shrivastava was appointed a Professor of Computing Science, University of Newcastle upon Tyne in 1986; he leads the Distributed Systems Research Group. He received his Ph.D. in computing science from Cambridge in 1975. His research interests are in the areas of distributed systems, real-time systems, fault tolerance and application of transaction and workflow technologies to e-commerce. His group is well known as the developers of an innovative distributed transaction system, called Arjuna and a CORBA based dependable workflow system for the Internet. Together with his colleagues he set Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE up Arjuna Solutions Ltd in 1998 in Newcastle to productise Arjuna transaction and workflow technologies. The company is now part of Hewlett-Packard. Stuart Wheater is a Distinguished Engineer/Architect, within HP Arjuna Labs., Newcastle upon Tyne, England. He joined HP via a series of company acquisitions: Bluestone Software, Arjuna Solutions, of which he was one of the founders. Before joining Arjuna Solutions he was for over 10 years a member of the Arjuna team within the University of Newcastle upon Tyne (where he continues to have a Visiting Fellowship). His research within the Arjuna team included transactions and long-lived process support, which includes the construction of a CORBA based transactional workflow system. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE
There are many challenges in devising solutions for online content processing of live networked multimedia sessions. These include content analysis under uncertainty (evidence of content are missed or hallucinated), the computational complexity of feature extraction and object recognition, and the massive amount of data to be analyzed under real-time requirements. In this paper we focus on middleware supporting online media content analysis. Our middleware supports processing, logically organized as a hierarchy of refined events extracted in real time from a set of potentially related time-based media streams. The processing can physically be distributed and redistributed during run time, as a set of interacting components, each performing some content analysis algorithm. The middleware is designed with reuseability, scalability, performance, resource management, and fault tolerance in mind by providing support for mechanisms such as, adaptation, reconfiguration, migration, and replication. The goal is to support applications in trading off the reliability and latency of the content analysis against the available computing resources.
Adaptation of distributed software to maintain the best possible application performance in the face of changes in available resources is an increasingly important and complex problem. We discuss the application of the QuO adaptive middleware framework and the CORBA A/V streaming service to the development of real-time embedded applications. We demonstrate a standards-based middleware platform for developing adaptive applications that are better architectured and easier to modify and that can adapt to changes in resource availability to meet QoS requirements. These are presented in the context of a video distribution application to an unmanned aerial vehicle. The application is developed using QuO and the AN streaming service, and uses adaptive behavior to meet timeliness requirements in the face of restrictions in processing power and network bandwidth. We present experimental results we have gathered for this application
Middleware helps to integrate software that has to be written on different systems and in different programming languages -middleware helps to bridge software boundaries. For many reasons there are now many different forms of middleware. Sometimes there is a natural choice of which to choose, while in other cases the choice comes down to personal or company preferences. This tutorial positions the most popular forms of middleware, discussing the programming model, flexibilities, strengths and weaknesses of each. CORBA is explained first, in part because it was the first standardized and popular form of high level middleware, and in part because its scope encompasses the programming models of many other forms of middleware. Nevertheless, none of the middleware approaches is held to be preferred, instead each is presented with it's own strengths and weaknesses. CORBA concepts such as IDL, IORs, etc, are briefly explained, as well as flexibility aspects such as the POA, and quality of service aspects such as transactions, security, store and forward, and so on. Some design patterns are presented to guide typical usages. General middleware scalability implications are discussed, including performance, load balancing, fault tolerance, connection management, and so on. Once this basis is set, other middleware solutions are introduced, including J2EE (including EJB distributed objects); web services (the latest kid on the middleware block); integration services (where message passing, routing, transformations and adapters are the key concepts); B2B middleware (which has to cater for web standards but also established and new standards such as EDI, Rosettenet and ebXML).The sum of the middleware selected will allow integration inside a company's systems, between companies, and across firewalls, that is across the edge of the network. Case studies form an important part of the tutorial. Sean Baker is a founder of IONA Technologies. His original experience in distributed computing was gained as a faculty member in the Distributed Systems Group, Department of Computer Science, Trinity College Dublin. Within Trinity, he worked on many projects, designing and implementing support environments for distributed object systems, and also their relationships to databases and persistence in general. In 1991 he co-founded IONA Technologies to exploit this experience. Sean is IONA’s Chief Technology Officer, and is responsible for IONA’s product vision. He also manages a small group of senior architects that ensure the consistency of our overall Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE product range and foster innovation throughout the company. Sean is the author of “CORBA Distributed Objects” published by Addison Wesley Longman and ACM Press. He is co-author of “CORBA Fundamentals and Programming”, published by Wiley. Before joining IONA in 1995, Declan O’Sullivan worked for Broadcom Eireann Research on projects studying the applicability of advanced information technologies to the telecoms industry within network services (e.g. Intelligent Networks) and within management systems (e.g. TMN). During this time he was an active participant in European research projects such as RACE and Eurescom. Within IONA, Declan has been responsible for studying and championing the use of middleware products within the telecoms industry, and has also coordinated IONA involvement within several European research ACTS projects. Declan holds BA (Mod.) and MSc degrees in computer science from Trinity College Dublin. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE
The industry is rapidly moving towards adopting a model called "XML Web services" to provide a standard infrastructure for loosely-coupled large-scale distributed systems. The infrastructure encompasses both flat data and objects; it is evolving and deploying rapidly on an international scale. This talk describes, often from a Microsoft-centric point of view, the vision, the challenges, and the products that will make the vision a reality. Jim Miller holds a PhD in Computer Science from MIT (Parallel Processing under Bert Halstead), and served on the faculty at Brandeis University as well as on the research staff at MIT (both the AI Lab and the Lab for Computer Science).He has been on the research staff at Digital Equipment Corporation and the Open Software Foundation.Before joining Microsoft, he was on the senior management team of the World Wide Web Consortium, reporting to Tim Berners-Lee and in charge of work on security, electronic commerce, child protection, privacy protection, accessibility, and intellectual property protection. He has joined Microsoft in 1998, leading the program management team for the kernel of the .NET Common Language Runtime. His responsibility includes garbage collection, metadata definition and file formats, intermediate language (IL) definition, IL-to-native code compilation, and remote objects.He also serves as editor for ECMA TC39/TG3, which is charged with creating an international standard for a Common Language Infrastructure. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE
The Global Change Master Directory (GCMD) is an earth science repository that specifically tracks research data on global climatic change. The GCMD is migrating from a centralized architecture to a globally distributed replicated heterogeneous federated system. One of the greatest challenges facing database research is the integration of heterogeneous systems without compromising the local autonomy, reliability and transparency of the various databases that are participating in the integration. This paper discusses these challenges in the context of the design and implementation of the next version of the GCMD software (Version 8.0). The proposed system has been designed and developed using an object-oriented system architecture based on Java, RMI (Remote Method Invocation) and JDBC. This system enables other sources to be integrated into the GCMD system, with limited changes to the local system itself. This paper describes the components of the GCMD system and addresses the issues of heterogeneity, distribution and autonomy.
The Eternal system provides CORBA applications with robust fault tolerance and the ability to be upgraded without a service interruption. The Eternal Evolution Manager handles both interface-preserving upgrades and interface-changing upgrades. The syntax and semantics of the application objects' IDL interfaces are unchanged by an interface-preserving upgrade. Interface-changing upgrades allow modification to one or more application object's IDL interfaces. Because modification to an object's IDL interface can affect clients of that object, an interface-changing upgrade requires coordinating the upgrade of multiple application objects at the same time
Explains our approach to help users graphically trace and control the behavior of distant objects in a knowledge-based system (KBS). This working context implies tackling several problems: numerous, varied and heterogeneous entities to distribute; dynamic and interactive communications; bi-directional control; and user-friendly means of expression. Our approach is based on an architecture using an existing tool (DICO*) that allows connecting distant heterogeneous objects through an interaction mechanism. We also offer two kinds of dedicated and extensible libraries of trace and control interactions. We have tested this approach in a prototype proving the advantages of these two libraries as well as those of DICO* to distribute KBSs. Our reified interaction service accommodates adaptive multi-access to a KBS without modifying its code.
In open distributed real-time and embedded (DRE) systems, different ORB endsystems may use different scheduling disciplines. To ensure appropriate end-to-end application behavior in an open architecture, DRE systems must enforce an ordering on activities originating in an endsystem and activities that migrate there, based on the relative importance of these activities. This paper describes the meta-programming techniques applied in Juno, which extends Real-time CORBA to enhance the openness of DRE systems with respect to their scheduling disciplines by enabling dynamic ordering of priority equivalence classes. We use the forthcoming OMG Real-Time CORBA 2.0: Dynamic Scheduling Joint Final Submission (RT-CORBA 2.0 JFS) to illustrate our techniques.
Objects are replicated in order to increase reliability and availability of an object-based system. We discuss how to invoke methods on replicas of objects in a nested manner. If a method t is invoked on multiple replicas and each instance of t on the replicas invokes a method u on another object y, u may be performed multiple times on some replica of y and then the replica gets inconsistent, i.e. redundant invocations. In addition, if each instance of t issues a request to a quorum, more of the replicas are manipulated than the quorum number of the method u, i.e. quorum explosion. We discuss an invocation protocol to resolve the redundant invocation and quorum explosion. We evaluate the protocol on how many replicas are manipulated and requests are issued
Mobile agents are a useful paradigm for the development of complex Internet applications. However, the effective development of mobile agent applications requires suitable models and infrastructures. This paper proposes an organizational approach to the design and development of mobile agent applications and describes an infrastructure designed to support such approach. The approach models the Internet as a multiplicity of local and active organizational contexts, intended as the places where coordination activities of application agents occur and are ruled. The MARS coordination infrastructure supports the development of mobile agent applications by implementing organizational contexts in terms of programmable tuple spaces. An application example related to the use of mobile agents to access and organize tourist information is introduced and discussed through the paper to clarify our approach and to show its effectiveness
This paper describes briefly the objectives, content, and usage of a real-time UML profile that has been standardized by the Object Management Group. This profile defines a common framework for describing the quantitative aspects of software systems. In addition, it provides specific facilities for analysing real-time systems for schedulability or performance.
We propose the Gateway Description Language (GDL) used to specify properties of media gateways. GDL describes the interfaces of a gateway, and the dependency between them. Gateways descriptions in GDL are used within a trading service to locate gateways, based on the properties of the gateway. This service can be used to automatically resolve incompatibly between heterogeneous participants in a multimedia binding. Based one the requirements of GDL and the trading service, a prototype is implemented using the trading service of CORBA, in order to evaluate the suitability of the CORBA trader for trading media gateways. The experiment shows that the CORBA trader has some shortcomings. This makes it necessary to introduce other entities to work in conjunction with the trader, to dynamically locate proper gateways for multimedia bindings.
This paper presents and discusses some infrastructure services necessary, for distributed applications development. The main service considered is the component search service which includes traditional naming and trading-like services. A number of studies have shown recently that current trading, based on interface type conformance, is insufficient for component-based applications. These studies have conclude that semantic information, describing especially the behavior of the component and its context dependencies, is required. This type of trading is called semantic trading. We address this problem and propose a component search service model based on semantic trading. Furthermore, we discuss the integration of the service in a deployment tool, through an enhanced deployment process early proposed by CORBA Component Model
Clients (user agents) on the World Wide Web vary greatly in computing power-from low-end WAP devices to high-end desktops even other servers as in a B2B scenario. It should be possible to build applications, which transparently adapt to the varying user agents. Most of the existing applications are written to execute only on the server without taking the computation power available on the client into account. We suggest a mechanism where an application can be written such that parts of the application can be executed either on the client side or on the server. This decision about which part of the code should be executed where can be taken at compile time or run time. This can either be under full user control or can be done automatically based on parameters like user agent type or server load. Applications of this type will allow loaded servers to transfer part of the load to clients to exploit the computing power available at client side
This paper describes a case study in the testing of distributed systems. The software under test is a middleware system developed in Java. The full test life cycle is examined including unit testing, integration testing, and system testing. Where possible, traditional tools and techniques are used to carry out the testing. One aspect where this is not possible is the testing of the low-level concurrency, which is often overlooked when testing commercial distributed systems, since the middleware or application server is already developed by a third-party and is assumed to operate correctly. This paper examines testing the middleware system itself, and therefore, a method for testing the concurrency properties of the system is used. The testing revealed a number of faults and design weaknesses, and showed that, with some adaptation, traditional tools and techniques go a long way in the testing of distributed applications
Using a middleware when designing a new distributed application allows portability across numerous software and hardware architectures, but introduces a new layer of potential incompatibilities due to the existence of various middleware standards. POLYORB, our generic middleware, directly addresses this problem: interoperability between distribution models. It can be customized into several "personalities" (e.g. CORBA, or RMI, or Ada 95 DSA), such as Jonathan and Quarterware. It also provides simultaneous support of multiple personalities within a single middleware instance. Software components implemented using a given distribution model may thus interact with remote entities from a different distribution model. This paper identifies the functions required to implement such a middleware and maps them on an operational design.
