Institut für
Technische Informatik und Kommunikationsnetze
SIRAMON: Service Provisioning Framework for Self-Organized Networks
Research Proposal
Károly Farkas, Bernhard Plattner
Computer Engineering and Networks Laboratory Swiss Federal Institute of Technology Gloriastrasse 35, 8092 Zurich, Switzerland
12th May 2004
Abstract
Self-organized networking (such as mobile ad-hoc or peer-to-peer networking) is an emerging and promis- ing communication paradigm. Not only the variety of devices but also the diversity of services introduced into these networks is continuously increasing. Such services must be provisioned in a flexible and distributed way without central infrastructure. Thus, service deployment and management for these dynamically appearing and disappearing devices are extremely difficult since a service provisioning framework must cope with the high level of heterogeneity, degree of mobility, and device resource limitations.
The contribution of this work is the development (design, implementation and analysis) of concepts and algorithms which may be used in the management of dynamic services in self-organized networks. Additionally, this work introduces a generic, decentralized service provisioning framework, called SIRAMON, for this self- organized environment. SIRAMON integrates and demonstrates the developed management concepts/algorithms and besides that it contains service specification, announcement/lookup, deployment and environment monitoring mechanisms to deal with the whole life-cycle of a service.
As the main focus of this work, we develop a management module which supports service maintenance, recon- figuration and termination in self-organized networks. Moreover, we provide a service description for complex, ad-hoc group services (e.g., a group game), and we adopt and integrate the mechanisms of the recent proposals for service announcement/lookup, deployment and environment monitoring into the framework.
1 Introduction
Self-organized (or often called also as ad-hoc) networks have been receiving much attention recently due to their immense field of application. An ad-hoc network is built of a collection of diverse nodes (users). These nodes form a multi-hop network communicating spontaneously without relying on any pre-existing infrastructure or central administration. In order to make an ad-hoc network functional, the nodes must organize themselves. That implies, that they not only provide terminal but also relaying functionalities for distant nodes. In such ad-hoc environments, efficient service provisioning is difficult to realize and requires flexible and distributed mechanisms. While the different applications and the great number of devices make them interesting, the lack of central infrastructure, the high level of heterogeneity, the degree of mobility and the resource constraints of devices make it hard to provide ad-hoc services.
Today two big types of self-organized networks are identified such as Peer-to-Peer networks (P2P) [1] and Mobile Ad-hoc NETworks (MANETs) [2]. In this work we focus on MANETs but the developed concepts and algorithms should be applicable in P2P networks, as well. So far, applications of MANETs have been envisioned mainly in the field of emergency and military situations. However, MANETs offer many more possibilities. We assume that mobile ad-hoc services will be introduced in the future into everyday life, and not just supporting work or daily activities but also giving pleasure in spare time. Hence, complex Mobile Ad-hoc Group (MAG) services1 will appear in MANETs soon. This assumption is supported by the lately published report on mobile entertainment2 and by the recently announced cooperation between SUN and NOKIA on new online multiplayer gaming solutions using Java technology3.
While new applications in MANETs will provide powerful environments for group-work or gaming, the com- plexity of service deployment and management in mobile ad-hoc networks demand for the support of a service provisioning framework. Traditional techniques for service provisioning used in communication and data net- works (Jini [3], UPnP [4], SDP [5], Chameleon [6], etc.) are not well suited for MANETs. First, they focus on a subset of service provisioning functionalities (e.g., resource discovery) only. And second, they are often based on the client-server model using a central, fixed infrastructure which is not available in a mobile ad-hoc network.
This work contributes to research by that it provides service management concepts and algorithms for ad-hoc services. Moreover, it introduces a generic service provisioning framework for self-organized environments, called SIRAMON (Service provIsioning fRAMework for self-Organized Networks), which integrates, demonstrates the developed management concepts/algorithms and provides mechanisms to deal with the whole life-cycle of a ser- vice. SIRAMON is based on a modular and distributed design. The single components of SIRAMON can be replaced according to specific demands which makes it possible to support different type of services. We introduce the following modules and definitions: (i) Service Specification; (ii) Service Indication; (iii) Service Deployment;
(iv) Service Management; (v) Environment Observer. The key to a Service Provisioning framework is the defini- tion of the Service. In this framework, the Service Specification defines the used Service Model which describes the role of the device in the service, and the functions and connections of service elements to build the service. The Service Indication is responsible for service announcement if the device hosts a service, or service lookup if the device intends to use a service. The Service Deployment module carries out the creation, installation and configu- ration of services. The Service Management component forms the main focus of our work controlling the service maintenance, reconfiguration and termination functions. And the Environment Observer deals with the monitoring of the device resources and the service context.
2 Related Work
Several proposals have been developed to standardize the functions of service announcement and service/resource lookup (e.g., Sun’s Jini [3], Microsoft’s Universal Plug and Play (UPnP) [4], Bluetooth’s Service Discovery Pro- tocol (SDP) [5], Service Location Protocol (SLP) [7] of IETF, IBM’s Salutation [8]). However, these proposals mainly target infrastructure-aware networks. Moreover, almost all of them include the client-server paradigm and mainly focus on resources/services provided by devices (e.g., printers, fax-machines) which restricts their applica- bility in ad-hoc networks.
1We use the term MAG or ‘Mobile Ad-hoc Group’ services referring to complex, mobile, device independent, distributed, software-based services (e.g., support for collaboration services or to provide service for mobile, online group games).
2http://www.mgain.org/MGAIN-wp3-d311-revised-final.pdf
3The latest game console of NOKIA, called N-Gage, is now furnished with a networking middleware and mobile Java technologies providing a Java-based, cross-platform approach to mobile multiplayer gaming.
In contrast, some recently appeared new proposals directly target infrastructure-less networks. The Konark sys- tem [9] is a middleware designed specifically for service discovery and delivery of device independent services in ad-hoc networks. Konark is based on a peer-to-peer model with each participating device having the capabilities to host its local services, deliver these services using a resident micro-HTTP server, query the network for available services offered by others, and use the services it discovered in the network. Another proposal is the distributed service discovery architecture [10] which relies on a virtual backbone for locating and registering available ser- vices within a dynamic network topology. It consists of two independent mechanisms: the formation of a virtual backbone which includes the nodes acting as service brokers; and the distribution of service registrations, requests and replies which establishes sub-trees rooted at service requesting devices and registers servers for efficient dis- semination of the service discovery messages. However, none of these proposals provide the full functionalities of service provisioning.
Several research projects have recently focused on service specification, dynamic service creation and deploy- ment in the context of active networks. Chameleon [6, 11] is a platform independent, node level service deployment framework which facilitates the installation of a service on a single node. It features a component-based service model in which a service is specified using a node-independent, XML based service description. Active pipes [12, 13] serve as an abstraction to describe the network level requirements of service components which are to be deployed on a path between two end-systems. Hierarchical service deployment [14] introduces an automated approach to network level service deployment that scales well to large heterogeneous programmable networks.
However, these research works target only infrastructure-aware networks and don’t offer comprehensive service provisioning functionalities.
Context information management have been receiving much attention due to the increasing demand of dynamic adaptation of service sessions to context changes. Recent research projects (e.g., agent based context usage [15], CONTEXT [16], general context management framework [17]) propose solutions for collecting and managing user context information to make its usage possible in the service. However, neither these proposals offer full service provisioning functionalities.
Our service provisioning framework targets ad-hoc environments. By distributed design it doesn’t rely on central network infrastructure. It is comprehensive and besides the management functions it integrates all the required mechanisms to support the whole life-cycle of a service.
3 Problem and Challenges
Service provisioning in self-organized networks is faced with special difficulties due to the constraints of these networks—such as lack of central infrastructure, high level of heterogeneity, degree of mobility, limited device and network resources. In this section, we survey these difficulties and identify the necessary functions of service provisioning in ad-hoc networks using a sample application scenario.
3.1 Sample Application Scenario
As our sample application scenario, we use an online, distributed group (multiplayer) game on a mobile ad-hoc network: A visitor of a network gaming conference wants to present and demonstrate the latest multiplayer game developed by his company. To do so, he brought a mobile device (e.g., a laptop) with the game software installed on it. The participants of the demo are supposed to possess also mobile devices that are able to communicate among each other. While only some of the devices are capable to actively participate in the game, all may act as a relay to forward data. Since they have come close together, a mobile ad-hoc network has been setup spontaneously.
Upon establishment of the ad-hoc network, the initiator announces the availability of a new application/service on the network. When each of the connected devices is informed they can decide whether to join the game or not.
Thereafter, the service will be automatically deployed on the selected devices (and in the network) and the game can be started. Further conference attendees are allowed to join (if the game allows for late arrivals) and leave the ongoing group game at any time. Even the initiator must be able to leave without interrupting the game session for the remaining players.
3.2 Difficulties and Required Functions of Service Provisioning
Analyzing this sample application scenario, several problems are identified. The first problem is to specify the service to be provisioned. In our game service this specification has to describe the participating device’s role (e.g., active player or auxiliary node which just aids the service to run); device-level local view (the game is composed
from moving pictures with music, sounds and voice requiring real time interaction from the player, etc.); and network-wide global view (the device has to communicate real time with all other player devices, etc.) of the game.
Hence, the different roles and views require the creation of a service model and the use of an appropriate service description method/language.
When the ad-hoc network is established, the initiator device (the host) has to announce the game service such that new participants can join. On the other hand, the devices of his friends must be able to lookup the service before deploying and using it. Unfortunately, ad-hoc networks cannot provide a permanent, central directory where the announced services can be registered and from where the available services can be read out. Moreover, the service hosting role can change dynamically in a MAG service. For example, in our scenario the initiator device hosted the game service but when it quits the game some other device has to take this role over or this role has to be implemented in a distributed manner.
When the devices in the ad-hoc network are informed of the game service the next step is to request, download, install, configure and activate the game software. Every device has to accomplish these procedures separately but in a synchronized manner to get a consistent state by when the game starts. This phase introduces some interesting problems. In general, heterogeneous devices form the ad-hoc networks (e.g., laptops, PDAs, mobile phones, etc.) representing several different platforms which requires the support of all the ported versions of the service software to these platforms from the service hosting device or the service has to be implemented in a platform independent way. Moreover, the lack of central infrastructure and the mobile behavior of the devices make it impossible to discover network resources beforehand and to use them permanently during the service session. For example, it’s realistic to assume that the auxiliary nodes in the game service have to support some multicast-like routing protocol to aid the communication among the player devices. But mobile devices can move almost arbitrarily so the selection of the auxiliary nodes and the deployment of the multicast protocol on them cannot be happen very in advance, furthermore it is doubtful that these nodes will be permanently available during the whole game session.
After the game started the service maintenance, reconfiguration and termination functions come to the front.
In the course of service maintenance the dynamic adaptation of the service to the resource variations must be assured. The players may experience frequently degraded performance of the service due to dynamic changes in network conditions (e.g., sudden drop in bandwidth when one of the player devices moves away from the others hereby reducing its communication capabilities) or other resources such as local computational cycles and memory space. Service reconfiguration takes place fundamentally in two forms, locally and globally. We are talking about the former if a service user device modifies the configuration of its local service instance (e.g., selecting a better resolution for the pictures, etc.). In the latter the network-wide global view of the service session changes, for example, when a new player joins the game session. Local reconfiguration is mostly transparent for the other users while global reconfiguration is always perceptible for every participant. Service provisioning must support global reconfiguration. Service termination can be considered as a special reconfiguration if a service device stops running the service instance, such as the game initiator when it quits the game. This incurs also the release of the reserved resources.
Dynamic adaptation to the resource variations and reconfiguration of the service session demand the continuous monitoring of the resources and the service context. This comprises the gathering and transformation of resource and context information into an appropriate form which can be used as input in the aforementioned functions (e.g., in service maintenance or reconfiguration).
Summarizing the above discussion, the main problem and challenges can be identified as follows: In the lack of a general service provisioning framework each application has to implement also the basic service provision- ing functions, such as service announcement/lookup; service request/download/installation/configuration; service maintenance/reconfiguration/termination. Moreover, the constraints of ad-hoc networks, such as the lack of central infrastructure, the high level of heterogeneity, the degree of mobility and the resource constraints of devices, make it difficult to develop and implement these functions.
4 Contributions and Expected Results
The main goal of this work is the development (design, implementation and analysis) of concepts and algorithms which may be used in the management of dynamic services. These mechanisms should support service mainte- nance, reconfiguration and termination in self-organized networks.
Additionally, to demonstrate these concepts/algorithms we introduce a general service provisioning framework for self-organized networks. In this framework, we provide a service description for complex, ad-hoc group ser- vices (e.g., a group game), and we adopt and integrate, besides the management functions, the mechanisms of the
recent proposals for service announcement/lookup, deployment and environment monitoring.
We expect an automatic operational mode in ad-hoc networks from the framework dealing with the full life cycle of services. Furthermore, we expect a flexible design to support not only trivial but also complex services.
5 Methodology
In this section, we declare our design goals and assumptions; introduce the architecture of SIRAMON, our generic service provisioning framework for ad-hoc networks; and describe the intended evaluation procedures.
5.1 Design Goals
Our design goals toward the service provisioning framework are the following:
(i) Target application context is in self-organized networks: The framework must be designed for use in self- organized networks.
(ii) Decentralized operation mode: The framework must work without relying on central infrastructure.
(iii) Comprehensive solution: The framework must support the service session during its whole session life-cycle, i.e., from the creation to its termination.
(iv) Transparency: The framework must conceal the details of service provisioning functions from the applica- tions providing a transparent interface to them.
(v) Robustness: The framework must aid the service session to dynamically adapt to mobility and resource variations. Moreover, it must cope with the heterogeneity of devices.
(vi) Flexibility: The framework must be generic and support a large variety of services. Specifically, the frame- work must be flexible enough to support complex, ad-hoc group applications.
5.2 Assumptions
We assume that all nodes are mobile, connected via wireless bidirectional links and are capable of relaying packets on behalf of others. All the nodes wishing to communicate with other nodes within the ad-hoc network are willing to participate fully in the communication protocols.
Nodes within the ad-hoc network may move at any time without notice and may even move continuously, but we assume that the speed with which nodes move is moderate with respect to the packet transmission latency and wireless transmission range.
Each node has a unique address (identifier) by which it will be known in the ad-hoc network.
Moreover, all nodes are furnished with SIRAMON in advance and required software (including ported versions for different device platforms) can be found on at least one networking node (very often this will be the initial service host).
5.3 SIRAMON
Our service provisioning framework is based on a decentralized and modular design. Every device runs an instance of SIRAMON which handles the control and synchronization among the devices, as well. We integrate the func- tions of the different service provisioning phases, as we discussed above, into separate modules. This makes the framework generic giving the possibility to replace the functions of a module with others which may fit better with the actual environment or the application’s needs. Moreover, we don’t want to reinvent the wheel, thus with the modular design we can easily integrate procedures which have been already developed for given functions (such as service announcement/lookup).
In our device model (see Figure 1) we introduce a management middleware layer where SIRAMON, integrating the service provisioning functions, is located. This layer provides an interface between the device’s resources and the applications. The Device Resource Manager is responsible for controlling these resources and mapping them to service elements. However, this module is beyond the scope of our work. SIRAMON can be accessed locally via well-defined APIs (Application Programming Interface) and it defines also an interface to communicate with other SIRAMON instances. In the following, we describe the definitions and functionalities of SIRAMON.
Figure 1: Ad-hoc Device Model with SIRAMON
5.3.1 Service Specification
It defines the service model used in the given service. SIRAMON is not bounded to any specific service model. The only requirement is that the service model must be able to describe the role of the node in the service, the functions of the service elements and the connections among them. In case of different type of services it is reasonable to use different service models if the other model suits better for describing the given service.
As a key component, we intend to design a service model for MAG services in this work.
5.3.2 Service Indication
This module covers service announcement and service lookup procedures. As we discussed, due to the lack of central infrastructure, the traditional central directory model cannot be applied in mobile ad-hoc environments.
A solution could be to replicate this directory on every device connected to the ad-hoc network. This introduces synchronization and propagation overhead to maintain a consistent database on all the devices but makes the service lookup very fast and efficient. Another solution is to establish a so-called virtual backbone in the ad-hoc network selecting some devices which store a copy of the service directory. This approach slows down the service lookup and is less efficient compared to the previous replica-on-each-device-type, but introduces less administrative overhead—however, it requires an extra procedure to select and maintain the set of virtual backbone nodes.
We don’t plan to develop a new service announcement/lookup mechanism, rather we adopt one of the recently proposed approaches which fits best with our demands.
5.3.3 Service Deployment
Deploying a service requires requesting/downloading software according to the specification; discovering/gathering resources; mapping of this specification to resources; configuring the resources and installing/configuring the downloaded softwares; activating the service in a synchronized manner along with the other service participants;
and handing the control on to the management module. The Service Deployment module includes these functions.
Traditionally, in infrastructure-aware networks service deployment consists of two levels: the network level and the node level. Briefly, on the network level the participants of the service should be explored and the required
network resources should be discovered and selected, since on the node level the appropriate service components should be deployed on the selected resources. However, in mobile ad-hoc networks due to the lack of central infrastructure and the mobile behavior of the devices these two levels cannot be clearly distinguished. It can easily happen that a previously selected relay node moves away even during the deployment phase and another has to be selected on the network level. Thus, the network and node level functions have to synchronize continuously each other during the whole deployment phase.
This module has to tightly cooperate with the Environment Observer for getting information about the available resources and with the Device Resource Manager for mapping the resources to the service components.
Again, we don’t plan to develop a new service deployment mechanism, rather we adopt an existing one.
5.3.4 Service Management
This module integrates the service maintenance, reconfiguration and termination functions.
Service maintenance is responsible for the dynamic adaptation of the service to the resource variations in order to optimize user’s perceived service quality. Using the terminology in [18] we distinguish three ways to adapt to changes in resources. These adaptations should be performed only after the effect has been observed to persist beyond a threshold amount of time, since reacting to transient resource changes results in unjustified overhead and instability of the system.
(i) Service-intelligent adaptation: The application is powerful enough to do its own adaptation to resource changes. For instance, the audio subservice of a teleconference service can combine multiple streams en- coded for different bit rates into a single clip. Thus during runtime, the audio stream dynamically adapts to changes in bandwidths. In this case, the management module should directly take advantage the application adaptation mechanism.
(ii) Service-specific adaptation: The application provides mechanisms for dynamic adjustment, but does not do so automatically. For instance, for bandwidth adaptation, there are different instances of the same codec intended for different bit rates. To select the appropriate one the application needs to be notified about the resource changes. In this case, the management module, consulting with the Environment Observer for resource changes, is responsible to provide feedback to the application to enable dynamic adaptation.
(iii) Service-independent adaptation: If the management module doesn’t have information about the underlying implementation of the application, it treats the application as a black box and tries to find other means to adapt to the changes. For example, to adapt to high packet loss rate, forward error correction can be used.
Service reconfiguration, as we discussed above, has two fundamental forms, local and global reconfiguration.
Local reconfiguration is mostly transparent for the other users and it takes place when the context of the device changes or the service user intends to modify the running service session. In global reconfiguration the network- wide global view of the service session changes (e.g., a new user joins) and global reconfiguration is always per- ceptible for every participant and requires global synchronization. The Service Management module gives support for global reconfiguration while local reconfiguration is in charge of the application.
Service termination can be considered as a special form of reconfiguration when a device stops running the service instance. All the other service participants have to be informed about the termination and the reserved resources have to be released.
This module also has to tightly cooperate with the Environment Observer and the Device Resource Manager.
As the main focus of our work, we intend to develop mechanisms which support the mentioned management functions.
5.3.5 Environment Observer
This module is responsible for monitoring the device resources and the service context. Resource and context infor- mation have to be gathered and transformed into an appropriate form, which can serve as input for the deployment and management modules.
For this function, we intend to adopt an existing mechanism.
5.4 Evaluation
As the proof of concept, we implement and evaluate SIRAMON in a simulator environment and in a testbed using a simple example group application. The purpose of the evaluation is to investigate SIRAMON’s scalability and performance in different simulated and the prototype scenario. Moreover, we intend to demonstrate the magic, how a group application is automatically provisioned in a mobile ad-hoc network.
6 Conclusions
With the spreading of ad-hoc networks of diverse devices new services will emerge soon. These services must be provisioned in a flexible and distributed way without central infrastructure and coping with the high level of heterogeneity, degree of mobility, and device limitations. To the best of our knowledge, the proposed service provisioning framework is the first approach which gives automatic service management functionalities, deals with the full life cycle of services, and is flexible enough to support not only trivial but also complex services. We are convinced that this flexibility and the generic design provide a powerful solution for service provisioning as required for ad-hoc networks.
References
[1] Andy Oram, editor. Peer-to-Peer: Harnessing the Power of Disruptive Technologies. 2001.
[2] C. E. Perkins, editor. Ad Hoc Networking. 2001.
[3] SUN Microsystems. JINI Architecture Specification, November 1999.
[4] Microsoft Corporation. Universal Plug and Play: Background. www.upnp.org/resources/UPnPbkgnd.htm, 1999.
[5] Specification of the Bluetooth System. www.bluetooth.com, December 1999.
[6] M. Bossardt, L. Ruf, R. Stadler, and B. Plattner. A Service Deployment Architecture for Heterogeneous Active Network Nodes. In IFIP International Conference on Intelligence in Networks (SmartNet), Saariselka, Finland, April 2002. Kluwer Academic Publishers.
[7] E. Guttman, C. Perkins, J. Veizades, and M. Day. Service Location Protocol, Version 2. IETF RFC 2608, June 1999.
[8] Salutation Consortium. Salutation Architecture Specification. www.salutation.org/specordr.htm, 1999.
[9] S. Helal, N. Desai, V Verma, and C. Lee. Konark – A Service Discovery and Delivery Protocol for Ad-hoc Networks. In Proceedings of the Third IEEE Conference on Wireless Communication Networks (WCNC), New Orleans, USA, March 2003.
[10] U. C. Kozat and L. Tassiulas. Network Layer Support for Service Discovery in Mobile Ad Hoc Networks. In Proceedings of the IEEE INFOCOM, San Francisco, USA, April 2003.
[11] M. Bossardt, R. Hoog Antink, A. Moser, and B. Plattner. Chameleon: Realizing Automatic Service Composition for Extensible Active Routers. In Proceedings of the Fifth Annual International Working Conference on Active Networks, (IWAN 2003), number 2982 in Lecture Notes in Computer Science, Kyoto, Japan, December 2004. Springer Verlag.
[12] R. Keller, T. Wolf, J. Ramamirtham, and B. Plattner. Programming Active Networks Using Active Pipes. Technical report, Washington University in St. Louis, USA.
[13] R. Keller and B. Plattner. Self-Configuring Active Services for Programmable Networks. In Proceedings of the Fifth Annual International Working Conference on Active Networks, (IWAN 2003), number 2982 in Lecture Notes in Computer Science, Kyoto, Japan, December 2003. Springer Verlag.
[14] R. Haas. Service Deployment in Programmable Networks. PhD thesis, Electrical Engineering Department, ETH Zurich, Switzerland, 2003.
[15] D. Prevedourou, M. Anagnostou, and et al. Use of Agent Technology in Service and Retailer Selection in a Personal Mobility Context. Computer Networks, Vol. 31:2079–2098, September 1999.
[16] IST-CONTEXT project proposal, Annex 1. http://context.upc.es/index.htm, May 2002.
[17] P. Mendes, C. Prehofer, and Q. Wei. Context Management with Programmable Mobile Networks. In IEEE Computer Communications Workshop (CCW 2003), Dana Point, California, USA, October 2003.
[18] Z. Morley Mao and Randy H. Katz. A Framework for Universal Service Access Using Device Ensemble. Grace Hopper Celebration of Women in Computing, 2002.
