FORMI: An RMI Extension for Adaptive Applications R¨ udiger Kapitza Dept. of Comp. Sciences Informatik 4 University of Erlangen-Nürnberg Germany rrkapitz@cs.fau.de Michael Kirstein Holger Schmidt Franz J. Hauck Distributed Systems Laboratory University of Ulm Germany formi@kirstein-michael.de {holger.schmidt,franz.hauck}@ uni-ulm.de ABSTRACT RMI is a well-known middleware that smoothly integrates into Java. RMI uses classical RPC-based client-server inter- action, precisely remote method calls. Although RMI has several extension points (i.e., for replacing transport proto- cols and call semantics), this is not enough for many appli- cations as it can not cope with non-RPC-based communi- cation, fault tolerance, scalability, and quality-of-service in general. We present FORMI, an RMI extension for support- ing the very flexible fragmented-object model. This model allows to build distributed objects with arbitrary internal communication protocols and interaction patterns (e.g., in- ternal peer-to-peer communication) and with a truly dis- tributed internal structure (e.g., replicated servers, smart proxies, hierarchical servers). Both, internal communica- tion and structure, remains hidden behind the RMI-object interface and is thus transparent to clients. We demonstrate our approach by an Internet radio example. Categories and Subject Descriptors C.2.4 [Computer Communication Networks]: Distributed Systems—Distributed applications ; D.2.12b [Software]: Soft- ware Engineering Interoperability[Distributed objects]; D.3.3.h [Programming Languages]: Language Constructs and Features—Distributed objects, components, containers General Terms Design Keywords Java RMI, Fragmented Objects, Adaptability Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. RM’05, November 28– December 2, 2005, Grenoble, France Copyright 2005 ACM 1-59593-270-4/05/11 ...$5.00. 1. INTRODUCTION Distributed object-oriented applications are commonly im- plemented on top of popular middleware platforms like CORBA, .Net-Remoting or Java Remote Method Invoca- tion (RMI). These platforms aim at simplifying the develop- ment and the execution of client-server–based applications. Whereas this is sufficient for most distributed applications based on the traditional client-server approach, there is a ris- ing number of applications demanding for fault-tolerance, high availability, shorter response times, and many more so-called non-functional requirements. Fault tolerance and availability have been addressed by introducing the object group paradigm [1]: A server object is replicated among a group of objects that are kept consistent via a group com- munication protocol. Clients interact transparently with the replicated object using group proxies. Unlike CORBA, which provides a special extension called FT-CORBA [2], this is left open in the Java RMI specification. Instead, the RMI framework provides extension points to implement new call semantics and transport protocols. Various research projects [3, 4] have used these extension points to integrate the object group paradigm into RMI. Fault tolerance and availability are, however, only two of many extended de- mands of recent distributed applications. Furthermore, the proposed solutions usually introduce a restricted set of pro- tocols and patterns of the possible internal structure. Exist- ing extensions do not provide any way to generically adapt the interaction pattern and the internal structure of dis- tributed objects to the application’s needs. A fragmented-object model as proposed by Shapiro [5] can meet the expected flexibility. It is far more generic and flexible than the traditional client-server approach or the object group paradigm. A fragmented object is a truly dis- tributed object that can be arbitrarily partitioned. Parts of the object—named fragments—may exist on different nodes and provide the object’s interface. Unlike RMI and most other middleware systems that use a stub-skeleton–based architecture in combination with an RPC-based protocol, accessing a fragmented object presumes the existence of a local fragment. This can act as a proxy supporting an- other fragment’s functionality, but may also contain local functionality. This principle can increase the application’s performance since in some cases no remote call is needed. Article 2